Uses of Interface
org.biojava.nbio.core.sequence.template.Compound

Packages that use Compound

Package	Description
org.biojava.nbio.alignment
org.biojava.nbio.alignment.routines
org.biojava.nbio.alignment.template
org.biojava.nbio.core.alignment
org.biojava.nbio.core.alignment.matrices
org.biojava.nbio.core.alignment.template
org.biojava.nbio.core.search.io
org.biojava.nbio.core.sequence
org.biojava.nbio.core.sequence.compound
org.biojava.nbio.core.sequence.edits
org.biojava.nbio.core.sequence.features
org.biojava.nbio.core.sequence.io
org.biojava.nbio.core.sequence.io.template
org.biojava.nbio.core.sequence.io.util
org.biojava.nbio.core.sequence.loader
org.biojava.nbio.core.sequence.location
org.biojava.nbio.core.sequence.location.template
org.biojava.nbio.core.sequence.storage
org.biojava.nbio.core.sequence.template
org.biojava.nbio.core.sequence.transcription
org.biojava.nbio.core.sequence.views
org.biojava.nbio.phylo
org.biojava.nbio.ws.alignment	This package contains the interfaces that need to be implemented by discrete alignment services.
org.biojava.nbio.ws.alignment.qblast

Uses of Compound in org.biojava.nbio.alignment

Classes in org.biojava.nbio.alignment with type parameters of type Compound

Modifier and Type	Class and Description
class	FractionalIdentityInProfileScorer<S extends Sequence<C>,C extends Compound> Implements an algorithm which computes a score for a sequence alignment pair picked from an alignment Profile.
class	FractionalIdentityScorer<S extends Sequence<C>,C extends Compound> Implements an algorithm which computes a score for a sequence alignment pair.
class	FractionalSimilarityInProfileScorer<S extends Sequence<C>,C extends Compound> Implements an algorithm which computes a score for a sequence alignment pair picked from an alignment Profile.
class	FractionalSimilarityScorer<S extends Sequence<C>,C extends Compound> Implements an algorithm which computes a score for a sequence alignment pair.
class	GuideTree<S extends Sequence<C>,C extends Compound> Implements a data structure for a guide tree used during progressive multiple sequence alignment.
class	NeedlemanWunsch<S extends Sequence<C>,C extends Compound> Needleman and Wunsch defined an algorithm for pairwise global sequence alignments (from the first until the last Compound of each Sequence).
class	SimpleProfileProfileAligner<S extends Sequence<C>,C extends Compound> Implements a simple (naive) Aligner for a pair of Profiles.
class	SmithWaterman<S extends Sequence<C>,C extends Compound> Smith and Waterman defined an algorithm for pairwise local sequence alignments (best match of sections from each Sequence).
class	StandardRescoreRefiner<S extends Sequence<C>,C extends Compound>
class	SubstitutionMatrixScorer<S extends Sequence<C>,C extends Compound> Scores using a substitution matrix.

Methods in org.biojava.nbio.alignment with type parameters of type Compound

Modifier and Type	Method and Description
static <S extends Sequence<C>,C extends Compound> List<SequencePair<S,C>>	Alignments.getAllPairsAlignments(List<S> sequences, Alignments.PairwiseSequenceAlignerType type, GapPenalty gapPenalty, SubstitutionMatrix<C> subMatrix) Factory method which computes a sequence alignment for all Sequence pairs in the given List.
static <S extends Sequence<C>,C extends Compound> List<PairwiseSequenceScorer<S,C>>	Alignments.getAllPairsScorers(List<S> sequences, Alignments.PairwiseSequenceScorerType type, GapPenalty gapPenalty, SubstitutionMatrix<C> subMatrix) Factory method which sets up a sequence pair scorer for all Sequence pairs in the given List.
static <S extends Sequence<C>,C extends Compound> double[]	Alignments.getAllPairsScores(List<S> sequences, Alignments.PairwiseSequenceScorerType type, GapPenalty gapPenalty, SubstitutionMatrix<C> subMatrix) Factory method which computes a sequence pair score for all Sequence pairs in the given List.
static <S extends Sequence<C>,C extends Compound> Profile<S,C>	Alignments.getMultipleSequenceAlignment(List<S> sequences, Object... settings) Factory method which computes a multiple sequence alignment for the given List of Sequences.
static <S extends Sequence<C>,C extends Compound> PairwiseSequenceAligner<S,C>	Alignments.getPairwiseAligner(S query, S target, Alignments.PairwiseSequenceAlignerType type, GapPenalty gapPenalty, SubstitutionMatrix<C> subMatrix) Factory method which constructs a pairwise sequence aligner.
static <S extends Sequence<C>,C extends Compound> SequencePair<S,C>	Alignments.getPairwiseAlignment(S query, S target, Alignments.PairwiseSequenceAlignerType type, GapPenalty gapPenalty, SubstitutionMatrix<C> subMatrix) Factory method which computes a sequence alignment for the given Sequence pair.
static <S extends Sequence<C>,C extends Compound> Profile<S,C>	Alignments.getProgressiveAlignment(GuideTree<S,C> tree, Alignments.ProfileProfileAlignerType type, GapPenalty gapPenalty, SubstitutionMatrix<C> subMatrix) Factory method to run the profile-profile alignments of a progressive multiple sequence alignment concurrently.
static <S extends Sequence<C>,C extends Compound> double[]	Alignments.runPairwiseScorers(List<PairwiseSequenceScorer<S,C>> scorers) Factory method to run a list of scorers concurrently.

Uses of Compound in org.biojava.nbio.alignment.routines

Classes in org.biojava.nbio.alignment.routines with type parameters of type Compound

Modifier and Type	Class and Description
class	AnchoredPairwiseSequenceAligner<S extends Sequence<C>,C extends Compound> This algorithm uses a divide-and-conquer approach to find optimal pairwise global sequence alignments (from the first until the last Compound of each Sequence) with the restriction that any alignment produced will connect the query sequence to the target sequence at the anchors.
class	GuanUberbacher<S extends Sequence<C>,C extends Compound> Guan and Uberbacher defined an algorithm for pairwise global sequence alignments (from the first until the last Compound of each Sequence).

Uses of Compound in org.biojava.nbio.alignment.template

Classes in org.biojava.nbio.alignment.template with type parameters of type Compound

Modifier and Type	Class and Description
class	AbstractMatrixAligner<S extends Sequence<C>,C extends Compound> Implements common code for an Aligner which builds a score matrix during computation.
class	AbstractPairwiseSequenceAligner<S extends Sequence<C>,C extends Compound> Implements common code for an Aligner for a pair of Sequences.
class	AbstractProfileProfileAligner<S extends Sequence<C>,C extends Compound> Implements common code for an Aligner for a pair of Profiles.
interface	Aligner<S extends Sequence<C>,C extends Compound> Defines an algorithm which computes an alignment Profile from a list of Sequences.
class	CallablePairwiseSequenceAligner<S extends Sequence<C>,C extends Compound> Implements a concurrency wrapper for a PairwiseSequenceAligner.
class	CallablePairwiseSequenceScorer<S extends Sequence<C>,C extends Compound> Implements a concurrency wrapper for a PairwiseSequenceScorer.
class	CallableProfileProfileAligner<S extends Sequence<C>,C extends Compound> Implements a concurrency wrapper for a ProfileProfileAligner.
interface	GuideTreeNode<S extends Sequence<C>,C extends Compound> Defines a data structure for the node in a guide tree used during progressive multiple sequence alignment.
interface	HierarchicalClusterer<S extends Sequence<C>,C extends Compound> Defines a clustering algorithm that converts a distance matrix into a tree.
interface	MatrixAligner<S extends Sequence<C>,C extends Compound> Defines an Aligner which builds a score matrix during computation.
interface	PairInProfileScorer<S extends Sequence<C>,C extends Compound> Defines an algorithm which computes a score for a sequence alignment pair picked from an alignment Profile.
interface	PairwiseSequenceAligner<S extends Sequence<C>,C extends Compound> Defines an Aligner for a pair of Sequences.
interface	PairwiseSequenceScorer<S extends Sequence<C>,C extends Compound> Defines an algorithm which computes a score for a pair of sequences.
interface	PartitionRefiner<S extends Sequence<C>,C extends Compound> Defines an algorithm which computes a new alignment Profile by splitting a current alignment and realigning.
interface	ProfileProfileAligner<S extends Sequence<C>,C extends Compound> Defines an Aligner for a pair of Profiles.
interface	ProfileProfileScorer<S extends Sequence<C>,C extends Compound> Defines an algorithm which computes a score for a pairing of alignment profiles.
interface	RescoreRefiner<S extends Sequence<C>,C extends Compound> Defines an algorithm which computes a new alignment Profile by rescoring all pairs in an alignment and realigning.

Uses of Compound in org.biojava.nbio.core.alignment

Classes in org.biojava.nbio.core.alignment with type parameters of type Compound

Modifier and Type	Class and Description
class	SimpleAlignedSequence<S extends Sequence<C>,C extends Compound> Implements a data structure for a Sequence within an alignment.
class	SimpleProfile<S extends Sequence<C>,C extends Compound> Implements a data structure for the results of sequence alignment.
class	SimpleProfilePair<S extends Sequence<C>,C extends Compound> Implements a data structure for the results of the alignment of a pair of Profiles.
class	SimpleSequencePair<S extends Sequence<C>,C extends Compound> Implements a data structure for the results of pairwise sequence alignment.

Methods in org.biojava.nbio.core.alignment with parameters of type Compound

Modifier and Type	Method and Description
int	SimpleAlignedSequence.countCompounds(C... compounds)

Uses of Compound in org.biojava.nbio.core.alignment.matrices

Classes in org.biojava.nbio.core.alignment.matrices with type parameters of type Compound

Modifier and Type	Class and Description
class	SimpleSubstitutionMatrix<C extends Compound> Implements a data structure which holds the score (penalty or bonus) given during alignment for the exchange of one Compound in a sequence for another.

Uses of Compound in org.biojava.nbio.core.alignment.template

Classes in org.biojava.nbio.core.alignment.template with type parameters of type Compound

Modifier and Type	Interface and Description
interface	AlignedSequence<S extends Sequence<C>,C extends Compound> Defines a data structure for a Sequence within an alignment.
interface	MutableAlignedSequence<S extends Sequence<C>,C extends Compound> Defines a mutable (editable) data structure for an AlignedSequence.
interface	MutableProfile<S extends Sequence<C>,C extends Compound> Defines a mutable (editable) data structure for a Profile.
interface	MutableProfilePair<S extends Sequence<C>,C extends Compound> Defines a mutable (editable) data structure for a ProfilePair.
interface	MutableSequencePair<S extends Sequence<C>,C extends Compound> Defines a mutable (editable) data structure for the results of pairwise sequence alignment.
interface	Profile<S extends Sequence<C>,C extends Compound> Defines a data structure for the results of sequence alignment.
interface	ProfilePair<S extends Sequence<C>,C extends Compound> Defines a data structure for the results of the alignment of a pair of Profiles.
interface	ProfileView<S extends Sequence<C>,C extends Compound> Defines a data structure for a view of sequence alignment.
interface	SequencePair<S extends Sequence<C>,C extends Compound> Defines a data structure for the results of pairwise sequence alignment.
interface	SubstitutionMatrix<C extends Compound> Defines a data structure which holds the score (penalty or bonus) given during alignment for the exchange of one Compound in a sequence for another.

Uses of Compound in org.biojava.nbio.core.search.io

Classes in org.biojava.nbio.core.search.io with type parameters of type Compound

Modifier and Type	Class and Description
class	Hsp<S extends Sequence<C>,C extends Compound> This class models a search Hsp.

Uses of Compound in org.biojava.nbio.core.sequence

Classes in org.biojava.nbio.core.sequence with type parameters of type Compound

Modifier and Type	Class and Description
class	BasicSequence<C extends Compound> Bare bones version of the Sequence object to be used sparingly.
class	MultipleSequenceAlignment<S extends Sequence<C>,C extends Compound> Implements a minimal data structure for reading and writing a sequence alignment.

Uses of Compound in org.biojava.nbio.core.sequence.compound

Classes in org.biojava.nbio.core.sequence.compound that implement Compound

Modifier and Type	Class and Description
class	AminoAcidCompound Used to describe an Amino Acid.
class	CodonCompound Define a codon
class	NucleotideCompound

Methods in org.biojava.nbio.core.sequence.compound with parameters of type Compound

Modifier and Type	Method and Description
boolean	CodonCompound.equalsIgnoreCase(Compound compound)
boolean	NucleotideCompound.equalsIgnoreCase(Compound compound)
boolean	AminoAcidCompound.equalsIgnoreCase(Compound compound)

Uses of Compound in org.biojava.nbio.core.sequence.edits

Classes in org.biojava.nbio.core.sequence.edits with type parameters of type Compound

Modifier and Type	Interface and Description
interface	Edit<C extends Compound> Interface for carrying out edit operations on a Sequence.
static class	Edit.AbstractEdit<C extends Compound> Abstract class which defines all edit operations as a call to discover what 5' and 3' ends of an editing Sequence should be joined together with a target Sequence.
static class	Edit.Delete<C extends Compound> Implementation which allows for the deletion of bases from a Sequence
static class	Edit.Insert<C extends Compound> Edit implementation which allows us to insert a base at any position in a Sequence.
static class	Edit.Substitute<C extends Compound> Allows for the substitution of bases into an existing Sequence.

Uses of Compound in org.biojava.nbio.core.sequence.features

Classes in org.biojava.nbio.core.sequence.features with type parameters of type Compound

Modifier and Type	Class and Description
class	AbstractFeature<S extends AbstractSequence<C>,C extends Compound> A feature is currently any descriptive item that can be associated with a sequence position(s) A feature has a type and a source which is currently a string to allow flexibility for the user Ideally well defined features should have a class to describe attributes of that feature
class	FeatureDbReferenceInfo<S extends AbstractSequence<C>,C extends Compound> It is DBReferenceInfo which implements FeatureInterface.
interface	FeatureInterface<S extends AbstractSequence<C>,C extends Compound> Interface class to handle describing arbitrary features.
class	QualityFeature<S extends AbstractSequence<C>,C extends Compound> DNA Sequences produced by modern sequencers usually have quality informaion attached to them.
class	QuantityFeature<S extends AbstractSequence<C>,C extends Compound> It is common to have a numerical value or values associated with a feature.
class	TextFeature<S extends AbstractSequence<C>,C extends Compound> A implmentation of AbstractFeature

Uses of Compound in org.biojava.nbio.core.sequence.io

Classes in org.biojava.nbio.core.sequence.io with type parameters of type Compound

Modifier and Type	Class and Description
class	FastaReader<S extends Sequence<?>,C extends Compound> Use FastaReaderHelper as an example of how to use this class where FastaReaderHelper should be the primary class used to read Fasta files
class	FastaWriter<S extends Sequence<?>,C extends Compound> The FastaWriter writes a collection of sequences to an outputStream.
class	GenbankReader<S extends AbstractSequence<C>,C extends Compound> Use GenbankReaderHelper as an example of how to use this class where GenbankReaderHelper should be the primary class used to read Genbank files
class	GenbankSequenceParser<S extends AbstractSequence<C>,C extends Compound>
class	GenbankWriter<S extends Sequence<?>,C extends Compound>
class	GenericFastaHeaderFormat<S extends AbstractSequence<?>,C extends Compound> We store the original header if the sequence is parsed from a fasta file and will use that exact sequence if we write out the sequences to a fasta file.
class	GenericFastaHeaderParser<S extends AbstractSequence<C>,C extends Compound> The default fasta header parser where some headers are well defined based on the source database which allows us to set the source of the protein sequence and the identifier that can be used in future implementations to load features from external sources If the user has a custom header with local data then they can create their own implementation of a FastaHeaderParserInterface GenBank gi|gi-number|gb|accession|locus ENA Data Library gi|gi-number|emb|accession|locus DDBJ, DNA Database of Japan gi|gi-number|dbj|accession|locus NBRF PIR pir||entry Protein Research Foundation prf||name SWISS-PROT sp|accession|name Brookhaven Protein Data Bank (1) pdb|entry|chain Brookhaven Protein Data Bank (2) entry:chain|PDBID|CHAIN|SEQUENCE PDB EBI PDB:1ECY_A mol:protein length:142 ECOTIN Patents pat|country|number GenInfo Backbone Id bbs|number General database identifier gnl|database|identifier NCBI Reference Sequence ref|accession|locus Local Sequence identifier lcl|identifier
class	GenericGenbankHeaderFormat<S extends AbstractSequence<C>,C extends Compound>
class	GenericGenbankHeaderParser<S extends AbstractSequence<C>,C extends Compound>
class	GenericInsdcHeaderFormat<S extends AbstractSequence<C>,C extends Compound>
class	PlainFastaHeaderParser<S extends AbstractSequence<C>,C extends Compound> The plain fasta header takes everything in the header as a single entity.

Uses of Compound in org.biojava.nbio.core.sequence.io.template

Classes in org.biojava.nbio.core.sequence.io.template with type parameters of type Compound

Modifier and Type	Interface and Description
interface	FastaHeaderFormatInterface<S extends Sequence<?>,C extends Compound>
interface	GenbankHeaderFormatInterface<S extends Sequence<?>,C extends Compound>
interface	SequenceCreatorInterface<C extends Compound>
interface	SequenceHeaderParserInterface<S extends Sequence<?>,C extends Compound>

Uses of Compound in org.biojava.nbio.core.sequence.io.util

Methods in org.biojava.nbio.core.sequence.io.util with type parameters of type Compound

Modifier and Type	Method and Description
static <S extends Sequence<C>,C extends Compound> int	IOUtils.getGCGChecksum(List<S> sequences) Calculates GCG checksum for entire list of sequences
static <S extends Sequence<C>,C extends Compound> int	IOUtils.getGCGChecksum(S sequence) Calculates GCG checksum for a given sequence
static <S extends Sequence<C>,C extends Compound> String	IOUtils.getGCGHeader(List<S> sequences) Assembles a GCG file header
static <C extends Compound> String	IOUtils.getGCGType(CompoundSet<C> cs) Determines GCG type
static <S extends Sequence<C>,C extends Compound> String	IOUtils.getIDFormat(List<S> sequences) Creates format String for accession IDs

Uses of Compound in org.biojava.nbio.core.sequence.loader

Classes in org.biojava.nbio.core.sequence.loader with type parameters of type Compound

Modifier and Type	Class and Description
class	ArrayListProxySequenceReader<C extends Compound>
class	GenbankProxySequenceReader<C extends Compound>
class	SequenceFileProxyLoader<C extends Compound> This class represents the storage container of a sequence stored in a fasta file where the initial parsing of the file we store the offset and length of the sequence.
class	StringProxySequenceReader<C extends Compound> An example of a ProxySequenceReader that is created from a String.
class	UniprotProxySequenceReader<C extends Compound> Pass in a Uniprot ID and this ProxySequenceReader when passed to a ProteinSequence will get the sequence data and other data elements associated with the ProteinSequence by Uniprot.

Methods in org.biojava.nbio.core.sequence.loader with type parameters of type Compound

Modifier and Type	Method and Description
static <C extends Compound> UniprotProxySequenceReader<C>	UniprotProxySequenceReader.parseUniprotXMLString(String xml, CompoundSet<C> compoundSet) The passed in xml is parsed as a DOM object so we know everything about the protein.

Methods in org.biojava.nbio.core.sequence.loader with parameters of type Compound

Modifier and Type	Method and Description
int	UniprotProxySequenceReader.countCompounds(C... compounds)
int	StringProxySequenceReader.countCompounds(C... compounds)
int	SequenceFileProxyLoader.countCompounds(C... compounds)

Uses of Compound in org.biojava.nbio.core.sequence.location

Classes in org.biojava.nbio.core.sequence.location with type parameters of type Compound

Modifier and Type	Class and Description
class	InsdcParser<S extends AbstractSequence<C>,C extends Compound> Parser for working with INSDC style locations.
class	SequenceLocation<S extends AbstractSequence<C>,C extends Compound> A location in a sequence that keeps a reference to its parent sequence

Uses of Compound in org.biojava.nbio.core.sequence.location.template

Methods in org.biojava.nbio.core.sequence.location.template with type parameters of type Compound

Modifier and Type	Method and Description
protected <C extends Compound> boolean	AbstractLocation.canComplement(Sequence<C> sequence) Uses the Sequence's CompoundSet to decide if a compound can be assgined to ComplementCompound meaning it can complement
<C extends Compound> Sequence<C>	AbstractLocation.getRelevantSubSequence(Sequence<C> sequence)
<C extends Compound> Sequence<C>	Location.getRelevantSubSequence(Sequence<C> sequence) Will return a SequenceReader object which offers a view of all resolved locations i.e. those locations which are not complex and define the true Sequence represented
<C extends Compound> Sequence<C>	AbstractLocation.getSubSequence(Sequence<C> sequence) If circular this will return the sequence represented by the sub locations joined.
<C extends Compound> Sequence<C>	Location.getSubSequence(Sequence<C> sequence) Will return a SequenceReader object which represents the outer bounds of this Location
protected <C extends Compound> Sequence<C>	AbstractLocation.reverseSequence(Sequence<C> sequence) Reverses and (if possible) complements the Sequence so as to represent the reverse strand (if one exists).

Methods in org.biojava.nbio.core.sequence.location.template that return types with arguments of type Compound

Modifier and Type	Method and Description
ProxySequenceReader<? extends Compound>	AccesionedLocation.getProxySequenceReader() Return the proxy reader used to get sequence for this location.

Uses of Compound in org.biojava.nbio.core.sequence.storage

Classes in org.biojava.nbio.core.sequence.storage with type parameters of type Compound

Modifier and Type	Class and Description
class	ArrayListSequenceReader<C extends Compound> Stores a Sequence as a collection of compounds in an ArrayList
class	BitSequenceReader<C extends Compound> An implementation of the popular bit encodings.
static class	BitSequenceReader.BitArrayWorker<C extends Compound> The logic of working with a bit has been separated out into this class to help developers create the bit data structures without having to put the code into an intermediate format and to also use the format without the need to copy this code.
class	FourBitSequenceReader<C extends Compound> Four bit encoding of the bit formats.
static class	FourBitSequenceReader.FourBitArrayWorker<C extends Compound> A four bit per compound implementation of the bit array worker code.
class	JoiningSequenceReader<C extends Compound> This reader actually proxies onto multiple types of sequence in order to allow a number of sequence objects to act as if they are one sequence.
class	SequenceAsStringHelper<C extends Compound> This is a common method that can be used across multiple storage/proxy implementations to handle Negative strand and other interesting elements of sequence data.
class	SingleCompoundSequenceReader<C extends Compound> An implementation of the SequenceReader interface which for every call will return only 1 compound (given to it during construction; a String is also valid but will require a CompoundSet).

Methods in org.biojava.nbio.core.sequence.storage with parameters of type Compound

Modifier and Type	Method and Description
int	SingleCompoundSequenceReader.countCompounds(C... compounds) Delegates to SequenceMixin#countCompounds(org.biojava.nbio.core.sequence.template.Sequence, C[])
int	JoiningSequenceReader.countCompounds(C... compounds)
int	ArrayListSequenceReader.countCompounds(C... compounds)
int	BitSequenceReader.countCompounds(C... compounds) Counts the number of times a compound appears in this sequence store

Uses of Compound in org.biojava.nbio.core.sequence.template

Classes in org.biojava.nbio.core.sequence.template with type parameters of type Compound

Modifier and Type	Class and Description
class	AbstractCompoundSet<C extends Compound>
class	AbstractCompoundTranslator<F extends Compound,T extends Compound>
class	AbstractCompoundTranslator<F extends Compound,T extends Compound>
class	AbstractSequence<C extends Compound> The base class for DNA, RNA and Protein sequences.
interface	CompoundSet<C extends Compound>
interface	CompoundTranslator<F extends Compound,T extends Compound>
interface	CompoundTranslator<F extends Compound,T extends Compound>
interface	LightweightProfile<S extends Sequence<C>,C extends Compound> Defines a minimal data structure for reading and writing a sequence alignment.
interface	ProxySequenceReader<C extends Compound>
interface	Sequence<C extends Compound> Main interface for defining a collection of Compounds and accessing them using biological indexes
static class	SequenceMixin.SequenceIterator<C extends Compound> A basic sequence iterator which iterates over the given Sequence by biological index.
class	SequenceProxyView<C extends Compound>
interface	SequenceReader<C extends Compound>
interface	SequenceView<C extends Compound>

Subinterfaces of Compound in org.biojava.nbio.core.sequence.template

Modifier and Type	Interface and Description
interface	ComplementCompound

Classes in org.biojava.nbio.core.sequence.template that implement Compound

Modifier and Type	Class and Description
class	AbstractCompound The details of a Compound

Methods in org.biojava.nbio.core.sequence.template with type parameters of type Compound

Modifier and Type	Method and Description
static <C extends Compound> String	SequenceMixin.checksum(Sequence<C> sequence) Performs a simple CRC64 checksum on any given sequence.
static <C extends Compound> int	SequenceMixin.countCompounds(Sequence<C> sequence, C... compounds) For the given vargs of compounds this method counts the number of times those compounds appear in the given sequence
static <C extends Compound> Iterator<C>	SequenceMixin.createIterator(Sequence<C> sequence) Creates a simple sequence iterator which moves through a sequence going from 1 to the length of the Sequence.
static <C extends Compound> SequenceView<C>	SequenceMixin.createSubSequence(Sequence<C> sequence, int start, int end) Creates a simple sub sequence view delimited by the given start and end.
static <C extends Compound> Map<C,Integer>	SequenceMixin.getComposition(Sequence<C> sequence) Does a linear scan over the given Sequence and records the number of times each base appears.
static <C extends Compound> Map<C,Double>	SequenceMixin.getDistribution(Sequence<C> sequence) Analogous to SequenceMixin.getComposition(Sequence) but returns the distribution of that Compound over the given sequence.
static <C extends Compound> int	SequenceMixin.indexOf(Sequence<C> sequence, C compound) Performs a linear search of the given Sequence for the given compound.
static <C extends Compound> SequenceView<C>	SequenceMixin.inverse(Sequence<C> sequence) A method which attempts to do the right thing when is comes to a reverse/reverse complement
static <C extends Compound> int	SequenceMixin.lastIndexOf(Sequence<C> sequence, C compound) Performs a reversed linear search of the given Sequence by wrapping it in a ReversedSequenceView and passing it into SequenceMixin.indexOf(Sequence, Compound).
static <C extends Compound> List<SequenceView<C>>	SequenceMixin.nonOverlappingKmers(Sequence<C> sequence, int kmer) Produces kmers of the specified size e.g.
static <C extends Compound> List<SequenceView<C>>	SequenceMixin.overlappingKmers(Sequence<C> sequence, int kmer) Used to generate overlapping k-mers such i.e.
static <C extends Compound> boolean	SequenceMixin.sequenceEquality(Sequence<C> source, Sequence<C> target) A case-sensitive manner of comparing two sequence objects together.
static <C extends Compound> boolean	SequenceMixin.sequenceEqualityIgnoreCase(Sequence<C> source, Sequence<C> target) A case-insensitive manner of comparing two sequence objects together.
static <C extends Compound> Sequence<C>	SequenceMixin.shuffle(Sequence<C> sequence) Implements sequence shuffling by first materializing the given Sequence into a List, applying Collections.shuffle(List) and then returning the shuffled elements in a new instance of SequenceBackingStore which behaves as a Sequence.
static <C extends Compound> List<C>	SequenceMixin.toList(Sequence<C> sequence) For the given Sequence this will return a List filled with the Compounds of that Sequence.
static <C extends Compound> String	SequenceMixin.toString(Sequence<C> sequence) Shortcut to SequenceMixin.toStringBuilder(org.biojava.nbio.core.sequence.template.Sequence) which calls toString() on the resulting object.
static <C extends Compound> StringBuilder	SequenceMixin.toStringBuilder(Sequence<C> sequence) For the given Sequence this will return a StringBuilder object filled with the results of Compound#toString().
static <C extends Compound> void	SequenceMixin.write(Appendable appendable, Sequence<C> sequence) Used as a way of sending a Sequence to a writer without the cost of converting to a full length String and then writing the data out

Methods in org.biojava.nbio.core.sequence.template with parameters of type Compound

Modifier and Type	Method and Description
protected void	AbstractCompoundSet.addCompound(C compound, C lowerCasedCompound, C... equivalents)
protected void	AbstractCompoundTranslator.addCompounds(F source, T... targets)
int	Sequence.countCompounds(C... compounds) Returns the number of times we found a compound in the Sequence
int	AbstractSequence.countCompounds(C... compounds)
int	SequenceProxyView.countCompounds(C... compounds)
static <C extends Compound> int	SequenceMixin.countCompounds(Sequence<C> sequence, C... compounds) For the given vargs of compounds this method counts the number of times those compounds appear in the given sequence
boolean	AbstractCompound.equalsIgnoreCase(Compound compound)
boolean	Compound.equalsIgnoreCase(Compound compound)

Uses of Compound in org.biojava.nbio.core.sequence.transcription

Classes in org.biojava.nbio.core.sequence.transcription that implement Compound

Modifier and Type	Class and Description
class	CaseInsensitiveCompound Attempts to wrap compounds so it is possible to view them in a case insensitive manner
static class	Table.Codon Instance of a Codon which is 3 NucleotideCompounds, its corresponding AminoAcidCompound and if it is a start or stop codon.

Methods in org.biojava.nbio.core.sequence.transcription with parameters of type Compound

Modifier and Type	Method and Description
boolean	Table.Codon.equalsIgnoreCase(Compound compound)
boolean	CaseInsensitiveCompound.equalsIgnoreCase(Compound compound)

Uses of Compound in org.biojava.nbio.core.sequence.views

Classes in org.biojava.nbio.core.sequence.views with type parameters of type Compound

Modifier and Type	Class and Description
class	ReversedSequenceView<C extends Compound> For a given sequence this class will return the base at the reversed position i.e. in a sequence of size 10, if you request base 2 you will get back the base at position 9.
class	WindowedSequence<C extends Compound> A sliding window view of a sequence which does not implement any interfaces like Sequence because they do not fit how this works.

Uses of Compound in org.biojava.nbio.phylo

Methods in org.biojava.nbio.phylo with type parameters of type Compound

Modifier and Type	Method and Description
static <C extends Sequence<D>,D extends Compound> org.forester.msa.Msa	ForesterWrapper.convert(MultipleSequenceAlignment<C,D> msa) Convert a BioJava MultipleSequenceAlignment to a forester Msa.
static <C extends Sequence<D>,D extends Compound> org.forester.evoinference.matrix.distance.DistanceMatrix	DistanceMatrixCalculator.dissimilarityScore(MultipleSequenceAlignment<C,D> msa, SubstitutionMatrix<D> M) The dissimilarity score is the additive inverse of the similarity score (sum of scores) between two aligned sequences using a substitution model (Substitution Matrix).
static <C extends Sequence<D>,D extends Compound> org.forester.evoinference.matrix.distance.DistanceMatrix	DistanceMatrixCalculator.fractionalDissimilarity(MultipleSequenceAlignment<C,D> msa) The fractional dissimilarity (D) is defined as the percentage of sites that differ between two aligned sequences.
static <C extends Sequence<D>,D extends Compound> org.forester.evoinference.matrix.distance.DistanceMatrix	DistanceMatrixCalculator.fractionalDissimilarityScore(MultipleSequenceAlignment<C,D> msa, SubstitutionMatrix<D> M) The fractional dissimilarity score (Ds) is a relative measure of the dissimilarity between two aligned sequences.
static <C extends Sequence<D>,D extends Compound> org.forester.evoinference.matrix.distance.DistanceMatrix	DistanceMatrixCalculator.kimuraDistance(MultipleSequenceAlignment<C,D> msa) The Kimura evolutionary distance (d) is a correction of the fractional dissimilarity (D) specially needed for large evolutionary distances.
static <C extends Sequence<D>,D extends Compound> org.forester.evoinference.matrix.distance.DistanceMatrix	DistanceMatrixCalculator.pamMLdistance(MultipleSequenceAlignment<C,D> msa) The PAM (Point Accepted Mutations) distance is a measure of evolutionary distance in protein sequences.
static <C extends Sequence<D>,D extends Compound> org.forester.evoinference.matrix.distance.DistanceMatrix	DistanceMatrixCalculator.percentageIdentity(MultipleSequenceAlignment<C,D> msa) BioJava implementation for percentage of identity (PID).
static <C extends Sequence<D>,D extends Compound> org.forester.evoinference.matrix.distance.DistanceMatrix	DistanceMatrixCalculator.poissonDistance(MultipleSequenceAlignment<C,D> msa) The Poisson (correction) evolutionary distance (d) is a function of the fractional dissimilarity (D), given by: d = -log(1 - D) The gapped positons in the alignment are ignored in the calculation.
static <C extends Sequence<D>,D extends Compound> org.forester.evoinference.matrix.distance.DistanceMatrix	DistanceMatrixCalculator.structuralDistance(double[][] rmsdMat, double alpha, double rmsdMax, double rmsd0) The structural distance (dS) uses the structural similarity (or dissimilarity) from a the structural alignment of two protein strutures.

Uses of Compound in org.biojava.nbio.ws.alignment

Method parameters in org.biojava.nbio.ws.alignment with type arguments of type Compound

Modifier and Type	Method and Description
String	RemotePairwiseAlignmentService.sendAlignmentRequest(Sequence<Compound> seq, RemotePairwiseAlignmentProperties rpa) Doing the actual analysis on the instantiated service using specified parameters and the RichSequence object

Uses of Compound in org.biojava.nbio.ws.alignment.qblast

Method parameters in org.biojava.nbio.ws.alignment.qblast with type arguments of type Compound

Modifier and Type	Method and Description
String	NCBIQBlastService.sendAlignmentRequest(Sequence<Compound> seq, RemotePairwiseAlignmentProperties rpa) Converts given sequence to String and calls NCBIQBlastService.sendAlignmentRequest(String, RemotePairwiseAlignmentProperties)