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

Packages that use IllegalAlphabetException
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.program.ssaha: SSAHA sequence searching API.
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.homol: The classes and interfaces for defining sequence similarity and honology.
org.biojava.bio.seq.impl: Standard in-memory implementations of `Sequence` and `Feature`.
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.db.biosql: Interface between biojava and biosql databases
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 IllegalAlphabetException in org.biojava.bio.chromatogram

Methods in org.biojava.bio.chromatogram that throw IllegalAlphabetException
`protected void` `AbstractChromatogram.setBaseCallAlignment(Alignment align)` Provides the list of base calls.
`void` `SimpleChromatogram.setSymbolLists(SymbolList dna, SymbolList offsets)` Set the DNA and OFFSETS symbol lists for the basecall alignment.

Uses of IllegalAlphabetException in org.biojava.bio.dist

Methods in org.biojava.bio.dist that throw IllegalAlphabetException
`Distribution` `OrderNDistributionFactory.createDistribution(Alphabet alpha)` Creates an OrderNDistribution of the appropriate type.
`Distribution` `DistributionFactory.createDistribution(Alphabet alpha)` Generate a new Distribution as requested.
`Distribution` `DistributionFactory.DefaultDistributionFactory.createDistribution(Alphabet alpha)`
`static Distribution[]` `DistributionTools.distOverAlignment(Alignment a)` Equivalent to distOverAlignment(a, false, 0.0).
`static Distribution[]` `DistributionTools.distOverAlignment(Alignment a, boolean countGaps)` Creates an array of distributions, one for each column of the alignment.
`static Distribution[]` `DistributionTools.distOverAlignment(Alignment a, boolean countGaps, double nullWeight)` Creates an array of distributions, one for each column of the alignment.
`static Distribution` `DistributionTools.jointDistOverAlignment(Alignment a, boolean countGaps, double nullWeight, int[] cols)` Creates a joint distribution.
`void` `IndexedCount.setCounts(Count c)`
`void` `Count.setCounts(Count c)` Set the counts in this Counts to be equal to the counts in c.
`void` `OrderNDistribution.setDistribution(Symbol sym, Distribution dist)` Set the distribution assocated with a symbol.
`void` `TranslatedDistribution.setNullModel(Distribution dist)`
`void` `PairDistribution.setNullModel(Distribution nullModel)`
`void` `GapDistribution.setNullModel(Distribution nullModel)`
`void` `Distribution.setNullModel(Distribution nullDist)` Set the null model Distribution that this Distribution recognizes.
`void` `AbstractDistribution.setNullModel(Distribution nullModel)`
`protected void` `UniformDistribution.setNullModelImpl(Distribution nullModel)` Assign a background distribution.
`protected void` `SimpleDistribution.setNullModelImpl(Distribution nullModel)`
`protected abstract void` `AbstractDistribution.setNullModelImpl(Distribution nullModel)` Implement this to set the null model.

Constructors in org.biojava.bio.dist that throw IllegalAlphabetException
`AbstractOrderNDistribution(Alphabet alpha)` Construct a new NthOrderDistribution.
`SimpleDistributionTrainer(Distribution dis)` Deprecated.
`TranslatedDistribution(ReversibleTranslationTable table, Distribution other, DistributionFactory distFact)` Create a new TranslatedDistribution.

Uses of IllegalAlphabetException in org.biojava.bio.dp

Methods in org.biojava.bio.dp that throw IllegalAlphabetException
`Sequence` `WeightMatrixAnnotator.annotate(Sequence seq)`
`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)`
`protected void` `ProfileHMM.connectModel()` This is called by constructor in setting up the allowed transitions in the model
`void` `SimpleStatePath.edit(Edit edit)`
`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 WeightMatrix` `XmlMarkovModel.readMatrix(Element root)`
`static MarkovModel` `XmlMarkovModel.readModel(Element root)`
`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)`
`abstract StatePath` `DP.viterbi(SymbolList[] symList, ScoreType scoreType)`

Constructors in org.biojava.bio.dp that throw IllegalAlphabetException
`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.
`SimpleWeightMatrix(Alphabet alpha, int columns, DistributionFactory dFact)`
`SimpleWeightMatrix(Distribution[] columns)`

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

Methods in org.biojava.bio.dp.onehead that throw IllegalAlphabetException
`double` `SingleDP.backward(SymbolList[] seq, ScoreType scoreType)`
`DPMatrix` `SingleDP.backwardMatrix(SymbolList[] seq, DPMatrix matrix, ScoreType scoreType)`
`DPMatrix` `SingleDP.backwardMatrix(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, ScoreType scoreType)`

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

Methods in org.biojava.bio.dp.twohead that throw IllegalAlphabetException
`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)`
`void` `CellCalculator.initialize(Cell[][] cells)` Initialize the cell at [0][0] to the recursion initial parameters.
`CellCalculator` `DPInterpreter.viterbi(ScoreType scoreType, BackPointer terminal)`
`CellCalculator` `CellCalculatorFactory.viterbi(ScoreType scoreType, BackPointer terminal)`
`StatePath` `PairwiseDP.viterbi(SymbolList[] seqs, ScoreType scoreType)`

Uses of IllegalAlphabetException in org.biojava.bio.gui

Methods in org.biojava.bio.gui that throw IllegalAlphabetException
`void` `DistributionLogo.setDistribution(Distribution dist)` Set the dist to render.

Uses of IllegalAlphabetException in org.biojava.bio.molbio

Constructors in org.biojava.bio.molbio that throw IllegalAlphabetException
`RestrictionEnzyme(String name, SymbolList site, int dsForward, int dsReverse)` Creates a new `RestrictionEnzyme` which cuts within or downstream of the recognition site.
`RestrictionEnzyme(String name, SymbolList site, int usForward, int usReverse, int dsForward, int dsReverse)` Creates a new `RestrictionEnzyme` of the unusual type which cuts both upstream and downstream of its recognition site.

Uses of IllegalAlphabetException in org.biojava.bio.program

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

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

Methods in org.biojava.bio.program.abi that throw IllegalAlphabetException
`static Alignment` `ABITools.getAlignment(SymbolList abiSeq)` View a symbol list over the QUALITY alphabet as an alignment.

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

Methods in org.biojava.bio.program.hmmer that throw IllegalAlphabetException
`protected void` `HmmerProfileHMM.connectModel()` This is called by constructor in setting up the allowed transitions in the model

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

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

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

Constructors in org.biojava.bio.program.phred that throw IllegalAlphabetException
`PhredSequence(SymbolList phredSequence, String name, String urn, Annotation anno)` Constructs a new PhredSequence.

Uses of IllegalAlphabetException in org.biojava.bio.program.ssaha

Methods in org.biojava.bio.program.ssaha that throw IllegalAlphabetException
`DataStore` `NIODataStoreFactory.buildDataStore(File storeFile, SequenceDB seqDB, Packing packing, int wordLength, int threshold)`
`DataStore` `MappedDataStoreFactory.buildDataStore(File storeFile, SequenceDB seqDB, Packing packing, int wordLength, int threshold)`
`DataStore` `DataStoreFactory.buildDataStore(File storeFile, SequenceDB seqDB, Packing packing, int wordLength, int threshold)` Build a new DataStore.
`DataStore` `CompactedDataStoreFactory.buildDataStore(File storeFile, SequenceDB seqDB, Packing packing, int wordLength, int threshold)`
`DataStore` `CompactedDataStoreFactory.buildDataStore(File storeFile, SequenceStreamer streamer, Packing packing, int wordLength, int stepSize, int threshold)`
`void` `DataStore.search(String id, SymbolList symList, SearchListener listener)` Search the DataStore with a symbol list.

Uses of IllegalAlphabetException in org.biojava.bio.proteomics

Methods in org.biojava.bio.proteomics that throw IllegalAlphabetException
`static double` `IsoelectricPointCalc.getIsoelectricPoint(SymbolList peptide)` Static public method to compute the pI for a polypeptide in denaturating and reduced conditions with both free ends.
`double` `IsoelectricPointCalc.getPI(SymbolList peptide, boolean hasFreeNTerm, boolean hasFreeCTerm)` Computes isoelectric point of specified peptide.

Uses of IllegalAlphabetException in org.biojava.bio.search

Methods in org.biojava.bio.search that throw IllegalAlphabetException
`BioMatcher` `SeqContentPattern.matcher(SymbolList symList)`
`BioMatcher` `MaxMismatchPattern.matcher(SymbolList symList)`
`BioMatcher` `BioPattern.matcher(SymbolList symList)` Get a matcher that will use these parameters to search a SymbolList.

Uses of IllegalAlphabetException in org.biojava.bio.seq

Methods in org.biojava.bio.seq that throw IllegalAlphabetException
`Sequence` `SequenceAnnotator.annotate(Sequence seq)` Return an annotated version of a sequence.
`static SymbolList` `RNATools.complement(SymbolList list)` Retrieve a complement view of list.
`static SymbolList` `NucleotideTools.complement(SymbolList list)` Retrieve a complement view of list.
`static SymbolList` `DNATools.complement(SymbolList list)` Retrieve a complement view of list.
`void` `SimpleAssembly.edit(Edit e)`
`void` `NewSimpleAssembly.edit(Edit e)`
`static SymbolList` `DNATools.flip(SymbolList list, StrandedFeature.Strand strand)` Returns a SymbolList that is reverse complemented if the strand is negative, and the origninal one if it is not.
`static Sequence` `SequenceTools.reverseComplement(Sequence seq)` Reverse-complement a sequence, and flip all of its features.
`static SymbolList` `RNATools.reverseComplement(SymbolList list)` Retrieve a reverse-complement view of list.
`static SymbolList` `NucleotideTools.reverseComplement(SymbolList list)` Retrieve a reverse-complement view of list.
`static SymbolList` `DNATools.reverseComplement(SymbolList list)` Retrieve a reverse-complement view of list.
`static Sequence` `SequenceTools.subSequence(Sequence seq, int start, int end, String name, StrandedFeature.Strand strand)` Extract a sub-sequence from a sequence.
`static SymbolList` `DNATools.toProtein(SymbolList syms)` Convenience method that directly converts a DNA sequence to RNA then to protein.
`static SymbolList` `DNATools.toProtein(SymbolList syms, int start, int end)` Convenience method to translate a region of a DNA sequence directly into protein.
`static SymbolList` `DNATools.toRNA(SymbolList syms)` Converts a `SymbolList` from the DNA `Alphabet` to the RNA `Alphabet`.
`static SymbolList` `RNATools.transcribe(SymbolList list)` Deprecated. The naming of this method is confusing and inconsistent use either DNATools.toRNA(SymbolList list) or DNATools.transcribeToRNA(SymbolList list) depending on the desired behaivour.
`static SymbolList` `GeneticCodes.transcribe(SymbolList theList)` Transcribe DNA into RNA.
`static SymbolList` `DNATools.transcribeToRNA(SymbolList syms)` Transcribes DNA to RNA.
`static SymbolList` `RNATools.translate(SymbolList syms)` Translate RNA into protein (with termination symbols).
`static SymbolList` `GeneticCodes.translate(SymbolList theList)` Translate RNA into protein (with termination symbols).

Uses of IllegalAlphabetException in org.biojava.bio.seq.homol

Methods in org.biojava.bio.seq.homol that throw IllegalAlphabetException
`void` `SimilarityPairFeature.EmptyPairwiseAlignment.edit(Edit edit)`

Uses of IllegalAlphabetException in org.biojava.bio.seq.impl

Methods in org.biojava.bio.seq.impl that throw IllegalAlphabetException
`void` `DummySequence.edit(Edit edit)`

Constructors in org.biojava.bio.seq.impl that throw IllegalAlphabetException
`RevCompSequence(Sequence seq)` URN, Name and Annotation are copied as is from the original Sequence, unless you use the the other contructor that sets these.
`RevCompSequence(Sequence seq, String urn, String name, Annotation annotation)`
`SimpleFramedFeature(Sequence sourceSeq, FeatureHolder parent, FramedFeature.Template template)`
`SimpleHomologyFeature(Sequence sourceSeq, FeatureHolder parent, HomologyFeature.Template template)`
`SimpleSimilarityPairFeature(Sequence sourceSeq, FeatureHolder parent, SimilarityPairFeature.Template template)` Creates a new `SimpleSimilarityPairFeature`.

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

Methods in org.biojava.bio.seq.io that throw IllegalAlphabetException
`void` `SwissprotFileFormer.addSymbols(Alphabet theAlphabet, Symbol[] theSymbols, int theStart, int theLength)` Deprecated. Prints out the sequences properties in order.
`void` `SmartSequenceBuilder.addSymbols(Alphabet alpha, Symbol[] syms, int pos, int len)`
`void` `SimpleSequenceBuilder.addSymbols(Alphabet alpha, Symbol[] syms, int pos, int len)`
`void` `SimpleAssemblyBuilder.addSymbols(Alphabet alpha, Symbol[] syms, int pos, int len)`
`void` `SequenceBuilderFilter.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)`
`abstract void` `SequenceBuilderBase.addSymbols(Alphabet alpha, Symbol[] syms, int pos, int len)`
`void` `SeqIOListener.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)` Notify the listener of symbol data.
`void` `SeqIOFilter.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)`
`void` `SeqIOAdapter.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)`
`void` `ProteinRefSeqFileFormer.addSymbols(Alphabet theAlphabet, Symbol[] theSymbols, int theStart, int theLength)` Deprecated.
`void` `GenbankFileFormer.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)` Deprecated.
`void` `EmblFileFormer.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)` Deprecated.
`void` `ChunkedSymbolListFactory.addSymbols(Alphabet alfa, Symbol[] syms, int pos, int len)` tool to construct the SymbolList by adding Symbols.
`protected List` `SwissprotFileFormer.breakSymbolArray(Alphabet theAlphabet, Symbol[] theSymbols, int theStart, int theLength)` Deprecated. Converts the symbol list passed in into an array of strings.
`protected List` `ProteinRefSeqFileFormer.breakSymbolArray(Alphabet theAlphabet, Symbol[] theSymbols, int theStart, int theLength)` Deprecated. Converts the symbol list passed in into an array of strings.
`SymbolList` `ChunkedSymbolListFactory.make(SymbolReader sr)` Method to create a Sequence with a SymbolReader.
`SymbolList` `ChunkedSymbolListFactory.makeSymbolList()` Converts accumulated Symbols to a SymbolList
`protected void` `SwissprotFileFormer.printOutSequenceHeaderLine(Alphabet theAlphabet, Symbol[] theSymbols, int theStart, int theLength)` Deprecated. Prints out sequence header with only length data.
`String` `WordTokenization.tokenizeSymbolList(SymbolList sl)`
`String` `SymbolTokenization.tokenizeSymbolList(SymbolList symList)` Return a string representation of a list of symbols.
`String` `CharacterTokenization.tokenizeSymbolList(SymbolList sl)`
`String` `AlternateTokenization.tokenizeSymbolList(SymbolList sl)`

Uses of IllegalAlphabetException in org.biojava.bio.symbol

Methods in org.biojava.bio.symbol that throw IllegalAlphabetException
`void` `SymbolList.edit(Edit edit)` Apply an edit to the SymbolList as specified by the edit object.
`void` `SimpleSymbolList.edit(Edit edit)` Apply and edit to the SymbolList as specified by Edit.
`void` `RelabeledAlignment.edit(Edit edit)`
`void` `AbstractSymbolList.edit(Edit edit)`
`static Alphabet` `AlphabetManager.getCrossProductAlphabet(List aList, String name)` Attempts to create a cross product alphabet and register it under a name.
`static SoftMaskedAlphabet` `SoftMaskedAlphabet.getInstance(FiniteAlphabet alphaToMask)` Generates a soft masked Alphabet where lowercase tokens are assumed to be soft masked.
`static SoftMaskedAlphabet` `SoftMaskedAlphabet.getInstance(FiniteAlphabet alphaToMask, SoftMaskedAlphabet.MaskingDetector maskingDetector)` Creates a compound alphabet that is a hybrid of the alphabet that is to be soft masked and a binary alphabet that indicates if any `Symbol` is soft masked or not.
`static Packing` `PackingFactory.getPacking(FiniteAlphabet alpha, boolean ambiguity)` Get the default packing for an alphabet.
`SymbolList` `SymbolListFactory.makeSymbolList(Symbol[] symbolArray, int size, Alphabet alfa)` makes a SymbolList containing size Symbols from a Symbol array.
`SymbolList` `SimpleSymbolListFactory.makeSymbolList(Symbol[] symbolArray, int size, Alphabet alfa)` Create a factory for SimpleSymbolLists.
`SymbolList` `PackedSymbolListFactory.makeSymbolList(Symbol[] symbolArray, int size, Alphabet alfa)` Makes a packed SymbolList out of a list of Symbols.
`static SymbolList` `SymbolListViews.orderNSymbolList(SymbolList source, int order)` An n-th order view of another SymbolList.
`static SymbolList` `SymbolListViews.translate(SymbolList symbols, TranslationTable table)` Provides a 'translated' view of an underlying SymbolList.

Constructors in org.biojava.bio.symbol that throw IllegalAlphabetException
`PackedSymbolList(Packing packing, Symbol[] symbols, int length, Alphabet alfa)` Create a new PackedSymbolList from an array of Symbols.
`PackedSymbolList(Packing packing, SymbolList symList)` Create a new PackedSymbolList as a packed copy of another symbol list.
`SimpleCodonPref(String geneticCodeName, Distribution codonPref, String name)`
`SimpleReversibleTranslationTable(FiniteAlphabet source, FiniteAlphabet target)` Construct a new translation table.

Uses of IllegalAlphabetException in org.biojava.utils.automata

Methods in org.biojava.utils.automata that throw IllegalAlphabetException
`StateMachineFactory` `ArrayStateMachineToolkit.getFactory(String factoryName, FiniteAutomaton fa)`
`void` `PatternBlitz.search(SymbolList sl)`

Uses of IllegalAlphabetException in org.biojava.utils.regex

Methods in org.biojava.utils.regex that throw IllegalAlphabetException
`void` `Search.addPattern(String patternString, boolean overlap)` add a search pattern to the searches to be conducted by this object.
`void` `Search.addPattern(String label, String patternString, boolean overlap)` add a search pattern to the searches to be conducted by this object.
`Pattern` `PatternFactory.compile(String pattern)` Returns a Pattern object that applies the specified regex against SymbolLists in the Alphabet that this PatternFactory was defined against.
`Pattern` `PatternFactory.compile(String pattern, String label)` Returns a Pattern object that applies the specified regex against SymbolLists in the Alphabet that this PatternFactory was defined against.

Uses of IllegalAlphabetException in org.biojavax.bio.db.biosql

Methods in org.biojavax.bio.db.biosql that throw IllegalAlphabetException

`void`

`BioSQLRichSequenceHandler.edit(RichSequence seq, Edit edit)`
Apply an edit to the Sequence as specified by the edit object.

## Description

All edits can be broken down into a series of operations that change contiguous blocks of the sequence. This represent a one of those operations.

When applied, this Edit will replace 'length' number of symbols starting a position 'pos' by the SymbolList 'replacement'. This allow to do insertions (length=0), deletions (replacement=SymbolList.EMPTY_LIST) and replacements (length>=1 and replacement.length()>=1).

The pos and pos+length should always be valid positions on the SymbolList to:

- be edited (between 0 and symL.length()+1).
- To append to a sequence, pos=symL.length()+1, pos=0.
- To insert something at the beginning of the sequence, set pos=1 and length=0.

## Examples

`

     RichSequence seq = //code to initialize RichSequence
     System.out.println(seq.seqString());

     // delete 5 bases from position 4
     Edit ed = new Edit(4, 5, SymbolList.EMPTY_LIST);
     seq.edit(ed);
     System.out.println(seq.seqString());

     // delete one base from the start
     ed = new Edit(1, 1, SymbolList.EMPTY_LIST);
     seq.edit(ed);

     // delete one base from the end
     ed = new Edit(seq.length(), 1, SymbolList.EMPTY_LIST);
     seq.edit(ed);
     System.out.println(seq.seqString());

     // overwrite 2 bases from position 3 with "tt"
     ed = new Edit(3, 2, DNATools.createDNA("tt"));
     seq.edit(ed);
     System.out.println(seq.seqString());

     // add 6 bases to the start
     ed = new Edit(1, 0, DNATools.createDNA("aattgg");
     seq.edit(ed);
     System.out.println(seq.seqString());

     // add 4 bases to the end
     ed = new Edit(seq.length() + 1, 0, DNATools.createDNA("tttt"));
     seq.edit(ed);
     System.out.println(seq.seqString());

     // full edit
     ed = new Edit(3, 2, DNATools.createDNA("aatagaa");
     seq.edit(ed);
     System.out.println(seq.seqString());

`

Uses of IllegalAlphabetException in org.biojavax.bio.seq

Methods in org.biojavax.bio.seq that throw IllegalAlphabetException
`void` `ThinRichSequence.edit(Edit edit)` Apply an edit to the SymbolList as specified by the edit object.
`void` `InfinitelyAmbiguousSymbolList.edit(Edit edit)` Apply an edit to the SymbolList as specified by the edit object. IGNORED
`void` `RichSequenceHandler.edit(RichSequence seq, Edit edit)` Apply an edit to the Sequence as specified by the edit object.
`void` `DummyRichSequenceHandler.edit(RichSequence seq, Edit edit)` Apply an edit to the Sequence as specified by the edit object.

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

Methods in org.biojavax.bio.seq.io that throw IllegalAlphabetException
`void` `SimpleRichSequenceBuilder.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)` Notify the listener of symbol data.
`void` `RichSeqIOAdapter.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)`
`void` `DebuggingRichSeqIOListener.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)`

Uses of IllegalAlphabetException in org.biojavax.ga

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

Uses of IllegalAlphabetException in org.biojavax.ga.functions

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

Uses of IllegalAlphabetException in org.biojavax.ga.impl

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

Uses of IllegalAlphabetException in org.biojavax.ga.util

Methods in org.biojavax.ga.util that throw IllegalAlphabetException
`static OrderNDistribution` `GATools.standardMutationDistribution(FiniteAlphabet a)` Makes a mutation `Distribution` where the probability of a `Symbol` being mutated to itself is zero and the probability of it being changed to any other `Symbol` in the `Alphabet a` is `1.0 / (a.size() - 1.0)`
`static OrderNDistribution` `GATools.uniformMutationDistribution(FiniteAlphabet a)` Makes a 1st order distribution which is infact uniform (equivalent to a uniform zero order distribution).