T
- the type of each positionpublic abstract class Sequence<T> extends Object implements Comparable<Sequence<T>>
Modifier and Type | Class and Description |
---|---|
protected static class |
Sequence.CompositeSequence<T>
The class handles composite
Sequence s. |
static class |
Sequence.RecursiveSequence<T>
This is the main class for subsequences, composite sequences, ...
|
static class |
Sequence.SubSequence<T>
This class handles subsequences.
|
Modifier and Type | Field and Description |
---|---|
protected AlphabetContainer |
alphabetCon
The underlying alphabets.
|
protected SequenceAnnotation[] |
annotation
The annotation of the
Sequence . |
protected Sequence<T> |
rc
The pointer to the reverse complement of the
Sequence . |
Modifier | Constructor and Description |
---|---|
protected |
Sequence(AlphabetContainer container,
SequenceAnnotation[] annotation)
Creates a new
Sequence with the given AlphabetContainer
and the given annotation, but without the content. |
Modifier and Type | Method and Description |
---|---|
protected abstract void |
addToRepresentation(Object representation,
int pos,
String delim)
This method adds the information of one position to the representation using the specified delimiter
|
Sequence |
annotate(boolean add,
SequenceAnnotation... annotation)
This method allows to append annotation to a
Sequence . |
int |
compareTo(Sequence<T> s) |
protected abstract int |
compareTo(T t1,
T t2)
This method compares to container and is used in
compareTo(Sequence) . |
Sequence |
complement()
|
Sequence |
complement(int start,
int end)
|
abstract double |
continuousVal(int pos)
Returns the continuous value at position
pos of the
Sequence . |
static Sequence |
create(AlphabetContainer con,
SequenceAnnotation[] annotation,
String sequence,
String delim)
Creates a
Sequence from a String based on the given
AlphabetContainer using the given delimiter delim
and some annotation for the Sequence . |
static Sequence |
create(AlphabetContainer con,
String sequence)
Creates a
Sequence from a String based on the given
AlphabetContainer using the standard delimiter for this
AlphabetContainer . |
static Sequence |
create(AlphabetContainer con,
String sequence,
String delim)
Creates a
Sequence from a String based on the given
AlphabetContainer using the given delimiter delim . |
abstract int |
discreteVal(int pos)
Returns the discrete value at position
pos of the
Sequence . |
boolean |
equals(Object o) |
abstract void |
fillContainer(T container,
int pos)
The method fills the content of a specific position in to the container.
|
protected abstract Sequence |
flatCloneWithoutAnnotation()
Works in analogy to
Object.clone() , but does not clone the
annotation. |
AlphabetContainer |
getAlphabetContainer()
Return the alphabets, i.e.
|
SequenceAnnotation[] |
getAnnotation()
Returns the annotation of the
Sequence . |
Sequence<T> |
getCompositeSequence(AlphabetContainer abc,
int[] starts,
int[] lengths)
This method should be used if one wants to create a
DataSet of
Sequence.CompositeSequence s. |
Sequence |
getCompositeSequence(int[] starts,
int[] lengths)
This is a very efficient way to create a
Sequence.CompositeSequence for
sequences with a simple AlphabetContainer . |
abstract T |
getEmptyContainer()
The method returns a container that can be used for accessing the symbols for each position.
|
protected abstract Object |
getEmptyRepresentation()
Returns an empty representation which is used to create the
String representation of this instance in the method toString(String, int, int) . |
int |
getHammingDistance(Sequence seq)
This method returns the Hamming distance between the current
Sequence and seq . |
abstract int |
getLength()
Returns the length of the
Sequence . |
int |
getNumberOfSequenceAnnotationsByType(String type)
|
SequenceAnnotation |
getSequenceAnnotationByType(String type,
int idx)
Returns the
SequenceAnnotation no. |
SequenceAnnotation |
getSequenceAnnotationByTypeAndIdentifier(String type,
String identifier)
|
protected abstract String |
getStringRepresentation(Object representation)
This method creates a String representation from the given representation.
|
Sequence |
getSubSequence(AlphabetContainer abc,
int start)
This method should be used if one wants to create a
DataSet of
subsequences of defined length. |
Sequence |
getSubSequence(AlphabetContainer abc,
int start,
int length)
This method should be used if one wants to create a
DataSet of
subsequences of defined length. |
Sequence |
getSubSequence(int start)
This is a very efficient way to create a subsequence/suffix for
Sequence s with a simple AlphabetContainer . |
Sequence |
getSubSequence(int start,
int length)
This is a very efficient way to create a subsequence of defined length
for
Sequence s with a simple AlphabetContainer . |
int |
hashCode() |
protected abstract int |
hashCodeForPos(int pos)
This method is used in
hashCode() and the hash code for one specific position. |
abstract boolean |
isMultiDimensional()
The method returns
true if the sequence is multidimensional, otherwise false . |
boolean |
matches(int maxHammingDistance,
Sequence shortSequence)
This method allows to answer the question whether there is a
similar pattern find a match with a given maximal number of mismatches.
|
Sequence |
reverse()
|
Sequence |
reverse(int start,
int end)
|
Sequence |
reverseComplement()
|
Sequence |
reverseComplement(int start,
int end)
|
protected int |
toDiscrete(int pos,
double content)
This method converts a continuous value at position
pos of
the Sequence into a discrete one. |
String |
toString()
|
String |
toString(int start)
|
String |
toString(int start,
int end)
|
String |
toString(String delim,
int start,
int end)
|
protected AlphabetContainer alphabetCon
protected SequenceAnnotation[] annotation
Sequence
.protected Sequence(AlphabetContainer container, SequenceAnnotation[] annotation)
Sequence
with the given AlphabetContainer
and the given annotation, but without the content. The content has to be
set by the constructor of the extending class.container
- the AlphabetContainer
of the Sequence
annotation
- the annotation of the Sequence
public abstract double continuousVal(int pos)
pos
of the
Sequence
.public abstract int discreteVal(int pos)
pos
of the
Sequence
.public final AlphabetContainer getAlphabetContainer()
AlphabetContainer
, used in this
Sequence
.AlphabetContainer
, used in this
Sequence
public final SequenceAnnotation[] getAnnotation()
Sequence
.Sequence
(can be null
)public SequenceAnnotation getSequenceAnnotationByTypeAndIdentifier(String type, String identifier)
type
- the chosen type of the SequenceAnnotation
identifier
- the chosen identifier of the SequenceAnnotation
SequenceAnnotation
that meets the criteriapublic SequenceAnnotation getSequenceAnnotationByType(String type, int idx)
type
- the chosen type of a subset of SequenceAnnotation
sidx
- the index of the returned SequenceAnnotation
within this subset.SequenceAnnotation
no. idx
with type type
public int getNumberOfSequenceAnnotationsByType(String type)
type
- the typepublic Sequence<T> getCompositeSequence(AlphabetContainer abc, int[] starts, int[] lengths)
DataSet
of
Sequence.CompositeSequence
s. With this constructor you are enabled to
create a DataSet
where every Sequence
has the same
AlphabetContainer
instance.
AlphabetContainer
matches with
the one of the Sequence.CompositeSequence
.abc
- the new AlphabetContainer
starts
- the start positions of the junkslengths
- the length of each junkSequence.CompositeSequence
Sequence.CompositeSequence.Sequence.CompositeSequence(de.jstacs.data.AlphabetContainer,
de.jstacs.data.sequences.Sequence, int[], int[])
public Sequence getCompositeSequence(int[] starts, int[] lengths)
Sequence.CompositeSequence
for
sequences with a simple AlphabetContainer
.starts
- the start positions of the junkslengths
- the length of each junkSequence.CompositeSequence
Sequence.CompositeSequence.Sequence.CompositeSequence(de.jstacs.data.sequences.Sequence, int[], int[])
public final Sequence getSubSequence(AlphabetContainer abc, int start)
DataSet
of
subsequences of defined length. With this constructor you are enabled to
create a DataSet
where every Sequence
has the same
AlphabetContainer
instance.
AlphabetContainer
matches with
the one of the subsequence.abc
- the new AlphabetContainer
start
- the index of the start positiongetSubSequence(de.jstacs.data.AlphabetContainer, int, int)
public Sequence getSubSequence(AlphabetContainer abc, int start, int length)
DataSet
of
subsequences of defined length. With this constructor you are enabled to
create a DataSet
where every Sequence
has the same
AlphabetContainer
instance.
AlphabetContainer
matches with
the one of the subsequence.abc
- the new AlphabetContainer
start
- the index of the start positionlength
- the length of the new Sequence
SubSequence#SubSequence(de.jstacs.data.AlphabetContainer, de.jstacs.data.Sequence, int, int)
public final Sequence getSubSequence(int start)
Sequence
s with a simple AlphabetContainer
.start
- the index of the start positiongetSubSequence(int, int)
public Sequence getSubSequence(int start, int length)
Sequence
s with a simple AlphabetContainer
.start
- the index of the start positionlength
- the length of the new Sequence
SubSequence#SubSequence(Sequence, int, int)
public Sequence annotate(boolean add, SequenceAnnotation... annotation)
Sequence
.add
- indicates whether to add the new annotation to the existing or
notannotation
- the new annotationSequence
flatCloneWithoutAnnotation()
protected abstract Sequence flatCloneWithoutAnnotation()
Object.clone()
, but does not clone the
annotation. This method is used in
annotate(boolean, SequenceAnnotation...)
.Sequence
without annotationpublic abstract int getLength()
Sequence
.Sequence
public String toString()
toString
in class Object
Sequence
as String
toString(String, int, int)
public String toString(int start)
String
representation of the Sequence
(normally
the Sequence
in its original Alphabet
) beginning at
position start
with a default delimiter as separator.start
- the start index (inclusive)Sequence
as String
toString(String, int, int)
public String toString(int start, int end)
String
representation of the Sequence
(normally
the Sequence
in its original Alphabet
) between
start
and end
with a default delimiter as
separator.start
- the start index (inclusive)end
- the end index (exclusive)Sequence
as String
toString(String, int, int)
public int compareTo(Sequence<T> s)
compareTo
in interface Comparable<Sequence<T>>
protected abstract int compareTo(T t1, T t2)
compareTo(Sequence)
.t1
- the first containert2
- the second containergetEmptyContainer()
,
fillContainer(Object, int)
,
Comparable.compareTo(java.lang.Object)
protected int toDiscrete(int pos, double content)
pos
of
the Sequence
into a discrete one.pos
- the position of the Sequence
content
- the value at this positionAlphabetContainer.toDiscrete(int, double)
public String toString(String delim, int start, int end)
String
representation of the Sequence
(normally
the Sequence
in its original alphabet) between start
and end
with delim
as separator.delim
- the delimiter/separatorstart
- the start index (inclusive)end
- the end index (exclusive)Sequence
as String
getEmptyRepresentation()
,
addToRepresentation(Object, int, String)
,
getStringRepresentation(Object)
protected abstract Object getEmptyRepresentation()
String
representation of this instance in the method toString(String, int, int)
.String
representationtoString(String, int, int)
protected abstract void addToRepresentation(Object representation, int pos, String delim)
representation
- the representationpos
- the positiondelim
- the delimiter separating the information for different positionsgetEmptyRepresentation()
,
toString(String, int, int)
protected abstract String getStringRepresentation(Object representation)
representation
- the representation instance (which should be created by getEmptyContainer()
and filled by addToRepresentation(Object, int, String)
)getEmptyRepresentation()
,
addToRepresentation(Object, int, String)
,
toString(String, int, int)
public static Sequence create(AlphabetContainer con, String sequence) throws WrongAlphabetException, IllegalArgumentException
Sequence
from a String
based on the given
AlphabetContainer
using the standard delimiter for this
AlphabetContainer
.con
- the AlphabetContainer
sequence
- the String
containing the Sequence
Sequence
instanceWrongAlphabetException
- if sequence
is not defined over con
IllegalArgumentException
- if the delimiter is empty and the AlphabetContainer
is not discretecreate(AlphabetContainer, String, String)
public static Sequence create(AlphabetContainer con, String sequence, String delim) throws WrongAlphabetException, IllegalArgumentException
Sequence
from a String
based on the given
AlphabetContainer
using the given delimiter delim
.con
- the AlphabetContainer
sequence
- the String
containing the Sequence
delim
- the given delimiterSequence
instanceWrongAlphabetException
- if sequence
is not defined over con
IllegalArgumentException
- if the delimiter is empty and the AlphabetContainer
is not discretecreate(AlphabetContainer, SequenceAnnotation[], String,
String)
public static Sequence create(AlphabetContainer con, SequenceAnnotation[] annotation, String sequence, String delim) throws WrongAlphabetException, IllegalArgumentException
Sequence
from a String
based on the given
AlphabetContainer
using the given delimiter delim
and some annotation
for the Sequence
.con
- the AlphabetContainer
annotation
- the annotation for the Sequence
sequence
- the String
containing the Sequence
delim
- the given delimiterSequence
instanceWrongAlphabetException
- if sequence
is not defined over con
IllegalArgumentException
- if the delimiter is empty and the AlphabetContainer
is not discretepublic final Sequence reverse() throws OperationNotSupportedException
Sequence
containing the
reverse current Sequence
.
Sequence
OperationNotSupportedException
- if the current Sequence
is based on an
AlphabetContainer
that is not simplereverse(int, int)
public Sequence reverse(int start, int end) throws OperationNotSupportedException
start
- the start position (inclusive) in the original
Sequence
end
- the end position (exclusive) in the original Sequence
Sequence
of the partOperationNotSupportedException
- if the current Sequence
is based on an
AlphabetContainer
that is not simplepublic Sequence complement() throws OperationNotSupportedException
Sequence
containing the
complementary current Sequence
.
AlphabetContainer
on
DNAAlphabet
returns "ATTAT".Sequence
OperationNotSupportedException
- if the current Sequence
is not based on a
ComplementableDiscreteAlphabet
ComplementableDiscreteAlphabet
,
complement(int, int)
public Sequence reverseComplement() throws OperationNotSupportedException
Sequence
containing the
reverse complementary current Sequence
. For more details see the
methods reverse()
and complement()
.Sequence
OperationNotSupportedException
- if the current Sequence
is not discrete and simple
(not based on a ComplementableDiscreteAlphabet
)reverse()
,
complement()
,
reverseComplement(int, int)
,
ComplementableDiscreteAlphabet
public Sequence complement(int start, int end) throws OperationNotSupportedException
Sequence
containing a part
of the complementary current Sequence
.
AlphabetContainer
on
DNAAlphabet
returns "ATTAT".start
- the start position (inclusive) in the original
Sequence
end
- the end position (exclusive) in the original Sequence
Sequence
of the partOperationNotSupportedException
- if the current Sequence
is not based on a
ComplementableDiscreteAlphabet
ComplementableDiscreteAlphabet
public Sequence reverseComplement(int start, int end) throws OperationNotSupportedException
Sequence
containing a
reverse part of the complementary current Sequence
. For more
details see the methods reverse()
and complement()
.start
- the start position (inclusive) in the original
Sequence
end
- the end position (exclusive) in the original Sequence
Sequence
of the partOperationNotSupportedException
- if the current Sequence
is not discrete and simple
((not based on a ComplementableDiscreteAlphabet
)reverse()
,
complement()
,
ComplementableDiscreteAlphabet
protected abstract int hashCodeForPos(int pos)
hashCode()
and the hash code for one specific position.pos
- the positionpublic int getHammingDistance(Sequence seq) throws WrongAlphabetException
Sequence
and seq
.
If the sequence have different length -1 is returned.seq
- the sequence to be comparedWrongAlphabetException
- it the sequences have different AlphabetContainer
public boolean matches(int maxHammingDistance, Sequence shortSequence) throws WrongAlphabetException
maxHammingDistance
- the maximal Hamming distanceshortSequence
- the short sequencetrue
if a match with maximal Hamming distance smaller than maxHammingDistance
exists, otherwise false
WrongAlphabetException
- if the sequence have different AlphabetContainer
public abstract boolean isMultiDimensional()
true
if the sequence is multidimensional, otherwise false
.true
if the sequence is multidimensional, otherwise false
public abstract T getEmptyContainer()
fillContainer(Object, int)
,
isMultiDimensional()
public abstract void fillContainer(T container, int pos)
container
- the container which is used for filling the content.pos
- the positiongetEmptyContainer()
,
isMultiDimensional()