Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Class
de.jstacs.data.AlphabetContainer

Packages that use AlphabetContainer
de.jstacs.classifiers | This package provides the framework for any classifier.
de.jstacs.classifiers.differentiableSequenceScoreBased | Provides the classes for `Classifier`s that are based on `SequenceScore`s.
de.jstacs.classifiers.differentiableSequenceScoreBased.gendismix | Provides an implementation of a classifier that allows to train the parameters of a set of `DifferentiableStatisticalModel`s by a unified generative-discriminative learning principle
de.jstacs.classifiers.differentiableSequenceScoreBased.sampling | Provides the classes for `AbstractScoreBasedClassifier`s that are based on `SamplingDifferentiableStatisticalModel`s and that sample parameters using the Metropolis-Hastings algorithm.
de.jstacs.data | Provides classes for the representation of data.
de.jstacs.data.alphabets | Provides classes for the representation of discrete and continuous alphabets, including a `DNAAlphabet` for the most common case of DNA-sequences
de.jstacs.data.sequences | Provides classes for representing sequences.
de.jstacs.data.sequences.annotation | Provides the facilities to annotate `Sequence`s using a number of pre-defined annotation types, or additional implementations of the `SequenceAnnotation` class
de.jstacs.io | Provides classes for reading data from and writing to a file and storing a number of datatypes, including all primitives, arrays of primitives, and `Storable`s to an XML-representation
de.jstacs.parameters | This package provides classes for parameters that establish a general convention for the description of parameters as defined in the `Parameter`-interface.
de.jstacs.sequenceScores | Provides all `SequenceScore`s, which can be used to score a `Sequence`, typically using some model assumptions.
de.jstacs.sequenceScores.differentiable |
de.jstacs.sequenceScores.differentiable.logistic |
de.jstacs.sequenceScores.statisticalModels.differentiable | Provides all `DifferentiableStatisticalModel`s, which can compute the gradient with respect to their parameters for a given input `Sequence`.
de.jstacs.sequenceScores.statisticalModels.differentiable.directedGraphicalModels | Provides `DifferentiableStatisticalModel`s that are directed graphical models.
de.jstacs.sequenceScores.statisticalModels.differentiable.homogeneous | Provides `DifferentiableStatisticalModel`s that are homogeneous, i.e. model probabilities or scores independent of the position within a sequence
de.jstacs.sequenceScores.statisticalModels.differentiable.mixture.motif |
de.jstacs.sequenceScores.statisticalModels.trainable | Provides all `TrainableStatisticalModel`s, which can be learned from a single `DataSet`.
de.jstacs.sequenceScores.statisticalModels.trainable.discrete |
de.jstacs.sequenceScores.statisticalModels.trainable.discrete.homogeneous |
de.jstacs.sequenceScores.statisticalModels.trainable.discrete.homogeneous.parameters |
de.jstacs.sequenceScores.statisticalModels.trainable.discrete.inhomogeneous | This package contains various inhomogeneous models.
de.jstacs.sequenceScores.statisticalModels.trainable.discrete.inhomogeneous.parameters |
de.jstacs.sequenceScores.statisticalModels.trainable.hmm | The package provides all interfaces and classes for a hidden Markov model (HMM).
de.jstacs.sequenceScores.statisticalModels.trainable.hmm.states.emissions |
de.jstacs.sequenceScores.statisticalModels.trainable.hmm.states.emissions.continuous |
de.jstacs.sequenceScores.statisticalModels.trainable.hmm.states.emissions.discrete |

Uses of AlphabetContainer in de.jstacs.classifiers

Methods in de.jstacs.classifiers that return AlphabetContainer
`AlphabetContainer` | `AbstractClassifier.getAlphabetContainer()` This method returns the container of alphabets that is used in the classifier.

Constructors in de.jstacs.classifiers with parameters of type AlphabetContainer
`AbstractClassifier(AlphabetContainer abc)` The constructor for a homogeneous classifier.
`AbstractClassifier(AlphabetContainer abc, int length)` The constructor for an inhomogeneous classifier.
`AbstractScoreBasedClassifier(AlphabetContainer abc, int classes)` The constructor for a homogeneous classifier.
`AbstractScoreBasedClassifier(AlphabetContainer abc, int classes, double classWeight)` The constructor for a homogeneous classifier.
`AbstractScoreBasedClassifier(AlphabetContainer abc, int length, int classes)` The constructor for an inhomogeneous classifier.
`AbstractScoreBasedClassifier(AlphabetContainer abc, int length, int classes, double classWeight)` The constructor for an inhomogeneous classifier.

Uses of AlphabetContainer in de.jstacs.classifiers.differentiableSequenceScoreBased

Constructors in de.jstacs.classifiers.differentiableSequenceScoreBased with parameters of type AlphabetContainer
`ScoreClassifierParameterSet(Class<? extends ScoreClassifier> instanceClass, AlphabetContainer alphabet, int length, byte algo, AbstractTerminationCondition tc, double lineps, double startD, boolean free, OptimizableFunction.KindOfParameter kind)` The constructor for a simple, instantiated parameter set.
`ScoreClassifierParameterSet(Class<? extends ScoreClassifier> instanceClass, AlphabetContainer alphabet, int length, byte algo, double eps, double lineps, double startD, boolean free, OptimizableFunction.KindOfParameter kind)` The constructor for a simple, instantiated parameter set.

Uses of AlphabetContainer in de.jstacs.classifiers.differentiableSequenceScoreBased.gendismix

Constructors in de.jstacs.classifiers.differentiableSequenceScoreBased.gendismix with parameters of type AlphabetContainer
`GenDisMixClassifierParameterSet(AlphabetContainer alphabet, int length, byte algo, double eps, double lineps, double startD, boolean free, OptimizableFunction.KindOfParameter kind, boolean norm, int threads)` The default constructor that constructs a new `GenDisMixClassifierParameterSet`.
`GenDisMixClassifierParameterSet(Class<? extends ScoreClassifier> instanceClass, AlphabetContainer alphabet, int length, byte algo, double eps, double lineps, double startD, boolean free, OptimizableFunction.KindOfParameter kind, boolean norm, int threads)` The default constructor that constructs a new `GenDisMixClassifierParameterSet`.

Uses of AlphabetContainer in de.jstacs.classifiers.differentiableSequenceScoreBased.sampling

Constructors in de.jstacs.classifiers.differentiableSequenceScoreBased.sampling with parameters of type AlphabetContainer
`SamplingGenDisMixClassifierParameterSet(AlphabetContainer alphabet, int length, int numStarts, int testSamplings, int stationarySamplings, String outfilePrefix, int threads)` Create a new `SamplingGenDisMixClassifierParameterSet` with a grouped sampling scheme, sampling all parameters (and not only the free ones), and adaption of the variance.
`SamplingGenDisMixClassifierParameterSet(AlphabetContainer alphabet, int length, int numStarts, SamplingScoreBasedClassifier.SamplingScheme scheme, int testSamplings, int stationarySamplings, boolean freeParameters, boolean adaptVariance, String outfilePrefix, int threads)` Create a new `SamplingGenDisMixClassifierParameterSet`.
`SamplingGenDisMixClassifierParameterSet(Class<? extends SamplingScoreBasedClassifier> instanceClass, AlphabetContainer alphabet, int length, int numStarts, SamplingScoreBasedClassifier.SamplingScheme scheme, int testSamplings, int stationarySamplings, boolean freeParameters, boolean adaptVariance, String outfilePrefix, int threads)` Create a new `SamplingGenDisMixClassifierParameterSet`.
`SamplingScoreBasedClassifierParameterSet(Class<? extends SamplingScoreBasedClassifier> instanceClass, AlphabetContainer alphabet, int length, int numStarts, int testSamplings, int stationarySamplings, String outfilePrefix)` Create a new `SamplingScoreBasedClassifierParameterSet` with a grouped sampling scheme, sampling all parameters (and not only the free ones), and adaption of the variance.
`SamplingScoreBasedClassifierParameterSet(Class<? extends SamplingScoreBasedClassifier> instanceClass, AlphabetContainer alphabet, int length, int numStarts, SamplingScoreBasedClassifier.SamplingScheme scheme, int testSamplings, int stationarySamplings, boolean freeParameters, boolean adaptVariance, String outfilePrefix)` Create a new `SamplingScoreBasedClassifierParameterSet`.

Uses of AlphabetContainer in de.jstacs.data

Classes in de.jstacs.data with type parameters of type AlphabetContainer
`static class` | `AlphabetContainer.AbstractAlphabetContainerParameterSet<T extends AlphabetContainer>` This class is the super class of any `InstanceParameterSet` for `AlphabetContainer`.

Methods in de.jstacs.data that return AlphabetContainer
`AlphabetContainer` | `DataSet.getAlphabetContainer()` Returns the `AlphabetContainer` of this `DataSet`.
`AlphabetContainer` | `AlphabetContainer.getCompositeContainer(int[] start, int[] length)` Returns an `AlphabetContainer` of `Alphabet`s e.g. for composite motifs/sequences.
`static AlphabetContainer` | `AlphabetContainer.getSimplifiedAlphabetContainer(Alphabet[] abc, int[] assignment)` This method creates a new `AlphabetContainer` that uses as less as possible `Alphabet`s to describe the container.
`AlphabetContainer` | `AlphabetContainer.getSubContainer(int start, int length)` Returns a sub-container with the `Alphabet`s for the positions starting at `start` and with length `length`.
`static AlphabetContainer` | `AlphabetContainer.insertAlphabet(AlphabetContainer aC, Alphabet a, boolean[] useNewAlphabet)` This method may be used to construct a new `AlphabetContainer` by incorporating additional `Alphabet`s into an existing `AlphabetContainer`.

Methods in de.jstacs.data that return types with arguments of type AlphabetContainer
`AlphabetContainer.AbstractAlphabetContainerParameterSet<? extends AlphabetContainer>` | `AlphabetContainer.getCurrentParameterSet()`

Methods in de.jstacs.data with parameters of type AlphabetContainer
`boolean` | `AlphabetContainer.checkConsistency(AlphabetContainer abc)` Checks if this `AlphabetContainer` is consistent consistent with another `AlphabetContainer`.
`int` | `AlphabetContainer.compareTo(AlphabetContainer abc)`
`static AlphabetContainer` | `AlphabetContainer.insertAlphabet(AlphabetContainer aC, Alphabet a, boolean[] useNewAlphabet)` This method may be used to construct a new `AlphabetContainer` by incorporating additional `Alphabet`s into an existing `AlphabetContainer`.

Constructors in de.jstacs.data with parameters of type AlphabetContainer
`AlphabetContainer(AlphabetContainer[] cons, int[] lengths)` Creates an new sparse `AlphabetContainer` based on given `AlphabetContainer`s.
`DataSet(AlphabetContainer abc, AbstractStringExtractor se)` Creates a new `DataSet` from a `StringExtractor` using the given `AlphabetContainer`.
`DataSet(AlphabetContainer abc, AbstractStringExtractor se, int subsequenceLength)` Creates a new `DataSet` from a `StringExtractor` using the given `AlphabetContainer` and all overlapping windows of length `subsequenceLength`.
`DataSet(AlphabetContainer abc, AbstractStringExtractor se, String delim)` Creates a new `DataSet` from a `StringExtractor` using the given `AlphabetContainer` and a delimiter `delim`.
`DataSet(AlphabetContainer abc, AbstractStringExtractor se, String delim, int subsequenceLength)` Creates a new `DataSet` from a `StringExtractor` using the given `AlphabetContainer`, the given delimiter `delim` and all overlapping windows of length `subsequenceLength`.
`DiscreteSequenceEnumerator(AlphabetContainer con, int length, boolean sparse)` Creates a new `DiscreteSequenceEnumerator` from a given `AlphabetContainer` and a length.

Constructor parameters in de.jstacs.data with type arguments of type AlphabetContainer
`AlphabetContainerParameterSet(Class<? extends AlphabetContainer> instanceClass, Alphabet... alphabets)` /** Creates a new `AlphabetContainerParameterSet` from an array of `Alphabet`s for a given sub-class of `AlphabetContainer`.

Uses of AlphabetContainer in de.jstacs.data.alphabets

Subclasses of AlphabetContainer in de.jstacs.data.alphabets
`class` | `DNAAlphabetContainer` This class implements a singleton for an `AlphabetContainer` that can be used for DNA.

Uses of AlphabetContainer in de.jstacs.data.sequences

Fields in de.jstacs.data.sequences declared as AlphabetContainer
`protected AlphabetContainer` | `Sequence.alphabetCon` The underlying alphabets.
`protected AlphabetContainer` | `MappedDiscreteSequence.originalAlphabetContainer` The original `AlphabetContainer`.

Methods in de.jstacs.data.sequences that return AlphabetContainer
`AlphabetContainer` | `Sequence.getAlphabetContainer()` Return the alphabets, i.e. the `AlphabetContainer`, used in this `Sequence`.
`static AlphabetContainer` | `MappedDiscreteSequence.getNewAlphabetContainer(AlphabetContainer original, DiscreteAlphabetMapping... transformation)` This method allows to create a new `AlphabetContainer` given an old `AlphabetContainer` and some `DiscreteAlphabetMapping`s.

Methods in de.jstacs.data.sequences with parameters of type AlphabetContainer
`static Sequence` | `Sequence.create(AlphabetContainer con, SequenceAnnotation[] annotation, String sequence, String delim)` Creates a `Sequence` from a `String` based on the given `AlphabetContainer` using the given delimiter `delim` and some `annotation` for the `Sequence`.
`static Sequence` | `Sequence.create(AlphabetContainer con, String sequence)` Creates a `Sequence` from a `String` based on the given `AlphabetContainer` using the standard delimiter for this `AlphabetContainer`.
`static Sequence` | `Sequence.create(AlphabetContainer con, String sequence, String delim)` Creates a `Sequence` from a `String` based on the given `AlphabetContainer` using the given delimiter `delim`.
`Sequence<T>` | `Sequence.getCompositeSequence(AlphabetContainer abc, int[] starts, int[] lengths)` This method should be used if one wants to create a `DataSet` of `Sequence.CompositeSequence`s.
`static DataSet` | `SparseSequence.getDataSet(AlphabetContainer con, AbstractStringExtractor... se)` This method allows to create a `DataSet` containing `SparseSequence`s.
`static DataSet` | `ArbitraryFloatSequence.getDataSet(AlphabetContainer con, AbstractStringExtractor... se)` This method allows to create a `DataSet` containing `ArbitraryFloatSequence`s.
`static DataSet` | `SparseSequence.getDataSet(AlphabetContainer con, String filename)` This method allows to create a `DataSet` containing `SparseSequence`s using a file name.
`static DataSet` | `ArbitraryFloatSequence.getDataSet(AlphabetContainer con, String filename)` This method allows to create a `DataSet` containing `ArbitraryFloatSequence`s using a file name.
`static DataSet` | `SparseSequence.getDataSet(AlphabetContainer con, String filename, SequenceAnnotationParser parser)` This method allows to create a `DataSet` containing `SparseSequence`s using a file name.
`static DataSet` | `ArbitraryFloatSequence.getDataSet(AlphabetContainer con, String filename, SequenceAnnotationParser parser)` This method allows to create a `DataSet` containing `ArbitraryFloatSequence`s using a file name.
`static AlphabetContainer` | `MappedDiscreteSequence.getNewAlphabetContainer(AlphabetContainer original, DiscreteAlphabetMapping... transformation)` This method allows to create a new `AlphabetContainer` given an old `AlphabetContainer` and some `DiscreteAlphabetMapping`s.
`Sequence` | `Sequence.getSubSequence(AlphabetContainer abc, int start)` This method should be used if one wants to create a `DataSet` of subsequences of defined length.
`Sequence` | `Sequence.getSubSequence(AlphabetContainer abc, int start, int length)` This method should be used if one wants to create a `DataSet` of subsequences of defined length.

Constructors in de.jstacs.data.sequences with parameters of type AlphabetContainer
`ArbitraryFloatSequence(AlphabetContainer alphabetContainer, float[] content)` Creates a new `ArbitraryFloatSequence` from an array of `float`-encoded alphabet symbols.
`ArbitraryFloatSequence(AlphabetContainer alphabetContainer, SequenceAnnotation[] annotation, String sequence, String delim)` Creates a new `ArbitraryFloatSequence` from a `String` representation using the delimiter `delim`.
`ArbitraryFloatSequence(AlphabetContainer alphabetContainer, SequenceAnnotation[] annotation, SymbolExtractor extractor)` Creates a new `ArbitraryFloatSequence` from a `SymbolExtractor`.
`ArbitraryFloatSequence(AlphabetContainer alphabetContainer, String sequence)` Creates a new `ArbitraryFloatSequence` from a `String` representation using the default delimiter.
`ArbitrarySequence(AlphabetContainer alphabetContainer, double[] content)` Creates a new `ArbitrarySequence` from an array of `double`-encoded alphabet symbols.
`ArbitrarySequence(AlphabetContainer alphabetContainer, SequenceAnnotation[] annotation, String sequence, String delim)` Creates a new `ArbitrarySequence` from a `String` representation using the delimiter `delim`.
`ArbitrarySequence(AlphabetContainer alphabetContainer, SequenceAnnotation[] annotation, SymbolExtractor extractor)` Creates a new `ArbitrarySequence` from a `SymbolExtractor`.
`ArbitrarySequence(AlphabetContainer alphabetContainer, String sequence)` Creates a new `ArbitrarySequence` from a `String` representation using the default delimiter.
`ByteSequence(AlphabetContainer alphabetContainer, byte[] content)` Creates a new `ByteSequence` from an array of `byte`- encoded alphabet symbols.
`ByteSequence(AlphabetContainer alphabetContainer, SequenceAnnotation[] annotation, String sequence, String delim)` Creates a new `ByteSequence` from a `String` representation using the delimiter `delim`.
`ByteSequence(AlphabetContainer alphabetContainer, SequenceAnnotation[] annotation, SymbolExtractor extractor)` Creates a new `ByteSequence` from a `SymbolExtractor`.
`ByteSequence(AlphabetContainer alphabetContainer, String sequence)` Creates a new `ByteSequence` from a `String` representation using the default delimiter.
`IntSequence(AlphabetContainer alphabetContainer, int... content)` Creates a new `IntSequence` from an array of `int`- encoded alphabet symbols.
`IntSequence(AlphabetContainer alphabetContainer, int[] content, int start, int length)` Creates a new `IntSequence` from a part of the array of `int`- encoded alphabet symbols.
`IntSequence(AlphabetContainer alphabetContainer, SequenceAnnotation[] annotation, String sequence, String delim)` Creates a new `IntSequence` from a `String` representation using the delimiter `delim`.
`IntSequence(AlphabetContainer alphabetContainer, SequenceAnnotation[] annotation, SymbolExtractor extractor)` Creates a new `IntSequence` from a `SymbolExtractor`.
`IntSequence(AlphabetContainer alphabetContainer, String sequence)` Creates a new `IntSequence` from a `String` representation using the default delimiter.
`MappedDiscreteSequence(AlphabetContainer originalAlphabetContainer, SequenceAnnotation[] seqAn, DiscreteAlphabetMapping... transformation)` This method allows to create an empty `MappedDiscreteSequence`.
`Sequence.CompositeSequence(AlphabetContainer abc, Sequence<T> seq, int[] starts, int[] lengths)` This constructor should be used if one wants to create a `DataSet` of `Sequence.CompositeSequence`s.
`Sequence.RecursiveSequence(AlphabetContainer alphabet, Sequence<T> seq)` Creates a new `Sequence.RecursiveSequence` on the `Sequence` `seq` with the `AlphabetContainer` `alphabet` using the annotation of the given `Sequence`.
`Sequence.RecursiveSequence(AlphabetContainer alphabet, SequenceAnnotation[] annotation, Sequence<T> seq)` Creates a new `Sequence.RecursiveSequence` on the `Sequence` `seq` with the `AlphabetContainer` `alphabet` and the annotation `annotation`.
`Sequence.SubSequence(AlphabetContainer abc, Sequence seq, int start, int length)` This constructor should be used if one wants to create a `DataSet` of `Sequence.SubSequence`s of defined length.
`Sequence(AlphabetContainer container, SequenceAnnotation[] annotation)` Creates a new `Sequence` with the given `AlphabetContainer` and the given annotation, but without the content.
`ShortSequence(AlphabetContainer alphabetContainer, SequenceAnnotation[] annotation, String sequence, String delim)` Creates a new `ShortSequence` from a `String` representation using the delimiter `delim`.
`ShortSequence(AlphabetContainer alphabetContainer, SequenceAnnotation[] annotation, SymbolExtractor extractor)` Creates a new `ShortSequence` from a `SymbolExtractor`.
`ShortSequence(AlphabetContainer alphabetContainer, short[] content)` Creates a new `ShortSequence` from an array of `short`- encoded alphabet symbols.
`ShortSequence(AlphabetContainer alphabetContainer, String sequence)` Creates a new `ShortSequence` from a `String` representation using the default delimiter.
`SimpleDiscreteSequence(AlphabetContainer container, SequenceAnnotation[] annotation)` This constructor creates a new `SimpleDiscreteSequence` with the `AlphabetContainer` `container` and the annotation `annotation` but without the content.
`SparseSequence(AlphabetContainer alphCon, String seq)` Creates a new `SparseSequence` from a `String` representation.
`SparseSequence(AlphabetContainer alphCon, SymbolExtractor se)` Creates a new `SparseSequence` from a `SymbolExtractor`.

Uses of AlphabetContainer in de.jstacs.data.sequences.annotation

Constructors in de.jstacs.data.sequences.annotation with parameters of type AlphabetContainer
`ReferenceSequenceAnnotationParser(String key, AlphabetContainer alphabet, String keyValueDelimiter, String annotationDelimiter)` Creates a new `ReferenceSequenceAnnotationParser` with user-specified delimiters.
`ReferenceSequenceAnnotationParser(String key, AlphabetContainer alphabet, String keyValueDelimiter, String annotationDelimiter, String delim)` Creates a new `ReferenceSequenceAnnotationParser` with user-specified delimiters.

Uses of AlphabetContainer in de.jstacs.io

Methods in de.jstacs.io with parameters of type AlphabetContainer
`static int` | `SymbolExtractor.filter(String inFile, char ignore, AlphabetContainer con, int minLength, String outFile)` This method allows the user to filter the content of a `File` using a given `AlphabetContainer` and a minimal sequence length.

Uses of AlphabetContainer in de.jstacs.parameters

Methods in de.jstacs.parameters that return AlphabetContainer
`AlphabetContainer` | `SequenceScoringParameterSet.getAlphabetContainer()` Returns the `AlphabetContainer` of the current instance.

Constructors in de.jstacs.parameters with parameters of type AlphabetContainer
`SequenceScoringParameterSet(Class<T> instanceClass, AlphabetContainer alphabet)` Constructs a `SequenceScoringParameterSet` for an object that can handle sequences of variable length and with the `AlphabetContainer` `alphabet`.
`SequenceScoringParameterSet(Class<T> instanceClass, AlphabetContainer alphabet, int length, boolean variableLength)` Constructs a `SequenceScoringParameterSet` from an `AlphabetContainer` and the length of a sequence.

Uses of AlphabetContainer in de.jstacs.sequenceScores

Methods in de.jstacs.sequenceScores that return AlphabetContainer
`AlphabetContainer` | `SequenceScore.getAlphabetContainer()` Returns the container of alphabets that were used when constructing the instance.

Uses of AlphabetContainer in de.jstacs.sequenceScores.differentiable

Fields in de.jstacs.sequenceScores.differentiable declared as AlphabetContainer
`protected AlphabetContainer` | `AbstractDifferentiableSequenceScore.alphabets` The `AlphabetContainer` of this `AbstractDifferentiableSequenceScore` .

Methods in de.jstacs.sequenceScores.differentiable that return AlphabetContainer
`AlphabetContainer` | `AbstractDifferentiableSequenceScore.getAlphabetContainer()`

Constructors in de.jstacs.sequenceScores.differentiable with parameters of type AlphabetContainer
`AbstractDifferentiableSequenceScore(AlphabetContainer alphabets, int length)` The main constructor.
`UniformDiffSS(AlphabetContainer alphabets, int length)` This is the main constructor that creates an instance of a `UniformDiffSS` that models each sequence uniformly.

Uses of AlphabetContainer in de.jstacs.sequenceScores.differentiable.logistic

Constructors in de.jstacs.sequenceScores.differentiable.logistic with parameters of type AlphabetContainer
`LogisticDiffSS(AlphabetContainer con, int length, LogisticConstraint... constraint)` This is the main constructor to create `LogisticDiffSS` instance.

Uses of AlphabetContainer in de.jstacs.sequenceScores.statisticalModels.differentiable

Methods in de.jstacs.sequenceScores.statisticalModels.differentiable with parameters of type AlphabetContainer
`static HomogeneousMMDiffSM` | `DifferentiableStatisticalModelFactory.createHomogeneousMarkovModel(AlphabetContainer con, double ess, int order, int priorLength)` This method returns a homogeneous Markov model with user-specified order.
`static BayesianNetworkDiffSM` | `DifferentiableStatisticalModelFactory.createInhomogeneousMarkovModel(AlphabetContainer con, int length, double ess, int order)` This method returns a inhomogeneous Markov model (IMM) with user-specified order.
`static MarkovRandomFieldDiffSM` | `DifferentiableStatisticalModelFactory.createMarkovRandomField(AlphabetContainer con, int length, String constraintType)` This method allows to create a `MarkovRandomFieldDiffSM` of the specified length and with the given constraint type.
`static BayesianNetworkDiffSM` | `DifferentiableStatisticalModelFactory.createPWM(AlphabetContainer con, int length, double ess)` This method returns a position weight matrix (PWM).

Constructors in de.jstacs.sequenceScores.statisticalModels.differentiable with parameters of type AlphabetContainer
`AbstractDifferentiableStatisticalModel(AlphabetContainer alphabets, int length)` The main constructor.
`AbstractVariableLengthDiffSM(AlphabetContainer alphabets)` This is the main constructor that creates an instance of a `VariableLengthDiffSM` that models sequences of arbitrary length.
`AbstractVariableLengthDiffSM(AlphabetContainer alphabets, int length)` This is the main constructor that creates an instance of a `VariableLengthDiffSM` that models sequences of a given length.
`CyclicMarkovModelDiffSM(AlphabetContainer alphabets, double[] frameHyper, double[][][] hyper, boolean plugIn, boolean optimize, int starts, int initFrame)` This constructor allows to create an instance with specific hyper-parameters for all conditional distributions.
`CyclicMarkovModelDiffSM(AlphabetContainer alphabets, int order, int period, double classEss, double[] sumOfHyperParams, boolean plugIn, boolean optimize, int starts, int initFrame)` The main constructor.
`MappingDiffSM(AlphabetContainer originalAlphabetContainer, DifferentiableStatisticalModel nsf, DiscreteAlphabetMapping... mapping)` The main constructor creating a `MappingDiffSM`.
`MarkovRandomFieldDiffSM(AlphabetContainer alphabets, int length, double ess, String constr)` This is the main constructor that creates an instance of a `MarkovRandomFieldDiffSM`.
`MarkovRandomFieldDiffSM(AlphabetContainer alphabets, int length, String constr)` This constructor creates an instance of a `MarkovRandomFieldDiffSM` with equivalent sample size (ess) 0.
`UniformDiffSM(AlphabetContainer alphabets, int length, double ess)` This is the main constructor that creates an instance of a `UniformDiffSM` that models each sequence uniformly.

Uses of AlphabetContainer in de.jstacs.sequenceScores.statisticalModels.differentiable.directedGraphicalModels

Constructors in de.jstacs.sequenceScores.statisticalModels.differentiable.directedGraphicalModels with parameters of type AlphabetContainer
`BayesianNetworkDiffSM(AlphabetContainer alphabet, int length, double ess, boolean plugInParameters, Measure structureMeasure)` Creates a new `BayesianNetworkDiffSM` that has neither been initialized nor trained.
`BayesianNetworkDiffSMParameterSet(AlphabetContainer alphabet, int length, double ess, boolean plugInParameters, Measure structureMeasure)` Creates a new `BayesianNetworkDiffSMParameterSet` with pre-defined parameter values.
`BNDiffSMParameterTree(int pos, int[] contextPoss, AlphabetContainer alphabet, int firstParent, int[] firstChildren)` Creates a new `BNDiffSMParameterTree` for the parameters at position `pos` using the parent positions in `contextPoss`.
`MarkovModelDiffSM(AlphabetContainer alphabet, int length, double ess, boolean plugInParameters, InhomogeneousMarkov structureMeasure)` This constructor creates an instance without any prior for the modeled length.
`MarkovModelDiffSM(AlphabetContainer alphabet, int length, double ess, boolean plugInParameters, InhomogeneousMarkov structureMeasure, DurationDiffSM lengthPenalty)` This constructor creates an instance with an prior for the modeled length.
`MarkovModelDiffSM(AlphabetContainer alphabet, int length, double ess, boolean plugInParameters, int order, DurationDiffSM lengthPenalty)` This constructor creates an instance with an prior for the modeled length.

Uses of AlphabetContainer in de.jstacs.sequenceScores.statisticalModels.differentiable.homogeneous

Constructors in de.jstacs.sequenceScores.statisticalModels.differentiable.homogeneous with parameters of type AlphabetContainer
`HomogeneousDiffSM(AlphabetContainer alphabets)` This is the main constructor that creates an instance of a `HomogeneousDiffSM` that models sequences of arbitrary length.
`HomogeneousDiffSM(AlphabetContainer alphabets, int length)` This is the main constructor that creates an instance of a `HomogeneousDiffSM` that models sequences of a given length.
`HomogeneousMM0DiffSM(AlphabetContainer alphabets, int length, double ess, boolean plugIn, boolean optimize)` The main constructor that creates an instance of a homogeneous Markov model of order 0.
`HomogeneousMMDiffSM(AlphabetContainer alphabets, int order, double classEss, double[] sumOfHyperParams, boolean plugIn, boolean optimize, int starts)` This is the main constructor that creates an instance of a homogeneous Markov model of arbitrary order.
`HomogeneousMMDiffSM(AlphabetContainer alphabets, int order, double classEss, int length)` This is a convenience constructor for creating an instance of a homogeneous Markov model of arbitrary order.
`UniformHomogeneousDiffSM(AlphabetContainer alphabets, double ess)` This is the main constructor that creates an instance of a `UniformHomogeneousDiffSM` that models each sequence uniformly.

Uses of AlphabetContainer in de.jstacs.sequenceScores.statisticalModels.differentiable.mixture.motif

Constructors in de.jstacs.sequenceScores.statisticalModels.differentiable.mixture.motif with parameters of type AlphabetContainer
`PositionDiffSM(AlphabetContainer con, int length)` This constructor allows create instance with more than one dimension.

Uses of AlphabetContainer in de.jstacs.sequenceScores.statisticalModels.trainable

Fields in de.jstacs.sequenceScores.statisticalModels.trainable declared as AlphabetContainer
`protected AlphabetContainer` | `AbstractTrainableStatisticalModel.alphabets` The underlying alphabets

Methods in de.jstacs.sequenceScores.statisticalModels.trainable that return AlphabetContainer
`AlphabetContainer` | `AbstractTrainableStatisticalModel.getAlphabetContainer()`

Methods in de.jstacs.sequenceScores.statisticalModels.trainable with parameters of type AlphabetContainer
`static BayesianNetworkTrainSM` | `TrainableStatisticalModelFactory.createBayesianNetworkModel(AlphabetContainer con, int length, double ess, byte order)` This method returns a Bayesian network model (BN) with user-specified order.
`static HomogeneousMM` | `TrainableStatisticalModelFactory.createHomogeneousMarkovModel(AlphabetContainer con, double ess, byte order)` This method returns a homogeneous Markov model with user-specified order.
`static FSDAGTrainSM` | `TrainableStatisticalModelFactory.createInhomogeneousMarkovModel(AlphabetContainer con, int length, double ess, byte order)` This method returns a inhomogeneous Markov model (IMM) with user-specified order.
`static BayesianNetworkTrainSM` | `TrainableStatisticalModelFactory.createPermutedMarkovModel(AlphabetContainer con, int length, double ess, byte order)` This method returns a permuted Markov model (PMM) with user-specified order.
`static FSDAGTrainSM` | `TrainableStatisticalModelFactory.createPWM(AlphabetContainer con, int length, double ess)` This method returns a position weight matrix (PWM).

Constructors in de.jstacs.sequenceScores.statisticalModels.trainable with parameters of type AlphabetContainer
`AbstractTrainableStatisticalModel(AlphabetContainer alphabets, int length)` Constructor that sets the length of the model to `length` and the `AlphabetContainer` to `alphabets`.
`CompositeTrainSM(AlphabetContainer alphabets, int[] assignment, TrainableStatisticalModel... models)` Creates a new `CompositeTrainSM`.
`UniformTrainSM(AlphabetContainer alphabet)` Creates a new `UniformTrainSM` using a given `AlphabetContainer`.

Uses of AlphabetContainer in de.jstacs.sequenceScores.statisticalModels.trainable.discrete

Methods in de.jstacs.sequenceScores.statisticalModels.trainable.discrete with parameters of type AlphabetContainer
`static double` | `ConstraintManager.countInhomogeneous(AlphabetContainer alphabets, int length, DataSet data, double[] weights, boolean reset, Constraint... constr)` Fills the (inhomogeneous) `Constraint` `constr` with the weighted absolute frequencies of the `DataSet` `data`.
`abstract String` | `Constraint.getDescription(AlphabetContainer con, int i)` Returns the decoded symbol for the encoded symbol `i`.
`String` | `Constraint.getFreqInfo(AlphabetContainer con)` Returns an information about the stored frequencies.

Constructors in de.jstacs.sequenceScores.statisticalModels.trainable.discrete with parameters of type AlphabetContainer
`DGTrainSMParameterSet(Class<T> instanceClass, AlphabetContainer alphabet, double ess, String description)` The constructor for models that can handle variable lengths.
`DGTrainSMParameterSet(Class<T> instanceClass, AlphabetContainer alphabet, int length, double ess, String description)` The constructor for models that can handle only sequences of fixed length given by `length`.

Uses of AlphabetContainer in de.jstacs.sequenceScores.statisticalModels.trainable.discrete.homogeneous

Methods in de.jstacs.sequenceScores.statisticalModels.trainable.discrete.homogeneous with parameters of type AlphabetContainer
`String` | `HomogeneousTrainSM.HomCondProb.getDescription(AlphabetContainer con, int i)`

Uses of AlphabetContainer in de.jstacs.sequenceScores.statisticalModels.trainable.discrete.homogeneous.parameters

Constructors in de.jstacs.sequenceScores.statisticalModels.trainable.discrete.homogeneous.parameters with parameters of type AlphabetContainer
`HomMMParameterSet(AlphabetContainer alphabet, double ess, String description, byte order)` Creates a new `HomMMParameterSet` with `AlphabetContainer`, ess (equivalent sample size), description and order of the homogeneous Markov model.
`HomogeneousTrainSMParameterSet(Class<? extends HomogeneousTrainSM> instanceClass, AlphabetContainer alphabet, double ess, String description, byte order)` Creates a new `HomogeneousTrainSMParameterSet` with `AlphabetContainer`, ess (equivalent sample size), description and order of the homogeneous Markov model.

Uses of AlphabetContainer in de.jstacs.sequenceScores.statisticalModels.trainable.discrete.inhomogeneous

Methods in de.jstacs.sequenceScores.statisticalModels.trainable.discrete.inhomogeneous that return AlphabetContainer
`AlphabetContainer` | `StructureLearner.getAlphabetContainer()` This method returns the `AlphabetContainer` of the `StructureLearner`.

Methods in de.jstacs.sequenceScores.statisticalModels.trainable.discrete.inhomogeneous with parameters of type AlphabetContainer
`String` | `InhConstraint.getDescription(AlphabetContainer con, int i)`
`String` | `InhCondProb.getDescription(AlphabetContainer con, int i)`

Constructors in de.jstacs.sequenceScores.statisticalModels.trainable.discrete.inhomogeneous with parameters of type AlphabetContainer
`StructureLearner(AlphabetContainer con, int length)` Creates a `StructureLearner` with equivalent sample size (ess) = 0.
`StructureLearner(AlphabetContainer con, int length, double ess)` Creates a new `StructureLearner` for a given `AlphabetContainer`, a given length and a given equivalent sample size (ess).

Uses of AlphabetContainer in de.jstacs.sequenceScores.statisticalModels.trainable.discrete.inhomogeneous.parameters

Constructors in de.jstacs.sequenceScores.statisticalModels.trainable.discrete.inhomogeneous.parameters with parameters of type AlphabetContainer
`BayesianNetworkTrainSMParameterSet(AlphabetContainer alphabet, int length, double ess, String description, StructureLearner.ModelType model, byte order, StructureLearner.LearningType method)` This is the constructor of a filled `BayesianNetworkTrainSMParameterSet` for a `BayesianNetworkTrainSM`.
`FSDAGModelForGibbsSamplingParameterSet(AlphabetContainer alphabet, int length, double ess, String description, String graph)` This is the constructor that creates a filled parameter set.
`FSDAGTrainSMParameterSet(AlphabetContainer alphabet, int length, double ess, String description, String graph)` This constructor creates an `FSDAGTrainSMParameterSet` instance.
`FSDAGTrainSMParameterSet(Class<? extends FSDAGTrainSM> clazz, AlphabetContainer alphabet, int length, double ess, String description, String graph)` This constructor creates an `FSDAGTrainSMParameterSet` instance for the specified class.
`IDGTrainSMParameterSet(Class<? extends InhomogeneousDGTrainSM> instanceClass, AlphabetContainer alphabet, int length, double ess, String description)` This constructor creates an `IDGTrainSMParameterSet` instance for the specified class.

Uses of AlphabetContainer in de.jstacs.sequenceScores.statisticalModels.trainable.hmm

Methods in de.jstacs.sequenceScores.statisticalModels.trainable.hmm with parameters of type AlphabetContainer
`static AbstractHMM` | `HMMFactory.createProfileHMM(MaxHMMTrainingParameterSet trainingParameterSet, double[][] initFromTo, boolean likelihood, int order, int numLayers, AlphabetContainer con, double ess, boolean conditionalMain, boolean closeCircle, double[][] conditionInitProbs, boolean insertUniform)` Creates a new profile HMM for a given architecture and number of layers.
`static AbstractHMM` | `HMMFactory.createProfileHMM(MaxHMMTrainingParameterSet trainingParameterSet, double[][] initFromTo, boolean likelihood, int order, int numLayers, AlphabetContainer con, double ess, boolean conditionalMain, int joiningStates, double[][] conditionInitProbs, boolean insertUniform)` Creates a new profile HMM for a given architecture and number of layers.
`static AbstractHMM` | `HMMFactory.createProfileHMM(MaxHMMTrainingParameterSet trainingParameterSet, HMMFactory.HMMType type, boolean likelihood, int order, int numLayers, AlphabetContainer con, double ess, boolean conditionalMain, boolean closeCircle, double[][] conditionInitProbs)` Creates a new profile HMM for a given architecture and number of layers.
`static AbstractHMM` | `HMMFactory.createPseudoErgodicHMM(HMMTrainingParameterSet pars, double ess, double selfTranistionPart, double finalTranistionPart, AlphabetContainer con, int numStates, boolean insertUniform)` Creates an HMM with `numStates+1` states, where `numStates` emitting build a clique and each of those states is connected to the absorbing silent final state.
`static AbstractHMM` | `HMMFactory.createSunflowerHMM(HMMTrainingParameterSet pars, AlphabetContainer con, double ess, int expectedSequenceLength, boolean startCentral, int... motifLength)` This method creates a first order sunflower HMM.
`static AbstractHMM` | `HMMFactory.createSunflowerHMM(HMMTrainingParameterSet pars, AlphabetContainer con, double ess, int expectedSequenceLength, boolean startCentral, PhyloTree[] t, double[] motifProb, int[] motifLength)` This method creates a first order sunflower HMM allowing phylogenetic emissions.

Uses of AlphabetContainer in de.jstacs.sequenceScores.statisticalModels.trainable.hmm.states.emissions

Methods in de.jstacs.sequenceScores.statisticalModels.trainable.hmm.states.emissions that return AlphabetContainer
`AlphabetContainer` | `UniformEmission.getAlphabetContainer()`
`AlphabetContainer` | `SilentEmission.getAlphabetContainer()`
`AlphabetContainer` | `MixtureEmission.getAlphabetContainer()`
`AlphabetContainer` | `Emission.getAlphabetContainer()` This method returns the `AlphabetContainer` of this emission.

Constructors in de.jstacs.sequenceScores.statisticalModels.trainable.hmm.states.emissions with parameters of type AlphabetContainer
`UniformEmission(AlphabetContainer con)` The main constructor for a `UniformEmission`.

Uses of AlphabetContainer in de.jstacs.sequenceScores.statisticalModels.trainable.hmm.states.emissions.continuous

Methods in de.jstacs.sequenceScores.statisticalModels.trainable.hmm.states.emissions.continuous that return AlphabetContainer
`AlphabetContainer` | `GaussianEmission.getAlphabetContainer()`

Constructors in de.jstacs.sequenceScores.statisticalModels.trainable.hmm.states.emissions.continuous with parameters of type AlphabetContainer
`GaussianEmission(AlphabetContainer con)` Creates a `GaussianEmission` which can be used for maximum likelihood.
`GaussianEmission(AlphabetContainer con, double ess, double priorMu, double priorAlpha, double priorBeta, boolean transformed)` Creates a `GaussianEmission` with normal-gamma prior by directly defining the hyper-parameters of the prior.
`GaussianEmission(double ess, AlphabetContainer con, double priorMu, double expectedPrecision, double sdPrecision, boolean transformed)` Creates a `GaussianEmission` with normal-gamma prior by defining the expected precision and the expected standard deviation of the precision, i.e. via the expectation and variance of the gamma part of the normal-gamma prior.

Uses of AlphabetContainer in de.jstacs.sequenceScores.statisticalModels.trainable.hmm.states.emissions.discrete

Fields in de.jstacs.sequenceScores.statisticalModels.trainable.hmm.states.emissions.discrete declared as AlphabetContainer
`protected AlphabetContainer` | `AbstractConditionalDiscreteEmission.con` The alphabet of the emissions

Methods in de.jstacs.sequenceScores.statisticalModels.trainable.hmm.states.emissions.discrete that return AlphabetContainer
`AlphabetContainer` | `AbstractConditionalDiscreteEmission.getAlphabetContainer()`

Constructors in de.jstacs.sequenceScores.statisticalModels.trainable.hmm.states.emissions.discrete with parameters of type AlphabetContainer
`AbstractConditionalDiscreteEmission(AlphabetContainer con, double[][] hyperParams)` This is a simple constructor for a `AbstractConditionalDiscreteEmission` defining the individual hyper parameters.
`AbstractConditionalDiscreteEmission(AlphabetContainer con, double[][] hyperParams, double[][] initHyperParams)` This constructor creates a `AbstractConditionalDiscreteEmission` defining the individual hyper parameters for the prior used during training and initialization.
`AbstractConditionalDiscreteEmission(AlphabetContainer con, int numberOfConditions, double ess)` This is a simple constructor for a `AbstractConditionalDiscreteEmission` based on the equivalent sample size.
`DiscreteEmission(AlphabetContainer con, double ess)` This is a simple constructor for a `DiscreteEmission` based on the equivalent sample size.
`DiscreteEmission(AlphabetContainer con, double[] hyperParams)` This is a simple constructor for a `DiscreteEmission` defining the individual hyper parameters.
`PhyloDiscreteEmission(AlphabetContainer con, double[] hyperParams, PhyloTree t)` This is a simple constructor for a `DiscreteEmission` defining the individual hyper parameters.
`PhyloDiscreteEmission(AlphabetContainer con, double ess, PhyloTree t)` This is a simple constructor for a `PhyloDiscreteEmission` based on the equivalent sample size.
`ReferenceSequenceDiscreteEmission(AlphabetContainer con, AlphabetContainer refCon, int refIdx, double ess)` This is a simple constructor for a `ReferenceSequenceDiscreteEmission` based on the equivalent sample size.
`ReferenceSequenceDiscreteEmission(AlphabetContainer con, AlphabetContainer refCon, int refIdx, double[][] hyperParams)` This constructor creates a `ReferenceSequenceDiscreteEmission` defining the individual hyper parameters.
`ReferenceSequenceDiscreteEmission(AlphabetContainer con, AlphabetContainer refCon, int refIdx, double[][] hyperParams, double[][] initHyperParams)` This constructor creates a `ReferenceSequenceDiscreteEmission` defining the individual hyper parameters.
`ReferenceSequenceDiscreteEmission(AlphabetContainer con, AlphabetContainer refCon, int refIdx, double ess, double[][] initHyperParams)` This is a simple constructor for a `ReferenceSequenceDiscreteEmission` based on the equivalent sample size.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES