a

algorithms

This module defines the interface for AlignmentAlgorithms as well as some helper classes. An AlignmentAlgorithm computes an alignment of two given input sequences, given an AlignmentSpecification. An AlignmentSpecification in turn is a vector of Comparators (refer to the respective module for more information), such that the distance between two elements of the input sequences can be computed. In that sense all an AlignmentAlgorithm has to do is to implement the computation of an Alignment, under the assumption that a distance between sequence elements is given as the weighted sum of comparator distances, as specified in the AlignmentSpecification. An AlignmentAlgorithm does not need to calculate just a real-valued distance between the input sequences but may also provide additional information about the alignment in order to calculate a derivative. To store such additional information this module contains the AlignmentDerivativeAlgorithm. A usual implementation of this is classic backtracing, which can be stored in an AlignmentPath object. If an AlignmentAlgorithm returns several possible AlignmentPaths, they can be stored in the PathList or PathMap datastructure. To make an alignment distance differentiable, we usually employ the Softmin approximation of the strict minimum. A standard implementation is provided in the Softmin class. For faster (parallel) computation of many different alignments or derivatives we also provide the ParallelProcessingEngine, the ParallelDerivativeEngine and the ParallelWeightDerivativeEngine.
http://openresearch.cit-ec.de/projects/tcs
The GNU Affero General Public License, Version 3
Benjamin Paaßen
pathlist need they store provide calculate contains distances derivative more given refer alignments returns elements alignmentderivativealgorithm valued alignmentspecification turn information such comparators under class sense many differentiable that input defines parallelderivativeengine pathmap several computation strict make this some different does alignment parallelweightderivativeengine softmin alignmentpath parallelprocessingengine alignmentalgorithm minimum computes about well object derivatives real distance backtracing possible faster weighted respective order vector computed usually implement between classic just classes usual parallel module alignmentalgorithms helper standard sequences comparator alignmentpaths interface stored employ which specified additional sequence implementation approximation assumption provided datastructure also
Files download
File Operation
algorithms-2.0.0.jar download
algorithms-2.0.0.pom download
algorithms-2.0.0-sources.jar download
Apache Maven 
<dependency>
  <groupId>de.cit-ec.tcs.alignment</groupId>
  <artifactId>algorithms</artifactId>
  <version>2.0.0</version>
</dependency>
Gradle Groovy 
implementation 'de.cit-ec.tcs.alignment:algorithms:2.0.0'
Gradle Kotlin 
implementation("de.cit-ec.tcs.alignment:algorithms:2.0.0")
Scala SBT 
libraryDependencies += "de.cit-ec.tcs.alignment" % "algorithms" % "2.0.0"
Groovy Grape 
@Grapes(
  @Grab(group='de.cit-ec.tcs.alignment', module='algorithms', version='2.0.0')
)
Apache Ivy 
<dependency org="de.cit-ec.tcs.alignment" name="algorithms" rev="2.0.0" />
Leiningen 
[de.cit-ec.tcs.alignment/algorithms "2.0.0"]
Apache Buildr 
'de.cit-ec.tcs.alignment:algorithms:jar:2.0.0'
Dependencies

compile

|-- de.cit-ec.tcs.alignment:comparators:2.0.0

|-- de.cit-ec.tcs.alignment:parallel:2.0.0

test

|-- de.cit-ec.tcs.alignment:comparators-lib:2.0.0

|-- junit:junit:4.10