Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## de.jstacs.data.sequences
Class ArbitraryFloatSequence

    java.lang.Object
      de.jstacs.data.sequences.Sequence<float[]>
          de.jstacs.data.sequences.ArbitraryFloatSequence

All Implemented Interfaces:
  Comparable<Sequence<float[]>>

    public class ArbitraryFloatSequence

extends Sequence<float[]>

This class is for any continuous or hybrid sequence. In contrast to `ArbitrarySequence`s, the numeric values are represented by `float`s instead of `double`s. This may be useful if either the represented data are known to be only of `float` precision or if `double` precision is dispensible for the sake of memory consumption.

Author:
  Jens Keilwagen, Jan Grau

Nested Class Summary

Nested classes/interfaces inherited from class de.jstacs.data.sequences.Sequence
`Sequence.CompositeSequence<T>, Sequence.RecursiveSequence<T>, Sequence.SubSequence<T>`

Field Summary

Fields inherited from class de.jstacs.data.sequences.Sequence
`alphabetCon, annotation, rc`

Constructor Summary
`ArbitraryFloatSequence(AlphabetContainer alphabetContainer, float[] content)` Creates a new `ArbitraryFloatSequence` from an array of `float`-encoded alphabet symbols.
`ArbitraryFloatSequence(AlphabetContainer alphabetContainer, SequenceAnnotation[] annotation, String sequence, String delim)` Creates a new `ArbitraryFloatSequence` from a `String` representation using the delimiter `delim`.
`ArbitraryFloatSequence(AlphabetContainer alphabetContainer, SequenceAnnotation[] annotation, SymbolExtractor extractor)` Creates a new `ArbitraryFloatSequence` from a `SymbolExtractor`.
`ArbitraryFloatSequence(AlphabetContainer alphabetContainer, String sequence)` Creates a new `ArbitraryFloatSequence` from a `String` representation using the default delimiter.

Method Summary
`protected void` | `addToRepresentation(Object representation, int pos, String delim)` This method adds the information of one position to the representation using the specified delimiter
`int` | `compareTo(float[] t1, float[] t2)` This method compares to container and is used in `Sequence.compareTo(Sequence)`.
`double` | `continuousVal(int pos)` Returns the continuous value at position `pos` of the `Sequence`.
`int` | `discreteVal(int pos)` Returns the discrete value at position `pos` of the `Sequence`.
`void` | `fillContainer(float[] container, int pos)` The method fills the content of a specific position in to the container.
`protected ArbitraryFloatSequence` | `flatCloneWithoutAnnotation()` Works in analogy to `Object.clone()`, but does not clone the annotation.
`static DataSet` | `getDataSet(AlphabetContainer con, AbstractStringExtractor... se)` This method allows to create a `DataSet` containing `ArbitraryFloatSequence`s.
`static DataSet` | `getDataSet(AlphabetContainer con, String filename)` This method allows to create a `DataSet` containing `ArbitraryFloatSequence`s using a file name.
`static DataSet` | `getDataSet(AlphabetContainer con, String filename, SequenceAnnotationParser parser)` This method allows to create a `DataSet` containing `ArbitraryFloatSequence`s using a file name.
`float[]` | `getEmptyContainer()` The method returns a container that can be used for accessing the symbols for each position.
`protected Object` | `getEmptyRepresentation()` Returns an empty representation which is used to create the `String` representation of this instance in the method `Sequence.toString(String, int, int)`.
`int` | `getLength()` Returns the length of the `Sequence`.
`protected String` | `getStringRepresentation(Object representation)` This method creates a String representation from the given representation.
`protected int` | `hashCodeForPos(int pos)` This method is used in `Sequence.hashCode()` and the hash code for one specific position.
`boolean` | `isMultiDimensional()` The method returns `true` if the sequence is multidimensional, otherwise .

Methods inherited from class de.jstacs.data.sequences.Sequence
`annotate, compareTo, complement, complement, create, create, create, equals, getAlphabetContainer, getAnnotation, getCompositeSequence, getCompositeSequence, getHammingDistance, getNumberOfSequenceAnnotationsByType, getSequenceAnnotationByType, getSequenceAnnotationByTypeAndIdentifier, getSubSequence, getSubSequence, getSubSequence, getSubSequence, hashCode, matches, reverse, reverse, reverseComplement, reverseComplement, toDiscrete, toString, toString, toString, toString`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Constructor Detail

### ArbitraryFloatSequence

    public ArbitraryFloatSequence(AlphabetContainer alphabetContainer,
                                  float[] content)
                           throws WrongAlphabetException,
                                  WrongSequenceTypeException

  Creates a new `ArbitraryFloatSequence` from an array of `float`-encoded alphabet symbols. This constructor is designed for the method `StatisticalModel.emitDataSet(int, int...)`.

  Parameters:
    `alphabetContainer` - the `AlphabetContainer` for the sequence
    `content` - an array containing the encoded symbols
  Throws:
    `WrongAlphabetException` - if the sequence is not defined over `alphabetContainer`
    `WrongSequenceTypeException` - if `alphabetContainer` contains alphabets that can not be encoded with `float`s
  See Also:
    `StatisticalModel.emitDataSet(int, int...)`, `Sequence.Sequence(AlphabetContainer, SequenceAnnotation[])`

### ArbitraryFloatSequence

    public ArbitraryFloatSequence(AlphabetContainer alphabetContainer,
                                  String sequence)
                           throws WrongAlphabetException,
                                  WrongSequenceTypeException

  Creates a new `ArbitraryFloatSequence` from a `String` representation using the default delimiter.

  Parameters:
    `alphabetContainer` - the `AlphabetContainer` for the sequence
    `sequence` - a `String` representation of the sequence
  Throws:
    `WrongAlphabetException` - if the sequence is not defined over `alphabetContainer`
    `WrongSequenceTypeException` - if `alphabetContainer` contains alphabets that can not be encoded with `float`s
  See Also:
    `ArbitraryFloatSequence(AlphabetContainer, SequenceAnnotation[], SymbolExtractor)`

### ArbitraryFloatSequence

    public ArbitraryFloatSequence(AlphabetContainer alphabetContainer,
                                  SequenceAnnotation[] annotation,
                                  String sequence,
                                  String delim)
                           throws WrongAlphabetException,
                                  WrongSequenceTypeException,
                                  IllegalArgumentException

  Creates a new `ArbitraryFloatSequence` from a `String` representation using the delimiter `delim`. Annotations for this sequence are considered by `annotation`.

  Parameters:
    `alphabetContainer` - the `AlphabetContainer` for the sequence
    `annotation` - the annotation for this sequence
    `sequence` - a `String` representation of the sequence
    `delim` - the delimiter, a `String` that separates the symbols
  Throws:
    `WrongAlphabetException` - if the sequence is not defined over `alphabetContainer`
    `WrongSequenceTypeException` - if `alphabetContainer` contains alphabets that can not be encoded with `float`s
    `IllegalArgumentException` - if the delimiter is empty and the alphabet container is not discrete
  See Also:
    `ArbitraryFloatSequence(AlphabetContainer, SequenceAnnotation[], SymbolExtractor)`

### ArbitraryFloatSequence

    public ArbitraryFloatSequence(AlphabetContainer alphabetContainer,
                                  SequenceAnnotation[] annotation,
                                  SymbolExtractor extractor)
                           throws WrongAlphabetException,
                                  WrongSequenceTypeException

  Creates a new `ArbitraryFloatSequence` from a `SymbolExtractor`. Annotations for this sequence are considered by `annotation`.

  Parameters:
    `alphabetContainer` - the alphabet container for the sequence
    `annotation` - the annotation for this sequence
    `extractor` - the `SymbolExtractor`
  Throws:
    `WrongAlphabetException` - if the sequence is not defined over `alphabetContainer`
    `WrongSequenceTypeException` - if `alphabetContainer` contains alphabets that can not be encoded with `float`s
  See Also:
    `Sequence.Sequence(AlphabetContainer, SequenceAnnotation[])`

Method Detail

### continuousVal

    public double continuousVal(int pos)

  Description copied from class: `Sequence`
  Returns the continuous value at position `pos` of the `Sequence`.

  Specified by:
    `continuousVal` in class `Sequence<float[]>`
  Parameters:
    `pos` - the position of the `Sequence`
  Returns:
    the continuous value at position `pos` of the `Sequence`

### discreteVal

    public int discreteVal(int pos)

  Description copied from class: `Sequence`
  Returns the discrete value at position `pos` of the `Sequence`.

  Specified by:
    `discreteVal` in class `Sequence<float[]>`
  Parameters:
    `pos` - the position of the `Sequence`
  Returns:
    the discrete value at position `pos` of the `Sequence`

### getLength

    public int getLength()

  Description copied from class: `Sequence`
  Returns the length of the `Sequence`.

  Specified by:
    `getLength` in class `Sequence<float[]>`
  Returns:
    the length of the `Sequence`

### flatCloneWithoutAnnotation

    protected ArbitraryFloatSequence flatCloneWithoutAnnotation()

  Description copied from class: `Sequence`
  Works in analogy to `Object.clone()`, but does not clone the annotation. This method is used in `Sequence.annotate(boolean, SequenceAnnotation...)`.

  Specified by:
    `flatCloneWithoutAnnotation` in class `Sequence<float[]>`
  Returns:
    the cloned `Sequence` without annotation

### isMultiDimensional

    public boolean isMultiDimensional()

  Description copied from class: `Sequence`
  The method returns `true` if the sequence is multidimensional, otherwise .

  Specified by:
    `isMultiDimensional` in class `Sequence<float[]>`
  Returns:
    `true` if the sequence is multidimensional, otherwise

### getEmptyContainer

    public float[] getEmptyContainer()

  Description copied from class: `Sequence`
  The method returns a container that can be used for accessing the symbols for each position. This is especially of interest for multidimensional sequences.

  Specified by:
    `getEmptyContainer` in class `Sequence<float[]>`
  Returns:
    a container that can be used for accessing the symbols for each position
  See Also:
    `Sequence.fillContainer(Object, int)`, `Sequence.isMultiDimensional()`

### fillContainer

    public void fillContainer(float[] container,
                              int pos)

  Description copied from class: `Sequence`
  The method fills the content of a specific position in to the container. This is especially of interest for multidimensional sequences.

  Specified by:
    `fillContainer` in class `Sequence<float[]>`
  Parameters:
    `container` - the container which is used for filling the content.
    `pos` - the position
  See Also:
    `Sequence.getEmptyContainer()`, `Sequence.isMultiDimensional()`

### compareTo

    public int compareTo(float[] t1,
                         float[] t2)

  Description copied from class: `Sequence`
  This method compares to container and is used in `Sequence.compareTo(Sequence)`.

  Specified by:
    `compareTo` in class `Sequence<float[]>`
  Parameters:
    `t1` - the first container
    `t2` - the second container
  Returns:
    zero if arguments are equal
  See Also:
    `Sequence.getEmptyContainer()`, `Sequence.fillContainer(Object, int)`, `Comparable.compareTo(java.lang.Object)`

### getEmptyRepresentation

    protected Object getEmptyRepresentation()

  Description copied from class: `Sequence`
  Returns an empty representation which is used to create the `String` representation of this instance in the method `Sequence.toString(String, int, int)`.

  Specified by:
    `getEmptyRepresentation` in class `Sequence<float[]>`
  Returns:
    an empty representation which is used to create the `String` representation
  See Also:
    `Sequence.toString(String, int, int)`

### addToRepresentation

    protected void addToRepresentation(Object representation,
                                       int pos,
                                       String delim)

  Description copied from class: `Sequence`
  This method adds the information of one position to the representation using the specified delimiter

  Specified by:
    `addToRepresentation` in class `Sequence<float[]>`
  Parameters:
    `representation` - the representation
    `pos` - the position
    `delim` - the delimiter separating the information for different positions
  See Also:
    `Sequence.getEmptyRepresentation()`, `Sequence.toString(String, int, int)`

### getStringRepresentation

    protected String getStringRepresentation(Object representation)

  Description copied from class: `Sequence`
  This method creates a String representation from the given representation.

  Specified by:
    `getStringRepresentation` in class `Sequence<float[]>`
  Parameters:
    `representation` - the representation instance (which should be created by `Sequence.getEmptyContainer()` and filled by `Sequence.addToRepresentation(Object, int, String)`)
  Returns:
    a String representation
  See Also:
    `Sequence.getEmptyRepresentation()`, `Sequence.addToRepresentation(Object, int, String)`, `Sequence.toString(String, int, int)`

### hashCodeForPos

    protected int hashCodeForPos(int pos)

  Description copied from class: `Sequence`
  This method is used in `Sequence.hashCode()` and the hash code for one specific position.

  Specified by:
    `hashCodeForPos` in class `Sequence<float[]>`
  Parameters:
    `pos` - the position
  Returns:
    the hash code for the position

### getDataSet

    public static DataSet getDataSet(AlphabetContainer con,
                                     String filename,
                                     SequenceAnnotationParser parser)
                              throws FileNotFoundException,
                                     WrongAlphabetException,
                                     WrongSequenceTypeException,
                                     EmptyDataSetException,
                                     IOException

  This method allows to create a `DataSet` containing `ArbitraryFloatSequence`s using a file name. Annotations are parsed by the supplied `SequenceAnnotationParser`. The file is assumed to be in FastA format.

  Parameters:
    `con` - the `AlphabetContainer` for the `DataSet` and `ArbitraryFloatSequence`s
    `filename` - the file name
    `parser` - a parser for the annotations of the `ArbitraryFloatSequence`s
  Returns:
    a `DataSet` containing `ArbitraryFloatSequence`s
  Throws:
    `FileNotFoundException` - if the file `filename` could not be found
    `WrongAlphabetException` - if the alphabet does not fit the data
    `WrongSequenceTypeException` - if the data can not be represented as floats
    `EmptyDataSetException` - if not sequences exist in `filename`
    `IOException` - if the file could not be read

### getDataSet

    public static DataSet getDataSet(AlphabetContainer con,
                                     String filename)
                              throws FileNotFoundException,
                                     WrongAlphabetException,
                                     WrongSequenceTypeException,
                                     EmptyDataSetException,
                                     IOException

  This method allows to create a `DataSet` containing `ArbitraryFloatSequence`s using a file name.

  Parameters:
    `con` - the `AlphabetContainer` for the `DataSet` and `ArbitraryFloatSequence`s
    `filename` - the file name
  Returns:
    a `DataSet` containing `ArbitraryFloatSequence`s
  Throws:
    `FileNotFoundException` - if the file `filename` could not be found
    `WrongAlphabetException` - if the alphabet does not fit the data
    `WrongSequenceTypeException` - if the data can not be represented as floats
    `EmptyDataSetException` - if not sequences exist in `filename`
    `IOException` - if the file could not be read

### getDataSet

    public static DataSet getDataSet(AlphabetContainer con,
                                     AbstractStringExtractor... se)
                              throws WrongAlphabetException,
                                     WrongSequenceTypeException,
                                     EmptyDataSetException

  This method allows to create a `DataSet` containing `ArbitraryFloatSequence`s.

  Parameters:
    `con` - the `AlphabetContainer` for the `DataSet` and `ArbitraryFloatSequence`s
    `se` - the `AbstractStringExtractor`s that handle the `DataSet` as `String`
  Returns:
    a `DataSet` containing `ArbitraryFloatSequence`s
  Throws:
    `WrongAlphabetException` - if the alphabet does not fit the data
    `WrongSequenceTypeException` - if the data can not be represented as floats
    `EmptyDataSetException` - if a `DataSet` with 0 (zero) `ArbitraryFloatSequence`s should be created

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD