A C D E F G H I J K L M N O P R S T V W Z 

A

AbstractADPAlgorithm<R,N extends Enum<N>> - Class in de.citec.tcs.alignment.adp
This is the most abstract ADP algorithm just implementing the forward calculation of the dynamic programming tables for an arbitrary grammar.
AbstractADPAlgorithm(Grammar<N>, Class<R>, AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.adp.AbstractADPAlgorithm
 
AbstractAffineAlignmentAlgorithm<R> - Class in de.citec.tcs.alignment
This is an implementation of the affine alignment algorithm scheme combining actually two approaches: First the algorithm of Gotoh et al.
AbstractAffineAlignmentAlgorithm(Class<R>, AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.AbstractAffineAlignmentAlgorithm
 
AbstractAffineAlignmentAlgorithm.Recurrence - Enum in de.citec.tcs.alignment
 
AbstractGapAlignmentAlgorithm<X extends AlignmentMatrixEntry,R> - Class in de.citec.tcs.alignment
This is an abstract super class for GapAlignmentAlgorithms that provides a generic implementation of the dynamic programming needed to efficiently calculate the alignment.
AbstractGapAlignmentAlgorithm(AlignmentSpecification, Class<X>, Class<R>) - Constructor for class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
 
AbstractHTMLColumn - Class in de.citec.tcs.alignment.visualization
This is a convenience abstract implementation of HTMLColumn.
AbstractHTMLColumn(String) - Constructor for class de.citec.tcs.alignment.visualization.AbstractHTMLColumn
 
AbstractParallelDerivativeEngine<R> - Class in de.citec.tcs.alignment
 
AbstractParallelDerivativeEngine(Map<MatrixEngine.MatrixCoordinate, AlignmentDerivativeAlgorithm>, int, int, Class<R>) - Constructor for class de.citec.tcs.alignment.AbstractParallelDerivativeEngine
 
AbstractParallelDerivativeEngine(AlignmentDerivativeAlgorithm[][], Class<R>) - Constructor for class de.citec.tcs.alignment.AbstractParallelDerivativeEngine
 
AbstractStrictDTWAlgorithm<R> - Class in de.citec.tcs.alignment
This serves as an abstract super class for strict Dynamic Time Warping implementations.
AbstractStrictDTWAlgorithm(Class<R>, AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.AbstractStrictDTWAlgorithm
 
AbstractValue - Class in de.citec.tcs.alignment.sequence
This is a convenience implementation of the Value interface.
AbstractValue(ValueType) - Constructor for class de.citec.tcs.alignment.sequence.AbstractValue
 
AbstractVisualizer - Class in de.citec.tcs.alignment.visualization
This is an abstract convenience implementation of the Visualizer interface.
AbstractVisualizer() - Constructor for class de.citec.tcs.alignment.visualization.AbstractVisualizer
 
add(int, double) - Method in interface de.citec.tcs.alignment.comparators.SparseLocalDerivative
This adds a new derivative to this sparse representation.
add(int, double) - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.EmptySparseLocalEntry
This adds a new derivative to this sparse representation.
add(int, double) - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.FixedSparseLocalDerivative
This adds a new derivative to this sparse representation.
add(int, double) - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.FlexibleSparseLocalDerivative
This adds a new derivative to this sparse representation.
add(int, double) - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.TrivialSparseLocalDerivative
This adds a new derivative to this sparse representation.
addRule(N, ProductionRule<N>) - Method in class de.citec.tcs.alignment.adp.FlexibleGrammar
Adds a production rule to this grammar.
addTask(I) - Method in class de.citec.tcs.alignment.parallel.Engine
Adds the task with the given identifier to this Engine.
addTasks(I[]) - Method in class de.citec.tcs.alignment.parallel.Engine
Adds the tasks with the given identifiers to this Engine.
addTasks(Collection<I>) - Method in class de.citec.tcs.alignment.parallel.Engine
Adds the tasks with the given identifiers to this Engine.
AffineGrammar - Class in de.citec.tcs.alignment.adp
This grammar describes affine (and local) sequence alignment as described by Smith&Waterman (1981) and Gotoh (1982).
AffineGrammar() - Constructor for class de.citec.tcs.alignment.adp.AffineGrammar
Creates an instance of the affine grammar.
AffineGrammar(int) - Constructor for class de.citec.tcs.alignment.adp.AffineGrammar
Creates an instance of the affine grammar.
AffineGrammar.Nonterminal - Enum in de.citec.tcs.alignment.adp
These are the nonterminal symbols for the affine grammar.
AffineNormalizer - Class in de.citec.tcs.alignment.comparators
The affine normalizer just maps the range [min, max] linearly to the range [0,1].
AffineNormalizer(double, double) - Constructor for class de.citec.tcs.alignment.comparators.AffineNormalizer
 
AlignmentAlgorithm<R> - Interface in de.citec.tcs.alignment
This is the most generic AlignmentAlgorithm interface for all algorithms that provide some sort of alignment between two input sequences.
AlignmentDerivativeAlgorithm - Interface in de.citec.tcs.alignment
This is an interface to provide calculation methods for the derivative of an alignment w.r.t.
AlignmentMatrixEntry - Interface in de.citec.tcs.alignment
This is an interface for the entries of an alignment matrix.
AlignmentPath - Class in de.citec.tcs.alignment
This class models an alignment path as it is given out by a strict alignment.
AlignmentPath(AlignmentSpecification, Sequence, Sequence, double) - Constructor for class de.citec.tcs.alignment.AlignmentPath
 
AlignmentSpecification - Class in de.citec.tcs.alignment
The alignment specification defines which keywords of the input sequences shall be used and which comparator is to be used to calculate the local distance between two values for that keyword.
AlignmentSpecification(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.AlignmentSpecification
Constructs a copy of the given other AlignmentSpecification.
AlignmentSpecification(NodeSpecification, Comparator[]) - Constructor for class de.citec.tcs.alignment.AlignmentSpecification
 
AlignmentSpecification(NodeSpecification, String[], Comparator[]) - Constructor for class de.citec.tcs.alignment.AlignmentSpecification
 
AlignmentSpecification(NodeSpecification, String[], Comparator[], double[]) - Constructor for class de.citec.tcs.alignment.AlignmentSpecification
 
Alphabet - Class in de.citec.tcs.alignment.sequence
An alphabet is an ordered set of arbitrary symbols.
Alphabet(HashMap<String, Integer>) - Constructor for class de.citec.tcs.alignment.sequence.Alphabet
 
Alphabet(String) - Constructor for class de.citec.tcs.alignment.sequence.Alphabet
Constructor for symbols either encoded as single characters without delimiter or as strings with | as delimiter.
Alphabet(String[]) - Constructor for class de.citec.tcs.alignment.sequence.Alphabet
Constructs an IndexingScheme from a mapping of indices to strings.
averageScore() - Method in class de.citec.tcs.alignment.PathMap
Returns the average score according to the given weighting scheme.

C

calc_weighted_comp_sum(Comparator[], double[], int[], Node, Node) - Static method in class de.citec.tcs.alignment.SoftDTWModel
Returns weighted sum k of local comparators: k = sum(w_i * k_i) with: k_i: local comparators w_i: local weights Note: Comparators, weights, originalIndices are supposed to originate from the same AlignmentSpecification.
calculate() - Method in class de.citec.tcs.alignment.parallel.Engine
Starts the actual, parallel computation.
calculateAlignment(Sequence, Sequence) - Method in class de.citec.tcs.alignment.AbstractAffineAlignmentAlgorithm
This calculates the alignment between the Sequences a and b and returns it as an instance of the result class for this algorithm.
calculateAlignment(Sequence, Sequence) - Method in class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
This calculates the alignment between the Sequences a and b and returns it as an instance of the result class for this algorithm.
calculateAlignment(Sequence, Sequence) - Method in class de.citec.tcs.alignment.AbstractStrictDTWAlgorithm
This calculates the alignment between the Sequences a and b and returns it as an instance of the result class for this algorithm.
calculateAlignment(Sequence, Sequence) - Method in class de.citec.tcs.alignment.adp.AbstractADPAlgorithm
This calculates the alignment between the Sequences a and b and returns it as an instance of the result class for this algorithm.
calculateAlignment(Sequence, Sequence) - Method in interface de.citec.tcs.alignment.AlignmentAlgorithm
This calculates the alignment between the Sequences a and b and returns it as an instance of the result class for this algorithm.
calculateAlignment(Sequence, Sequence) - Method in class de.citec.tcs.alignment.KernelDTWFullAlgorithm
This calculates the alignment between the Sequences a and b and returns it as an instance of the result class for this algorithm.
calculateComparatorDistances(OperationType, Node, Node, AlignmentSpecification) - Static method in class de.citec.tcs.alignment.Operation
 
calculateCompressedSize(String) - Method in enum de.citec.tcs.alignment.comparators.NCDComparator.CompressorType
Calculates the compressed size of the given input string in bytes.
calculateDeletionCosts(Node) - Method in class de.citec.tcs.alignment.AlignmentSpecification
This calculates the non-weighted costs for deleting the single values in node a.
calculateDerivative(AlignmentAlgorithm<? extends AlignmentDerivativeAlgorithm>, Sequence, Sequence) - Static method in class de.citec.tcs.alignment.wrappers.StringEditDistance
Calculates the alignment derivative between the two given input sequences using the given algorithm.
calculateDerivatives(AlignmentAlgorithm<R>, Sequence[], int) - Static method in class de.citec.tcs.alignment.wrappers.StringEditDistance
Calculates the pairwise alignment derivative between all given input sequences using the given algorithm.
calculateInsertionCosts(Node) - Method in class de.citec.tcs.alignment.AlignmentSpecification
This calculates the non-weighted costs for inserting the single values of node b.
calculateLocalDerivative(int, V, V, OperationType) - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
This is called by an AlignmentDerivativeAlgorithm and should calculate the local derivative for only one comparison of the values a and b.
calculateLocalDerivative(int, X, X, OperationType) - Method in interface de.citec.tcs.alignment.comparators.DerivableComparator
This is called by an AlignmentDerivativeAlgorithm and should calculate the local derivative for only one comparison of the values a and b.
calculateLocalDerivative(int, VectorialValue, VectorialValue, OperationType) - Method in class de.citec.tcs.alignment.comparators.DTWKernelComparator
TODO: think about opterationType This is called by an AlignmentDerivativeAlgorithm and should calculate the local derivative for only one comparison of the values a and b.
calculateLocalDerivative(int, SymbolicValue, SymbolicValue, OperationType) - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
This is called by an AlignmentDerivativeAlgorithm and should calculate the local derivative for only one comparison of the values a and b.
calculateLocalDerivative(int, V, V, OperationType) - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
This is called by an AlignmentDerivativeAlgorithm and should calculate the local derivative for only one comparison of the values a and b.
calculateNCD(String, String) - Method in class de.citec.tcs.alignment.comparators.NCDComparator
Returns the normalized compression distance between two input strings according to the compressor currently set.
calculateParameterDerivative(DerivableComparator<X, Y>, String) - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateParameterDerivative(DerivableComparator<X, Y>, String) - Method in interface de.citec.tcs.alignment.AlignmentDerivativeAlgorithm
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateParameterDerivative(DerivableComparator<X, Y>, String) - Method in class de.citec.tcs.alignment.AlignmentPath
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateParameterDerivative(DerivableComparator<X, Y>, String) - Method in class de.citec.tcs.alignment.PathList
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateParameterDerivative(DerivableComparator<X, Y>, String) - Method in class de.citec.tcs.alignment.PathMap
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateParameterDerivative(DerivableComparator<X, Y>, String) - Method in class de.citec.tcs.alignment.SoftAffinePathModel
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateParameterDerivative(DerivableComparator<X, Y>, String) - Method in class de.citec.tcs.alignment.SoftDTWModel
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateParameterDerivative(DerivableComparator<X, Y>, String) - Method in class de.citec.tcs.alignment.SoftPathModel
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateRawParameterDerivative(DerivableComparator<X, Y>, String) - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateRawParameterDerivative(DerivableComparator<X, Y>, String) - Method in interface de.citec.tcs.alignment.AlignmentDerivativeAlgorithm
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateRawParameterDerivative(DerivableComparator<X, Y>, String) - Method in class de.citec.tcs.alignment.AlignmentPath
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateRawParameterDerivative(DerivableComparator<X, Y>, String) - Method in class de.citec.tcs.alignment.PathList
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateRawParameterDerivative(DerivableComparator<X, Y>, String) - Method in class de.citec.tcs.alignment.PathMap
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateRawParameterDerivative(DerivableComparator<X, Y>, String) - Method in class de.citec.tcs.alignment.SoftAffinePathModel
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateRawParameterDerivative(DerivableComparator<X, Y>, String) - Method in class de.citec.tcs.alignment.SoftDTWModel
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateRawParameterDerivative(DerivableComparator<X, Y>, String) - Method in class de.citec.tcs.alignment.SoftPathModel
This returns the derivatives for all parameters of the given comparator according to the implementation.
calculateReplacementCosts(Node, Node) - Method in class de.citec.tcs.alignment.AlignmentSpecification
This calculates the non-weighted costs for replacing the single values in node a by the values in node b.
calculateSkipDeletionCosts(Node) - Method in class de.citec.tcs.alignment.AlignmentSpecification
This calculates the non-weighted costs for skip-deleting the single values in node a.
calculateSkipInsertionCosts(Node) - Method in class de.citec.tcs.alignment.AlignmentSpecification
This calculates the non-weighted costs for skip-inserting the single values of node b.
calculateSoftminDerivatives(double, double[]) - Static method in class de.citec.tcs.alignment.Softmin
Calculates the softmin'(x_i) function for all variables x_i in the given input.
calculateSoftminDerivatives(double, double, double[]) - Static method in class de.citec.tcs.alignment.Softmin
Calculates the softmin'(x_i) function for all variables x_i in the given input.
calculateSoftminProbabilities(double, double[]) - Static method in class de.citec.tcs.alignment.Softmin
Calculates the softmin probabilities p_i for the given beta and the given variables.
calculateSoftminProbabilities(double, double, double[]) - Static method in class de.citec.tcs.alignment.Softmin
Calculates the softmin probabilities p_i for the given beta and the given variables.
calculateSparseLocalDerivative(V, V, OperationType) - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
This method shall return a sparse representation of the derivative for all parameters that have non-zero derivatives in this step of the alignment.
calculateSparseLocalDerivative(SymbolicValue, SymbolicValue, OperationType) - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
This method shall return a sparse representation of the derivative for all parameters that have non-zero derivatives in this step of the alignment.
calculateSparseLocalDerivative(V, V, OperationType) - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
This method shall return a sparse representation of the derivative for all parameters that have non-zero derivatives in this step of the alignment.
calculateSparseLocalDerivative(X, X, OperationType) - Method in interface de.citec.tcs.alignment.comparators.SparseDerivableComparator
This method shall return a sparse representation of the derivative for all parameters that have non-zero derivatives in this step of the alignment.
calculateWeightDerivative() - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
Calculates the derivative for each keyword weight.
calculateWeightDerivative() - Method in interface de.citec.tcs.alignment.AlignmentDerivativeAlgorithm
Calculates the derivative for each keyword weight.
calculateWeightDerivative() - Method in class de.citec.tcs.alignment.AlignmentPath
Calculates the derivative for each keyword weight.
calculateWeightDerivative() - Method in class de.citec.tcs.alignment.PathList
Calculates the derivative for each keyword weight.
calculateWeightDerivative() - Method in class de.citec.tcs.alignment.PathMap
Calculates the derivative for each keyword weight.
calculateWeightDerivative() - Method in class de.citec.tcs.alignment.SoftAffinePathModel
Calculates the derivative for each keyword weight.
calculateWeightDerivative() - Method in class de.citec.tcs.alignment.SoftDTWModel
Calculates the derivative for each keyword weight.
calculateWeightDerivative() - Method in class de.citec.tcs.alignment.SoftPathModel
Calculates the derivative for each keyword weight.
calculateWeighting(Collection<Double>) - Method in enum de.citec.tcs.alignment.ScoreBasedWeighting
 
calculateWeighting(double[]) - Method in enum de.citec.tcs.alignment.ScoreBasedWeighting
This calculates the normalized weights (between 0 and 1 and adding up to 1) for the given scores.
CharStatComparator - Class in de.citec.tcs.alignment.comparators
This compares strings using statistics over the number of letters inside.
CharStatComparator() - Constructor for class de.citec.tcs.alignment.comparators.CharStatComparator
 
choice(double...) - Method in class de.citec.tcs.alignment.AbstractAffineAlignmentAlgorithm
This should implement the choice function as the term is used in the Bellman's Gap context.
choice(double[]) - Method in class de.citec.tcs.alignment.adp.AbstractADPAlgorithm
This should implement the choice function as the term is used in the Bellman's Gap context.
choice(double[]) - Method in class de.citec.tcs.alignment.adp.SoftADPFullAlgorithm
This should implement the choice function as the term is used in the Bellman's Gap context.
choice(double[]) - Method in class de.citec.tcs.alignment.adp.SoftADPScoreAlgorithm
This should implement the choice function as the term is used in the Bellman's Gap context.
choice(double[]) - Method in class de.citec.tcs.alignment.adp.StrictADPFullAlgorithm
This should implement the choice function as the term is used in the Bellman's Gap context.
choice(double[]) - Method in class de.citec.tcs.alignment.adp.StrictADPScoreAlgorithm
This should implement the choice function as the term is used in the Bellman's Gap context.
choice(double...) - Method in class de.citec.tcs.alignment.SoftAffineAlignmentFullAlgorithm
This implements the strict maximum of the given input doubles.
choice(double...) - Method in class de.citec.tcs.alignment.SoftAffineAlignmentScoreAlgorithm
This implements the strict maximum of the given input doubles.
choice(double...) - Method in class de.citec.tcs.alignment.StrictAffineAlignmentFullAlgorithm
This implements the strict maximum of the given input doubles.
choice(double...) - Method in class de.citec.tcs.alignment.StrictAffineAlignmentScoreAlgorithm
This implements the strict maximum of the given input doubles.
clearTasks() - Method in class de.citec.tcs.alignment.parallel.Engine
Removes all tasks from this Engine.
clone() - Method in class de.citec.tcs.alignment.AlignmentPath
clone() - Method in class de.citec.tcs.alignment.AlignmentSpecification
 
CommandLineProgressReporter - Class in de.citec.tcs.alignment.parallel
This is a default ProgressReporter that writes a notification to the command line after progressReportStepSize percent of computation are finished.
CommandLineProgressReporter() - Constructor for class de.citec.tcs.alignment.parallel.CommandLineProgressReporter
 
Comparator<X extends Value> - Interface in de.citec.tcs.alignment.comparators
This defines a function that returns a (normalized) dissimilarity between values of a certain value space.
compare(StringValue, StringValue) - Method in class de.citec.tcs.alignment.comparators.CharStatComparator
This has to return a distance between a and b with the following restrictions: The return value has to lie between 0 and 1. 1 means maximum dissimilarity between a and b. 0 means maximum similarity between a and b (especially it should be true that a = b implies a zero distance). distance(a,b) should be equal or at least close to distance(b,a) Please note that this has to be well-defined, even if an input is null.
compare(X, X) - Method in interface de.citec.tcs.alignment.comparators.Comparator
This has to return a distance between a and b with the following restrictions: The return value has to lie between 0 and 1. 1 means maximum dissimilarity between a and b. 0 means maximum similarity between a and b (especially it should be true that a = b implies a zero distance). distance(a,b) should be equal or at least close to distance(b,a) Please note that this has to be well-defined, even if an input is null.
compare(VectorialValue, VectorialValue) - Method in class de.citec.tcs.alignment.comparators.DTWKernelComparator
This has to return a distance between a and b with the following restrictions: The return value has to lie between 0 and 1. 1 means maximum dissimilarity between a and b. 0 means maximum similarity between a and b (especially it should be true that a = b implies a zero distance). distance(a,b) should be equal or at least close to distance(b,a) Please note that this has to be well-defined, even if an input is null.
compare(VectorialValue, VectorialValue) - Method in class de.citec.tcs.alignment.comparators.EuclideanComparator
This has to return a distance between a and b with the following restrictions: The return value has to lie between 0 and 1. 1 means maximum dissimilarity between a and b. 0 means maximum similarity between a and b (especially it should be true that a = b implies a zero distance). distance(a,b) should be equal or at least close to distance(b,a) Please note that this has to be well-defined, even if an input is null.
compare(VectorialValue, VectorialValue) - Method in class de.citec.tcs.alignment.comparators.L1NormComparator
This has to return a distance between a and b with the following restrictions: The return value has to lie between 0 and 1. 1 means maximum dissimilarity between a and b. 0 means maximum similarity between a and b (especially it should be true that a = b implies a zero distance). distance(a,b) should be equal or at least close to distance(b,a) Please note that this has to be well-defined, even if an input is null.
compare(StringValue, StringValue) - Method in class de.citec.tcs.alignment.comparators.NCDComparator
This has to return a distance between a and b with the following restrictions: The return value has to lie between 0 and 1. 1 means maximum dissimilarity between a and b. 0 means maximum similarity between a and b (especially it should be true that a = b implies a zero distance). distance(a,b) should be equal or at least close to distance(b,a) Please note that this has to be well-defined, even if an input is null.
compare(SymbolicValue, SymbolicValue) - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
This has to return a distance between a and b with the following restrictions: The return value has to lie between 0 and 1. 1 means maximum dissimilarity between a and b. 0 means maximum similarity between a and b (especially it should be true that a = b implies a zero distance). distance(a,b) should be equal or at least close to distance(b,a) Please note that this has to be well-defined, even if an input is null.
compare(SymbolicValue, SymbolicValue) - Method in class de.citec.tcs.alignment.comparators.TrivialEditComparator
This has to return a distance between a and b with the following restrictions: The return value has to lie between 0 and 1. 1 means maximum dissimilarity between a and b. 0 means maximum similarity between a and b (especially it should be true that a = b implies a zero distance). distance(a,b) should be equal or at least close to distance(b,a) Please note that this has to be well-defined, even if an input is null.
compare(VectorialValue, VectorialValue) - Method in class de.citec.tcs.alignment.comparators.ZeroNormComparator
This has to return a distance between a and b with the following restrictions: The return value has to lie between 0 and 1. 1 means maximum dissimilarity between a and b. 0 means maximum similarity between a and b (especially it should be true that a = b implies a zero distance). distance(a,b) should be equal or at least close to distance(b,a) Please note that this has to be well-defined, even if an input is null.
compareTo(DPCellId) - Method in class de.citec.tcs.alignment.adp.DPCellId
 
compareTo(MatrixEngine.MatrixCoordinate) - Method in class de.citec.tcs.alignment.parallel.MatrixEngine.MatrixCoordinate
ComparisonBasedSkipExtendedComparator<V extends Value> - Class in de.citec.tcs.alignment.comparators
This is an abstract class allowing to define a dynamic method to extend a simple Comparator to a SkipComparator.
ComparisonBasedSkipExtendedComparator(V, V, V, V) - Constructor for class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
 
comparisonDerivative(int, StringValue, StringValue) - Method in class de.citec.tcs.alignment.comparators.CharStatComparator
This should implement the local derivative calculation in case of comparisons.
comparisonDerivative(int, VectorialValue, VectorialValue) - Method in class de.citec.tcs.alignment.comparators.EuclideanComparator
This should implement the local derivative calculation in case of comparisons.
comparisonDerivative(int, VectorialValue, VectorialValue) - Method in class de.citec.tcs.alignment.comparators.L1NormComparator
This should implement the local derivative calculation in case of comparisons.
comparisonDerivative(int, StringValue, StringValue) - Method in class de.citec.tcs.alignment.comparators.NCDComparator
This should implement the local derivative calculation in case of comparisons.
comparisonDerivative(int, V, V) - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
This should implement the local derivative calculation in case of comparisons.
comparisonDerivative(int, SymbolicValue, SymbolicValue) - Method in class de.citec.tcs.alignment.comparators.TrivialEditComparator
This should implement the local derivative calculation in case of comparisons.
comparisonDerivative(int, VectorialValue, VectorialValue) - Method in class de.citec.tcs.alignment.comparators.ZeroNormComparator
This should implement the local derivative calculation in case of comparisons.
containsGaps() - Method in class de.citec.tcs.alignment.adp.AffineGrammar
This should return true if and only if this grammar contains at least one production rule with the OperationType DELETION or INSERTION.
containsGaps() - Method in class de.citec.tcs.alignment.adp.FlexibleGrammar
This should return true if and only if this grammar contains at least one production rule with the OperationType DELETION or INSERTION.
containsGaps() - Method in class de.citec.tcs.alignment.adp.GlobalAsymmetricGrammar
This should return true if and only if this grammar contains at least one production rule with the OperationType DELETION or INSERTION.
containsGaps() - Method in class de.citec.tcs.alignment.adp.GlobalGrammar
This should return true if and only if this grammar contains at least one production rule with the OperationType DELETION or INSERTION.
containsGaps() - Method in interface de.citec.tcs.alignment.adp.Grammar
This should return true if and only if this grammar contains at least one production rule with the OperationType DELETION or INSERTION.
containsSkips() - Method in class de.citec.tcs.alignment.adp.AffineGrammar
This should return true if and only if this grammar contains at least one production rule with the OperationType SKIPDELETION or SKIPINSERTION.
containsSkips() - Method in class de.citec.tcs.alignment.adp.FlexibleGrammar
This should return true if and only if this grammar contains at least one production rule with the OperationType SKIPDELETION or SKIPINSERTION.
containsSkips() - Method in class de.citec.tcs.alignment.adp.GlobalAsymmetricGrammar
This should return true if and only if this grammar contains at least one production rule with the OperationType SKIPDELETION or SKIPINSERTION.
containsSkips() - Method in class de.citec.tcs.alignment.adp.GlobalGrammar
This should return true if and only if this grammar contains at least one production rule with the OperationType SKIPDELETION or SKIPINSERTION.
containsSkips() - Method in interface de.citec.tcs.alignment.adp.Grammar
This should return true if and only if this grammar contains at least one production rule with the OperationType SKIPDELETION or SKIPINSERTION.
createCallable(MatrixEngine.MatrixCoordinate) - Method in class de.citec.tcs.alignment.AbstractParallelDerivativeEngine
A method that should create a Callable (computation job) for the given identifier object.
createCallable(I) - Method in class de.citec.tcs.alignment.parallel.Engine
A method that should create a Callable (computation job) for the given identifier object.
createCallable(MatrixEngine.MatrixCoordinate) - Method in class de.citec.tcs.alignment.ParallelProcessingEngine
A method that should create a Callable (computation job) for the given identifier object.
createCallableWithAlgorithm(AlignmentDerivativeAlgorithm) - Method in class de.citec.tcs.alignment.AbstractParallelDerivativeEngine
Instead of a matrix coordinate identifier, this method should create a fitting calculation job for the derivative with the given AlignmentDerivativeAlgorithm.
createCallableWithAlgorithm(AlignmentDerivativeAlgorithm) - Method in class de.citec.tcs.alignment.ParallelDerivativeEngine
Instead of a matrix coordinate identifier, this method should create a fitting calculation job for the derivative with the given AlignmentDerivativeAlgorithm.
createCallableWithAlgorithm(AlignmentDerivativeAlgorithm) - Method in class de.citec.tcs.alignment.ParallelRawDerivativeEngine
Instead of a matrix coordinate identifier, this method should create a fitting calculation job for the derivative with the given AlignmentDerivativeAlgorithm.
createCallableWithAlgorithm(AlignmentDerivativeAlgorithm) - Method in class de.citec.tcs.alignment.ParallelWeightDerivativeEngine
Instead of a matrix coordinate identifier, this method should create a fitting calculation job for the derivative with the given AlignmentDerivativeAlgorithm.
createDelInitial(X, int, double) - Method in class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,0) of the alignment matrix with this method given the entry (i,0).
createDelInitial(SoftPathModel.SoftMatrixEntry, int, double) - Method in class de.citec.tcs.alignment.SoftAlignmentFullAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,0) of the alignment matrix with this method given the entry (i,0).
createDelInitial(SoftPathModel.SoftMatrixEntry, int, double) - Method in class de.citec.tcs.alignment.SoftAlignmentSamplingAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,0) of the alignment matrix with this method given the entry (i,0).
createDelInitial(SoftAlignmentScoreAlgorithm.ScoreEntry, int, double) - Method in class de.citec.tcs.alignment.SoftAlignmentScoreAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,0) of the alignment matrix with this method given the entry (i,0).
createDelInitial(StrictAlignmentFullAlgorithm.FullMatrixEntry, int, double) - Method in class de.citec.tcs.alignment.StrictAlignmentFullAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,0) of the alignment matrix with this method given the entry (i,0).
createDelInitial(StrictAlignmentScoreAlgorithm.ScoreEntry, int, double) - Method in class de.citec.tcs.alignment.StrictAlignmentScoreAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,0) of the alignment matrix with this method given the entry (i,0).
createDelInitial(StrictAllOptimalAlgorithm.FullMatrixEntry, int, double) - Method in class de.citec.tcs.alignment.StrictAllOptimalAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,0) of the alignment matrix with this method given the entry (i,0).
createDelInitial(StrictAllOptimalAlgorithm.FullMatrixEntry, int, double) - Method in class de.citec.tcs.alignment.StrictKPathAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,0) of the alignment matrix with this method given the entry (i,0).
createGenericArray(int, Class<X>) - Static method in class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
This circumvents Javas rule against generic array cration by using reflection.
createGenericMatrix(int, int, Class<X>) - Static method in class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
This circumvents Javas rule against generic array cration by using reflection.
createGenericMatrix(int, int, Class<X>) - Static method in class de.citec.tcs.alignment.parallel.MatrixEngine
This is a helper method that creates an object matrix of the given class.
createInitial() - Method in class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,0) of the alignment matrix with this method.
createInitial() - Method in class de.citec.tcs.alignment.SoftAlignmentFullAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,0) of the alignment matrix with this method.
createInitial() - Method in class de.citec.tcs.alignment.SoftAlignmentSamplingAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,0) of the alignment matrix with this method.
createInitial() - Method in class de.citec.tcs.alignment.SoftAlignmentScoreAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,0) of the alignment matrix with this method.
createInitial() - Method in class de.citec.tcs.alignment.StrictAlignmentFullAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,0) of the alignment matrix with this method.
createInitial() - Method in class de.citec.tcs.alignment.StrictAlignmentScoreAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,0) of the alignment matrix with this method.
createInitial() - Method in class de.citec.tcs.alignment.StrictAllOptimalAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,0) of the alignment matrix with this method.
createInitial() - Method in class de.citec.tcs.alignment.StrictKPathAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,0) of the alignment matrix with this method.
createInsInitial(X, int, double) - Method in class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,j+1) of the alignment matrix with this method given the entry (0,j).
createInsInitial(SoftPathModel.SoftMatrixEntry, int, double) - Method in class de.citec.tcs.alignment.SoftAlignmentFullAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,j+1) of the alignment matrix with this method given the entry (0,j).
createInsInitial(SoftPathModel.SoftMatrixEntry, int, double) - Method in class de.citec.tcs.alignment.SoftAlignmentSamplingAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,j+1) of the alignment matrix with this method given the entry (0,j).
createInsInitial(SoftAlignmentScoreAlgorithm.ScoreEntry, int, double) - Method in class de.citec.tcs.alignment.SoftAlignmentScoreAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,j+1) of the alignment matrix with this method given the entry (0,j).
createInsInitial(StrictAlignmentFullAlgorithm.FullMatrixEntry, int, double) - Method in class de.citec.tcs.alignment.StrictAlignmentFullAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,j+1) of the alignment matrix with this method given the entry (0,j).
createInsInitial(StrictAlignmentScoreAlgorithm.ScoreEntry, int, double) - Method in class de.citec.tcs.alignment.StrictAlignmentScoreAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,j+1) of the alignment matrix with this method given the entry (0,j).
createInsInitial(StrictAllOptimalAlgorithm.FullMatrixEntry, int, double) - Method in class de.citec.tcs.alignment.StrictAllOptimalAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,j+1) of the alignment matrix with this method given the entry (0,j).
createInsInitial(StrictAllOptimalAlgorithm.FullMatrixEntry, int, double) - Method in class de.citec.tcs.alignment.StrictKPathAlgorithm
This method should not be called from outside! The subclass specifies the entry (0,j+1) of the alignment matrix with this method given the entry (0,j).
createNewEntry(X, X, X, int, int, double, double, double) - Method in class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,j+1) of the alignment matrix with this method given the entries (i,j+1) (deletion), (i+1,j) (insertion) and (i,j) (replacement).
createNewEntry(SoftPathModel.SoftMatrixEntry, SoftPathModel.SoftMatrixEntry, SoftPathModel.SoftMatrixEntry, int, int, double, double, double) - Method in class de.citec.tcs.alignment.SoftAlignmentFullAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,j+1) of the alignment matrix with this method given the entries (i,j+1) (deletion), (i+1,j) (insertion) and (i,j) (replacement).
createNewEntry(SoftPathModel.SoftMatrixEntry, SoftPathModel.SoftMatrixEntry, SoftPathModel.SoftMatrixEntry, int, int, double, double, double) - Method in class de.citec.tcs.alignment.SoftAlignmentSamplingAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,j+1) of the alignment matrix with this method given the entries (i,j+1) (deletion), (i+1,j) (insertion) and (i,j) (replacement).
createNewEntry(SoftAlignmentScoreAlgorithm.ScoreEntry, SoftAlignmentScoreAlgorithm.ScoreEntry, SoftAlignmentScoreAlgorithm.ScoreEntry, int, int, double, double, double) - Method in class de.citec.tcs.alignment.SoftAlignmentScoreAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,j+1) of the alignment matrix with this method given the entries (i,j+1) (deletion), (i+1,j) (insertion) and (i,j) (replacement).
createNewEntry(StrictAlignmentFullAlgorithm.FullMatrixEntry, StrictAlignmentFullAlgorithm.FullMatrixEntry, StrictAlignmentFullAlgorithm.FullMatrixEntry, int, int, double, double, double) - Method in class de.citec.tcs.alignment.StrictAlignmentFullAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,j+1) of the alignment matrix with this method given the entries (i,j+1) (deletion), (i+1,j) (insertion) and (i,j) (replacement).
createNewEntry(StrictAlignmentScoreAlgorithm.ScoreEntry, StrictAlignmentScoreAlgorithm.ScoreEntry, StrictAlignmentScoreAlgorithm.ScoreEntry, int, int, double, double, double) - Method in class de.citec.tcs.alignment.StrictAlignmentScoreAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,j+1) of the alignment matrix with this method given the entries (i,j+1) (deletion), (i+1,j) (insertion) and (i,j) (replacement).
createNewEntry(StrictAllOptimalAlgorithm.FullMatrixEntry, StrictAllOptimalAlgorithm.FullMatrixEntry, StrictAllOptimalAlgorithm.FullMatrixEntry, int, int, double, double, double) - Method in class de.citec.tcs.alignment.StrictAllOptimalAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,j+1) of the alignment matrix with this method given the entries (i,j+1) (deletion), (i+1,j) (insertion) and (i,j) (replacement).
createNewEntry(StrictAllOptimalAlgorithm.FullMatrixEntry, StrictAllOptimalAlgorithm.FullMatrixEntry, StrictAllOptimalAlgorithm.FullMatrixEntry, int, int, double, double, double) - Method in class de.citec.tcs.alignment.StrictKPathAlgorithm
This method should not be called from outside! The subclass specifies the entry (i+1,j+1) of the alignment matrix with this method given the entries (i,j+1) (deletion), (i+1,j) (insertion) and (i,j) (replacement).

D

de.citec.tcs.alignment - package de.citec.tcs.alignment
This module defines the interface for AlignmentAlgorithms as well as some helper classes.
de.citec.tcs.alignment.adp - package de.citec.tcs.alignment.adp
This package contains a more general approach to construct AlignmentAlgorithms by relying on the theoretical concept of Algebraic Dynamic Programming (ADP) as developed by Giegerich et al.
de.citec.tcs.alignment.comparators - package de.citec.tcs.alignment.comparators
This module defines the interfaces for comparators in the TCS Alignment Toolbox.
de.citec.tcs.alignment.parallel - package de.citec.tcs.alignment.parallel
This module provides a very basic support for the parallel computing of tasks (Engine class) and entries of a matrix (MatrixEngine).
de.citec.tcs.alignment.sequence - package de.citec.tcs.alignment.sequence
This module contains the sequence datastructure of the TCS Alignment Toolbox.
de.citec.tcs.alignment.visualization - package de.citec.tcs.alignment.visualization
This module contains means to visualize AlignmentPaths.
de.citec.tcs.alignment.wrappers - package de.citec.tcs.alignment.wrappers
This module contains some wrappers to make usage of the TCSAlignmentToolbox easier.
DEFAULT_NUMBER_OF_THREADS - Static variable in class de.citec.tcs.alignment.parallel.Engine
 
DEFAULT_PROGRESS_REPORT_STEP_SIZE - Static variable in class de.citec.tcs.alignment.parallel.CommandLineProgressReporter
 
DEFAULTALPHABET - Static variable in class de.citec.tcs.alignment.wrappers.RandomSequenceGenerator
 
DEFAULTAPPROXTHRESHOLD - Static variable in class de.citec.tcs.alignment.Softmin
This means that softmin arguments with a weight smaller than 10^-3 will be disregarded.
DEFAULTBETA - Static variable in class de.citec.tcs.alignment.SoftAffineAlignmentFullAlgorithm
 
DEFAULTBETA - Static variable in class de.citec.tcs.alignment.SoftAffineAlignmentScoreAlgorithm
 
DEFAULTBETA - Static variable in class de.citec.tcs.alignment.SoftAlignmentFullAlgorithm
 
DEFAULTBETA - Static variable in class de.citec.tcs.alignment.SoftAlignmentSamplingAlgorithm
 
DEFAULTBETA - Static variable in class de.citec.tcs.alignment.SoftAlignmentScoreAlgorithm
 
DEFAULTBETA - Static variable in class de.citec.tcs.alignment.Softmin
 
DEFAULTKEYWORD - Static variable in class de.citec.tcs.alignment.sequence.Sequence
 
DEFAULTPATHLIMIT - Static variable in class de.citec.tcs.alignment.SoftAlignmentSamplingAlgorithm
 
DEFAULTPATHLIMIT - Static variable in class de.citec.tcs.alignment.StrictAllOptimalAlgorithm
 
DEFAULTPATHLIMIT - Static variable in class de.citec.tcs.alignment.StrictKPathAlgorithm
 
Defaults - Class in de.citec.tcs.alignment.comparators
This is a class with convenience methods that provide sensible default comparators for given KeywordSpecifications.
Defaults() - Constructor for class de.citec.tcs.alignment.comparators.Defaults
 
DEFAULTSTRINGLENGTH - Static variable in class de.citec.tcs.alignment.wrappers.RandomSequenceGenerator
 
DEFAULTVECTORIALLENGTH - Static variable in class de.citec.tcs.alignment.wrappers.RandomSequenceGenerator
 
delete(V) - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
This should be called during an alignment to retrieve the costs for a deletion of value a from the first sequence.
delete(X) - Method in interface de.citec.tcs.alignment.comparators.GapComparator
This should be called during an alignment to retrieve the costs for a deletion of value a from the first sequence.
delete(SymbolicValue) - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
This should be called during an alignment to retrieve the costs for a deletion of value a from the first sequence.
delete(V) - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
This should be called during an alignment to retrieve the costs for a deletion of value a from the first sequence.
dependencySort() - Method in class de.citec.tcs.alignment.adp.AffineGrammar
Returns the nonterminals of this grammar sorted according to their dependencies on one another.
dependencySort() - Method in class de.citec.tcs.alignment.adp.FlexibleGrammar
Returns the nonterminals of this grammar sorted according to their dependencies on one another.
dependencySort() - Method in class de.citec.tcs.alignment.adp.GlobalAsymmetricGrammar
Returns the nonterminals of this grammar sorted according to their dependencies on one another.
dependencySort() - Method in class de.citec.tcs.alignment.adp.GlobalGrammar
Returns the nonterminals of this grammar sorted according to their dependencies on one another.
dependencySort() - Method in interface de.citec.tcs.alignment.adp.Grammar
Returns the nonterminals of this grammar sorted according to their dependencies on one another.
DerivableComparator<X extends Value,Y> - Interface in de.citec.tcs.alignment.comparators
This is an interface for comparators that have derivable parameters.
distance(String, String) - Static method in class de.citec.tcs.alignment.comparators.CharStatComparator
This calculates the distance between the two strings a and b calculating for each alphanumeric character (a-z, 0-9) the number of times it occured in both strings at taking the difference of both.
distance(double[], double[]) - Method in class de.citec.tcs.alignment.comparators.EuclideanComparator
Returns the euclidian distance between the vectors a and b, given that they have the same length.
distance(double[], double[]) - Method in class de.citec.tcs.alignment.comparators.L1NormComparator
Returns the L1-distance between the vectors a and b, given that they have the same length.
distance(double[], double[]) - Static method in class de.citec.tcs.alignment.comparators.ZeroNormComparator
Calculates the zero norm distance between both input vectors, which is equivalent to the number of unequal elements.
DPCellId - Class in de.citec.tcs.alignment.adp
This identifies a cell in the dynamic programming tables by the ordinal of the nonterminal symbol, the index in the left sequence (i) and the index in the right sequence (j).
DPCellId(int, int, int) - Constructor for class de.citec.tcs.alignment.adp.DPCellId
 
DTWKernelComparator - Class in de.citec.tcs.alignment.comparators
implements halved gauss-kernel k: k = exp(-1/2sigma^2 * |x-y|^2) /2, with |.| beeing the weighted euclidian distance k is positive definite
DTWKernelComparator(double[]) - Constructor for class de.citec.tcs.alignment.comparators.DTWKernelComparator
 
DTWKernelComparator(double[], double) - Constructor for class de.citec.tcs.alignment.comparators.DTWKernelComparator
 

E

Engine<I extends Comparable<I>,R> - Class in de.citec.tcs.alignment.parallel
This is an abstract parent class to calculate generic jobs in parallel and handle their messages.
Engine(Class<I>, Class<R>) - Constructor for class de.citec.tcs.alignment.parallel.Engine
 
Engine.CalculationResult<I,R> - Class in de.citec.tcs.alignment.parallel
This is a helper class to store results of parallel computations.
Engine.CalculationResult(I, R) - Constructor for class de.citec.tcs.alignment.parallel.Engine.CalculationResult
 
equals(Object) - Method in class de.citec.tcs.alignment.adp.DPCellId
 
equals(Object) - Method in class de.citec.tcs.alignment.adp.ProductionRule
equals(Object) - Method in class de.citec.tcs.alignment.AlignmentPath
equals(Object) - Method in class de.citec.tcs.alignment.AlignmentSpecification
equals(Object) - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
equals(Object) - Method in class de.citec.tcs.alignment.comparators.EuclideanComparator
equals(Object) - Method in class de.citec.tcs.alignment.comparators.ExponentialNormalizer
equals(Object) - Method in class de.citec.tcs.alignment.comparators.HyperbolicNormalizer
equals(Object) - Method in class de.citec.tcs.alignment.comparators.L1NormComparator
equals(Object) - Method in class de.citec.tcs.alignment.comparators.NCDComparator
equals(Object) - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
equals(Object) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
equals(Object) - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
equals(Object) - Method in class de.citec.tcs.alignment.Operation
equals(Object) - Method in class de.citec.tcs.alignment.parallel.MatrixEngine.MatrixCoordinate
equals(Object) - Method in class de.citec.tcs.alignment.sequence.AbstractValue
equals(Object) - Method in class de.citec.tcs.alignment.sequence.IndexingScheme
equals(Object) - Method in class de.citec.tcs.alignment.sequence.KeywordSpecification
equals(Object) - Method in class de.citec.tcs.alignment.sequence.Node
equals(Object) - Method in class de.citec.tcs.alignment.sequence.NodeSpecification
equals(Object) - Method in class de.citec.tcs.alignment.sequence.Sequence
equals(Object) - Method in class de.citec.tcs.alignment.sequence.StringValue
equals(Object) - Method in class de.citec.tcs.alignment.sequence.SymbolicKeywordSpecification
equals(Object) - Method in class de.citec.tcs.alignment.sequence.SymbolicValue
equals(Object) - Method in class de.citec.tcs.alignment.sequence.VectorialKeywordSpecification
equals(Object) - Method in class de.citec.tcs.alignment.sequence.VectorialValue
equals(Object) - Method in class de.citec.tcs.alignment.SparseMatrix
EuclideanComparator - Class in de.citec.tcs.alignment.comparators
Compares vectors using the L2-Norm.
EuclideanComparator(int) - Constructor for class de.citec.tcs.alignment.comparators.EuclideanComparator
 
EuclideanComparator(Normalizer, int) - Constructor for class de.citec.tcs.alignment.comparators.EuclideanComparator
 
EuclideanComparator(int, double) - Constructor for class de.citec.tcs.alignment.comparators.EuclideanComparator
 
EuclideanComparator(Normalizer, int, double) - Constructor for class de.citec.tcs.alignment.comparators.EuclideanComparator
 
EuclideanComparator(VectorialValue, VectorialValue, VectorialValue, VectorialValue) - Constructor for class de.citec.tcs.alignment.comparators.EuclideanComparator
 
EuclideanComparator(Normalizer, VectorialValue, VectorialValue, VectorialValue, VectorialValue) - Constructor for class de.citec.tcs.alignment.comparators.EuclideanComparator
 
ExponentialNormalizer - Class in de.citec.tcs.alignment.comparators
This normalizes by using the function 1-exp(-beta*d)
ExponentialNormalizer(double) - Constructor for class de.citec.tcs.alignment.comparators.ExponentialNormalizer
 
ExponentialNormalizer() - Constructor for class de.citec.tcs.alignment.comparators.ExponentialNormalizer
 
extractNumberOfColumns(R[][]) - Static method in class de.citec.tcs.alignment.parallel.MatrixEngine
Returns the number of columns in the given matrix and checks if the number of columns is consistent, that is: if the given input-array is indeed a matrix.

F

FlexibleGrammar<N extends Enum<N>> - Class in de.citec.tcs.alignment.adp
This is a flexible grammar implementation that allows users to create new grammars at runtime.
FlexibleGrammar(Class<N>, N) - Constructor for class de.citec.tcs.alignment.adp.FlexibleGrammar
 

G

GapAlignmentAlgorithm<R> - Interface in de.citec.tcs.alignment
This is an interface for Alignment algorithms that use gaps (insertion and deletion operations) in the alignment.
GapComparator<X extends Value> - Interface in de.citec.tcs.alignment.comparators
This specifies the comparator interface slightly to include the case that entities might be deleted/inserted.
GAPDEFAULT - Static variable in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
generateSequences(int, int, int) - Static method in class de.citec.tcs.alignment.wrappers.RandomSequenceGenerator
This generates N random sequences of length L each with K keywords.
generateSequences(int, int, NodeSpecification) - Static method in class de.citec.tcs.alignment.wrappers.RandomSequenceGenerator
This generates N random sequences of length L each according to the given NodeSpecification.
generateSpecification(int) - Static method in class de.citec.tcs.alignment.wrappers.RandomSequenceGenerator
This generates an AlignmentSpecification and implicitly a NodeSpecification for K keywords.
get(int, int) - Method in class de.citec.tcs.alignment.SparseMatrix
Returns the value stored at the given position or null if no value was stored there until now.
getAccepting() - Method in class de.citec.tcs.alignment.adp.AffineGrammar
Returns the set of all accepting nonterminals of this grammar.
getAccepting() - Method in class de.citec.tcs.alignment.adp.FlexibleGrammar
Returns the set of all accepting nonterminals of this grammar.
getAccepting() - Method in class de.citec.tcs.alignment.adp.GlobalAsymmetricGrammar
Returns the set of all accepting nonterminals of this grammar.
getAccepting() - Method in class de.citec.tcs.alignment.adp.GlobalGrammar
Returns the set of all accepting nonterminals of this grammar.
getAccepting() - Method in interface de.citec.tcs.alignment.adp.Grammar
Returns the set of all accepting nonterminals of this grammar.
getAdditionalColumns() - Method in class de.citec.tcs.alignment.visualization.HTMLVisualizer
Optionally you may manipulate this list to add or remove additional columns for the HTML table.
getAlgorithm() - Method in class de.citec.tcs.alignment.ParallelProcessingEngine
 
getAllPaths() - Method in class de.citec.tcs.alignment.PathMap
Returns all paths stored in this map in order of their score (from good/low to bad/high).
getAlpha() - Method in class de.citec.tcs.alignment.comparators.HyperbolicNormalizer
 
getAlphabet() - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
getAlphabet() - Method in class de.citec.tcs.alignment.sequence.SymbolicKeywordSpecification
Returns the Alphabet that defines which symbols are allowed for this keyword.
getAlphabet() - Method in class de.citec.tcs.alignment.sequence.SymbolicValue
Returns the Alphabet that defines which symbols are allowed for this keyword.
getApproxThreshold() - Method in class de.citec.tcs.alignment.adp.SoftADPFullAlgorithm
For more information on the ApproxThreshold have a look at the Softmin class.
getApproxThreshold() - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
For more information on the ApproxThreshold have a look at the Softmin class.
getApproxThreshold() - Method in class de.citec.tcs.alignment.adp.SoftADPScoreAlgorithm
For more information on the ApproxThreshold have a look at the Softmin class.
getApproxThreshold() - Method in class de.citec.tcs.alignment.SoftAffineAlignmentFullAlgorithm
For more information on the ApproxThreshold have a look at the Softmin class.
getApproxThreshold() - Method in class de.citec.tcs.alignment.SoftAffineAlignmentScoreAlgorithm
For more information on the ApproxThreshold have a look at the Softmin class.
getApproxThreshold() - Method in class de.citec.tcs.alignment.SoftAlignmentFullAlgorithm
Returns the threshold for which exponents within the softmin function will be disregarded.
getApproxThreshold() - Method in class de.citec.tcs.alignment.SoftAlignmentSamplingAlgorithm
Returns the threshold for which exponents within the softmin function will be disregarded.
getApproxThreshold() - Method in class de.citec.tcs.alignment.SoftAlignmentScoreAlgorithm
For more information on the ApproxThreshold have a look at the Softmin class.
getAxiom() - Method in class de.citec.tcs.alignment.adp.AffineGrammar
Returns the axiom of this grammar.
getAxiom() - Method in class de.citec.tcs.alignment.adp.FlexibleGrammar
Returns the axiom of this grammar.
getAxiom() - Method in class de.citec.tcs.alignment.adp.GlobalAsymmetricGrammar
Returns the axiom of this grammar.
getAxiom() - Method in class de.citec.tcs.alignment.adp.GlobalGrammar
Returns the axiom of this grammar.
getAxiom() - Method in interface de.citec.tcs.alignment.adp.Grammar
Returns the axiom of this grammar.
getBeta() - Method in class de.citec.tcs.alignment.adp.SoftADPFullAlgorithm
 
getBeta() - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
Returns the parameter defining the "softness" of the alignment.
getBeta() - Method in class de.citec.tcs.alignment.adp.SoftADPScoreAlgorithm
Returns the parameter defining the "softness" of the alignment.
getBeta() - Method in class de.citec.tcs.alignment.comparators.ExponentialNormalizer
 
getBeta() - Method in class de.citec.tcs.alignment.SoftAffineAlignmentFullAlgorithm
Returns the parameter defining the "softness" of the alignment.
getBeta() - Method in class de.citec.tcs.alignment.SoftAffineAlignmentScoreAlgorithm
Returns the parameter defining the "softness" of the alignment.
getBeta() - Method in class de.citec.tcs.alignment.SoftAffinePathModel
Returns the parameter defining the "softness" of the alignment.
getBeta() - Method in class de.citec.tcs.alignment.SoftAlignmentFullAlgorithm
 
getBeta() - Method in class de.citec.tcs.alignment.SoftAlignmentSamplingAlgorithm
 
getBeta() - Method in class de.citec.tcs.alignment.SoftAlignmentScoreAlgorithm
 
getBeta() - Method in class de.citec.tcs.alignment.SoftPathModel
The parameter defining the "softness" of the alignment.
getComparator(String) - Method in class de.citec.tcs.alignment.AlignmentSpecification
Returns the Comparator that is currently set for the given keyword.
getComparator(int) - Method in class de.citec.tcs.alignment.AlignmentSpecification
Returns the Comparator that is currently set for the given keyword.
getComparatorDistances() - Method in class de.citec.tcs.alignment.Operation
Returns the local costs given by the Comparators specified for this Alignment to align the left Node in this Operation with the right Node (or deleting, inserting, skipping nodes respectively).
getCompareMatrix() - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
Returns the matrix of comparison costs between both input sequences.
getCompareMatrix() - Method in class de.citec.tcs.alignment.SoftAffinePathModel
Returns the matrix of comparison costs between both input sequences.
getCompressor() - Method in class de.citec.tcs.alignment.comparators.NCDComparator
 
getCostMatrix() - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
Returns the ReplacementCosts object that defines the explicit cost matrix for replacements between the symbols in the given alphabet.
getCostMatrix() - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
Returns the cost matrix itself.
getCSS() - Method in class de.citec.tcs.alignment.visualization.AbstractHTMLColumn
This default implementation returns an empty string.
getCSS() - Method in interface de.citec.tcs.alignment.visualization.HTMLColumn
This method should return CSS code containing styling rules for this column.
getCSS() - Method in class de.citec.tcs.alignment.visualization.SourceCodeColumn
This default implementation returns an empty string.
getDecimalPlaces() - Method in class de.citec.tcs.alignment.visualization.HTMLVisualizer
This specifies how many decimal places (after comma) should be visualized.
getDefaultComparator(KeywordSpecification) - Static method in class de.citec.tcs.alignment.comparators.Defaults
Returns a sensible default comparator for the given KeywordSpecification.
getDefaultComparators(KeywordSpecification[]) - Static method in class de.citec.tcs.alignment.comparators.Defaults
Returns sensible default comparators for the given KeywordSpecifications.
getDefaultComparators(NodeSpecification) - Static method in class de.citec.tcs.alignment.comparators.Defaults
Returns sensible default comparators for the given NodeSpecification, one for each contained KeywordSpecification.
getDelCosts() - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
getDeleteComparison() - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
Returns the comparison value that is used to compute the cost of deletions if the dynamic flag is set to true.
getDeletionCost(String) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
getDeletionCost() - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
Returns the (constant) cost for deleting a value.
getDeletionCosts() - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
Returns all deletion costs without any other costs.
getDeletionMatrix() - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
Returns the vector of deletion costs.
getDeletionMatrix() - Method in class de.citec.tcs.alignment.SoftAffinePathModel
Returns the vector of deletion costs.
getDelLocal() - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
getDelLocal() - Method in class de.citec.tcs.alignment.StrictAllOptimalAlgorithm.FullMatrixEntry
 
getDelProb() - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
getDelSoftDerivative() - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
getDerivative() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.SparseDeriativeEntry
 
getDifference(AlignmentPath) - Static method in class de.citec.tcs.alignment.wrappers.VectorialSequences
Returns the difference at each operation of the given AlignmentPath.
getDistance() - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
Returns the distance between the two input sequences of this Derivative.
getDistance() - Method in interface de.citec.tcs.alignment.AlignmentDerivativeAlgorithm
Returns the distance between the two input sequences of this Derivative.
getDistance() - Method in class de.citec.tcs.alignment.AlignmentPath
Returns the distance between the two input sequences of this Derivative.
getDistance() - Method in class de.citec.tcs.alignment.PathList
Returns the average distance of all stored paths.
getDistance() - Method in class de.citec.tcs.alignment.PathMap
Returns the average distance of all stored paths.
getDistance() - Method in class de.citec.tcs.alignment.SoftAffinePathModel
Returns the distance between the two input sequences of this Derivative.
getDistance() - Method in class de.citec.tcs.alignment.SoftDTWModel
Returns the distance between the two input sequences of this Derivative.
getDistance() - Method in class de.citec.tcs.alignment.SoftPathModel
Returns the distance between the two input sequences of this Derivative.
getDoubleResultMatrix() - Method in class de.citec.tcs.alignment.parallel.MatrixEngine
Returns the results of the calculation as a primitive double matrix.
getDp_tables() - Method in class de.citec.tcs.alignment.SoftAffinePathModel
Returns the dynamic programming tables that constitute the (soft) affine alignment of both input sequences.
getDpTables() - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
Returns the dynamic programming tables that constitute the soft alignment of both input sequences.
getEntryClass() - Method in class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
Returns the class of matrix entries.
getExtensions(AlignmentPath) - Static method in class de.citec.tcs.alignment.wrappers.VectorialSequences
Returns the sequence extensions modelled by this AlignmentPath.
getGenericClass(Grammar<N>) - Static method in class de.citec.tcs.alignment.adp.SoftADPPathModel
Returns the generic class of a SoftADPPathModel given a grammar.
getGrammar() - Method in class de.citec.tcs.alignment.adp.AbstractADPAlgorithm
Returns the ADP grammar that is used as basis of this ADPAlgorithm.
getGrammar() - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
Returns the ADP grammar that was used to compute this SoftADPPathModel.
getHTML(Operation) - Method in interface de.citec.tcs.alignment.visualization.HTMLColumn
This method should return one or multiple td-tags (corresponding to the return value of getNumColumns()) containing the additional information for the given alignment Operation.
getHTML(Operation) - Method in class de.citec.tcs.alignment.visualization.SourceCodeColumn
This method should return one or multiple td-tags (corresponding to the return value of getNumColumns()) containing the additional information for the given alignment Operation.
getHTML(Operation) - Method in class de.citec.tcs.alignment.visualization.ValueColumn
This method should return one or multiple td-tags (corresponding to the return value of getNumColumns()) containing the additional information for the given alignment Operation.
getI() - Method in class de.citec.tcs.alignment.StrictAlignmentFullAlgorithm.FullMatrixEntry
 
getI() - Method in class de.citec.tcs.alignment.StrictAllOptimalAlgorithm.FullMatrixEntry
 
getIdentClass() - Method in class de.citec.tcs.alignment.parallel.Engine
Returns the class of objects to identify jobs for this Engine.
getInsCosts() - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
getInsertComparison() - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
Returns the comparison value that is used to compute the cost of insertions if the dynamic flag is set to true.
getInsertionCost(String) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
getInsertionCost() - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
Returns the (constant) cost for inserting a value.
getInsertionCosts() - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
Returns all insertion costs without any other costs.
getInsertionMatrix() - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
Returns the vector of insertion costs.
getInsertionMatrix() - Method in class de.citec.tcs.alignment.SoftAffinePathModel
Returns the vector of insertion costs.
getInsLocal() - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
getInsLocal() - Method in class de.citec.tcs.alignment.StrictAllOptimalAlgorithm.FullMatrixEntry
 
getInsProb() - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
getInsSoftDerivative() - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
getJ() - Method in class de.citec.tcs.alignment.StrictAlignmentFullAlgorithm.FullMatrixEntry
 
getJ() - Method in class de.citec.tcs.alignment.StrictAllOptimalAlgorithm.FullMatrixEntry
 
getJS() - Method in class de.citec.tcs.alignment.visualization.AbstractHTMLColumn
This default implementation returns an empty string.
getJS() - Method in interface de.citec.tcs.alignment.visualization.HTMLColumn
This method should return JavaScript containing code relevant for this column.
getKey() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.SparseDeriativeEntry
 
getKeyword(int) - Method in class de.citec.tcs.alignment.sequence.IndexingScheme
Returns the keyword for the given index.
getKeyword() - Method in class de.citec.tcs.alignment.sequence.KeywordSpecification
Returns the keyword.
getKeyword() - Method in class de.citec.tcs.alignment.visualization.AbstractHTMLColumn
This method should return the keyword of this column.
getKeyword() - Method in interface de.citec.tcs.alignment.visualization.HTMLColumn
This method should return the keyword of this column.
getKeywordIndex(String) - Method in class de.citec.tcs.alignment.sequence.IndexingScheme
Returns the index of the given keyword.
getKeywords() - Method in class de.citec.tcs.alignment.sequence.IndexingScheme
Returns the keywords that are mapped.
getKeywords() - Method in class de.citec.tcs.alignment.visualization.HTMLVisualizer
Optionally you may manipulate this set to restrict the keywords for which the HTMLVisualizer will print columns in the html table.
getKeywordSpecification(String) - Method in class de.citec.tcs.alignment.sequence.NodeSpecification
Returns the specification for the given keyword.
getKeywordSpecification(int) - Method in class de.citec.tcs.alignment.sequence.NodeSpecification
Returns the specification for the given keyword.
getKeywordSpecifications() - Method in class de.citec.tcs.alignment.sequence.NodeSpecification
 
getLastAlignmentMatrix() - Method in class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
The last matrix that was calculated using this algorithm.
getLastDTWMatrix() - Method in class de.citec.tcs.alignment.AbstractStrictDTWAlgorithm
This returns the dynamic programming matrix that was calculated in the last call of calculateAlignment.
getLeft() - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
Returns the left sequence of this derivative.
getLeft() - Method in interface de.citec.tcs.alignment.AlignmentDerivativeAlgorithm
Returns the left sequence of this derivative.
getLeft() - Method in class de.citec.tcs.alignment.AlignmentPath
Returns the left sequence of this derivative.
getLeft() - Method in class de.citec.tcs.alignment.Operation
 
getLeft() - Method in class de.citec.tcs.alignment.PathList
Returns the left sequence of this derivative.
getLeft() - Method in class de.citec.tcs.alignment.PathMap
Returns the left sequence of this derivative.
getLeft() - Method in class de.citec.tcs.alignment.SoftAffinePathModel
Returns the left sequence of this derivative.
getLeft() - Method in class de.citec.tcs.alignment.SoftDTWModel
Returns the left sequence of this derivative.
getLeft() - Method in class de.citec.tcs.alignment.SoftPathModel
Returns the left sequence of this derivative.
getLength() - Method in class de.citec.tcs.alignment.sequence.VectorialKeywordSpecification
The length all vectors for this keyword have to have.
getM() - Method in class de.citec.tcs.alignment.parallel.MatrixEngine
Returns the number of rows in the matrix.
getMatchCost() - Method in class de.citec.tcs.alignment.comparators.TrivialEditComparator
Returns the cost for matches (0 per default).
getMax() - Method in class de.citec.tcs.alignment.comparators.AffineNormalizer
Returns the maximum possible value, which will be mapped to 1.
getMin() - Method in class de.citec.tcs.alignment.comparators.AffineNormalizer
Returns the minimum possible value, which will be mapped to 0.
getMinMiddleSkips() - Method in class de.citec.tcs.alignment.AbstractAffineAlignmentAlgorithm
The minimum number of skips that have to be done in the middle of an alignment.
getMinMiddleSkips() - Method in class de.citec.tcs.alignment.adp.AffineGrammar
Returns the minimum number of skip operations that are required for a skip-region in the middle to be permitted.
getMinMiddleSkips() - Method in class de.citec.tcs.alignment.SoftAffinePathModel
The minimum number of skips that have to be done in the middle of an alignment.
getMismatchCost() - Method in class de.citec.tcs.alignment.comparators.TrivialEditComparator
Returns the cost for mismatches (1 per default).
getN() - Method in class de.citec.tcs.alignment.parallel.MatrixEngine
Returns the number of columns in the matrix.
getNodes() - Method in class de.citec.tcs.alignment.sequence.Sequence
Returns the actual list of nodes.
getNodeSpecification() - Method in class de.citec.tcs.alignment.AlignmentSpecification
 
getNodeSpecification() - Method in class de.citec.tcs.alignment.sequence.Sequence
Returns the NodeSpecification all Nodes in this sequence belong to.
getNonterminal() - Method in class de.citec.tcs.alignment.adp.ProductionRule
Returns the target nonterminal symbol of this rule.
getNonterminalClass() - Method in class de.citec.tcs.alignment.adp.AffineGrammar
Returns the enum class that lists the nonterminal symbols of this grammar.
getNonterminalClass() - Method in class de.citec.tcs.alignment.adp.FlexibleGrammar
Returns the enum class that lists the nonterminal symbols of this grammar.
getNonterminalClass() - Method in class de.citec.tcs.alignment.adp.GlobalAsymmetricGrammar
Returns the enum class that lists the nonterminal symbols of this grammar.
getNonterminalClass() - Method in class de.citec.tcs.alignment.adp.GlobalGrammar
Returns the enum class that lists the nonterminal symbols of this grammar.
getNonterminalClass() - Method in interface de.citec.tcs.alignment.adp.Grammar
Returns the enum class that lists the nonterminal symbols of this grammar.
getNormalizer() - Method in class de.citec.tcs.alignment.comparators.EuclideanComparator
Please refer to the corresponding setter method for more information.
getNormalizer() - Method in class de.citec.tcs.alignment.comparators.L1NormComparator
Please refer to the corresponding setter method for more information.
getNumberOfComparisonParameters() - Method in class de.citec.tcs.alignment.comparators.CharStatComparator
Implementing classes should return the number of (derivative-relevant) parameters used for the compare-function.
getNumberOfComparisonParameters() - Method in class de.citec.tcs.alignment.comparators.EuclideanComparator
Implementing classes should return the number of (derivative-relevant) parameters used for the compare-function.
getNumberOfComparisonParameters() - Method in class de.citec.tcs.alignment.comparators.L1NormComparator
Implementing classes should return the number of (derivative-relevant) parameters used for the compare-function.
getNumberOfComparisonParameters() - Method in class de.citec.tcs.alignment.comparators.NCDComparator
Implementing classes should return the number of (derivative-relevant) parameters used for the compare-function.
getNumberOfComparisonParameters() - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
Implementing classes should return the number of (derivative-relevant) parameters used for the compare-function.
getNumberOfComparisonParameters() - Method in class de.citec.tcs.alignment.comparators.TrivialEditComparator
Implementing classes should return the number of (derivative-relevant) parameters used for the compare-function.
getNumberOfComparisonParameters() - Method in class de.citec.tcs.alignment.comparators.ZeroNormComparator
Implementing classes should return the number of (derivative-relevant) parameters used for the compare-function.
getNumberOfParameters() - Method in interface de.citec.tcs.alignment.comparators.DerivableComparator
This shall return the number of parameters of this comparator.
getNumberOfParameters() - Method in class de.citec.tcs.alignment.comparators.DTWKernelComparator
 
getNumberOfParameters() - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
This shall return the number of parameters of this comparator.
getNumberOfParameters() - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
This shall return the number of parameters of this comparator.
getNumberOfThreads() - Method in class de.citec.tcs.alignment.parallel.Engine
Returns the number of threads that are used for computation (16 per default).
getNumColumns() - Method in interface de.citec.tcs.alignment.visualization.HTMLColumn
This method should return the number of HTML columns occupied by this column.
getNumColumns() - Method in class de.citec.tcs.alignment.visualization.SourceCodeColumn
This method should return the number of HTML columns occupied by this column.
getNumColumns() - Method in class de.citec.tcs.alignment.visualization.ValueColumn
This method should return the number of HTML columns occupied by this column.
getOperations() - Method in class de.citec.tcs.alignment.adp.ProductionRule
Returns the operations that are applied in this production rule.
getOperations() - Method in class de.citec.tcs.alignment.AlignmentPath
 
getOriginalIndex(int) - Method in class de.citec.tcs.alignment.AlignmentSpecification
This is semantically equivalent to getNodeSpecification().getKeywordIndex(getKeyword(index)) but this is preprocessed here for better performance.
getParameterIndex() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.SparseDeriativeEntry
 
getPath() - Method in class de.citec.tcs.alignment.Operation
 
getPathLimit() - Method in class de.citec.tcs.alignment.SoftAlignmentSamplingAlgorithm
Returns the the number of paths that shall be sampled.
getPathLimit() - Method in class de.citec.tcs.alignment.StrictAllOptimalAlgorithm
Please refer to the corresponding setter-method for more information.
getPathLimit() - Method in class de.citec.tcs.alignment.StrictKPathAlgorithm
Please refer to the corresponding setter method for more calculation.
getPathMatrix() - Method in class de.citec.tcs.alignment.SoftPathModel
This is the dynamic programming matrix calculated by a SoftAlignmentAlgorithm.
getPaths(double) - Method in class de.citec.tcs.alignment.PathMap
Returns all paths with the given score.
getPossibleRules(AffineGrammar.Nonterminal, int, int) - Method in class de.citec.tcs.alignment.adp.AffineGrammar
Returns all production rules of this grammar that can be applied in the current situation.
getPossibleRules(N, int, int) - Method in class de.citec.tcs.alignment.adp.FlexibleGrammar
Returns all production rules of this grammar that can be applied in the current situation.
getPossibleRules(GlobalAsymmetricGrammar.Nonterminal, int, int) - Method in class de.citec.tcs.alignment.adp.GlobalAsymmetricGrammar
Returns all production rules of this grammar that can be applied in the current situation.
getPossibleRules(GlobalGrammar.Nonterminal, int, int) - Method in class de.citec.tcs.alignment.adp.GlobalGrammar
Returns all production rules of this grammar that can be applied in the current situation.
getPossibleRules(N, int, int) - Method in interface de.citec.tcs.alignment.adp.Grammar
Returns all production rules of this grammar that can be applied in the current situation.
getPredecessor() - Method in class de.citec.tcs.alignment.StrictAlignmentFullAlgorithm.FullMatrixEntry
 
getPreferredCooptimal() - Method in class de.citec.tcs.alignment.StrictAffineAlignmentFullAlgorithm
This allows to specify an order in which operations shall be preferred if cooptimal alignments occur.
getProgressReportStepSize() - Method in class de.citec.tcs.alignment.parallel.CommandLineProgressReporter
Returns the percent of computation that have to be completed until a new notification is written to the command line.
getProperty(String) - Static method in class de.citec.tcs.alignment.visualization.HTMLVisualizer
 
getRepCosts() - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
getReplacementCost(String, String) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
getReplacementCosts() - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
Returns the whole matrix of replacement costs without gap and skip costs.
getRepLocal() - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
getRepLocal() - Method in class de.citec.tcs.alignment.StrictAllOptimalAlgorithm.FullMatrixEntry
 
getReporter() - Method in class de.citec.tcs.alignment.parallel.Engine
Returns the ProgressReporter that is used to report progress.
getRepProb() - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
getRepSoftDerivative() - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
getResultClass() - Method in class de.citec.tcs.alignment.AbstractAffineAlignmentAlgorithm
This method shall return the class of the alignment result.
getResultClass() - Method in class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
This method shall return the class of the alignment result.
getResultClass() - Method in class de.citec.tcs.alignment.AbstractStrictDTWAlgorithm
This method shall return the class of the alignment result.
getResultClass() - Method in class de.citec.tcs.alignment.adp.AbstractADPAlgorithm
This method shall return the class of the alignment result.
getResultClass() - Method in interface de.citec.tcs.alignment.AlignmentAlgorithm
This method shall return the class of the alignment result.
getResultClass() - Method in interface de.citec.tcs.alignment.comparators.DerivableComparator
Returns the class of the intuitive format of the derivatives for all parameters of this comparator.
getResultClass() - Method in class de.citec.tcs.alignment.comparators.DTWKernelComparator
 
getResultClass() - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
Returns the class of the intuitive format of the derivatives for all parameters of this comparator.
getResultClass() - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
 
getResultClass() - Method in class de.citec.tcs.alignment.KernelDTWFullAlgorithm
This method shall return the class of the alignment result.
getResultClass() - Method in class de.citec.tcs.alignment.parallel.Engine
Returns the class of result objects of jobs in this Engine.
getResultMatrix() - Method in class de.citec.tcs.alignment.parallel.MatrixEngine
Returns the results of the calculation as an object matrix.
getResults() - Method in class de.citec.tcs.alignment.parallel.Engine
Returns the results of this Engines last computation.
getRGBColor(double) - Static method in class de.citec.tcs.alignment.visualization.HTMLVisualizer
Returns an hexadecimal rgb color string for the given score.
getRight() - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
Returns the right sequence of this derivative.
getRight() - Method in interface de.citec.tcs.alignment.AlignmentDerivativeAlgorithm
Returns the right sequence of this derivative.
getRight() - Method in class de.citec.tcs.alignment.AlignmentPath
Returns the right sequence of this derivative.
getRight() - Method in class de.citec.tcs.alignment.Operation
 
getRight() - Method in class de.citec.tcs.alignment.PathList
Returns the right sequence of this derivative.
getRight() - Method in class de.citec.tcs.alignment.PathMap
Returns the right sequence of this derivative.
getRight() - Method in class de.citec.tcs.alignment.SoftAffinePathModel
Returns the right sequence of this derivative.
getRight() - Method in class de.citec.tcs.alignment.SoftDTWModel
Returns the right sequence of this derivative.
getRight() - Method in class de.citec.tcs.alignment.SoftPathModel
Returns the right sequence of this derivative.
getRoundedString(double, int) - Static method in class de.citec.tcs.alignment.visualization.HTMLVisualizer
Returns the string representation of the given number to the given precision.
getRules() - Method in class de.citec.tcs.alignment.adp.FlexibleGrammar
Returns all production rules that are stored in this grammar.
getScore() - Method in class de.citec.tcs.alignment.SoftAlignmentScoreAlgorithm.ScoreEntry
 
getScore() - Method in class de.citec.tcs.alignment.StrictAlignmentFullAlgorithm.FullMatrixEntry
 
getScore() - Method in class de.citec.tcs.alignment.StrictAlignmentScoreAlgorithm.ScoreEntry
 
getScore() - Method in class de.citec.tcs.alignment.StrictAllOptimalAlgorithm.FullMatrixEntry
 
getScores() - Method in class de.citec.tcs.alignment.PathMap
Get all scores for which paths exist within this map.
getSequence() - Method in class de.citec.tcs.alignment.sequence.Node
Returns the sequence this node belongs to.
getSequences() - Method in class de.citec.tcs.alignment.ParallelProcessingEngine
 
getSigma() - Method in class de.citec.tcs.alignment.comparators.DTWKernelComparator
 
getSimilarityMatrix() - Method in class de.citec.tcs.alignment.SoftDTWModel
This is the dynamic programming matrix calculated by a DynamicTimeWarpingAlgorithm.
getSimilarityScore() - Method in class de.citec.tcs.alignment.SoftDTWModel
Returns the softDTW score between the two input sequences.
getSize() - Method in class de.citec.tcs.alignment.PathMap
Returns the number of paths stored in this map.
getSkipDeleteComparison() - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
Returns the comparison value that is used to compute the cost of skip-deletions if the dynamic flag is set to true.
getSkipDeletionCost(String) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
getSkipDeletionCost() - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
Returns the (constant) cost for deleting a value using a skip.
getSkipDeletionCosts() - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
Returns all skip deletion costs without any other costs.
getSkipDeletionMatrix() - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
Returns the vector of skip-deletion costs.
getSkipDeletionMatrix() - Method in class de.citec.tcs.alignment.SoftAffinePathModel
Returns the vector of skip-deletion costs.
getSkipFactor() - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
Returns the cost factor for skipDeletions and skipInsertions for a dynamic comparison.
getSkipInsertComparison() - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
Returns the comparison value that is used to compute the cost of skip-insertions if the dynamic flag is set to true.
getSkipInsertionCost(String) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
getSkipInsertionCost() - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
Returns the (constant) cost for inserting a value using a skip.
getSkipInsertionCosts() - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
Returns all skip insertion costs without any other costs.
getSkipInsertionMatrix() - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
Returns the vector of skip-insertion costs.
getSkipInsertionMatrix() - Method in class de.citec.tcs.alignment.SoftAffinePathModel
Returns the vector of skip-insertion costs.
getSoftmin() - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
getSpecification() - Method in class de.citec.tcs.alignment.AbstractAffineAlignmentAlgorithm
This should return the specification that is used for this Algorithm.
getSpecification() - Method in class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
This should return the specification that is used for this Algorithm.
getSpecification() - Method in class de.citec.tcs.alignment.AbstractStrictDTWAlgorithm
This should return the specification that is used for this Algorithm.
getSpecification() - Method in class de.citec.tcs.alignment.adp.AbstractADPAlgorithm
This should return the specification that is used for this Algorithm.
getSpecification() - Method in class de.citec.tcs.alignment.adp.SoftADPPathModel
Returns the AlignmentSpecification that was used to compute this SoftAffinePathModel.
getSpecification() - Method in interface de.citec.tcs.alignment.AlignmentAlgorithm
This should return the specification that is used for this Algorithm.
getSpecification() - Method in class de.citec.tcs.alignment.KernelDTWFullAlgorithm
 
getSpecification() - Method in class de.citec.tcs.alignment.SoftAffinePathModel
Returns the AlignmentSpecification that was used to compute this SoftAffinePathModel.
getSpecification() - Method in class de.citec.tcs.alignment.SoftPathModel
Returns the AlignmentSpecification that was basis for this Alignment.
getSpecificationClass() - Method in enum de.citec.tcs.alignment.sequence.ValueType
Returns the corresponding specification class for this ValueType.
getSpecificaton() - Method in class de.citec.tcs.alignment.AlignmentPath
 
getSpecificaton() - Method in class de.citec.tcs.alignment.SoftDTWModel
Returns the AlignmentSpecification that was basis for this Alignment.
getSteps() - Method in class de.citec.tcs.alignment.parallel.CommandLineProgressReporter
Returns the number of steps that already have been completed.
getSteps() - Method in interface de.citec.tcs.alignment.parallel.ProgressReporter
Returns the number of steps that already have been completed.
getString() - Method in class de.citec.tcs.alignment.sequence.StringValue
Returns the actual string.
getSymbol(int) - Method in class de.citec.tcs.alignment.sequence.Alphabet
This is equivalent to "getKeyword"
getSymbol() - Method in class de.citec.tcs.alignment.sequence.SymbolicValue
Returns this actual symbol.
getSymbolIndex(String) - Method in class de.citec.tcs.alignment.sequence.Alphabet
This is equivalent to "getKeywordIndex"
getSymbols() - Method in class de.citec.tcs.alignment.sequence.Alphabet
This is equivalent to "getKeywords"
getTabSize() - Method in class de.citec.tcs.alignment.visualization.SourceCodeColumn
Returns as how many characters a tab should be counted.
getTotalSteps() - Method in class de.citec.tcs.alignment.parallel.CommandLineProgressReporter
Returns the total number of steps that are necessary to complete the overall task.
getTotalSteps() - Method in interface de.citec.tcs.alignment.parallel.ProgressReporter
Returns the total number of steps that are necessary to complete the overall task.
getType() - Method in class de.citec.tcs.alignment.comparators.CharStatComparator
getType() - Method in interface de.citec.tcs.alignment.comparators.Comparator
 
getType() - Method in class de.citec.tcs.alignment.comparators.DTWKernelComparator
 
getType() - Method in class de.citec.tcs.alignment.comparators.EuclideanComparator
getType() - Method in class de.citec.tcs.alignment.comparators.L1NormComparator
getType() - Method in class de.citec.tcs.alignment.comparators.NCDComparator
getType() - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
getType() - Method in class de.citec.tcs.alignment.comparators.TrivialEditComparator
getType() - Method in class de.citec.tcs.alignment.comparators.ZeroNormComparator
getType() - Method in class de.citec.tcs.alignment.Operation
 
getType() - Method in class de.citec.tcs.alignment.sequence.AbstractValue
Returns the type of this value.
getType() - Method in class de.citec.tcs.alignment.sequence.KeywordSpecification
Returns the specified type for that keyword.
getType() - Method in interface de.citec.tcs.alignment.sequence.Value
Returns the type of this value.
getValue() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.SparseDeriativeEntry
 
getValue(String) - Method in class de.citec.tcs.alignment.sequence.Node
Returns the value stored in this Node for the given keyword or null of no value is stored for the given keyword in this node.
getValue(int) - Method in class de.citec.tcs.alignment.sequence.Node
Returns the value stored in this Node for the given keyword or null of no value is stored for the given keyword in this node.
getValueClass() - Method in enum de.citec.tcs.alignment.sequence.ValueType
The corresponding class of this ValueType.
getVector() - Method in class de.citec.tcs.alignment.sequence.VectorialValue
Returns the actual vector.
getVisualizationData(AlignmentPath) - Method in class de.citec.tcs.alignment.visualization.AbstractVisualizer
Returns the visualization as string.
getWeightedLocalCost() - Method in class de.citec.tcs.alignment.Operation
 
getWeighting() - Method in class de.citec.tcs.alignment.AlignmentSpecification
Returns the current keyword weighting.
getWeighting() - Method in class de.citec.tcs.alignment.PathMap
Returns the weighting that is used during derivative calculation.
getWeightThreshold() - Method in class de.citec.tcs.alignment.AbstractAffineAlignmentAlgorithm
 
getWeightThreshold() - Method in class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
 
getWeightThreshold() - Method in class de.citec.tcs.alignment.AbstractStrictDTWAlgorithm
 
getWeightThreshold() - Method in class de.citec.tcs.alignment.adp.AbstractADPAlgorithm
 
GlobalAsymmetricGrammar - Class in de.citec.tcs.alignment.adp
This is a slight variation of the global alignment grammar.
GlobalAsymmetricGrammar() - Constructor for class de.citec.tcs.alignment.adp.GlobalAsymmetricGrammar
Creates an instance of the global, asymmetric grammar.
GlobalAsymmetricGrammar.Nonterminal - Enum in de.citec.tcs.alignment.adp
 
GlobalGrammar - Class in de.citec.tcs.alignment.adp
This is the most basic (and classic) alignment grammar there is.
GlobalGrammar() - Constructor for class de.citec.tcs.alignment.adp.GlobalGrammar
This creates an instance of the global alignment grammar.
GlobalGrammar.Nonterminal - Enum in de.citec.tcs.alignment.adp
 
Grammar<N extends Enum<N>> - Interface in de.citec.tcs.alignment.adp
An Algebraic Dynamic Programming (ADP) grammar is a regular tree grammar.
GrammarValidityException - Exception in de.citec.tcs.alignment.adp
This exception is thrown if a flexible grammar is invalid.
GrammarValidityException(String) - Constructor for exception de.citec.tcs.alignment.adp.GrammarValidityException
 

H

hashCode() - Method in class de.citec.tcs.alignment.adp.DPCellId
 
hashCode() - Method in class de.citec.tcs.alignment.adp.ProductionRule
hashCode() - Method in class de.citec.tcs.alignment.AlignmentPath
hashCode() - Method in class de.citec.tcs.alignment.AlignmentSpecification
hashCode() - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
hashCode() - Method in class de.citec.tcs.alignment.comparators.EuclideanComparator
hashCode() - Method in class de.citec.tcs.alignment.comparators.ExponentialNormalizer
hashCode() - Method in class de.citec.tcs.alignment.comparators.HyperbolicNormalizer
hashCode() - Method in class de.citec.tcs.alignment.comparators.L1NormComparator
hashCode() - Method in class de.citec.tcs.alignment.comparators.NCDComparator
hashCode() - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
hashCode() - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
hashCode() - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
hashCode() - Method in class de.citec.tcs.alignment.Operation
hashCode() - Method in class de.citec.tcs.alignment.parallel.MatrixEngine.MatrixCoordinate
hashCode() - Method in class de.citec.tcs.alignment.sequence.AbstractValue
hashCode() - Method in class de.citec.tcs.alignment.sequence.IndexingScheme
hashCode() - Method in class de.citec.tcs.alignment.sequence.KeywordSpecification
hashCode() - Method in class de.citec.tcs.alignment.sequence.Node
hashCode() - Method in class de.citec.tcs.alignment.sequence.NodeSpecification
hashCode() - Method in class de.citec.tcs.alignment.sequence.Sequence
hashCode() - Method in class de.citec.tcs.alignment.sequence.StringValue
hashCode() - Method in class de.citec.tcs.alignment.sequence.SymbolicKeywordSpecification
hashCode() - Method in class de.citec.tcs.alignment.sequence.SymbolicValue
hashCode() - Method in class de.citec.tcs.alignment.sequence.VectorialKeywordSpecification
hashCode() - Method in class de.citec.tcs.alignment.sequence.VectorialValue
hashCode() - Method in class de.citec.tcs.alignment.SparseMatrix
hasKeyword(String) - Method in class de.citec.tcs.alignment.sequence.IndexingScheme
Returns true if and only if this keyword is contained in the mapping.
hasNext() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.EmptySparseLocalEntry
hasNext() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.FixedSparseLocalDerivative
hasNext() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.TrivialSparseLocalDerivative
hasSymbol(String) - Method in class de.citec.tcs.alignment.sequence.Alphabet
This is equivalent to "hasKeyword".
highestScore() - Method in class de.citec.tcs.alignment.PathMap
Returns the highest/worst score stored in this map.
HTMLColumn - Interface in de.citec.tcs.alignment.visualization
This is an interface for classes that provide additional information for the HTML output in form of additional columns for the HTML table.
HTMLVisualizer - Class in de.citec.tcs.alignment.visualization
This creates an HTML table visualization of an AlignmentPath.
HTMLVisualizer() - Constructor for class de.citec.tcs.alignment.visualization.HTMLVisualizer
 
HyperbolicNormalizer - Class in de.citec.tcs.alignment.comparators
This normalizes by using the function 1 - 1/(alpha*d+1).
HyperbolicNormalizer() - Constructor for class de.citec.tcs.alignment.comparators.HyperbolicNormalizer
 

I

i - Variable in class de.citec.tcs.alignment.adp.DPCellId
 
i - Variable in class de.citec.tcs.alignment.parallel.MatrixEngine.MatrixCoordinate
 
ident - Variable in class de.citec.tcs.alignment.parallel.Engine.CalculationResult
 
incrementSteps() - Method in class de.citec.tcs.alignment.parallel.CommandLineProgressReporter
 
incrementSteps() - Method in interface de.citec.tcs.alignment.parallel.ProgressReporter
Notes that one additional step has been completed.
IndexingScheme - Class in de.citec.tcs.alignment.sequence
This serves as an abstract superclass for classes that define an indexing scheme for keywords.
IndexingScheme(IndexingScheme) - Constructor for class de.citec.tcs.alignment.sequence.IndexingScheme
This performs a shallow copy of the given other IndexingScheme, meaning that only references are copied and manipulations of the given other IndexingScheme will influence the copy as well.
IndexingScheme(HashMap<String, Integer>) - Constructor for class de.citec.tcs.alignment.sequence.IndexingScheme
Constructs an IndexingScheme from a mapping of strings to indices.
IndexingScheme(String[]) - Constructor for class de.citec.tcs.alignment.sequence.IndexingScheme
Constructs an IndexingScheme from a mapping of indices to strings.
IndexingScheme(String) - Constructor for class de.citec.tcs.alignment.sequence.IndexingScheme
Constructor for symbols either encoded as single characters without delimiter or as strings with | as delimiter.
insert(V) - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
This should be called during an alignment to retrieve the costs for an insertion of value b into the first sequence.
insert(X) - Method in interface de.citec.tcs.alignment.comparators.GapComparator
This should be called during an alignment to retrieve the costs for an insertion of value b into the first sequence.
insert(SymbolicValue) - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
This should be called during an alignment to retrieve the costs for an insertion of value b into the first sequence.
insert(V) - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
This should be called during an alignment to retrieve the costs for an insertion of value b into the first sequence.
isCancelOnException() - Method in class de.citec.tcs.alignment.parallel.Engine
Returns true if and only if this Engine stops computation if one thread throws an exception.
isDynamic() - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
Returns true if and only if this comparator will use a dynamic method to determine deletion, insertion and skip costs.
isEndExclusive() - Method in class de.citec.tcs.alignment.visualization.SourceCodeColumn
Returns true if the end column of each given codePosition are excluded in the visualization.
isGapAlignmentMatrix() - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
isLocalAlignmentMatrix() - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
isRestrictKeywords() - Method in class de.citec.tcs.alignment.visualization.HTMLVisualizer
If this flag is set to "true" the HTMLVisualizer will only print out table columns for the keywords specified in "keywords".
isValidWeighting(double[]) - Static method in class de.citec.tcs.alignment.AlignmentSpecification
This checks whether the given weighting is a valid one.
iterator() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.EmptySparseLocalEntry
iterator() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.FixedSparseLocalDerivative
iterator() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.TrivialSparseLocalDerivative

J

j - Variable in class de.citec.tcs.alignment.adp.DPCellId
 
j - Variable in class de.citec.tcs.alignment.parallel.MatrixEngine.MatrixCoordinate
 

K

KernelDTWFullAlgorithm - Class in de.citec.tcs.alignment
Implements soft alignment DTW.
KernelDTWFullAlgorithm(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.KernelDTWFullAlgorithm
 
keyword - Variable in class de.citec.tcs.alignment.visualization.AbstractHTMLColumn
 
KeywordSpecification - Class in de.citec.tcs.alignment.sequence
This specifies a keyword via its name and the type of its values.
KeywordSpecification(String, ValueType) - Constructor for class de.citec.tcs.alignment.sequence.KeywordSpecification
Sets up a KeywordSpecification that defines a type for the given keyword.

L

L1NormComparator - Class in de.citec.tcs.alignment.comparators
Compares vectors using the L1-Norm.
L1NormComparator(int) - Constructor for class de.citec.tcs.alignment.comparators.L1NormComparator
 
L1NormComparator(Normalizer, int) - Constructor for class de.citec.tcs.alignment.comparators.L1NormComparator
 
L1NormComparator(int, double) - Constructor for class de.citec.tcs.alignment.comparators.L1NormComparator
 
L1NormComparator(Normalizer, int, double) - Constructor for class de.citec.tcs.alignment.comparators.L1NormComparator
 
L1NormComparator(VectorialValue, VectorialValue, VectorialValue, VectorialValue) - Constructor for class de.citec.tcs.alignment.comparators.L1NormComparator
 
L1NormComparator(Normalizer, VectorialValue, VectorialValue, VectorialValue, VectorialValue) - Constructor for class de.citec.tcs.alignment.comparators.L1NormComparator
 
lowestScore() - Method in class de.citec.tcs.alignment.PathMap
Returns the lowest/best score stored in this map.

M

mapToDoubleVector(Object) - Static method in class de.citec.tcs.alignment.sequence.VectorialValue
Tries to convert an object to a double vector.
MatrixEngine<R> - Class in de.citec.tcs.alignment.parallel
This is a subclass of the Engine class to enable parallel processing to calculate the entries of a matrix.
MatrixEngine(int, int, Class<R>) - Constructor for class de.citec.tcs.alignment.parallel.MatrixEngine
 
MatrixEngine.MatrixCoordinate - Class in de.citec.tcs.alignment.parallel
This identifies a coordinate in a matrix as a tuple of row index and column index.
MatrixEngine.MatrixCoordinate(int, int) - Constructor for class de.citec.tcs.alignment.parallel.MatrixEngine.MatrixCoordinate
 
META_COLUMN_IDS - Static variable in class de.citec.tcs.alignment.visualization.HTMLVisualizer
 
MISMATCHDEFAULT - Static variable in class de.citec.tcs.alignment.comparators.ReplacementCosts
 

N

NCDComparator - Class in de.citec.tcs.alignment.comparators
This compares strings using normalized compression distance.
NCDComparator() - Constructor for class de.citec.tcs.alignment.comparators.NCDComparator
 
NCDComparator.CompressorType - Enum in de.citec.tcs.alignment.comparators
This class contains all possible CompressorTypes for this NCD implementation.
next() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.EmptySparseLocalEntry
next() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.FixedSparseLocalDerivative
next() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.TrivialSparseLocalDerivative
Node - Class in de.citec.tcs.alignment.sequence
This is a node in a Sequence storing values for the keywords defined in the sequence.
Node(Sequence) - Constructor for class de.citec.tcs.alignment.sequence.Node
 
NodeSpecification - Class in de.citec.tcs.alignment.sequence
This specifies the contents of the nodes in a given sequence.
NodeSpecification(KeywordSpecification[]) - Constructor for class de.citec.tcs.alignment.sequence.NodeSpecification
 
normalize(double) - Method in class de.citec.tcs.alignment.comparators.AffineNormalizer
normalize(double) - Method in class de.citec.tcs.alignment.comparators.ExponentialNormalizer
normalize(double) - Method in class de.citec.tcs.alignment.comparators.HyperbolicNormalizer
normalize(double) - Method in interface de.citec.tcs.alignment.comparators.Normalizer
 
Normalizer - Interface in de.citec.tcs.alignment.comparators
A Normalizer specifies a function to normalize arbitrary distance values between 0 and infinity to the realm of 0 to 1.

O

Operation - Class in de.citec.tcs.alignment
This defines an applied alignment operation.
Operation(Node, Node, OperationType, AlignmentPath) - Constructor for class de.citec.tcs.alignment.Operation
This constructs an Operation within an AlignmentPath.
OperationType - Enum in de.citec.tcs.alignment.comparators
This defines the possible types of operations that may be used in an alignment within this Toolbox.
ordinal - Variable in class de.citec.tcs.alignment.adp.DPCellId
 

P

ParallelDerivativeEngine<Y> - Class in de.citec.tcs.alignment
This allows parallel processing of derivative calculations.
ParallelDerivativeEngine(Map<MatrixEngine.MatrixCoordinate, AlignmentDerivativeAlgorithm>, int, int, DerivableComparator<?, Y>, String) - Constructor for class de.citec.tcs.alignment.ParallelDerivativeEngine
 
ParallelDerivativeEngine(AlignmentDerivativeAlgorithm[][], DerivableComparator<?, Y>, String) - Constructor for class de.citec.tcs.alignment.ParallelDerivativeEngine
 
ParallelProcessingEngine<R> - Class in de.citec.tcs.alignment
This allows parallel processing of alignment calculations.
ParallelProcessingEngine(AlignmentAlgorithm<R>, Sequence[]) - Constructor for class de.citec.tcs.alignment.ParallelProcessingEngine
This sets up a ParallelProcessingEngine for the given AlignmentAlgorithm and the given Sequences.
ParallelRawDerivativeEngine - Class in de.citec.tcs.alignment
This allows parallel processing of derivative calculations.
ParallelRawDerivativeEngine(Map<MatrixEngine.MatrixCoordinate, AlignmentDerivativeAlgorithm>, int, int, DerivableComparator<?, ?>, String) - Constructor for class de.citec.tcs.alignment.ParallelRawDerivativeEngine
 
ParallelRawDerivativeEngine(AlignmentDerivativeAlgorithm[][], DerivableComparator<?, ?>, String) - Constructor for class de.citec.tcs.alignment.ParallelRawDerivativeEngine
 
ParallelWeightDerivativeEngine - Class in de.citec.tcs.alignment
This allows parallel processing of derivative calculations.
ParallelWeightDerivativeEngine(Map<MatrixEngine.MatrixCoordinate, AlignmentDerivativeAlgorithm>, int, int) - Constructor for class de.citec.tcs.alignment.ParallelWeightDerivativeEngine
 
ParallelWeightDerivativeEngine(AlignmentDerivativeAlgorithm[][]) - Constructor for class de.citec.tcs.alignment.ParallelWeightDerivativeEngine
 
pathKeyword - Variable in class de.citec.tcs.alignment.visualization.SourceCodeColumn
 
PathList - Class in de.citec.tcs.alignment
This is a list-based datastructure accumulating multiple AlignmentPaths.
PathList() - Constructor for class de.citec.tcs.alignment.PathList
 
PathMap - Class in de.citec.tcs.alignment
This is a TreeMap-based datastructure implementing a mapping from scores to AlignmentPaths.
PathMap() - Constructor for class de.citec.tcs.alignment.PathMap
 
pollFirst() - Method in class de.citec.tcs.alignment.StrictKPathAlgorithm.IndexedStochasticPriorityQueue
Polls the value associated with the minimum key.
pollLast() - Method in class de.citec.tcs.alignment.StrictKPathAlgorithm.IndexedStochasticPriorityQueue
Polls the value associated with the maximum key.
positionKeyword - Variable in class de.citec.tcs.alignment.visualization.SourceCodeColumn
 
ProductionRule<N extends Enum<N>> - Class in de.citec.tcs.alignment.adp
A ProductionRule actually represents the right hand side of a production rule in an ADP grammar.
ProductionRule(OperationType[], N) - Constructor for class de.citec.tcs.alignment.adp.ProductionRule
Creates a new production rule of the form A -> operation_1( ...
ProductionRule(OperationType, N) - Constructor for class de.citec.tcs.alignment.adp.ProductionRule
Creates a new production rule of the form A -> operation(left, B, right)
ProductionRule(N) - Constructor for class de.citec.tcs.alignment.adp.ProductionRule
Creats a new production rule of the form A -> B Use these rules with care as they may produce endless loops if you put them in a cycle, like A -> B -> C -> ...
ProgressReporter - Interface in de.citec.tcs.alignment.parallel
This is an interface for classes that measure (and report) the progress of a task with a discrete number of steps.
put(AlignmentPath) - Method in class de.citec.tcs.alignment.PathMap
Adds a new AlignmentPath to this map.
put(K, V) - Method in class de.citec.tcs.alignment.StrictKPathAlgorithm.IndexedStochasticPriorityQueue
 

R

RandomSequenceGenerator - Class in de.citec.tcs.alignment.wrappers
This class is more for demonstration purposes and creates random sequences according to given input parameters.
RandomSequenceGenerator() - Constructor for class de.citec.tcs.alignment.wrappers.RandomSequenceGenerator
 
remove() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.EmptySparseLocalEntry
remove() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.FixedSparseLocalDerivative
remove() - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.TrivialSparseLocalDerivative
removeDiagonal() - Method in class de.citec.tcs.alignment.parallel.MatrixEngine
Ensures that the diagonal of the matrix is not calculated at the next call to "calculate".
removeTask(I) - Method in class de.citec.tcs.alignment.parallel.Engine
Removes the task with the given identifier from this Engine.
removeTasks(I[]) - Method in class de.citec.tcs.alignment.parallel.Engine
Removes the tasks with the given identifiers from this Engine.
removeTasks(Collection<I>) - Method in class de.citec.tcs.alignment.parallel.Engine
Removes the tasks with the given identifiers from this Engine.
removeValues(double) - Method in class de.citec.tcs.alignment.PathMap
Removes all AlignmentPaths with the given score from the map and returns them.
ReplacementComparator - Class in de.citec.tcs.alignment.comparators
This comparator defines explicit replacement (and deletion/insertion) costs for comparison of symbolic values.
ReplacementComparator() - Constructor for class de.citec.tcs.alignment.comparators.ReplacementComparator
 
ReplacementComparator(ReplacementCosts) - Constructor for class de.citec.tcs.alignment.comparators.ReplacementComparator
 
ReplacementCosts - Class in de.citec.tcs.alignment.comparators
This is a matrix of parameters specifying costs to replace one symbol of an alphabet with another one.
ReplacementCosts(Alphabet, boolean, boolean) - Constructor for class de.citec.tcs.alignment.comparators.ReplacementCosts
Initializes an empty replacement score matrix with sensible defaults: The diagonal is set to 0 (it costs nothing to replace a symbol by itself), every other replacement is set to MISMATCHDEFAULT, gap costs are set to GAPDEFAULT and skip costs to SKIPDEFAULT.
ReplacementCosts(Alphabet, double[][]) - Constructor for class de.citec.tcs.alignment.comparators.ReplacementCosts
 
resetSteps() - Method in class de.citec.tcs.alignment.parallel.CommandLineProgressReporter
Resets the number of completed steps to zero.
resetSteps() - Method in interface de.citec.tcs.alignment.parallel.ProgressReporter
Resets the number of completed steps to zero.
result - Variable in class de.citec.tcs.alignment.parallel.Engine.CalculationResult
 

S

ScoreBasedWeighting - Enum in de.citec.tcs.alignment
This is a helper class to enable users to weight a collection of scores based on different schemes specified below.
Sequence - Class in de.citec.tcs.alignment.sequence
Usually a sequence for alignments is defined as a sequence of symbols.
Sequence(NodeSpecification) - Constructor for class de.citec.tcs.alignment.sequence.Sequence
Sets up an empty sequence with the given NodeSpecification as basis.
Sequence(String) - Constructor for class de.citec.tcs.alignment.sequence.Sequence
Sets up a trivial sequence with only one keyword (DEFAULTKEYWORD) and treats the string content between | delimiters in the input string as symbolic values.
Sequence(String, Alphabet) - Constructor for class de.citec.tcs.alignment.sequence.Sequence
Sets up a trivial sequence with only one keyword (DEFAULTKEYWORD) and treats the string content between | delimiters in the input string as symbolic values.
set(int, int, X) - Method in class de.citec.tcs.alignment.SparseMatrix
Sets the value at the given position in the matrix.
setAlpha(double) - Method in class de.citec.tcs.alignment.comparators.HyperbolicNormalizer
 
setApproxThreshold(double) - Method in class de.citec.tcs.alignment.adp.SoftADPFullAlgorithm
For more information on the ApproxThreshold have a look at the Softmin class.
setApproxThreshold(double) - Method in class de.citec.tcs.alignment.adp.SoftADPScoreAlgorithm
For more information on the ApproxThreshold have a look at the Softmin class.
setApproxThreshold(double) - Method in class de.citec.tcs.alignment.SoftAffineAlignmentFullAlgorithm
For more information on the ApproxThreshold have a look at the Softmin class.
setApproxThreshold(double) - Method in class de.citec.tcs.alignment.SoftAffineAlignmentScoreAlgorithm
For more information on the ApproxThreshold have a look at the Softmin class.
setApproxThreshold(double) - Method in class de.citec.tcs.alignment.SoftAlignmentFullAlgorithm
Sets the threshold for which exponents within the softmin function will be disregarded.
setApproxThreshold(double) - Method in class de.citec.tcs.alignment.SoftAlignmentSamplingAlgorithm
Sets the threshold for which exponents within the softmin function will be disregarded.
setApproxThreshold(double) - Method in class de.citec.tcs.alignment.SoftAlignmentScoreAlgorithm
For more information on the ApproxThreshold have a look at the Softmin class.
setBeta(double) - Method in class de.citec.tcs.alignment.adp.SoftADPFullAlgorithm
 
setBeta(double) - Method in class de.citec.tcs.alignment.adp.SoftADPScoreAlgorithm
Sets the parameter defining the "softness" of the alignment.
setBeta(double) - Method in class de.citec.tcs.alignment.comparators.ExponentialNormalizer
 
setBeta(double) - Method in class de.citec.tcs.alignment.SoftAffineAlignmentFullAlgorithm
Sets the parameter defining the "softness" of the alignment.
setBeta(double) - Method in class de.citec.tcs.alignment.SoftAffineAlignmentScoreAlgorithm
Sets the parameter defining the "softness" of the alignment.
setBeta(double) - Method in class de.citec.tcs.alignment.SoftAlignmentFullAlgorithm
 
setBeta(double) - Method in class de.citec.tcs.alignment.SoftAlignmentSamplingAlgorithm
 
setBeta(double) - Method in class de.citec.tcs.alignment.SoftAlignmentScoreAlgorithm
 
setCancelOnException(boolean) - Method in class de.citec.tcs.alignment.parallel.Engine
Sets a flag that decides whether this Engine stops computation if one thread throws an exception.
setComparator(String, Comparator) - Method in class de.citec.tcs.alignment.AlignmentSpecification
Sets the comparator for a given keyword.
setComparator(int, Comparator) - Method in class de.citec.tcs.alignment.AlignmentSpecification
Sets the comparator for a given keyword.
setComparatorDistances(double[]) - Method in class de.citec.tcs.alignment.Operation
Sets the local costs given by the Comparators specified for this Alignment to align the left Node in this Operation with the right Node (or deleting, inserting, skipping nodes respectively).
setCompressor(NCDComparator.CompressorType) - Method in class de.citec.tcs.alignment.comparators.NCDComparator
 
setCostMatrix(ReplacementCosts) - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
Sets the ReplacementCosts that shall be used within this Comparator.
setCostMatrix(double[][]) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
Sets the cost matrix itself.
setDecimalPlaces(int) - Method in class de.citec.tcs.alignment.visualization.HTMLVisualizer
This specifies how many decimal places (after comma) should be visualized.
setDelCosts(double[]) - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
setDeleteComparison(V) - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
Sets the comparison value that is used to compute the cost of deletions if the dynamic flag is set to true.
setDeletionCost(String, double) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
setDeletionCost(double) - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
Sets the (constant) cost for deleting a value.
setDeletionCosts(double[]) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
Sets all deletion costs without any other costs.
setDelLocal(double) - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
setDelProb(double) - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
setDelSoftDerivative(double) - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
setDynamic(boolean) - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
Set to true if and only if this comparator shall use a dynamic method to determine deletion, insertion and skip costs.
setEndExclusive(boolean) - Method in class de.citec.tcs.alignment.visualization.SourceCodeColumn
Sets if the end column of each given codePosition should be in- or excluded in the visualization.
setFull() - Method in class de.citec.tcs.alignment.parallel.MatrixEngine
Clears all current calculation tasks and instead adds a task for every matrix entry, such that the full matrix is calculated on the next call of the "calculate" method.
setInsCosts(double[]) - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
setInsertComparison(V) - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
Sets the comparison value that is used to compute the cost of insertions if the dynamic flag is set to true.
setInsertionCost(String, double) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
setInsertionCost(double) - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
Sets the (constant) cost for inserting a value.
setInsertionCosts(double[]) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
Sets all insertion costs without any other costs.
setInsLocal(double) - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
setInsProb(double) - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
setInsSoftDerivative(double) - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
setMatchCost(double) - Method in class de.citec.tcs.alignment.comparators.TrivialEditComparator
Sets the cost for matches (0 per default).
setMax(double) - Method in class de.citec.tcs.alignment.comparators.AffineNormalizer
Sets the maximum possible value, which will be mapped to 1.
setMin(double) - Method in class de.citec.tcs.alignment.comparators.AffineNormalizer
Sets the minimum possible value, which will be mapped to 0.
setMinMiddleSkips(int) - Method in class de.citec.tcs.alignment.AbstractAffineAlignmentAlgorithm
The minimum number of skips that have to be done in the middle of an alignment.
setMismatchCost(double) - Method in class de.citec.tcs.alignment.comparators.TrivialEditComparator
Sets the cost for mismatches (1 per default).
setNormalizer(Normalizer) - Method in class de.citec.tcs.alignment.comparators.EuclideanComparator
The euclidian distance per default is bound by 0 but has no upper bound.
setNormalizer(Normalizer) - Method in class de.citec.tcs.alignment.comparators.L1NormComparator
The L1-norm per default is bound by 0 but has no upper bound.
setNumberOfThreads(int) - Method in class de.citec.tcs.alignment.parallel.Engine
Sets the number of threads that are used for computation (16 per default).
setPathLimit(int) - Method in class de.citec.tcs.alignment.SoftAlignmentSamplingAlgorithm
This sets the number of paths that shall be sampled.
setPathLimit(int) - Method in class de.citec.tcs.alignment.StrictAllOptimalAlgorithm
The total number of co-optimal alignments can be very huge as multiple co-optimal operations lead to a combinatorial explosion of possible alignments.
setPathLimit(int) - Method in class de.citec.tcs.alignment.StrictKPathAlgorithm
This sets the k that gives the StrictKPathAlgorithm its name: The number of returned AlignmentPaths is limited to the k best alignments.
setPreferredCooptimal(OperationType[]) - Method in class de.citec.tcs.alignment.StrictAffineAlignmentFullAlgorithm
This allows to specify an order in which operations shall be preferred if cooptimal alignments occur.
setProgressReportStepSize(double) - Method in class de.citec.tcs.alignment.parallel.CommandLineProgressReporter
Sets the percent of computation that have to be completed until a new notification is written to the command line.
setRepCosts(double[]) - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
setReplacementCost(String, String, double) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
setReplacementCosts(double[][]) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
Sets the whole matrix of replacement costs without gap and skip costs.
setRepLocal(double) - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
setReporter(ProgressReporter) - Method in class de.citec.tcs.alignment.parallel.Engine
Sets the ProgressReporter that is used to report progress.
setRepProb(double) - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
setRepSoftDerivative(double) - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
setRestrictKeywords(boolean) - Method in class de.citec.tcs.alignment.visualization.HTMLVisualizer
If this flag is set to "true" the HTMLVisualizer will only print out table columns for the keywords specified in "keywords".
setSkipDeleteComparison(V) - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
Sets the comparison value that is used to compute the cost of skip-deletions if the dynamic flag is set to true.
setSkipDeletionCost(String, double) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
setSkipDeletionCost(double) - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
Sets the (constant) cost for deleting a value using a skip.
setSkipDeletionCosts(double[]) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
Sets all skip deletion costs without any other costs.
setSkipFactor(double) - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
Sets the cost factor for skipDeletions and skipInsertions for a dynamic comparison.
setSkipInsertComparison(V) - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
Sets the comparison value that is used to compute the cost of skip-insertions if the dynamic flag is set to true.
setSkipInsertionCost(String, double) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
setSkipInsertionCost(double) - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
Sets the (constant) cost for inserting a value using a skip.
setSkipInsertionCosts(double[]) - Method in class de.citec.tcs.alignment.comparators.ReplacementCosts
Sets all skip insertion costs without any other costs.
setSoftmin(double) - Method in class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
setSpecificTasks(boolean[][]) - Method in class de.citec.tcs.alignment.parallel.MatrixEngine
Clears all current calculation tasks and instead adds a task for every matrix entry that is set to "true" in the given boolean matrix.
setSpecificTasks(MatrixEngine.MatrixCoordinate[]) - Method in class de.citec.tcs.alignment.parallel.MatrixEngine
Clears all current calculation tasks and instead adds a task for every given matrix coordinate.
setSpecificTasks(Collection<MatrixEngine.MatrixCoordinate>) - Method in class de.citec.tcs.alignment.parallel.MatrixEngine
Clears all current calculation tasks and instead adds a task for every given matrix coordinate.
setSpecificTasks(int[][]) - Method in class de.citec.tcs.alignment.parallel.MatrixEngine
Clears all current calculation tasks and instead adds a task for every given matrix coordinate.
setString(String) - Method in class de.citec.tcs.alignment.sequence.StringValue
 
setSymbol(String) - Method in class de.citec.tcs.alignment.sequence.SymbolicValue
Sets the actual symbol.
setSymmetric() - Method in class de.citec.tcs.alignment.parallel.MatrixEngine
Clears all current calculation tasks and instead adds a task for every matrix entry in the upper half of the matrix.
setTabSize(int) - Method in class de.citec.tcs.alignment.visualization.SourceCodeColumn
This manipulates as how many characters a tab should be counted.
setTotalSteps(int) - Method in class de.citec.tcs.alignment.parallel.CommandLineProgressReporter
Sets the total number of steps that are necessary to complete the overall task.
setTotalSteps(int) - Method in interface de.citec.tcs.alignment.parallel.ProgressReporter
Sets the total number of steps that are necessary to complete the overall task.
setUpSpecification(Sequence[]) - Static method in class de.citec.tcs.alignment.wrappers.StringEditDistance
Sets up a default AlignmentSpecification for the simple StringEditDistance problem.
setUpSpecification(Sequence[], double, double, double) - Static method in class de.citec.tcs.alignment.wrappers.StringEditDistance
Sets up an AlignmentSpecification for the simple StringEditDistance problem.
setUpSpecification(Sequence[], double[][]) - Static method in class de.citec.tcs.alignment.wrappers.StringEditDistance
Sets up an AlignmentSpecification for the simple StringEditDistance problem.
setUpSpecification(Sequence[]) - Static method in class de.citec.tcs.alignment.wrappers.VectorialSequences
Sets up an AlignmentSpecification for an array of vectorial sequences.
setUpSpecification(Sequence[], GapComparator<VectorialValue>) - Static method in class de.citec.tcs.alignment.wrappers.VectorialSequences
Sets up an AlignmentSpecification for an array of vectorial sequences.
setUpSpecification(Sequence[], GapComparator[]) - Static method in class de.citec.tcs.alignment.wrappers.VectorialSequences
Sets up an AlignmentSpecification for an array of vectorial sequences.
setUpSpecification(Sequence[], double[]) - Static method in class de.citec.tcs.alignment.wrappers.VectorialSequences
Sets up an AlignmentSpecification for an array of vectorial sequences.
setUpSpecification(Sequence[], GapComparator<VectorialValue>, double[]) - Static method in class de.citec.tcs.alignment.wrappers.VectorialSequences
Sets up an AlignmentSpecification for an array of vectorial sequences.
setUpSpecification(Sequence[], GapComparator[], double[]) - Static method in class de.citec.tcs.alignment.wrappers.VectorialSequences
Sets up an AlignmentSpecification for an array of vectorial sequences.
setValue(Double) - Method in class de.citec.tcs.alignment.comparators.SparseLocalDerivative.SparseDeriativeEntry
 
setValue(String, Value) - Method in class de.citec.tcs.alignment.sequence.Node
Sets the value for the given keyword.
setValue(int, Value) - Method in class de.citec.tcs.alignment.sequence.Node
Sets the value for the given keyword.
setVector(double[]) - Method in class de.citec.tcs.alignment.sequence.VectorialValue
Sets the actual vector.
setVector(Object) - Method in class de.citec.tcs.alignment.sequence.VectorialValue
Sets the actual vector.
setWeighting(double[]) - Method in class de.citec.tcs.alignment.AlignmentSpecification
This sets the current weighting of keywords.
setWeighting(ScoreBasedWeighting) - Method in class de.citec.tcs.alignment.PathMap
Sets the weighting that is used during derivative calculation.
setWeightThreshold(double) - Method in class de.citec.tcs.alignment.AbstractAffineAlignmentAlgorithm
Set a weight threshold (between 0 and 1) that determines which keywords should be ignored during calculation because their weight is negligible.
setWeightThreshold(double) - Method in class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
Set a weight threshold (between 0 and 1) that determines which keywords should be ignored during calculation because their weight is negligible.
setWeightThreshold(double) - Method in class de.citec.tcs.alignment.AbstractStrictDTWAlgorithm
Set a weight threshold (between 0 and 1) that determines which keywords should be ignored during calculation because their weight is negligible.
setWeightThreshold(double) - Method in class de.citec.tcs.alignment.adp.AbstractADPAlgorithm
Set a weight threshold (between 0 and 1) that determines which keywords should be ignored during calculation because their weight is negligible.
size() - Method in class de.citec.tcs.alignment.sequence.IndexingScheme
Returns the number of mapped keywords.
SkipAlignmentAlgorithm<R> - Interface in de.citec.tcs.alignment
This is an interface for GapAlignmentAlgorithms that also use skips (SkipDeletion, SkipInsertion) and in that way are local distance measures.
SkipComparator<X extends Value> - Interface in de.citec.tcs.alignment.comparators
This further specifies the AlignmentComparator to include skips.
SKIPDEFAULT - Static variable in class de.citec.tcs.alignment.comparators.ReplacementCosts
 
skipDelete(V) - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
This should be called during an alignment to retrieve the costs for a skip deletion of value a from the first sequence.
skipDelete(SymbolicValue) - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
This should be called during an alignment to retrieve the costs for a skip deletion of value a from the first sequence.
skipDelete(X) - Method in interface de.citec.tcs.alignment.comparators.SkipComparator
This should be called during an alignment to retrieve the costs for a skip deletion of value a from the first sequence.
skipDelete(V) - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
This should be called during an alignment to retrieve the costs for a skip deletion of value a from the first sequence.
SkipExtendedComparator<V extends Value> - Class in de.citec.tcs.alignment.comparators
This is an abstract class to be used for Comparators that are only to be used for comparisons per se but can be extended for use with gaps and skips.
SkipExtendedComparator() - Constructor for class de.citec.tcs.alignment.comparators.SkipExtendedComparator
 
skipInsert(V) - Method in class de.citec.tcs.alignment.comparators.ComparisonBasedSkipExtendedComparator
This should be called during an alignment to retrieve the costs for a skip insertion of value b into the first sequence.
skipInsert(SymbolicValue) - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
This should be called during an alignment to retrieve the costs for a skip insertion of value b into the first sequence.
skipInsert(X) - Method in interface de.citec.tcs.alignment.comparators.SkipComparator
This should be called during an alignment to retrieve the costs for a skip insertion of value b into the first sequence.
skipInsert(V) - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
This should be called during an alignment to retrieve the costs for a skip insertion of value b into the first sequence.
SoftADPFullAlgorithm<N extends Enum<N>> - Class in de.citec.tcs.alignment.adp
This algorithm returns a SoftADPPathModel based on the given grammar and algebra/AlignmentSpecification.
SoftADPFullAlgorithm(Grammar<N>, AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.adp.SoftADPFullAlgorithm
Creates a new SoftFullAlgorithm based on the given ADP grammar and the given AlignmentSpecification/algebra.
SoftADPPathModel<N extends Enum<N>> - Class in de.citec.tcs.alignment.adp
This is basically a large storage class for all results of a SoftADPFullAlgorithm to facilitate derivative calculation.
SoftADPPathModel(AlignmentSpecification, Grammar<N>, double, double, double, EnumMap<N, double[][]>, double[][], double[], double[], double[], double[], Sequence, Sequence) - Constructor for class de.citec.tcs.alignment.adp.SoftADPPathModel
 
SoftADPScoreAlgorithm<N extends Enum<N>> - Class in de.citec.tcs.alignment.adp
This algorithm calculates the soft alignment score for the given input grammar and algebra/AlignmentSpecification.
SoftADPScoreAlgorithm(Grammar<N>, AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.adp.SoftADPScoreAlgorithm
 
SoftAffineAlignmentFullAlgorithm - Class in de.citec.tcs.alignment
This implements a local affine alignment similar to Smith-Waterman and Gotoh.
SoftAffineAlignmentFullAlgorithm(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.SoftAffineAlignmentFullAlgorithm
 
SoftAffineAlignmentScoreAlgorithm - Class in de.citec.tcs.alignment
This implements a local affine alignment similar to Smith-Waterman and Gotoh.
SoftAffineAlignmentScoreAlgorithm(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.SoftAffineAlignmentScoreAlgorithm
 
SoftAffinePathModel - Class in de.citec.tcs.alignment
This is basically a storage for the DP matrix of the SoftAffineAlignmentAlgorithm.
SoftAffinePathModel(double, AlignmentSpecification, int, double, EnumMap<AbstractAffineAlignmentAlgorithm.Recurrence, double[][]>, double[][], double[], double[], double[], double[], Sequence, Sequence) - Constructor for class de.citec.tcs.alignment.SoftAffinePathModel
 
SoftAlignmentFullAlgorithm - Class in de.citec.tcs.alignment
This calculates the soft (global) alignment of two sequences similarly to the Needleman-Wunsch-Algorithm.
SoftAlignmentFullAlgorithm(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.SoftAlignmentFullAlgorithm
This sets up an AlignmentAlgorithm instance according to the given specification.
SoftAlignmentSamplingAlgorithm - Class in de.citec.tcs.alignment
This calculates the soft (global) alignment of two sequences similarly to the Needleman-Wunsch-Algorithm.
SoftAlignmentSamplingAlgorithm(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.SoftAlignmentSamplingAlgorithm
This sets up an AlignmentAlgorithm instance according to the given specification.
SoftAlignmentScoreAlgorithm - Class in de.citec.tcs.alignment
This calculates the soft (global) alignment of two sequences similarly to the Needleman-Wunsch-Algorithm.
SoftAlignmentScoreAlgorithm(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.SoftAlignmentScoreAlgorithm
This sets up an AlignmentAlgorithm instance according to the given specification.
SoftAlignmentScoreAlgorithm.ScoreEntry - Class in de.citec.tcs.alignment
 
SoftAlignmentScoreAlgorithm.ScoreEntry(double) - Constructor for class de.citec.tcs.alignment.SoftAlignmentScoreAlgorithm.ScoreEntry
 
SoftDTWModel - Class in de.citec.tcs.alignment
storage unit for soft DTW alignment result, provides functions to calculate the soft DTW derivatives based on the stored soft alignment
SoftDTWModel(AlignmentSpecification, Sequence, Sequence, double[][]) - Constructor for class de.citec.tcs.alignment.SoftDTWModel
 
Softmin - Class in de.citec.tcs.alignment
This implements utility functions for the softmin function.
Softmin() - Constructor for class de.citec.tcs.alignment.Softmin
 
softmin(double, double[]) - Static method in class de.citec.tcs.alignment.Softmin
This calculates softmin for the given input and the given value of beta.
softmin(double, double, double[]) - Static method in class de.citec.tcs.alignment.Softmin
This calculates softmin for the given input and the given value of beta.
SoftPathModel - Class in de.citec.tcs.alignment
This is the soft pendant to the AlignmentPath.
SoftPathModel(AlignmentSpecification, Sequence, Sequence, double, double, SoftPathModel.SoftMatrixEntry[][]) - Constructor for class de.citec.tcs.alignment.SoftPathModel
 
SoftPathModel.SoftMatrixEntry - Class in de.citec.tcs.alignment
 
SoftPathModel.SoftMatrixEntry() - Constructor for class de.citec.tcs.alignment.SoftPathModel.SoftMatrixEntry
 
SourceCodeColumn - Class in de.citec.tcs.alignment.visualization
This special HTML column allows users to visualize source code, given that you have put the information on the location into the Sequence, meaning that your NodeSpecification has two keywords, one specifying the path to the respective code file and one specifying the position within that code file.
SourceCodeColumn(String, String, String, String) - Constructor for class de.citec.tcs.alignment.visualization.SourceCodeColumn
 
SourceCodeColumn(String, String, String) - Constructor for class de.citec.tcs.alignment.visualization.SourceCodeColumn
 
SourceCodeColumn(String, String) - Constructor for class de.citec.tcs.alignment.visualization.SourceCodeColumn
 
sparseComparisonDerivative(StringValue, StringValue) - Method in class de.citec.tcs.alignment.comparators.CharStatComparator
This should implement the local derivative calculation in case of comparisons.
sparseComparisonDerivative(VectorialValue, VectorialValue) - Method in class de.citec.tcs.alignment.comparators.EuclideanComparator
This should implement the local derivative calculation in case of comparisons.
sparseComparisonDerivative(VectorialValue, VectorialValue) - Method in class de.citec.tcs.alignment.comparators.L1NormComparator
This should implement the local derivative calculation in case of comparisons.
sparseComparisonDerivative(StringValue, StringValue) - Method in class de.citec.tcs.alignment.comparators.NCDComparator
This should implement the local derivative calculation in case of comparisons.
sparseComparisonDerivative(V, V) - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
This should implement the local derivative calculation in case of comparisons.
sparseComparisonDerivative(SymbolicValue, SymbolicValue) - Method in class de.citec.tcs.alignment.comparators.TrivialEditComparator
This should implement the local derivative calculation in case of comparisons.
sparseComparisonDerivative(VectorialValue, VectorialValue) - Method in class de.citec.tcs.alignment.comparators.ZeroNormComparator
This should implement the local derivative calculation in case of comparisons.
SparseDerivableComparator<X extends Value,Y> - Interface in de.citec.tcs.alignment.comparators
Some derivable comparators have the special property that in each alignment step only a small subset of parameters is needed.
SparseLocalDerivative - Interface in de.citec.tcs.alignment.comparators
This is an interface for classes that are able to hold sparse representations of a local derivative, where only for one or a few parameters the derivative is non-zero.
SparseLocalDerivative.EmptySparseLocalEntry - Class in de.citec.tcs.alignment.comparators
 
SparseLocalDerivative.EmptySparseLocalEntry() - Constructor for class de.citec.tcs.alignment.comparators.SparseLocalDerivative.EmptySparseLocalEntry
 
SparseLocalDerivative.FixedSparseLocalDerivative - Class in de.citec.tcs.alignment.comparators
This implements the SparseLocalDerivative interface for a fixed number of entries.
SparseLocalDerivative.FixedSparseLocalDerivative(int) - Constructor for class de.citec.tcs.alignment.comparators.SparseLocalDerivative.FixedSparseLocalDerivative
 
SparseLocalDerivative.FlexibleSparseLocalDerivative - Class in de.citec.tcs.alignment.comparators
 
SparseLocalDerivative.FlexibleSparseLocalDerivative() - Constructor for class de.citec.tcs.alignment.comparators.SparseLocalDerivative.FlexibleSparseLocalDerivative
 
SparseLocalDerivative.SparseDeriativeEntry - Class in de.citec.tcs.alignment.comparators
 
SparseLocalDerivative.SparseDeriativeEntry(int, double) - Constructor for class de.citec.tcs.alignment.comparators.SparseLocalDerivative.SparseDeriativeEntry
 
SparseLocalDerivative.TrivialSparseLocalDerivative - Class in de.citec.tcs.alignment.comparators
This is a representation with just one entry.
SparseLocalDerivative.TrivialSparseLocalDerivative() - Constructor for class de.citec.tcs.alignment.comparators.SparseLocalDerivative.TrivialSparseLocalDerivative
 
SparseMatrix<X> - Class in de.citec.tcs.alignment
This models a sparse matrix that does not have to be fully calculated.
SparseMatrix() - Constructor for class de.citec.tcs.alignment.SparseMatrix
 
SRC_LIMIT - Static variable in class de.citec.tcs.alignment.visualization.SourceCodeColumn
 
STDKEYWORD - Static variable in class de.citec.tcs.alignment.wrappers.VectorialSequences
 
StrictADPFullAlgorithm<N extends Enum<N>> - Class in de.citec.tcs.alignment.adp
This algorithm calculates an optimal AlignmentPath using the given ADP grammar and algebra/AlignmentSpecification.
StrictADPFullAlgorithm(Grammar<N>, AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.adp.StrictADPFullAlgorithm
 
StrictADPScoreAlgorithm<N extends Enum<N>> - Class in de.citec.tcs.alignment.adp
This algorithm calculates the strict alignment score for the given input grammar and algebra/AlignmentSpecification.
StrictADPScoreAlgorithm(Grammar<N>, AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.adp.StrictADPScoreAlgorithm
 
StrictAffineAlignmentFullAlgorithm - Class in de.citec.tcs.alignment
This implements a local affine alignment similar to Smith-Waterman and Gotoh.
StrictAffineAlignmentFullAlgorithm(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.StrictAffineAlignmentFullAlgorithm
 
StrictAffineAlignmentScoreAlgorithm - Class in de.citec.tcs.alignment
This implements a local affine alignment similar to Smith-Waterman and Gotoh.
StrictAffineAlignmentScoreAlgorithm(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.StrictAffineAlignmentScoreAlgorithm
 
StrictAlignmentFullAlgorithm - Class in de.citec.tcs.alignment
This is an implementation of the Needleman-Wunsch-Algorithm for sequence alignment.
StrictAlignmentFullAlgorithm(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.StrictAlignmentFullAlgorithm
This sets up an AlignmentAlgorithm instance according to the given specification.
StrictAlignmentFullAlgorithm.FullMatrixEntry - Class in de.citec.tcs.alignment
 
StrictAlignmentFullAlgorithm.FullMatrixEntry(double, int, int, StrictAlignmentFullAlgorithm.FullMatrixEntry) - Constructor for class de.citec.tcs.alignment.StrictAlignmentFullAlgorithm.FullMatrixEntry
 
StrictAlignmentScoreAlgorithm - Class in de.citec.tcs.alignment
This is an implementation of the Needleman-Wunsch-Algorithm for sequence alignment.
StrictAlignmentScoreAlgorithm(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.StrictAlignmentScoreAlgorithm
This sets up an AlignmentAlgorithm instance according to the given specification.
StrictAlignmentScoreAlgorithm.ScoreEntry - Class in de.citec.tcs.alignment
 
StrictAlignmentScoreAlgorithm.ScoreEntry(double) - Constructor for class de.citec.tcs.alignment.StrictAlignmentScoreAlgorithm.ScoreEntry
 
StrictAllOptimalAlgorithm - Class in de.citec.tcs.alignment
This is an implementation of the Needleman-Wunsch-Algorithm for sequence alignment.
StrictAllOptimalAlgorithm(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.StrictAllOptimalAlgorithm
This sets up an AlignmentAlgorithm instance according to the given specification.
StrictAllOptimalAlgorithm.FullMatrixEntry - Class in de.citec.tcs.alignment
 
StrictAllOptimalAlgorithm.FullMatrixEntry(double, double, double, double, int, int) - Constructor for class de.citec.tcs.alignment.StrictAllOptimalAlgorithm.FullMatrixEntry
 
StrictDTWFullAlgorithm - Class in de.citec.tcs.alignment
This is an implementation of the AbstractStrictDTWAlgorithm to calculate just one exemplary optimal DTW path.
StrictDTWFullAlgorithm(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.StrictDTWFullAlgorithm
 
StrictDTWScoreAlgorithm - Class in de.citec.tcs.alignment
This is an implementation of the AbstractStrictDTWAlgorithm to calculate just the score.
StrictDTWScoreAlgorithm(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.StrictDTWScoreAlgorithm
 
StrictKPathAlgorithm - Class in de.citec.tcs.alignment
This is an implementation of the Needleman-Wunsch-Algorithm for sequence alignment.
StrictKPathAlgorithm(AlignmentSpecification) - Constructor for class de.citec.tcs.alignment.StrictKPathAlgorithm
This sets up an AlignmentAlgorithm instance according to the given specification.
StrictKPathAlgorithm.IndexedStochasticPriorityQueue<K extends Comparable<K>,V> - Class in de.citec.tcs.alignment
This is a helper class, which actually extends the TreeMap to implement a PriorityQueue that is able to poll the minimum as well as the maximum in constanst time.
StrictKPathAlgorithm.IndexedStochasticPriorityQueue() - Constructor for class de.citec.tcs.alignment.StrictKPathAlgorithm.IndexedStochasticPriorityQueue
 
StringEditDistance - Class in de.citec.tcs.alignment.wrappers
This is a simple wrapper to support an easier interface for the simple StringEditDistance problem.
StringEditDistance() - Constructor for class de.citec.tcs.alignment.wrappers.StringEditDistance
 
StringKeywordSpecification - Class in de.citec.tcs.alignment.sequence
This specifies String keywords which are not especially restricted.
StringKeywordSpecification(String) - Constructor for class de.citec.tcs.alignment.sequence.StringKeywordSpecification
 
StringValue - Class in de.citec.tcs.alignment.sequence
This value is supposed to represent strings that are not restricted to a certain alphabet.
StringValue() - Constructor for class de.citec.tcs.alignment.sequence.StringValue
 
StringValue(String) - Constructor for class de.citec.tcs.alignment.sequence.StringValue
 
StringVisualizer - Class in de.citec.tcs.alignment.visualization
This is a trivial Visualizer that just calls the toString() method of AlignmentPath.
StringVisualizer() - Constructor for class de.citec.tcs.alignment.visualization.StringVisualizer
 
SymbolicKeywordSpecification - Class in de.citec.tcs.alignment.sequence
This specifies symbolic keywords by their alphabet.
SymbolicKeywordSpecification(Alphabet, String) - Constructor for class de.citec.tcs.alignment.sequence.SymbolicKeywordSpecification
 
SymbolicValue - Class in de.citec.tcs.alignment.sequence
This is a special value class that is restricted to a finite list of values defined by an alphabet.
SymbolicValue(Alphabet) - Constructor for class de.citec.tcs.alignment.sequence.SymbolicValue
 
SymbolicValue(Alphabet, String) - Constructor for class de.citec.tcs.alignment.sequence.SymbolicValue
 

T

toMatrix() - Method in class de.citec.tcs.alignment.AlignmentPath
This transforms the AlignmentPath to a matrix, mostly for visualization purposes.
toMatrix() - Method in class de.citec.tcs.alignment.PathList
This transforms the PathList to a matrix, mostly for visualization purposes.
toMatrix() - Method in class de.citec.tcs.alignment.PathMap
This transforms the PathMap to a matrix, mostly for visualization purposes.
toSequences(String[]) - Static method in class de.citec.tcs.alignment.wrappers.StringEditDistance
Transforms the given strings to the TCSAlignmentToolbox Sequence format.
toSequences(Collection<String>) - Static method in class de.citec.tcs.alignment.wrappers.StringEditDistance
Transforms the given strings to the TCSAlignmentToolbox Sequence format.
toSequences(String[], Alphabet) - Static method in class de.citec.tcs.alignment.wrappers.StringEditDistance
Transforms the given strings to the TCSAlignmentToolbox Sequence format using the given alphabet.
toSequences(Collection<String>, Alphabet) - Static method in class de.citec.tcs.alignment.wrappers.StringEditDistance
Transforms the given strings to the TCSAlignmentToolbox Sequence format using the given alphabet.
toSequences(double[][]) - Static method in class de.citec.tcs.alignment.wrappers.VectorialSequences
Transforms the given arrays to sequences.
toSequences(double[][][]) - Static method in class de.citec.tcs.alignment.wrappers.VectorialSequences
Transforms the given arrays to sequences.
toSequences(double[][][], String[]) - Static method in class de.citec.tcs.alignment.wrappers.VectorialSequences
Transforms the given arrays to sequences.
toSequences(double[][][], String[], int[]) - Static method in class de.citec.tcs.alignment.wrappers.VectorialSequences
Transforms the given arrays to sequences.
toString() - Method in class de.citec.tcs.alignment.adp.DPCellId
 
toString(Enum[]) - Method in class de.citec.tcs.alignment.adp.DPCellId
 
toString() - Method in class de.citec.tcs.alignment.adp.FlexibleGrammar
toString() - Method in class de.citec.tcs.alignment.adp.ProductionRule
toString() - Method in class de.citec.tcs.alignment.AlignmentPath
toString() - Method in class de.citec.tcs.alignment.AlignmentSpecification
 
toString() - Method in class de.citec.tcs.alignment.Operation
toString() - Method in class de.citec.tcs.alignment.parallel.MatrixEngine.MatrixCoordinate
toString() - Method in class de.citec.tcs.alignment.sequence.Alphabet
toString() - Method in class de.citec.tcs.alignment.sequence.KeywordSpecification
 
toString() - Method in class de.citec.tcs.alignment.sequence.NodeSpecification
toString() - Method in class de.citec.tcs.alignment.sequence.Sequence
toString() - Method in class de.citec.tcs.alignment.sequence.StringValue
toString() - Method in class de.citec.tcs.alignment.sequence.SymbolicValue
toString() - Method in class de.citec.tcs.alignment.sequence.VectorialValue
toString() - Method in class de.citec.tcs.alignment.SparseMatrix
transformToResult(EnumMap<AbstractAffineAlignmentAlgorithm.Recurrence, double[][]>, double[][], double[], double[], double[], double[], Sequence, Sequence) - Method in class de.citec.tcs.alignment.AbstractAffineAlignmentAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(X[][], Sequence, Sequence) - Method in class de.citec.tcs.alignment.AbstractGapAlignmentAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(double[][], Sequence, Sequence) - Method in class de.citec.tcs.alignment.AbstractStrictDTWAlgorithm
This method has to be implemented by sub classes to transform a calculated dynamic programming matrix to a valid result of that implementation.
transformToResult(EnumMap<N, double[][]>, double[][], double[], double[], double[], double[], Sequence, Sequence) - Method in class de.citec.tcs.alignment.adp.AbstractADPAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(EnumMap<N, double[][]>, double[][], double[], double[], double[], double[], Sequence, Sequence) - Method in class de.citec.tcs.alignment.adp.SoftADPFullAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(EnumMap<N, double[][]>, double[][], double[], double[], double[], double[], Sequence, Sequence) - Method in class de.citec.tcs.alignment.adp.SoftADPScoreAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(EnumMap<N, double[][]>, double[][], double[], double[], double[], double[], Sequence, Sequence) - Method in class de.citec.tcs.alignment.adp.StrictADPFullAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(EnumMap<N, double[][]>, double[][], double[], double[], double[], double[], Sequence, Sequence) - Method in class de.citec.tcs.alignment.adp.StrictADPScoreAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(double[]) - Method in interface de.citec.tcs.alignment.comparators.DerivableComparator
This method is supposed to construct the derivative for this comparator in an intuitive format given its vectorial form.
transformToResult(double[]) - Method in class de.citec.tcs.alignment.comparators.DTWKernelComparator
This method is supposed to construct the derivative for this comparator in an intuitive format given its vectorial form.
transformToResult(double[]) - Method in class de.citec.tcs.alignment.comparators.ReplacementComparator
This method is supposed to construct the derivative for this comparator in an intuitive format given its vectorial form.
transformToResult(double[]) - Method in class de.citec.tcs.alignment.comparators.SkipExtendedComparator
This method is supposed to construct the derivative for this comparator in an intuitive format given its vectorial form.
transformToResult(EnumMap<AbstractAffineAlignmentAlgorithm.Recurrence, double[][]>, double[][], double[], double[], double[], double[], Sequence, Sequence) - Method in class de.citec.tcs.alignment.SoftAffineAlignmentFullAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(EnumMap<AbstractAffineAlignmentAlgorithm.Recurrence, double[][]>, double[][], double[], double[], double[], double[], Sequence, Sequence) - Method in class de.citec.tcs.alignment.SoftAffineAlignmentScoreAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(SoftPathModel.SoftMatrixEntry[][], Sequence, Sequence) - Method in class de.citec.tcs.alignment.SoftAlignmentFullAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(SoftPathModel.SoftMatrixEntry[][], Sequence, Sequence) - Method in class de.citec.tcs.alignment.SoftAlignmentSamplingAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(SoftAlignmentScoreAlgorithm.ScoreEntry[][], Sequence, Sequence) - Method in class de.citec.tcs.alignment.SoftAlignmentScoreAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(EnumMap<AbstractAffineAlignmentAlgorithm.Recurrence, double[][]>, double[][], double[], double[], double[], double[], Sequence, Sequence) - Method in class de.citec.tcs.alignment.StrictAffineAlignmentFullAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(EnumMap<AbstractAffineAlignmentAlgorithm.Recurrence, double[][]>, double[][], double[], double[], double[], double[], Sequence, Sequence) - Method in class de.citec.tcs.alignment.StrictAffineAlignmentScoreAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(StrictAlignmentFullAlgorithm.FullMatrixEntry[][], Sequence, Sequence) - Method in class de.citec.tcs.alignment.StrictAlignmentFullAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(StrictAlignmentScoreAlgorithm.ScoreEntry[][], Sequence, Sequence) - Method in class de.citec.tcs.alignment.StrictAlignmentScoreAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(StrictAllOptimalAlgorithm.FullMatrixEntry[][], Sequence, Sequence) - Method in class de.citec.tcs.alignment.StrictAllOptimalAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
transformToResult(double[][], Sequence, Sequence) - Method in class de.citec.tcs.alignment.StrictDTWFullAlgorithm
This method has to be implemented by sub classes to transform a calculated dynamic programming matrix to a valid result of that implementation.
transformToResult(double[][], Sequence, Sequence) - Method in class de.citec.tcs.alignment.StrictDTWScoreAlgorithm
This method has to be implemented by sub classes to transform a calculated dynamic programming matrix to a valid result of that implementation.
transformToResult(StrictAllOptimalAlgorithm.FullMatrixEntry[][], Sequence, Sequence) - Method in class de.citec.tcs.alignment.StrictKPathAlgorithm
This method should not be called from outside! The subclass uses this method to transform the alignment matrix and the input sequences to the actual alignment result.
TrivialEditComparator - Class in de.citec.tcs.alignment.comparators
This is a Comparator for SymbolicValues that just specifies a score for: the deletion of a symbol (1 per default) the insertion of a symbol (1 per default) the skip deletion of a symbol (0.5 per default) the skip insertion of a symbol (0.5 per default) a match between the same symbols (0 per default) a mismatch between different symbols (1 per default) Please note that this is just a special case of the much more general ReplacementComparator.
TrivialEditComparator() - Constructor for class de.citec.tcs.alignment.comparators.TrivialEditComparator
 

V

validate() - Method in class de.citec.tcs.alignment.adp.FlexibleGrammar
This ensures that the grammar is terminal, that is: 1.) There is at least one possible path of production rules that leads from the axiom to an accepting nonterminal.
validate(Value) - Method in class de.citec.tcs.alignment.sequence.KeywordSpecification
 
validate(Value) - Method in class de.citec.tcs.alignment.sequence.SymbolicKeywordSpecification
validate(Value) - Method in class de.citec.tcs.alignment.sequence.VectorialKeywordSpecification
Value - Interface in de.citec.tcs.alignment.sequence
This represents a single value for a keyword in a given node.
ValueColumn - Class in de.citec.tcs.alignment.visualization
This creates a HTML column containing the string representation of values in the left/right node of the input operation for the given keyword.
ValueColumn(String) - Constructor for class de.citec.tcs.alignment.visualization.ValueColumn
 
valueOf(String) - Static method in enum de.citec.tcs.alignment.AbstractAffineAlignmentAlgorithm.Recurrence
Returns the enum constant of this type with the specified name.
valueOf(String) - Static method in enum de.citec.tcs.alignment.adp.AffineGrammar.Nonterminal
Returns the enum constant of this type with the specified name.
valueOf(String) - Static method in enum de.citec.tcs.alignment.adp.GlobalAsymmetricGrammar.Nonterminal
Returns the enum constant of this type with the specified name.
valueOf(String) - Static method in enum de.citec.tcs.alignment.adp.GlobalGrammar.Nonterminal
Returns the enum constant of this type with the specified name.
valueOf(String) - Static method in enum de.citec.tcs.alignment.comparators.NCDComparator.CompressorType
Returns the enum constant of this type with the specified name.
valueOf(String) - Static method in enum de.citec.tcs.alignment.comparators.OperationType
Returns the enum constant of this type with the specified name.
valueOf(String) - Static method in enum de.citec.tcs.alignment.ScoreBasedWeighting
Returns the enum constant of this type with the specified name.
valueOf(String) - Static method in enum de.citec.tcs.alignment.sequence.ValueType
Returns the enum constant of this type with the specified name.
values() - Static method in enum de.citec.tcs.alignment.AbstractAffineAlignmentAlgorithm.Recurrence
Returns an array containing the constants of this enum type, in the order they are declared.
values() - Static method in enum de.citec.tcs.alignment.adp.AffineGrammar.Nonterminal
Returns an array containing the constants of this enum type, in the order they are declared.
values() - Static method in enum de.citec.tcs.alignment.adp.GlobalAsymmetricGrammar.Nonterminal
Returns an array containing the constants of this enum type, in the order they are declared.
values() - Static method in enum de.citec.tcs.alignment.adp.GlobalGrammar.Nonterminal
Returns an array containing the constants of this enum type, in the order they are declared.
values() - Static method in enum de.citec.tcs.alignment.comparators.NCDComparator.CompressorType
Returns an array containing the constants of this enum type, in the order they are declared.
values() - Static method in enum de.citec.tcs.alignment.comparators.OperationType
Returns an array containing the constants of this enum type, in the order they are declared.
values() - Static method in enum de.citec.tcs.alignment.ScoreBasedWeighting
Returns an array containing the constants of this enum type, in the order they are declared.
values() - Static method in enum de.citec.tcs.alignment.sequence.ValueType
Returns an array containing the constants of this enum type, in the order they are declared.
ValueType - Enum in de.citec.tcs.alignment.sequence
This defines all possible types of values.
VectorialKeywordSpecification - Class in de.citec.tcs.alignment.sequence
This specifies vectors by their length.
VectorialKeywordSpecification(int, String) - Constructor for class de.citec.tcs.alignment.sequence.VectorialKeywordSpecification
 
VectorialSequences - Class in de.citec.tcs.alignment.wrappers
This provides an easier interface for simple vectorial sequences.
VectorialSequences() - Constructor for class de.citec.tcs.alignment.wrappers.VectorialSequences
 
VectorialValue - Class in de.citec.tcs.alignment.sequence
This value is reserved for numeric vectors, represented internally as doubles.
VectorialValue() - Constructor for class de.citec.tcs.alignment.sequence.VectorialValue
 
VectorialValue(double[]) - Constructor for class de.citec.tcs.alignment.sequence.VectorialValue
 
VectorialValue(Object) - Constructor for class de.citec.tcs.alignment.sequence.VectorialValue
 
visualize(AlignmentPath, File) - Method in class de.citec.tcs.alignment.visualization.AbstractVisualizer
Returns the visualization as string.
visualize(AlignmentPath, String) - Method in class de.citec.tcs.alignment.visualization.AbstractVisualizer
Returns the visualization as string.
visualize(AlignmentPath, OutputStream) - Method in class de.citec.tcs.alignment.visualization.HTMLVisualizer
A visualization in this sense is some arbitrary data that can be written to an output stream and is created from an AlignmentPath.
visualize(AlignmentPath, OutputStream) - Method in class de.citec.tcs.alignment.visualization.StringVisualizer
A visualization in this sense is some arbitrary data that can be written to an output stream and is created from an AlignmentPath.
visualize(AlignmentPath, OutputStream) - Method in interface de.citec.tcs.alignment.visualization.Visualizer
A visualization in this sense is some arbitrary data that can be written to an output stream and is created from an AlignmentPath.
visualizeMatrix(AlignmentPath[][], String[], File, boolean) - Method in class de.citec.tcs.alignment.visualization.HTMLVisualizer
This takes a full or sparse matrix of AlignmentPaths and provides HTML output for it.
visualizeMatrix(AlignmentPath[][], String[], String[], File, boolean) - Method in class de.citec.tcs.alignment.visualization.HTMLVisualizer
This takes a full or sparse matrix of AlignmentPaths and provides HTML output for it.
Visualizer - Interface in de.citec.tcs.alignment.visualization
This is an interface for visualizers.

W

workingDir - Variable in class de.citec.tcs.alignment.visualization.SourceCodeColumn
 
writeFromClassPath(String, Writer) - Static method in class de.citec.tcs.alignment.visualization.HTMLVisualizer
Writes the data found at the given path in the class path to the given writer.
writeFromClassPath(Class, String, Writer) - Static method in class de.citec.tcs.alignment.visualization.HTMLVisualizer
Writes the data found at the given path in the class path to the given writer.

Z

ZeroNormComparator - Class in de.citec.tcs.alignment.comparators
This comparator works on basis of the zero norm.
ZeroNormComparator(VectorialKeywordSpecification) - Constructor for class de.citec.tcs.alignment.comparators.ZeroNormComparator
 
ZeroNormComparator(int) - Constructor for class de.citec.tcs.alignment.comparators.ZeroNormComparator
 
A C D E F G H I J K L M N O P R S T V W Z 

Copyright (C) 2013-2015 Benjamin Paaßen, Georg Zentgraf, AG Theoretical Computer Science, Centre of Excellence Cognitive Interaction Technology (CITEC), University of Bielefeld, licensed under the AGPL v. 3: http://openresearch.cit-ec.de/projects/tcs