Package | Description |
---|---|
de.citec.tcs.alignment |
This module defines the interface for AlignmentAlgorithms as well as some helper classes.
|
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 |
This module defines the interfaces for Comparators in the TCS Alignment Toolbox.
|
Modifier and Type | Method and Description |
---|---|
Comparator<X,Y> |
AbstractStrictDTWAlgorithm.getComparator() |
Comparator<X,Y> |
AbstractStrictAlignmentAlgorithm.getComparator() |
Comparator<X,Y> |
AlignmentAlgorithm.getComparator()
This should return the Comparator used to compute local distances for this algorithm.
|
Modifier and Type | Method and Description |
---|---|
static <X,Y> IllegalArgumentException |
ComparatorValidator.checkValidity(AlignmentAlgorithm<X,Y,?> algorithm,
Comparator<? extends X,? extends Y> comp)
Checks whether the given Comparator supports all OperationType the given AlignmentAlgorithm
requires and returns an IllegalArgumentException if it does not.
|
static <X,Y> boolean |
ComparatorValidator.isValid(AlignmentAlgorithm<X,Y,?> algorithm,
Comparator<? extends X,? extends Y> comp)
Returns true if and only if the given Comparator supports all OperationType the given
AlignmentAlgorithm requires.
|
void |
AbstractStrictDTWAlgorithm.setComparator(Comparator<X,Y> comparator) |
void |
AbstractStrictAlignmentAlgorithm.setComparator(Comparator<X,Y> comparator) |
void |
AlignmentAlgorithm.setComparator(Comparator<X,Y> comparator)
This should set the Comparator used to compute local distances for this algorithm.
|
static <X,Y> void |
ComparatorValidator.validate(AlignmentAlgorithm<X,Y,?> algorithm,
Comparator<? extends X,? extends Y> comp)
Checks whether the given Comparator supports all OperationType the given AlignmentAlgorithm
requires and throws an IllegalArgumentException if it does not.
|
Constructor and Description |
---|
AbstractStrictAlignmentAlgorithm(Comparator<X,Y> comparator,
Class<R> resultClass) |
AbstractStrictDTWAlgorithm(Class<R> resultClass,
Comparator<X,Y> comparator) |
Alignment(Comparator<X,Y> comparator,
List<X> left,
List<Y> right,
double distance) |
Alignment(List<Operation<X,Y>> operations,
Comparator<X,Y> comparator,
List<X> left,
List<Y> right,
double distance) |
CooptimalModel(Comparator<X,Y> comparator,
List<X> left,
List<Y> right,
double distance) |
StrictAlignmentAllOptimalAlgorithm(Comparator<X,Y> comparator) |
StrictAlignmentFullAlgorithm(Comparator<X,Y> comparator) |
StrictAlignmentScoreAlgorithm(Comparator<X,Y> comparator) |
StrictDTWFullAlgorithm(Comparator<X,Y> comp) |
StrictDTWScoreAlgorithm(Comparator<X,Y> comp) |
Modifier and Type | Method and Description |
---|---|
Comparator<X,Y> |
SparseAbstractADPAlgorithm.getComparator() |
Comparator<X,Y> |
AbstractADPAlgorithm.getComparator() |
Modifier and Type | Method and Description |
---|---|
static IllegalArgumentException |
ComparatorValidator.checkValidity(Grammar grammar,
Comparator comp)
Checks whether the given Comparator supports all OperationType the given Grammar
requires and returns an IllegalArgumentException if it does not.
|
static boolean |
ComparatorValidator.isValid(Grammar grammar,
Comparator comp)
Returns true if and only if the given Comparator supports all OperationType the given
Grammar requires.
|
void |
SparseAbstractADPAlgorithm.setComparator(Comparator<X,Y> comparator) |
void |
AbstractADPAlgorithm.setComparator(Comparator<X,Y> comparator) |
static void |
ComparatorValidator.validate(Grammar grammar,
Comparator comp)
Checks whether the given Comparator supports all OperationType the given Grammar
requires and throws an IllegalArgumentException if it does not.
|
Constructor and Description |
---|
AbstractADPAlgorithm(Grammar<N> grammar,
Class<R> resultClass,
Comparator<X,Y> comparator) |
SoftADPFullAlgorithm(Grammar<N> grammar,
Comparator<X,Y> comparator)
Creates a new SoftFullAlgorithm based on the given ADP grammar
and the given Comparator/algebra.
|
SoftADPPathModel(Comparator<X,Y> comparator,
Grammar<N> grammar,
double beta,
double approxThreshold,
double distance,
EnumMap<N,double[][]> dpTables,
EnumMap<OperationType,double[][]> repMatrices,
EnumMap<OperationType,double[]> delVectors,
EnumMap<OperationType,double[]> insVectors,
List<X> left,
List<Y> right) |
SoftADPScoreAlgorithm(Grammar<N> grammar,
Comparator<X,Y> comparator) |
SparseAbstractADPAlgorithm(SparseGrammar<N> grammar,
Class<R> resultClass,
Comparator<X,Y> comparator) |
SparseStrictADPFullAlgorithm(SparseGrammar<N> grammar,
Comparator<X,Y> comparator) |
SparseStrictADPScoreAlgorithm(SparseGrammar<N> grammar,
Comparator<X,Y> comparator) |
StrictADPCooptimalAlgorithm(Grammar<N> grammar,
Comparator<X,Y> comparator) |
StrictADPFullAlgorithm(Grammar<N> grammar,
Comparator<X,Y> comparator) |
StrictADPScoreAlgorithm(Grammar<N> grammar,
Comparator<X,Y> comparator) |
Modifier and Type | Interface and Description |
---|---|
interface |
DerivableComparator<X,Y>
This is an interface for comparators that have derivable parameters.
|
interface |
ValueComparator
An interface for comparators on Values as defined in the sequence module.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractDerivableValueComparatorWrapper<V>
An abstract convenience implementation of the ValueComparator interface and the
DerivableComparator interface.
|
class |
AbstractValueComparatorWrapper<V>
An abstract convenience implementation of the ValueComparator interface.
|
class |
AlignmentSpecification
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.
|
class |
CharStatComparator
This compares strings using statistics over the number of letters inside.
|
class |
ComparisonBasedSkipExtendedComparator<X,Y>
This is an abstract class providing - in addition to the constant gap and skip costs provided by
the SkipExtendedComparator - the possibility to define gap and skip costs with respect to a
constant element from both input sets.
|
class |
DerivableStringComparatorWrapper
This is a wrapper for Comparators on StringValues.
|
class |
DerivableSymbolicComparatorWrapper
This is a wrapper for Comparators on SymbolicValues.
|
class |
DerivableVectorialComparatorWrapper
This is a wrapper for Comparators on VectorialValues.
|
class |
EuclideanComparator
Compares vectors using the L2-Norm.
|
class |
L1NormComparator
Compares vectors using the L1-Norm.
|
class |
NCDComparator
This compares strings using normalized compression distance.
|
class |
NormalizedEuclideanComparator
Implements a normalized L2 distance, defined as:
||x - y|| / (||x|| + ||y||) .
|
class |
NormalizedEuclideanRelevanceComparator
Implements a normalized relevance L2 distance, defined as:
||Λ * x - Λ * y|| / (||Λ * x|| + ||Λ * y||)
where Λ is a diagonal matrix.
|
class |
NormalizedL1Comparator
Implements a normalized L1 distance, defined as:
|x - y| / (|x| + |y|) .
|
class |
NormalizedL1RelevanceComparator
Implements a normalized relevance L1 distance, defined as:
|Λ * x - Λ * y| / (|Λ * x| + |Λ * y|)
where Λ is a diagonal matrix.
|
class |
ParameterLessComparisonBasedSkipExtendedComparator<X,Y>
A convenience implementation for ComparisonBasedSkipExtendedComparators without (own) parameters.
|
class |
ParameterLessSkipExtendedComparator<X,Y>
A convenience implementation for SkipExtendedComparators without (own) parameters.
|
class |
SkipExtendedComparator<X,Y>
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.
|
class |
SquareReplacementMatrixComparator<X>
This comparator defines explicit replacement (and deletion/insertion) costs for comparison of
values from a discrete set.
|
class |
StringComparatorWrapper
This is a wrapper for Comparators on StringValues.
|
class |
SymbolicComparatorWrapper
This is a wrapper for Comparators on SymbolicValues.
|
class |
TrivialEditComparator<X>
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.
|
class |
VectorialComparatorWrapper
This is a wrapper for Comparators on VectorialValues.
|
class |
ZeroNormComparator
This comparator works on basis of the zero norm.
|
Constructor and Description |
---|
AbstractValueComparatorWrapper(String keyword,
ValueType type,
Comparator<V,V> actualComparator) |
StringComparatorWrapper(String keyword,
Comparator<String,String> actualComparator) |
SymbolicComparatorWrapper(String keyword,
Comparator<String,String> actualComparator) |
VectorialComparatorWrapper(String keyword,
Comparator<double[],double[]> actualComparator) |
Copyright (C) 2016 Benjamin Paaßen, 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 . This documentation is licensed under the conditions of CC-BY-SA 4.0: https://creativecommons.org/licenses/by-sa/4.0/