## Uses of Class
org.biojava.bio.symbol.IllegalSymbolException

Packages that use IllegalSymbolException
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.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.structure: Interfaces and classes for protein structure (PDB).
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
org.biojavax.ga.impl: Default implementations and abstract classes.
org.biojavax.ga.util: Utility functions and helper classes

Uses of IllegalSymbolException in org.biojava.bio.chromatogram

Methods in org.biojava.bio.chromatogram that throw IllegalSymbolException
`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.

Uses of IllegalSymbolException in org.biojava.bio.dist

Methods in org.biojava.bio.dist that throw IllegalSymbolException
`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` `SimpleDistribution.Trainer.addCount(DistributionTrainerContext dtc, AtomicSymbol sym, double times)`
`void` `IgnoreCountsTrainer.addCount(DistributionTrainerContext dtc, AtomicSymbol sym, double times)`
`void` `DistributionTrainer.addCount(DistributionTrainerContext dtc, AtomicSymbol sym, double times)` Registers that sym was counted in this state.
`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` `SimpleDistribution.Trainer.getCount(DistributionTrainerContext dtc, AtomicSymbol sym)`
`double` `IgnoreCountsTrainer.getCount(DistributionTrainerContext dtc, AtomicSymbol sym)`
`double` `DistributionTrainer.getCount(DistributionTrainerContext dtc, AtomicSymbol sym)` Get the current count for this state.
`Distribution` `OrderNDistribution.getDistribution(Symbol sym)`
`double` `TranslatedDistribution.getWeight(Symbol sym)`
`double` `PairDistribution.getWeight(Symbol sym)`
`double` `GapDistribution.getWeight(Symbol sym)`
`double` `Distribution.getWeight(Symbol s)` Return the probability that Symbol s is emitted by this spectrum.
`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` `GapDistribution.setWeight(Symbol s, double w)`
`void` `Distribution.setWeight(Symbol s, double w)` Set the probability or odds that Symbol s is emitted by this state.
`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.

Uses of IllegalSymbolException in org.biojava.bio.dp

Methods in org.biojava.bio.dp that throw IllegalSymbolException
`void` `TransitionTrainer.addCount(State from, State to, double count)` Add 'count' to the transition from->to.
`void` `WMAsMM.addState(State toAdd)`
`void` `SimpleMarkovModel.addState(State toAdd)`
`void` `MarkovModel.addState(State newState)` Adds a state to the model.
`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` `SimpleMarkovModel.containsTransition(State from, State to)`
`boolean` `MarkovModel.containsTransition(State from, State to)` Returns wether a transition exists or not.
`void` `SimpleMarkovModel.createTransition(State from, State to)`
`void` `MarkovModel.createTransition(State from, State to)` Makes a transition between two states legal.
`void` `SimpleMarkovModel.destroyTransition(State from, State to)`
`void` `MarkovModel.destroyTransition(State from, State to)` Breaks a transition between two states legal.
`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` `SimpleMarkovModel.getWeights(State source)`
`Distribution` `MarkovModel.getWeights(State source)` Get a probability Distribution over the transition from '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` `SimpleMarkovModel.removeState(State toGo)`
`void` `MarkovModel.removeState(State toGo)` Remove a state from the model.
`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` `SimpleMarkovModel.setWeights(State source, Distribution dist)` Use this methods to customize the transition probabilities.
`void` `MarkovModel.setWeights(State source, Distribution dist)` Set the probability distribution over the transitions from 'source'.
`protected double` `BaumWelchTrainer.singleSequenceIteration(ModelTrainer trainer, SymbolList symList)`
`protected double` `BaumWelchSampler.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` `SimpleMarkovModel.transitionsFrom(State from)`
`FiniteAlphabet` `MarkovModel.transitionsFrom(State source)` Returns the FiniteAlphabet of all states that have a transition from 'source'.
`FiniteAlphabet` `WMAsMM.transitionsTo(State to)`
`FiniteAlphabet` `SimpleMarkovModel.transitionsTo(State to)`
`FiniteAlphabet` `MarkovModel.transitionsTo(State dest)` Returns the FiniteAlphabet of all states that have a transition to 'dest'.
`abstract StatePath` `DP.viterbi(SymbolList[] symList, ScoreType scoreType)`

Constructors in org.biojava.bio.dp that throw IllegalSymbolException
`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)`

Uses of IllegalSymbolException in org.biojava.bio.dp.onehead

Methods in org.biojava.bio.dp.onehead that throw IllegalSymbolException
`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)`

Constructors in org.biojava.bio.dp.onehead that throw IllegalSymbolException
`SingleDP(MarkovModel model)`

Uses of IllegalSymbolException in org.biojava.bio.dp.twohead

Methods in org.biojava.bio.dp.twohead that throw IllegalSymbolException
`double` `PairwiseDP.backward(SymbolList[] seqs, ScoreType scoreType)`
`DPMatrix` `PairwiseDP.backwardMatrix(SymbolList[] seqs, DPMatrix d, ScoreType scoreType)`
`DPMatrix` `PairwiseDP.backwardMatrix(SymbolList[] seqs, ScoreType scoreType)`
`CellCalculator` `DPInterpreter.backwards(ScoreType scoreType)`
`CellCalculator` `CellCalculatorFactory.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` `DPInterpreter.forwards(ScoreType scoreType)`
`CellCalculator` `CellCalculatorFactory.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` `PairDPCursor.next(Cell[][] cells)` retrieve the next block of cells
`void` `LightPairDPCursor.next(Cell[][] cells)` Description of the Method
`CellCalculator` `DPInterpreter.viterbi(ScoreType scoreType, BackPointer terminal)`
`CellCalculator` `CellCalculatorFactory.viterbi(ScoreType scoreType, BackPointer terminal)`
`StatePath` `PairwiseDP.viterbi(SymbolList[] seqs, ScoreType scoreType)`

Constructors in org.biojava.bio.dp.twohead that throw IllegalSymbolException
`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)`

Uses of IllegalSymbolException in org.biojava.bio.gui

Methods in org.biojava.bio.gui that throw IllegalSymbolException
`static double` `DistributionLogo.entropy(Distribution dist, Symbol s)` Calculate the information content of a symbol in bits.
`Paint` `SymbolStyle.fillPaint(Symbol s)` Return the fill paint for a symbol.
`Paint` `SimpleSymbolStyle.fillPaint(Symbol s)`
`Paint` `DNAStyle.fillPaint(Symbol s)`
`Paint` `SymbolStyle.outlinePaint(Symbol s)` Return the outline paint for a symbol.
`Paint` `SimpleSymbolStyle.outlinePaint(Symbol s)`
`Paint` `DNAStyle.outlinePaint(Symbol s)`
`void` `SimpleSymbolStyle.setFillPaint(Symbol s, Paint paint)`
`void` `DNAStyle.setFillPaint(Symbol s, Paint paint)`
`void` `SimpleSymbolStyle.setOutlinePaint(Symbol s, Paint paint)`
`void` `DNAStyle.setOutlinePaint(Symbol s, Paint paint)`

Uses of IllegalSymbolException in org.biojava.bio.molbio

Methods in org.biojava.bio.molbio that throw IllegalSymbolException
`void` `Composition.setSymbolList(SymbolList symbolList)` Set the `SymbolList` to calculation the composition of.

Uses of IllegalSymbolException in org.biojava.bio.program

Constructors in org.biojava.bio.program that throw IllegalSymbolException
`Meme(InputStream is, SymbolTokenization symParser)`

Uses of IllegalSymbolException in org.biojava.bio.program.abi

Methods in org.biojava.bio.program.abi that throw IllegalSymbolException
`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.

Uses of IllegalSymbolException in org.biojava.bio.program.hmmer

Methods in org.biojava.bio.program.hmmer that throw IllegalSymbolException
`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)`

Constructors in org.biojava.bio.program.hmmer that throw IllegalSymbolException
`HmmerProfileHMM(Alphabet alpha, int columns, DistributionFactory matchFactory, DistributionFactory insertFactory, String name)`

Uses of IllegalSymbolException in org.biojava.bio.program.phred

Methods in org.biojava.bio.program.phred that throw IllegalSymbolException
`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)`

Uses of IllegalSymbolException in org.biojava.bio.proteomics

Methods in org.biojava.bio.proteomics that throw IllegalSymbolException
`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.

Constructors in org.biojava.bio.proteomics that throw IllegalSymbolException
`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)`

Uses of IllegalSymbolException in org.biojava.bio.search

Methods in org.biojava.bio.search that throw IllegalSymbolException
`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.

Uses of IllegalSymbolException in org.biojava.bio.seq

Methods in org.biojava.bio.seq that throw IllegalSymbolException
`static Symbol` `RNATools.complement(Symbol sym)` Complement the symbol.
`static Symbol` `NucleotideTools.complement(Symbol sym)` Complement the symbol.
`static Symbol` `DNATools.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` `RNATools.forSymbol(char token)` Retrieve the symbol for a 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 int` `RNATools.index(Symbol sym)` Return an integer index for a symbol - compatible with forIndex.
`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 char` `NucleotideTools.nucleotideToken(Symbol sym)` Get a single-character token for a Nucleotide symbol

Uses of IllegalSymbolException in org.biojava.bio.seq.io

Methods in org.biojava.bio.seq.io that throw IllegalSymbolException
`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` `SymbolTokenization.parseToken(String token)` Returns the symbol for a single token.
`Symbol` `SubIntegerTokenization.parseToken(String seq)`
`Symbol` `NameTokenization.parseToken(String token)`
`Symbol` `IntegerTokenization.parseToken(String seq)`
`Symbol` `DoubleTokenization.parseToken(String seq)`
`Symbol` `CrossProductTokenization.parseToken(String token)`
`Symbol` `CharacterTokenization.parseToken(String token)`
`Symbol` `AlternateTokenization.parseToken(String token)` Will throw an exception.
`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` `SequenceFormat.readSequence(BufferedReader reader, SymbolTokenization symParser, SeqIOListener listener)` Read a sequence and pass data on to a SeqIOListener.
`boolean` `GenbankXmlFormat.readSequence(BufferedReader reader, SymbolTokenization symParser, SeqIOListener listener)` Deprecated.
`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.
`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` `EmblLikeFormat.readSequence(BufferedReader reader, SymbolTokenization symParser, SeqIOListener listener)` Deprecated.
`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` `SymbolTokenization.tokenizeSymbol(Symbol sym)` Return a token representing a single symbol.
`String` `SubIntegerTokenization.tokenizeSymbol(Symbol sym)`
`String` `NameTokenization.tokenizeSymbol(Symbol s)`
`String` `IntegerTokenization.tokenizeSymbol(Symbol sym)`
`String` `DoubleTokenization.tokenizeSymbol(Symbol sym)`
`String` `CrossProductTokenization.tokenizeSymbol(Symbol s)`
`String` `CharacterTokenization.tokenizeSymbol(Symbol s)`
`String` `AlternateTokenization.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)`

Uses of IllegalSymbolException in org.biojava.bio.structure

Methods in org.biojava.bio.structure that throw IllegalSymbolException
`static Character` `StructureTools.convert_3code_1code(String code3)` convert three character amino acid codes into single character e.g.
`Sequence` `ChainImpl.getBJSequence()` Convert the SEQRES groups of a Chain to a Biojava Sequence object.
`Sequence` `Chain.getBJSequence()` Convert the SEQRES groups of a Chain to a Biojava Sequence object.
`static double` `AlphaCTools.getPhiAngle(Symbol phiPsiSym)` extracts the Phi angle from a `Symbol`.
`static Symbol` `AlphaCTools.getPhiPsiSymbol(double phiAngle, double psiAngle)` Makes a Phi - Psi Symbol from the ALPHA CARBON ANGLES alphabet.
`static double` `AlphaCTools.getPsiAngle(Symbol phiPsiSym)` extracts the Psi angle from a `Symbol`.

Uses of IllegalSymbolException in org.biojava.bio.symbol

Methods in org.biojava.bio.symbol that throw IllegalSymbolException
`void` `SimpleSymbolList.addSymbol(Symbol sym)` Add a new Symbol to the end of this list.
`void` `FiniteAlphabet.addSymbol(Symbol s)` Adds a symbol to this alphabet.
`void` `AbstractAlphabet.addSymbol(Symbol s)`
`void` `SingletonAlphabet.addSymbolImpl(AtomicSymbol sym)`
`protected void` `SimpleAlphabet.addSymbolImpl(AtomicSymbol s)`
`protected abstract void` `AbstractAlphabet.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 Symbol` `AbstractReversibleTranslationTable.doUntranslate(Symbol sym)` this method is expected to reverse-translate any symbol in the source alphabet.
`protected abstract Set` `AbstractManyToOneTranslationTable.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` `Alphabet.getAmbiguity(Set syms)` Get a symbol that represents the set of symbols in syms.
`Symbol` `AbstractAlphabet.getAmbiguity(Set 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` `SymbolPropertyTable.getDoubleValue(Symbol s)`
`double` `SimpleSymbolPropertyTable.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` `SoftMaskedAlphabet.getSymbol(List l)` Gets the compound symbol composed of the `Symbols` in the List.
`Symbol` `IntegerAlphabet.getSymbol(List symList)`
`Symbol` `DoubleAlphabet.getSymbol(List symList)`
`Symbol` `DoubleAlphabet.SubDoubleAlphabet.getSymbol(List rl)`
`Symbol` `Alphabet.getSymbol(List rl)` Get a symbol from the Alphabet which corresponds to the specified ordered list of symbols.
`Symbol` `AbstractAlphabet.getSymbol(List syms)`
`protected AtomicSymbol` `SingletonAlphabet.getSymbolImpl(List symList)`
`protected AtomicSymbol` `SimpleAlphabet.getSymbolImpl(List symL)`
`protected AtomicSymbol` `IntegerAlphabet.SubIntegerAlphabet.getSymbolImpl(List symL)`
`protected abstract AtomicSymbol` `AbstractAlphabet.getSymbolImpl(List symList)`
`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` `SimpleGappedSymbolList.removeGap(int pos)`
`void` `GappedSymbolList.removeGap(int pos)` Remove a single gap at position pos in this GappedSymbolList.
`void` `SimpleGappedSymbolList.removeGaps(int pos, int length)`
`void` `GappedSymbolList.removeGaps(int pos, int length)` Remove some gaps at position pos in this GappedSymbolList.
`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` `SimpleTranslationTable.setTranslation(AtomicSymbol from, AtomicSymbol to)` Alter the translation mapping.
`void` `SimpleReversibleTranslationTable.setTranslation(AtomicSymbol from, AtomicSymbol to)` Alter the translation mapping.
`void` `SimpleManyToOneTranslationTable.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` `Packing.unpack(byte packed)` Return the symbol for a packing.
`Symbol` `DNANoAmbPack.unpack(byte b)`
`Symbol` `ReversibleTranslationTable.untranslate(Symbol sym)` Translate a single symbol from target alphabet to the source alphabet.
`Set` `ManyToOneTranslationTable.untranslate(Symbol sym)` Translate a single symbol from target alphabet to the source alphabet.
`Symbol` `AbstractReversibleTranslationTable.untranslate(Symbol sym)`
`Set` `AbstractManyToOneTranslationTable.untranslate(Symbol sym)` returns a Set of Atomic Symbols that are the reverse translation of the specified Symbol in the target alphabet.
`void` `SoftMaskedAlphabet.validate(Symbol s)`
`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)`
`static void` `CodonPrefTools.writeToXML(CodonPref codonPref, PrintWriter writer)` write out a specified CodonPref object in XML format.

Constructors in org.biojava.bio.symbol that throw IllegalSymbolException
`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.

Uses of IllegalSymbolException in org.biojava.utils.automata

Methods in org.biojava.utils.automata that throw IllegalSymbolException
`protected int` `Nfa.alphaIndex(Symbol sym)`
`protected int` `FiniteAutomaton.alphaIndex(Symbol sym)`

Uses of IllegalSymbolException in org.biojava.utils.regex

Methods in org.biojava.utils.regex that throw IllegalSymbolException
`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.

Uses of IllegalSymbolException in org.biojavax.bio.seq

Methods in org.biojavax.bio.seq that throw IllegalSymbolException
`protected void` `ThinRichSequence.setAlphabetName(String alphaname)`
`protected void` `SimpleRichSequence.setAlphabetName(String alphaname)`
`protected void` `SimpleRichSequence.setStringSequence(String seq)`

Uses of IllegalSymbolException in org.biojavax.bio.seq.io

Methods in org.biojavax.bio.seq.io that throw IllegalSymbolException
`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. If namespace is null, then the namespace of the sequence in the fasta is used.
`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` `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` `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` `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` `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. If namespace is null, then the namespace of the sequence in the fasta is used.
`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` `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` `UniProtXMLFormat.readSequence(BufferedReader reader, SymbolTokenization symParser, SeqIOListener listener)` Read a sequence and pass data on to a SeqIOListener.
`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` `GenbankFormat.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` `EMBLFormat.readSequence(BufferedReader reader, SymbolTokenization symParser, SeqIOListener listener)` Read a sequence and pass data on to a SeqIOListener.

Uses of IllegalSymbolException in org.biojavax.ga

Methods in org.biojavax.ga that throw IllegalSymbolException
`void` `GeneticAlgorithm.run(GAStoppingCriteria stoppingCriteria)` Iterates the Algorithm until the stopping criteria are met.

Uses of IllegalSymbolException in org.biojavax.ga.functions

Methods in org.biojavax.ga.functions that throw IllegalSymbolException
`SymbolList` `SwapMutationFunction.mutate(SymbolList seq)`
`SymbolList` `SimpleMutationFunction.mutate(SymbolList seq)`
`SymbolList` `MutationFunction.mutate(SymbolList seq)` Produces a new SymbolList by mutation.

Uses of IllegalSymbolException in org.biojavax.ga.impl

Methods in org.biojavax.ga.impl that throw IllegalSymbolException
`void` `SimpleGeneticAlgorithm.run(GAStoppingCriteria stoppingCriteria)`

Uses of IllegalSymbolException in org.biojavax.ga.util

Methods in org.biojavax.ga.util that throw IllegalSymbolException
`static SymbolList` `GATools.createBinary(String binarySequence)` Creates a `SymbolList` in the GABinary `Alphabet`