Struct multi_seq_align::Alignment

pub struct Alignment<T> { /* fields omitted */ }

An alignment of DNA or amino acids sequences

Aligned sequences should all have the same length. Each sequence is stored as one vector of chars. This allows an easy access to columns and rows of the alignment.

Implementations

impl<T> Alignment<T>

#[must_use]pub const fn length(&self) -> &usize

Returns the fixed length of the Alignment self

#[must_use]pub const fn n_sequences(&self) -> &usize

Returns the number of sequences contained in self

pub fn iter_positions(
    &self
) -> impl Iterator<Item = Vec<&T>> + ExactSizeIterator<Item = Vec<&T>> where
    T: Clone, 

Returns an Iterator over the positions of the alignment

Examples

let align = Alignment::with_sequences(
    &[
        b"AVEQTPRK".to_vec(),
        b"SVEQTPRK".to_vec(),
        b"SVEQTPKK".to_vec(),
    ],
)
.unwrap();

for position in align.iter_positions() {
    assert_eq!(position.len(), 3)
}

pub fn iter_sequences(
    &self
) -> impl Iterator<Item = Vec<&T>> + ExactSizeIterator<Item = Vec<&T>> where
    T: Clone, 

Returns an Iterator over the sequences of the alignment

Examples

let align = Alignment::with_sequences(
    &[
        b"AVEQTPRK".to_vec(),
        b"SVEQTPRK".to_vec(),
        b"SVEQTPKK".to_vec(),
    ],
)
.unwrap();

for sequence in align.iter_sequences() {
    assert_eq!(sequence.len(), 8)
}

#[must_use]pub const fn new(length: usize) -> Self

Returns an empty Alignment of fixed length

Examples

 let alignment = Alignment::<char>::new(42);

 assert_eq!(*alignment.length(), 42 as usize);
 assert_eq!(*alignment.n_sequences(), 0 as usize);

#[must_use]pub const fn is_empty(&self) -> bool

Returns true if self doesn't contains any sequence

Examples

let alignment = Alignment::<char>::new(42);

assert!(alignment.is_empty())

pub fn with_sequences(sequences: &[Vec<T>]) -> Result<Self, MultiSeqAlignError> where
    T: Clone, 

Create an Alignment from same length vectors of names, descriptions, sequences

Examples

let align = Alignment::with_sequences(
    &[
        b"AVEQTPRK".to_vec(),
        b"SVEQTPRK".to_vec(),
        b"SVEQTPKK".to_vec(),
    ],
)
.unwrap();

assert_eq!(*align.length(), 8);
assert_eq!(*align.n_sequences(), 3);

Errors

Will return an error if names, descriptions and sequences have different lengths, and also if the sequences have different lengths (based on the first sequence).

pub fn add<'a>(
    &'a mut self,
    sequence: Vec<T>
) -> Result<&'a mut Self, MultiSeqAlignError>

Add a sequence to self

The new sequence must have the same length than self.length.

Examples

let mut align = Alignment::new(8);

 assert_eq!(*align.n_sequences(), 0);

align
    .add(b"AVEQTPRK".to_vec())
    .unwrap();

assert_eq!(*align.n_sequences(), 1);

align
    .add(b"SVEQTPRK".to_vec())
    .unwrap();

assert_eq!(*align.n_sequences(), 2);

Errors

Will return an error if the length of sequence is different from the one of the alignment.

#[must_use]pub fn nth_position(&self, n: usize) -> Option<Vec<&T>>

Returns all amino acids / bases at a position in the alignment self. The returned vector has a length equal of number of sequences in self.

Examples

let align = Alignment::<u8>::with_sequences(
    &[b"ELK".to_vec(), b"ILK".to_vec()],
)
.unwrap();

assert_eq!(align.nth_position(0).unwrap(), &[&b'E', &b'I']);

Panics

Panics if n is greater or equal to the length of the Alignment.

#[must_use]pub fn nth_sequence(&self, index: usize) -> Option<Vec<&T>>

Returns all amino acids / bases of the sequence at the index of the Alignment self. The returned vector has a length equal to the length of the Alignment self.

Examples

let align = Alignment::<u8>::with_sequences(
    &[b"ELK".to_vec(), b"ILK".to_vec()],
)
.unwrap();

assert_eq!(align.nth_sequence(1).unwrap(), &[&b'I', &b'L', &b'K']);

Panics

Panics if index is greater or equal to the n_sequences of the Alignment.

Trait Implementations

impl<T: Clone> Clone for Alignment<T>

fn clone(&self) -> Alignment<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Alignment<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for Alignment<T> where
    T: Clone, 

fn default() -> Self

Returns the "default value" for a type.

impl<T: Eq> Eq for Alignment<T>

impl<A> FromIterator<Vec<A>> for Alignment<A> where
    A: Clone, 

fn from_iter<I: IntoIterator<Item = Vec<A>>>(iter: I) -> Self

Panics

Panics if sequences are of different lengths

impl<T: Hash> Hash for Alignment<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T: Ord> Ord for Alignment<T>

fn cmp(&self, other: &Alignment<T>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq<Alignment<T>> for Alignment<T>

fn eq(&self, other: &Alignment<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Alignment<T>) -> bool

This method tests for !=.

impl<T: PartialOrd> PartialOrd<Alignment<T>> for Alignment<T>

fn partial_cmp(&self, other: &Alignment<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Alignment<T>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Alignment<T>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Alignment<T>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Alignment<T>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> StructuralEq for Alignment<T>

impl<T> StructuralPartialEq for Alignment<T>