Uses of Class org.biojava.bio.symbol.IllegalAlphabetException (BioJava-1.5-beta API)

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

## 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 |
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` | `AbstractDistribution.setNullModel(Distribution nullModel)`
`void` | `GapDistribution.setNullModel(Distribution nullModel)`
`void` | `Distribution.setNullModel(Distribution nullDist)` Set the null model Distribution that this Distribution recognizes.
`void` | `TranslatedDistribution.setNullModel(Distribution dist)`
`void` | `PairDistribution.setNullModel(Distribution nullModel)`
`protected abstract void` | `AbstractDistribution.setNullModelImpl(Distribution nullModel)` Implement this to set the null model.
`protected void` | `UniformDistribution.setNullModelImpl(Distribution nullModel)` Assign a background distribution.
`protected void` | `SimpleDistribution.setNullModelImpl(Distribution nullModel)`

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 abstract double` | `AbstractTrainer.singleSequenceIteration(ModelTrainer trainer, SymbolList symList)`
`protected double` | `BaumWelchSampler.singleSequenceIteration(ModelTrainer trainer, SymbolList symList)`
`protected double` | `BaumWelchTrainer.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` | `CompactedDataStoreFactory.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` | `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` | `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
`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` | `MaxMismatchPattern.matcher(SymbolList symList)`
`BioMatcher` | `SeqContentPattern.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` | `DNATools.complement(SymbolList list)` Retrieve a complement view of list.
`static SymbolList` | `NucleotideTools.complement(SymbolList list)` Retrieve a complement view of list.
`static SymbolList` | `RNATools.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` | `DNATools.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` | `RNATools.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.toRNA(SymbolList syms)` Converts a `SymbolList` from the DNA `Alphabet` to the RNA `Alphabet`.
`static SymbolList` | `GeneticCodes.transcribe(SymbolList theList)` Transcribe DNA into RNA.
`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` | `DNATools.transcribeToRNA(SymbolList syms)` Transcribes DNA to RNA.
`static SymbolList` | `GeneticCodes.translate(SymbolList theList)` Translate RNA into protein (with termination symbols).
`static SymbolList` | `RNATools.translate(SymbolList syms)` 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` | `SequenceBuilderFilter.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)`
`void` | `SeqIOFilter.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)`
`abstract void` | `SequenceBuilderBase.addSymbols(Alphabet alpha, Symbol[] syms, int pos, int len)`
`void` | `SwissprotFileFormer.addSymbols(Alphabet theAlphabet, Symbol[] theSymbols, int theStart, int theLength)` Deprecated. Prints out the sequences properties in order.
`void` | `GenbankFileFormer.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)` Deprecated.
`void` | `SmartSequenceBuilder.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` | `SimpleSequenceBuilder.addSymbols(Alphabet alpha, Symbol[] syms, int pos, int len)`
`void` | `EmblFileFormer.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)` Deprecated.
`void` | `SimpleAssemblyBuilder.addSymbols(Alphabet alpha, Symbol[] syms, int pos, int len)`
`void` | `ProteinRefSeqFileFormer.addSymbols(Alphabet theAlphabet, Symbol[] theSymbols, int theStart, int theLength)` Deprecated.
`void` | `ChunkedSymbolListFactory.addSymbols(Alphabet alfa, Symbol[] syms, int pos, int len)` tool to construct the SymbolList by adding Symbols.
`void` | `SeqIOAdapter.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)`
`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` | `SymbolTokenization.tokenizeSymbolList(SymbolList symList)` Return a string representation of a list of symbols.
`String` | `WordTokenization.tokenizeSymbolList(SymbolList sl)`
`String` | `CharacterTokenization.tokenizeSymbolList(SymbolList sl)`

Uses of IllegalAlphabetException in org.biojava.bio.symbol

Methods in org.biojava.bio.symbol that throw IllegalAlphabetException
`void` | `AbstractSymbolList.edit(Edit edit)`
`void` | `RelabeledAlignment.edit(Edit edit)`
`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.
`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` | `SimpleSymbolListFactory.makeSymbolList(Symbol[] symbolArray, int size, Alphabet alfa)` Create a factory for SimpleSymbolLists.
`SymbolList` | `SymbolListFactory.makeSymbolList(Symbol[] symbolArray, int size, Alphabet alfa)` makes a SymbolList containing size Symbols from a Symbol array.
`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` | `DebuggingRichSeqIOListener.addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)`
`void` | `RichSeqIOAdapter.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` | `MutationFunction.mutate(SymbolList seq)` Produces a new SymbolList by mutation.
`SymbolList` | `SimpleMutationFunction.mutate(SymbolList seq)`

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).

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