| Package | Description | 
|---|---|
| org.biojava.bio.chromatogram | 
 
Interfaces and classes for chromatogram data, as produced by DNA sequencing equipment. 
 | 
| org.biojava.bio.dist | 
 
Probability distributions over Alphabets. 
 | 
| org.biojava.bio.dp | 
 HMM and Dynamic Programming Algorithms. 
 | 
| org.biojava.bio.dp.onehead | |
| org.biojava.bio.dp.twohead | |
| org.biojava.bio.gui | 
 Graphical interfaces for biojava objects. 
 | 
| org.biojava.bio.molbio | 
 The classes and interfaces in this package cover common molecular
biological techniques such as restriction digests and PCR. 
 | 
| org.biojava.bio.program | 
 
Java wrappers for interacting with external bioinformatics tools. 
 | 
| org.biojava.bio.program.abi | 
 ABI Trace Handling. 
 | 
| org.biojava.bio.program.fastq | 
 FASTQ and variants sequence format I/O. 
 | 
| org.biojava.bio.program.hmmer | 
 
Tools for working with profile Hidden Markov Models from the HMMer package. 
 | 
| org.biojava.bio.program.phred | 
 Parser for Phred output 
 | 
| org.biojava.bio.proteomics | 
 Utilities to aid in performing various physical analysis of proteins. 
 | 
| org.biojava.bio.search | 
 
Interfaces and classes for representing sequence similarity search results. 
 | 
| org.biojava.bio.seq | 
 Classes and interfaces for defining biological sequences and informatics
objects. 
 | 
| org.biojava.bio.seq.io | 
 Classes and interfaces for processing and producing flat-file representations
of sequences. 
 | 
| org.biojava.bio.symbol | 
 Representation of the Symbols that make up a sequence, and locations within
them. 
 | 
| org.biojava.utils.automata | |
| org.biojava.utils.regex | 
 This package is used to perform regular expression searches of
SymbolLists defined in arbitrary Alphabets. 
 | 
| org.biojavax.bio.seq | 
 Rich implementations of Sequences, Locations and Features. 
 | 
| org.biojavax.bio.seq.io | 
 Classes to support the I/O of RichSequence and 
     Bioentry objects. 
 | 
| org.biojavax.ga | 
 Classes to provide a genetic algorithm framework 
 | 
| org.biojavax.ga.functions | 
 GA functions
  A genetic algorithm requires a number of functions. 
 | 
| org.biojavax.ga.impl | 
 Default implementations and abstract classes. 
 | 
| org.biojavax.ga.util | 
 Utility functions and helper classes 
 | 
| Modifier and Type | Method and Description | 
|---|---|
protected SymbolList | 
AbstractChromatogram.createImmutableSymbolList(Alphabet alpha,
                         List syms)
A factory method for creating new symbol lists with a given alphabet. 
 | 
int | 
Chromatogram.getMax(AtomicSymbol nucleotide)
Gets the max intensity on the trace for the specified nucleotide. 
 | 
int | 
AbstractChromatogram.getMax(AtomicSymbol nucleotide)  | 
int[] | 
Chromatogram.getTrace(AtomicSymbol nucleotide)
Returns an array containing the intensities of the sampled waveform
  representing the chromatogram trace for base  
nucleotide. | 
int[] | 
AbstractChromatogram.getTrace(AtomicSymbol nucleotide)  | 
protected void | 
AbstractChromatogram.setTrace(AtomicSymbol nuc,
        int[] trace,
        int maxVal)
Provides the trace samples for a particular nucleotide. 
 | 
void | 
SimpleChromatogram.setTraceValues(AtomicSymbol nuc,
              int[] trace,
              int maxVal)
Sets the trace array for one of the DNA nucleotides. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
SimpleDistributionTrainerContext.addCount(Distribution dist,
        Symbol sym,
        double times)  | 
void | 
DistributionTrainerContext.addCount(Distribution dist,
        Symbol sym,
        double times)
 Registers that sym was counted in this state. 
 | 
void | 
SimpleDistributionTrainer.addCount(DistributionTrainerContext dtc,
        AtomicSymbol sym,
        double count)
Deprecated.  
  | 
void | 
DistributionTrainer.addCount(DistributionTrainerContext dtc,
        AtomicSymbol sym,
        double times)
 Registers that sym was counted in this state. 
 | 
void | 
SimpleDistribution.Trainer.addCount(DistributionTrainerContext dtc,
        AtomicSymbol sym,
        double times)  | 
void | 
IgnoreCountsTrainer.addCount(DistributionTrainerContext dtc,
        AtomicSymbol sym,
        double times)  | 
double | 
IndexedCount.getCount(AtomicSymbol s)  | 
double | 
Count.getCount(AtomicSymbol s)
Return the counts for a given Symbol. 
 | 
double | 
SimpleDistributionTrainerContext.getCount(Distribution dist,
        Symbol sym)  | 
double | 
DistributionTrainerContext.getCount(Distribution dist,
        Symbol sym)
Return the number of counts of a particular symbol which will be used
 to train the specified distribution. 
 | 
double | 
SimpleDistributionTrainer.getCount(DistributionTrainerContext dtc,
        AtomicSymbol sym)
Deprecated.  
  | 
double | 
DistributionTrainer.getCount(DistributionTrainerContext dtc,
        AtomicSymbol sym)
 Get the current count for this state. 
 | 
double | 
SimpleDistribution.Trainer.getCount(DistributionTrainerContext dtc,
        AtomicSymbol sym)  | 
double | 
IgnoreCountsTrainer.getCount(DistributionTrainerContext dtc,
        AtomicSymbol sym)  | 
Distribution | 
OrderNDistribution.getDistribution(Symbol sym)  | 
double | 
TranslatedDistribution.getWeight(Symbol sym)  | 
double | 
Distribution.getWeight(Symbol s)
 Return the probability that Symbol s is emitted by this spectrum. 
 | 
double | 
GapDistribution.getWeight(Symbol sym)  | 
double | 
PairDistribution.getWeight(Symbol sym)  | 
double | 
AbstractDistribution.getWeight(Symbol sym)
Retrieve the weight for this distribution. 
 | 
protected double | 
UniformDistribution.getWeightImpl(AtomicSymbol s)  | 
double | 
SimpleDistribution.getWeightImpl(AtomicSymbol s)  | 
protected double | 
AbstractOrderNDistribution.getWeightImpl(AtomicSymbol sym)
Get a weight from one of the sub-distributions, conditioned
 on the first part of the symbol. 
 | 
protected abstract double | 
AbstractDistribution.getWeightImpl(AtomicSymbol sym)
Override this method to implement getting the weight for an atomic
 symbol. 
 | 
void | 
IndexedCount.increaseCount(AtomicSymbol s,
             double c)  | 
void | 
Count.increaseCount(AtomicSymbol s,
             double c)
Set the probability or odds that Symbol s is emitted by this state. 
 | 
void | 
IndexedCount.setCount(AtomicSymbol s,
        double c)  | 
void | 
Count.setCount(AtomicSymbol s,
        double c)
Set the count for the Symbol s. 
 | 
void | 
OrderNDistribution.setDistribution(Symbol sym,
               Distribution dist)
Set the distribution assocated with a symbol. 
 | 
void | 
TranslatedDistribution.setWeight(Symbol sym,
         double weight)  | 
void | 
Distribution.setWeight(Symbol s,
         double w)
Set the probability or odds that Symbol s is emitted by this state. 
 | 
void | 
GapDistribution.setWeight(Symbol s,
         double w)  | 
void | 
AbstractDistribution.setWeight(Symbol sym,
         double weight)
Set the weight of a given symbol in this distribution. 
 | 
protected void | 
SimpleDistribution.setWeightImpl(AtomicSymbol s,
             double w)  | 
void | 
AbstractOrderNDistribution.setWeightImpl(AtomicSymbol sym,
             double w)
Set a weight in one of the conditioned distributions. 
 | 
protected abstract void | 
AbstractDistribution.setWeightImpl(AtomicSymbol sym,
             double weight)
Implement this to actually set the weight. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
TransitionTrainer.addCount(State from,
        State to,
        double count)
Add 'count' to the transition from->to. 
 | 
void | 
WMAsMM.addState(State toAdd)  | 
void | 
MarkovModel.addState(State newState)
Adds a state to the model. 
 | 
void | 
SimpleMarkovModel.addState(State toAdd)  | 
abstract double | 
DP.backward(SymbolList[] symList,
        ScoreType scoreType)  | 
abstract DPMatrix | 
DP.backwardMatrix(SymbolList[] symList,
              DPMatrix matrix,
              ScoreType scoreType)  | 
abstract DPMatrix | 
DP.backwardMatrix(SymbolList[] symList,
              ScoreType scoreType)  | 
static int[][] | 
DP.backwardTransitions(MarkovModel model,
                   State[] states)  | 
double | 
ScoreType.calculateScore(Distribution dist,
              Symbol sym)
Calculates the score associated with a distribution and a symbol. 
 | 
double | 
ScoreType.Probability.calculateScore(Distribution dist,
              Symbol sym)  | 
double | 
ScoreType.Odds.calculateScore(Distribution dist,
              Symbol sym)  | 
double | 
ScoreType.NullModel.calculateScore(Distribution dist,
              Symbol sym)  | 
protected void | 
ProfileHMM.connectModel()
This is called by constructor in setting up the allowed transitions in the model 
 | 
boolean | 
WMAsMM.containsTransition(State from,
                  State to)  | 
boolean | 
MarkovModel.containsTransition(State from,
                  State to)
Returns wether a transition exists or not. 
 | 
boolean | 
SimpleMarkovModel.containsTransition(State from,
                  State to)  | 
void | 
MarkovModel.createTransition(State from,
                State to)
Makes a transition between two states legal. 
 | 
void | 
SimpleMarkovModel.createTransition(State from,
                State to)  | 
void | 
MarkovModel.destroyTransition(State from,
                 State to)
Breaks a transition between two states legal. 
 | 
void | 
SimpleMarkovModel.destroyTransition(State from,
                 State to)  | 
static MarkovModel | 
DP.flatView(MarkovModel model)  | 
abstract double | 
DP.forward(SymbolList[] symList,
       ScoreType scoreType)  | 
abstract DPMatrix | 
DP.forwardMatrix(SymbolList[] symList,
             DPMatrix matrix,
             ScoreType scoreType)  | 
abstract DPMatrix | 
DP.forwardMatrix(SymbolList[] symList,
             ScoreType scoreType)  | 
static int[][] | 
DP.forwardTransitions(MarkovModel model,
                  State[] states)
Returns a matrix for the specified States describing all
 valid Transitions between those States. 
 | 
StatePath | 
DP.generate(int length)
 Generates an alignment from a model. 
 | 
Distribution | 
WMAsMM.getWeights(State source)  | 
Distribution | 
MarkovModel.getWeights(State source)
Get a probability Distribution over the transition from 'source'. 
 | 
Distribution | 
SimpleMarkovModel.getWeights(State source)  | 
static WeightMatrix | 
XmlMarkovModel.readMatrix(Element root)  | 
static MarkovModel | 
XmlMarkovModel.readModel(Element root)  | 
void | 
SimpleHMMTrainer.recordEmittedSymbol(State state,
                   Symbol symbol,
                   double weight)  | 
void | 
HMMTrainer.recordEmittedSymbol(State state,
                   Symbol symbol,
                   double weight)
record that the specified symbol was emitted from the specified state. 
 | 
void | 
WMAsMM.removeState(State toAdd)  | 
void | 
MarkovModel.removeState(State toGo)
Remove a state from the model. 
 | 
void | 
SimpleMarkovModel.removeState(State toGo)  | 
static double | 
DP.scoreWeightMatrix(WeightMatrix matrix,
                 SymbolList symList,
                 int start)
Scores the SymbolList from symbol start to symbol (start+columns) with a
 weight matrix. 
 | 
static double | 
DP.scoreWeightMatrix(WeightMatrix matrix,
                 SymbolList symList,
                 ScoreType scoreType,
                 int start)
Scores the SymbolList from symbol start to symbol (start+columns) with a
 weight matrix using a particular ScoreType. 
 | 
void | 
MarkovModel.setWeights(State source,
          Distribution dist)
Set the probability distribution over the transitions from 'source'. 
 | 
void | 
SimpleMarkovModel.setWeights(State source,
          Distribution dist)
Use this methods to customize the transition probabilities. 
 | 
protected double | 
BaumWelchSampler.singleSequenceIteration(ModelTrainer trainer,
                       SymbolList symList)  | 
protected double | 
BaumWelchTrainer.singleSequenceIteration(ModelTrainer trainer,
                       SymbolList symList)  | 
protected abstract double | 
AbstractTrainer.singleSequenceIteration(ModelTrainer trainer,
                       SymbolList symList)  | 
protected double | 
BaumWelchSampler.singleSequenceIteration(ModelTrainer trainer,
                       SymbolList symList,
                       ScoreType scoreType)  | 
State[] | 
DP.stateList(MarkovModel mm)  | 
void | 
TransitionTrainer.train(double nullModel,
     double weight)
Trains the transition, given an expected probability, and a weight for
 that probability. 
 | 
void | 
TrainingAlgorithm.train(SequenceDB db,
     double nullWeight,
     StoppingCriteria stopper)
Trains the sequences in db untill stopper says to finnish. 
 | 
void | 
AbstractTrainer.train(SequenceDB db,
     double nullModelWeight,
     StoppingCriteria stopper)
Trains the sequences in db until stopper says to finnish. 
 | 
FiniteAlphabet | 
WMAsMM.transitionsFrom(State from)  | 
FiniteAlphabet | 
MarkovModel.transitionsFrom(State source)
Returns the FiniteAlphabet of all states that have a transition from 'source'. 
 | 
FiniteAlphabet | 
SimpleMarkovModel.transitionsFrom(State from)  | 
FiniteAlphabet | 
WMAsMM.transitionsTo(State to)  | 
FiniteAlphabet | 
MarkovModel.transitionsTo(State dest)
Returns the FiniteAlphabet of all states that have a transition to 'dest'. 
 | 
FiniteAlphabet | 
SimpleMarkovModel.transitionsTo(State to)  | 
abstract StatePath | 
DP.viterbi(SymbolList[] symList,
       ScoreType scoreType)  | 
| Constructor and Description | 
|---|
ProfileHMM(Alphabet alpha,
          int columns,
          DistributionFactory matchFactory,
          DistributionFactory insertFactory)
Deprecated.   
 | 
ProfileHMM(Alphabet alpha,
          int columns,
          DistributionFactory matchFactory,
          DistributionFactory insertFactory,
          String name)
Create a new ProfileHMM. 
 | 
SimpleHMMTrainer(MarkovModel model)  | 
WMAsMM(WeightMatrix wm)  | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
SingleDP.backward_initialize(DPCursor dpCursor,
                   ScoreType scoreType)  | 
protected void | 
SingleDP.backward_recurse(DPCursor dpCursor,
                ScoreType scoreType)  | 
protected double | 
SingleDP.backward_termination(DPCursor dpCursor,
                    ScoreType scoreType)  | 
protected double | 
SingleDP.backward(DPCursor dpCursor,
        ScoreType scoreType)  | 
double | 
SingleDP.backward(SymbolList[] seq,
        ScoreType scoreType)  | 
double | 
SingleDP.backward(SymbolList[] seq,
        ScoreType scoreType)  | 
DPMatrix | 
SingleDP.backwardMatrix(SymbolList[] seq,
              DPMatrix matrix,
              ScoreType scoreType)  | 
DPMatrix | 
SingleDP.backwardMatrix(SymbolList[] seq,
              DPMatrix matrix,
              ScoreType scoreType)  | 
DPMatrix | 
SingleDP.backwardMatrix(SymbolList[] seq,
              ScoreType scoreType)  | 
DPMatrix | 
SingleDP.backwardMatrix(SymbolList[] seq,
              ScoreType scoreType)  | 
protected void | 
SingleDP.forward_initialize(DPCursor dpCursor,
                  ScoreType scoreType)  | 
protected double | 
SingleDP.forward(DPCursor dpCursor,
       ScoreType scoreType)  | 
double | 
SingleDP.forward(SymbolList[] seq,
       ScoreType scoreType)  | 
double | 
SingleDP.forward(SymbolList[] seq,
       ScoreType scoreType)  | 
DPMatrix | 
SingleDP.forwardMatrix(SymbolList[] seq,
             DPMatrix matrix,
             ScoreType scoreType)  | 
DPMatrix | 
SingleDP.forwardMatrix(SymbolList[] seq,
             DPMatrix matrix,
             ScoreType scoreType)  | 
DPMatrix | 
SingleDP.forwardMatrix(SymbolList[] seq,
             ScoreType scoreType)  | 
DPMatrix | 
SingleDP.forwardMatrix(SymbolList[] seq,
             ScoreType scoreType)  | 
double[] | 
SingleDP.getEmission(Symbol sym,
           ScoreType scoreType)
This method is public for the benefit of training algorithms,
 and in the future we should look at a better way of exposing
 the emissions cache. 
 | 
StatePath | 
SingleDP.viterbi(SymbolList[] symList,
       ScoreType scoreType)  | 
| Constructor and Description | 
|---|
SingleDP(MarkovModel model)  | 
| Modifier and Type | Method and Description | 
|---|---|
double | 
PairwiseDP.backward(SymbolList[] seqs,
        ScoreType scoreType)  | 
DPMatrix | 
PairwiseDP.backwardMatrix(SymbolList[] seqs,
              DPMatrix d,
              ScoreType scoreType)  | 
DPMatrix | 
PairwiseDP.backwardMatrix(SymbolList[] seqs,
              ScoreType scoreType)  | 
CellCalculator | 
CellCalculatorFactory.backwards(ScoreType scoreType)  | 
CellCalculator | 
DPInterpreter.backwards(ScoreType scoreType)  | 
void | 
CellCalculator.calcCell(Cell[][] cells)
 Calculate the 'scores' array in the cell at cells[0][0]. 
 | 
double | 
PairwiseDP.forward(SymbolList[] seqs,
       ScoreType scoreType)  | 
DPMatrix | 
PairwiseDP.forwardMatrix(SymbolList[] seqs,
             DPMatrix d,
             ScoreType scoreType)  | 
DPMatrix | 
PairwiseDP.forwardMatrix(SymbolList[] seqs,
             ScoreType scoreType)  | 
CellCalculator | 
CellCalculatorFactory.forwards(ScoreType scoreType)  | 
CellCalculator | 
DPInterpreter.forwards(ScoreType scoreType)  | 
double[] | 
EmissionCache.getEmissions(List symList)  | 
double[] | 
EmissionCache.getEmissions(List symList,
            boolean exorcise)
Retrieve the emission scores from the cache for every EmissionState
 for the specified symbols. 
 | 
void | 
CellCalculator.initialize(Cell[][] cells)
Initialize the cell at [0][0] to the recursion initial parameters. 
 | 
void | 
LightPairDPCursor.next(Cell[][] cells)
Description of the Method 
 | 
void | 
PairDPCursor.next(Cell[][] cells)
retrieve the next block of cells 
 | 
CellCalculator | 
CellCalculatorFactory.viterbi(ScoreType scoreType,
       BackPointer terminal)  | 
CellCalculator | 
DPInterpreter.viterbi(ScoreType scoreType,
       BackPointer terminal)  | 
StatePath | 
PairwiseDP.viterbi(SymbolList[] seqs,
       ScoreType scoreType)  | 
| Constructor and Description | 
|---|
AbstractMatrixPairDPCursor(SymbolList seq1,
                          SymbolList seq2,
                          int start1,
                          int start2,
                          int depth1,
                          int depth2,
                          PairDPMatrix matrix,
                          EmissionCache eCache)  | 
BackMatrixPairDPCursor(SymbolList seq1,
                      SymbolList seq2,
                      int depth1,
                      int depth2,
                      PairDPMatrix matrix,
                      EmissionCache eCache)  | 
LightPairDPCursor(SymbolList seq1,
                 SymbolList seq2,
                 int depth1,
                 int depth2,
                 int numStates,
                 EmissionCache eCache)
Constructor for the LightPairDPCursor object 
 | 
MatrixPairDPCursor(SymbolList seq1,
                  SymbolList seq2,
                  int depth1,
                  int depth2,
                  PairDPMatrix matrix,
                  EmissionCache eCache)  | 
PairwiseDP(MarkovModel mm,
          CellCalculatorFactoryMaker ccfm)  | 
| Modifier and Type | Method and Description | 
|---|---|
static double | 
DistributionLogo.entropy(Distribution dist,
       Symbol s)
Calculate the information content of a symbol in bits. 
 | 
Paint | 
DNAStyle.fillPaint(Symbol s)  | 
Paint | 
SimpleSymbolStyle.fillPaint(Symbol s)  | 
Paint | 
SymbolStyle.fillPaint(Symbol s)
Return the fill paint for a symbol. 
 | 
Paint | 
DNAStyle.outlinePaint(Symbol s)  | 
Paint | 
SimpleSymbolStyle.outlinePaint(Symbol s)  | 
Paint | 
SymbolStyle.outlinePaint(Symbol s)
Return the outline paint for a symbol. 
 | 
void | 
DNAStyle.setFillPaint(Symbol s,
            Paint paint)  | 
void | 
SimpleSymbolStyle.setFillPaint(Symbol s,
            Paint paint)  | 
void | 
DNAStyle.setOutlinePaint(Symbol s,
               Paint paint)  | 
void | 
SimpleSymbolStyle.setOutlinePaint(Symbol s,
               Paint paint)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
Composition.setSymbolList(SymbolList symbolList)
Set the  
SymbolList to calculation the composition of. | 
| Constructor and Description | 
|---|
Meme(InputStream is,
    SymbolTokenization symParser)  | 
| Modifier and Type | Method and Description | 
|---|---|
static Symbol | 
ABIFParser.decodeDNAToken(char token)
Decodes a character into a  
Symbol in the DNA alphabet. | 
int[] | 
ABITrace.getTrace(AtomicSymbol base)
Returns one of the four traces - all of the y-coordinate values,
 each of which correspond to a single x-coordinate relative to the
 position in the array, so that if element 4 in the array is 972, then
 x is 4 and y is 972 for that point. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static SymbolList | 
FastqTools.createDNA(Fastq fastq)
Create and return a new DNA  
SymbolList from the specified FASTQ formatted sequence. | 
static Sequence | 
FastqTools.createDNASequence(Fastq fastq)
Create and return a new DNA  
Sequence from the specified FASTQ formatted sequence. | 
static PhredSequence | 
FastqTools.createPhredSequence(Fastq fastq)
Create and return a new  
PhredSequence from the specified FASTQ formatted sequence. | 
static SymbolList | 
FastqTools.createQualityScores(Fastq fastq)
Create and return a new  
SymbolList of quality scores from the specified FASTQ formatted sequence. | 
static Distribution[] | 
FastqTools.createSymbolDistribution(Fastq fastq)
Create and return a new array of symbol  
Distributions from the specified FASTQ formatted sequence. | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
HmmerProfileHMM.connectModel()
This is called by constructor in setting up the allowed transitions in the model 
 | 
double | 
ProfileEmissionState.logProb(Symbol sym)  | 
double | 
HmmerProfileHMM.transScore(State from,
          State to,
          Symbol symFrom,
          Symbol symTo)  | 
| Constructor and Description | 
|---|
HmmerProfileHMM(Alphabet alpha,
               int columns,
               DistributionFactory matchFactory,
               DistributionFactory insertFactory,
               String name)  | 
| Modifier and Type | Method and Description | 
|---|---|
static SymbolList | 
PhredTools.createPhred(SymbolList dna,
           SymbolList quality)
Merges a Symbol List from the DNA alphabet with a SymbolList from the
 [0..99] subset of the IntegerAlphabet into a SymbolList from
 the PHRED alphabet. 
 | 
static Symbol | 
PhredTools.dnaSymbolFromPhred(Symbol phredSym)
Retrives the DNA symbol component of the Phred BasisSymbol from the
 PHRED alphabet. 
 | 
static Symbol | 
PhredTools.getPhredSymbol(Symbol dna,
              Symbol integer)
Creates a symbol from the PHRED alphabet by combining a Symbol from the
 DNA alphabet and a Symbol from the IntegerAlphabet (or one of its subsets). 
 | 
static IntegerAlphabet.IntegerSymbol | 
PhredTools.integerSymbolFromPhred(Symbol phredSym)
Retrives the IntegerSymbol component of the Phred BasisSymbol from the
 PHRED alphabet. 
 | 
boolean | 
PhredFormat.readSequence(BufferedReader reader,
            SymbolTokenization symParser,
            SeqIOListener siol)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
MassCalc.addVariableModification(char residue,
                       double[] masses)
Add Variable modifications. 
 | 
void | 
MassCalc.addVariableModification(Symbol residue,
                       double[] masses)
Add Variable modifications. 
 | 
static Protease | 
ProteaseManager.createProtease(String cleaveRes,
              boolean endoProtease,
              String name)  | 
static Protease | 
ProteaseManager.createProtease(String cleaveRes,
              boolean endoProtease,
              String notCleaveRes,
              String name)  | 
static Protease | 
ProteaseManager.createProtease(SymbolList cleaveRes,
              boolean endoProtease,
              String name)  | 
static Protease | 
ProteaseManager.createProtease(SymbolList cleaveRes,
              boolean endoProtease,
              SymbolList notCleaveRes,
              String name)
Creates and registers a new Protease. 
 | 
double | 
MassCalc.getMass(SymbolList proteinSeq)
Get the Mass of this peptide. 
 | 
static double | 
MassCalc.getMass(SymbolList proteinSeq,
       String isotopicType,
       boolean MH_PLUS)
getMass calculates the mass of this peptide. | 
static double | 
MassCalc.getMolecularWeight(SymbolList proteinSeq)
Calculate the molecular weight of a protein, making estimates whenever it is 
 possible like averaging mass values for ambiguity symbols or counting
 zero when gaps are encountered. 
 | 
double[] | 
MassCalc.getVariableMasses(SymbolList peptide)
Get all masses including the variable mass. 
 | 
boolean | 
MassCalc.removeVariableModifications(char residue)
Remove all variable modifications assocaited with this residue. 
 | 
void | 
MassCalc.setSymbolModification(char symbolToken,
                     double mass)
Use this to set a post translational modification for the
  
Symbol represented by this character. | 
| Constructor and Description | 
|---|
Protease(String cleavageRes,
        boolean endoProtease)
Deprecated. 
 
Creating a Protease with this constructor will not register it
 with the ProteaseManager (use ProteaseManager.createProtease()) 
 | 
Protease(String cleaveRes,
        boolean endoProtease,
        String notCleaveRes)
Deprecated. 
 
Creating a Protease with this constructor will not register it
 with the ProteaseManager (use ProteaseManager.createProtease()) 
 | 
Protease(SymbolList cleaveRes,
        boolean endoProtease,
        SymbolList notCleaveRes)
Deprecated. 
 
Creating a Protease with this constructor will not register it
 with the ProteaseManager (use ProteaseManager.createProtease()) 
 | 
Protease(SymbolList cleaveRes,
        boolean endoProtease,
        SymbolList notCleaveRes,
        String name)  | 
| Modifier and Type | Method and Description | 
|---|---|
int | 
SeqContentPattern.getMaxCounts(AtomicSymbol as)
Get the maximum counts required for a symbol. 
 | 
int | 
SeqContentPattern.getMinCounts(AtomicSymbol as)
Get the minimum counts required for a symbol. 
 | 
void | 
SeqContentPattern.setMaxCounts(AtomicSymbol as,
            int count)
Set the maximum counts required for a symbol. 
 | 
void | 
SeqContentPattern.setMinCounts(AtomicSymbol as,
            int count)
Set the minimum counts required for a symbol. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static Symbol | 
NucleotideTools.complement(Symbol sym)
Complement the symbol. 
 | 
static Symbol | 
DNATools.complement(Symbol sym)
Complement the symbol. 
 | 
static Symbol | 
RNATools.complement(Symbol sym)
Complement the symbol. 
 | 
static SymbolList | 
DNATools.createDNA(String dna)
Return a new DNA SymbolList for
 dna. 
 | 
static Sequence | 
DNATools.createDNASequence(String dna,
                 String name)
Return a new DNA Sequence for
 dna. 
 | 
static Sequence | 
SequenceTools.createDummy(Alphabet alpha,
           int length,
           Symbol sym,
           String uri,
           String name)
Create a new Sequence that contains a single symbol repeated over and over. 
 | 
static GappedSequence | 
DNATools.createGappedDNASequence(String dna,
                       String name)
Get a new dna as a GappedSequence 
 | 
static GappedSequence | 
ProteinTools.createGappedProteinSequence(String theProtein,
                           String name)
Get a new protein as a GappedSequence 
 | 
static SymbolList | 
NucleotideTools.createNucleotide(String nucleotide)
Return a new Nucleotide SymbolList for
 nucleotide. 
 | 
static Sequence | 
NucleotideTools.createNucleotideSequence(String nucleotide,
                        String name)
Return a new Nucleotide Sequence for
 nucleotide. 
 | 
static SymbolList | 
ProteinTools.createProtein(String theProtein)
Return a new Protein SymbolList for protein. 
 | 
static Sequence | 
ProteinTools.createProteinSequence(String protein,
                     String name)
Return a new PROTEIN Sequence for
 protein. 
 | 
static SymbolList | 
RNATools.createRNA(String rna)
Return a new RNA SymbolList for
 rna. 
 | 
static Sequence | 
RNATools.createRNASequence(String rna,
                 String name)
Return a new RNA Sequence for
 rna. 
 | 
static char | 
DNATools.dnaToken(Symbol sym)
Get a single-character token for a DNA symbol 
 | 
static Symbol | 
NucleotideTools.forSymbol(char token)
Retrieve the symbol for a symbol. 
 | 
static Symbol | 
DNATools.forSymbol(char token)
Retrieve the symbol for a symbol. 
 | 
static Symbol | 
RNATools.forSymbol(char token)
Retrieve the symbol for a symbol. 
 | 
static int | 
NucleotideTools.index(Symbol sym)
Return an integer index for a symbol - compatible with
  
forIndex. | 
static int | 
DNATools.index(Symbol sym)
Return an integer index for a symbol - compatible with
  
forIndex. | 
static int | 
RNATools.index(Symbol sym)
Return an integer index for a symbol - compatible with forIndex. 
 | 
static char | 
NucleotideTools.nucleotideToken(Symbol sym)
Get a single-character token for a Nucleotide symbol 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static void | 
SeqIOTools.biojavaToFile(int fileType,
             OutputStream os,
             Object biojava)
Deprecated.  
Converts a Biojava object to the given filetype. 
 | 
static void | 
SeqIOTools.biojavaToFile(String formatName,
             String alphabetName,
             OutputStream os,
             Object biojava)
Deprecated.  
Writes a Biojava  
SequenceIterator,
 SequenceDB, Sequence or Aligment
 to an OutputStream | 
void | 
StreamParser.characters(char[] data,
          int start,
          int len)  | 
void | 
StreamParser.close()  | 
SymbolList | 
ChunkedSymbolListFactory.make(SymbolReader sr)
Method to create a Sequence with a SymbolReader. 
 | 
protected Symbol[] | 
WordTokenization.parseString(String s)  | 
Symbol | 
CharacterTokenization.parseToken(String token)  | 
Symbol | 
NameTokenization.parseToken(String token)  | 
Symbol | 
DoubleTokenization.parseToken(String seq)  | 
Symbol | 
IntegerTokenization.parseToken(String seq)  | 
Symbol | 
AlternateTokenization.parseToken(String token)
Will throw an exception. 
 | 
Symbol | 
SubIntegerTokenization.parseToken(String seq)  | 
Symbol | 
SymbolTokenization.parseToken(String token)
Returns the symbol for a single token. 
 | 
Symbol | 
CrossProductTokenization.parseToken(String token)  | 
protected Symbol | 
CharacterTokenization.parseTokenChar(char c)  | 
protected void | 
EmblLikeFormat.processSequenceLine(String line,
                   StreamParser parser)
Deprecated.  
Dispatch symbol data from SQ-block line of an EMBL-like file. 
 | 
boolean | 
EmblLikeFormat.readSequence(BufferedReader reader,
            SymbolTokenization symParser,
            SeqIOListener listener)
Deprecated.  
  | 
boolean | 
FastaFormat.readSequence(BufferedReader reader,
            SymbolTokenization symParser,
            SeqIOListener siol)
Deprecated.  
Reads information from a flatfile to a  
SeqIOListener
 using a SymbolTokenizer to convert sequence strings
 to Symbol objects. | 
boolean | 
GenbankXmlFormat.readSequence(BufferedReader reader,
            SymbolTokenization symParser,
            SeqIOListener listener)
Deprecated.  
  | 
boolean | 
SequenceFormat.readSequence(BufferedReader reader,
            SymbolTokenization symParser,
            SeqIOListener listener)
Read a sequence and pass data on to a SeqIOListener. 
 | 
boolean | 
GenbankFormat.readSequence(BufferedReader reader,
            SymbolTokenization symParser,
            SeqIOListener listener)
Deprecated.  
Reads a sequence from the specified reader using the Symbol
 parser and Sequence Factory provided. 
 | 
Symbol | 
SymbolReader.readSymbol()
Return a single symbol from the stream. 
 | 
int | 
SymbolReader.readSymbols(Symbol[] buffer,
           int start,
           int length)
Read one or more symbols from the stream. 
 | 
protected List | 
WordTokenization.splitString(String str)  | 
String | 
CharacterTokenization.tokenizeSymbol(Symbol s)  | 
String | 
NameTokenization.tokenizeSymbol(Symbol s)  | 
String | 
DoubleTokenization.tokenizeSymbol(Symbol sym)  | 
String | 
IntegerTokenization.tokenizeSymbol(Symbol sym)  | 
String | 
AlternateTokenization.tokenizeSymbol(Symbol s)  | 
String | 
SubIntegerTokenization.tokenizeSymbol(Symbol sym)  | 
String | 
SymbolTokenization.tokenizeSymbol(Symbol sym)
Return a token representing a single symbol. 
 | 
String | 
CrossProductTokenization.tokenizeSymbol(Symbol s)  | 
String | 
WordTokenization.tokenizeSymbolList(SymbolList sl)  | 
String | 
SymbolTokenization.tokenizeSymbolList(SymbolList symList)
Return a string representation of a list of symbols. 
 | 
void | 
MSFAlignmentFormat.write(OutputStream os,
     Alignment align,
     int fileType)  | 
void | 
FastaAlignmentFormat.write(OutputStream os,
     Alignment align,
     int fileType)
Writes out the alignment to an FASTA file. 
 | 
void | 
MSFAlignmentFormat.writeDna(OutputStream os,
        Alignment align)  | 
void | 
FastaAlignmentFormat.writeDna(OutputStream os,
        Alignment align)  | 
void | 
MSFAlignmentFormat.writeProtein(OutputStream os,
            Alignment align)  | 
void | 
FastaAlignmentFormat.writeProtein(OutputStream os,
            Alignment align)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
SimpleSymbolList.addSymbol(Symbol sym)
Add a new Symbol to the end of this list. 
 | 
void | 
AbstractAlphabet.addSymbol(Symbol s)  | 
void | 
FiniteAlphabet.addSymbol(Symbol s)
Adds a symbol to this alphabet. 
 | 
void | 
SingletonAlphabet.addSymbolImpl(AtomicSymbol sym)  | 
protected abstract void | 
AbstractAlphabet.addSymbolImpl(AtomicSymbol s)  | 
protected void | 
SimpleAlphabet.addSymbolImpl(AtomicSymbol s)  | 
void | 
UkkonenSuffixTree.addSymbolList(SymbolList list,
             String name,
             boolean doNotTerminate)  | 
void | 
SuffixTree.addSymbols(SymbolList sList,
          int window)
Add a count for all motifs with length of up to  
window
 to this tree. | 
static Symbol | 
AlphabetManager.createSymbol(Annotation annotation,
            List symList,
            Alphabet alpha)
 Generates a new Symbol instance that represents the tuple of Symbols in
 symList. 
 | 
static Symbol | 
AlphabetManager.createSymbol(Annotation annotation,
            Set symSet,
            Alphabet alpha)
 Generates a new Symbol instance that represents the tuple of Symbols in
 symList. 
 | 
static Symbol | 
AlphabetManager.createSymbol(char token,
            Annotation annotation,
            List symList,
            Alphabet alpha)
Deprecated. 
 
use the new version, without the token argument 
 | 
static Symbol | 
AlphabetManager.createSymbol(char token,
            Annotation annotation,
            Set symSet,
            Alphabet alpha)
Deprecated. 
 
use the three-arg version of this method instead. 
 | 
protected abstract Set | 
AbstractManyToOneTranslationTable.doUntranslate(Symbol sym)
this method is expected to reverse-translate any symbol
 in the source alphabet. 
 | 
protected abstract Symbol | 
AbstractReversibleTranslationTable.doUntranslate(Symbol sym)
this method is expected to reverse-translate any symbol
 in the source alphabet. 
 | 
static List | 
AlphabetManager.factorize(Alphabet alpha,
         Set symSet)
 Return a list of BasisSymbol instances that uniquely sum up all
 AtomicSymbol
 instances in symSet. 
 | 
static AlphabetIndex | 
AlphabetManager.getAlphabetIndex(Symbol[] syms)
Get an indexer for an array of symbols. 
 | 
Symbol | 
IntegerAlphabet.getAmbiguity(Set symSet)  | 
Symbol | 
DoubleAlphabet.getAmbiguity(Set syms)  | 
Symbol | 
AbstractAlphabet.getAmbiguity(Set syms)  | 
Symbol | 
Alphabet.getAmbiguity(Set<Symbol> syms)
 Get a symbol that represents the set of symbols in syms. 
 | 
protected Symbol | 
AbstractAlphabet.getAmbiguityImpl(Set syms)
Backend for getAmbiguity, called when it is actually necessarly to create a new symbol. 
 | 
SuffixTree.SuffixNode | 
SuffixTree.getChild(SuffixTree.SuffixNode node,
        Symbol s)
Get a child of a SuffixTree.SuffixNode, constructing a new
 one if need be. 
 | 
double | 
SimpleSymbolPropertyTable.getDoubleValue(Symbol s)  | 
double | 
SymbolPropertyTable.getDoubleValue(Symbol s)  | 
Distribution | 
SimpleCodonPref.getFrequencyForSynonyms(Symbol residue)  | 
Distribution | 
CodonPref.getFrequencyForSynonyms(Symbol residue)
returns a Distribution giving the
 frequency of synonymous codons. 
 | 
DoubleAlphabet.DoubleSymbol | 
DoubleAlphabet.SubDoubleAlphabet.getSymbol(double val)  | 
IntegerAlphabet.IntegerSymbol | 
IntegerAlphabet.SubIntegerAlphabet.getSymbol(int val)  | 
Symbol | 
IntegerAlphabet.getSymbol(List symList)  | 
Symbol | 
DoubleAlphabet.getSymbol(List symList)  | 
Symbol | 
DoubleAlphabet.SubDoubleAlphabet.getSymbol(List rl)  | 
Symbol | 
AbstractAlphabet.getSymbol(List syms)  | 
Symbol | 
SoftMaskedAlphabet.getSymbol(List l)
Gets the compound symbol composed of the  
Symbols in the List. | 
Symbol | 
Alphabet.getSymbol(List<Symbol> rl)
 Get a symbol from the Alphabet which corresponds
 to the specified ordered list of symbols. 
 | 
protected AtomicSymbol | 
IntegerAlphabet.SubIntegerAlphabet.getSymbolImpl(List symL)  | 
protected AtomicSymbol | 
SingletonAlphabet.getSymbolImpl(List symList)  | 
protected abstract AtomicSymbol | 
AbstractAlphabet.getSymbolImpl(List symList)  | 
protected AtomicSymbol | 
SimpleAlphabet.getSymbolImpl(List symL)  | 
WobbleDistribution | 
SimpleCodonPref.getWobbleDistributionForSynonyms(Symbol residue)  | 
WobbleDistribution | 
CodonPref.getWobbleDistributionForSynonyms(Symbol residue)
returns a WobbleDistribution for
 a specified residue. 
 | 
int | 
AlphabetIndex.indexForSymbol(Symbol s)
Return the unique index for a symbol. 
 | 
boolean | 
SoftMaskedAlphabet.isMasked(BasisSymbol s)
Determines if a  
Symbol is masked. | 
static int | 
PackingFactory.nextWord(SymbolList symList,
        int word,
        int offset,
        int wordLength,
        Packing packing)  | 
byte | 
Packing.pack(Symbol sym)
 Return a byte representing the packing of a symbol. 
 | 
Symbol | 
SoftMaskedAlphabet.CaseSensitiveTokenization.parseToken(String token)  | 
static int | 
PackingFactory.primeWord(SymbolList symList,
         int wordLength,
         Packing packing)  | 
void | 
GappedSymbolList.removeGap(int pos)
Remove a single gap at position pos in this GappedSymbolList. 
 | 
void | 
SimpleGappedSymbolList.removeGap(int pos)  | 
void | 
GappedSymbolList.removeGaps(int pos,
          int length)
Remove some gaps at position pos in this GappedSymbolList. 
 | 
void | 
SimpleGappedSymbolList.removeGaps(int pos,
          int length)  | 
void | 
SingletonAlphabet.removeSymbol(Symbol sym)  | 
void | 
SimpleAlphabet.removeSymbol(Symbol s)  | 
void | 
FiniteAlphabet.removeSymbol(Symbol s)
Remove a symbol from this alphabet. 
 | 
void | 
SimpleSymbolPropertyTable.setDoubleProperty(Symbol s,
                 String value)  | 
void | 
SimpleManyToOneTranslationTable.setTranslation(AtomicSymbol from,
              AtomicSymbol to)
Alter the translation mapping. 
 | 
void | 
SimpleReversibleTranslationTable.setTranslation(AtomicSymbol from,
              AtomicSymbol to)
Alter the translation mapping. 
 | 
void | 
SimpleTranslationTable.setTranslation(AtomicSymbol from,
              AtomicSymbol to)
Alter the translation mapping. 
 | 
String | 
SoftMaskedAlphabet.CaseSensitiveTokenization.tokenizeSymbol(Symbol s)  | 
String | 
SoftMaskedAlphabet.CaseSensitiveTokenization.tokenizeSymbolList(SymbolList sl)  | 
Symbol | 
TranslationTable.translate(Symbol sym)
Translate a single symbol from source alphabet to the target alphabet. 
 | 
Symbol | 
DNANoAmbPack.unpack(byte b)  | 
Symbol | 
Packing.unpack(byte packed)
 Return the symbol for a packing. 
 | 
Set | 
ManyToOneTranslationTable.untranslate(Symbol sym)
Translate a single symbol from target alphabet to the source alphabet. 
 | 
Set | 
AbstractManyToOneTranslationTable.untranslate(Symbol sym)
returns a Set of Atomic Symbols that are the reverse translation
 of the specified Symbol in the target alphabet. 
 | 
Symbol | 
AbstractReversibleTranslationTable.untranslate(Symbol sym)  | 
Symbol | 
ReversibleTranslationTable.untranslate(Symbol sym)
Translate a single symbol from target alphabet to the source alphabet. 
 | 
void | 
IntegerAlphabet.validate(Symbol s)  | 
void | 
DoubleAlphabet.validate(Symbol s)  | 
void | 
DoubleAlphabet.SubDoubleAlphabet.validate(Symbol sym)  | 
void | 
Alphabet.validate(Symbol s)
 Throws a precanned IllegalSymbolException if the symbol is not contained
 within this Alphabet. 
 | 
void | 
AbstractAlphabet.validate(Symbol sym)  | 
void | 
SoftMaskedAlphabet.validate(Symbol s)  | 
static void | 
CodonPrefTools.writeToXML(CodonPref codonPref,
          PrintWriter writer)
write out a specified CodonPref object in XML format. 
 | 
| Constructor and Description | 
|---|
DummySymbolList(Alphabet alpha,
               int length,
               Symbol sym)  | 
Edit(int pos,
    Alphabet alpha,
    Symbol replacement)
Convenience construtor for making single residue changes 
 | 
SimpleAtomicSymbol(Annotation annotation,
                  List syms)  | 
SimpleSymbolList(Alphabet alpha,
                List rList)
Construct a SymbolList containing the symbols in the specified list. 
 | 
SimpleSymbolList(SymbolTokenization parser,
                String seqString)
Construct a SymbolList from a string. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
protected int | 
FiniteAutomaton.alphaIndex(Symbol sym)  | 
protected int | 
Nfa.alphaIndex(Symbol sym)  | 
| Modifier and Type | Method and Description | 
|---|---|
char | 
Search.charValue(Symbol sym)  | 
char | 
PatternFactory.charValue(Symbol sym)
Returns the character that represents the specified Symbol in
 the Alphabet that this PatternFactory was defined for. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
ThinRichSequence.setAlphabetName(String alphaname)  | 
protected void | 
SimpleRichSequence.setAlphabetName(String alphaname)  | 
protected void | 
SimpleRichSequence.setStringSequence(String seq)  | 
| Modifier and Type | Method and Description | 
|---|---|
boolean | 
UniProtFormat.readRichSequence(BufferedReader reader,
                SymbolTokenization symParser,
                RichSeqIOListener rlistener,
                Namespace ns)
Reads a sequence from the given buffered reader using the given tokenizer to parse
 sequence symbols. 
 | 
boolean | 
INSDseqFormat.readRichSequence(BufferedReader reader,
                SymbolTokenization symParser,
                RichSeqIOListener rlistener,
                Namespace ns)
Reads a sequence from the given buffered reader using the given tokenizer to parse
 sequence symbols. 
 | 
boolean | 
UniProtXMLFormat.readRichSequence(BufferedReader reader,
                SymbolTokenization symParser,
                RichSeqIOListener rlistener,
                Namespace ns)
Reads a sequence from the given buffered reader using the given tokenizer to parse
 sequence symbols. 
 | 
boolean | 
FastaFormat.readRichSequence(BufferedReader reader,
                SymbolTokenization symParser,
                RichSeqIOListener rsiol,
                Namespace ns)
Reads a sequence from the given buffered reader using the given tokenizer to parse
 sequence symbols. 
 | 
boolean | 
RichSequenceFormat.readRichSequence(BufferedReader reader,
                SymbolTokenization symParser,
                RichSeqIOListener listener,
                Namespace ns)
Reads a sequence from the given buffered reader using the given tokenizer to parse
 sequence symbols. 
 | 
boolean | 
EMBLxmlFormat.readRichSequence(BufferedReader reader,
                SymbolTokenization symParser,
                RichSeqIOListener rlistener,
                Namespace ns)
Reads a sequence from the given buffered reader using the given tokenizer to parse
 sequence symbols. 
 | 
boolean | 
GenbankFormat.readRichSequence(BufferedReader reader,
                SymbolTokenization symParser,
                RichSeqIOListener rlistener,
                Namespace ns)
Reads a sequence from the given buffered reader using the given tokenizer to parse
 sequence symbols. 
 | 
boolean | 
EMBLFormat.readRichSequence(BufferedReader reader,
                SymbolTokenization symParser,
                RichSeqIOListener rlistener,
                Namespace ns)
Reads a sequence from the given buffered reader using the given tokenizer to parse
 sequence symbols. 
 | 
boolean | 
UniProtFormat.readSequence(BufferedReader reader,
            SymbolTokenization symParser,
            SeqIOListener listener)
Read a sequence and pass data on to a SeqIOListener. 
 | 
boolean | 
INSDseqFormat.readSequence(BufferedReader reader,
            SymbolTokenization symParser,
            SeqIOListener listener)
Read a sequence and pass data on to a SeqIOListener. 
 | 
boolean | 
UniProtXMLFormat.readSequence(BufferedReader reader,
            SymbolTokenization symParser,
            SeqIOListener listener)
Read a sequence and pass data on to a SeqIOListener. 
 | 
boolean | 
FastaFormat.readSequence(BufferedReader reader,
            SymbolTokenization symParser,
            SeqIOListener listener)
Read a sequence and pass data on to a SeqIOListener. 
 | 
boolean | 
EMBLxmlFormat.readSequence(BufferedReader reader,
            SymbolTokenization symParser,
            SeqIOListener listener)
Read a sequence and pass data on to a SeqIOListener. 
 | 
boolean | 
GenbankFormat.readSequence(BufferedReader reader,
            SymbolTokenization symParser,
            SeqIOListener listener)
Read a sequence and pass data on to a SeqIOListener. 
 | 
boolean | 
EMBLFormat.readSequence(BufferedReader reader,
            SymbolTokenization symParser,
            SeqIOListener listener)
Read a sequence and pass data on to a SeqIOListener. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
GeneticAlgorithm.run(GAStoppingCriteria stoppingCriteria)
Iterates the Algorithm until the stopping criteria are met. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
SymbolList | 
MutationFunction.mutate(SymbolList seq)
Produces a new SymbolList by mutation. 
 | 
SymbolList | 
SwapMutationFunction.mutate(SymbolList seq)  | 
SymbolList | 
SimpleMutationFunction.mutate(SymbolList seq)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
SimpleGeneticAlgorithm.run(GAStoppingCriteria stoppingCriteria)  | 
| Modifier and Type | Method and Description | 
|---|---|
static SymbolList | 
GATools.createBinary(String binarySequence)
Creates a  
SymbolList in the GABinary Alphabet | 
Copyright © 2020 BioJava. All rights reserved.