Struct SeqArray

#[repr(transparent)]
pub struct SeqArray<A: Codec, const N: usize, const W: usize> {
    pub _p: PhantomData<A>,
    pub ba: BitArray<[usize; W], Lsb0>,
}

Fields

_p: PhantomData<A>

ba: BitArray<[usize; W], Lsb0>

Implementations

impl<const N: usize, const W: usize> SeqArray<Iupac, N, W>

pub fn contains(&self, rhs: &SeqSlice<Iupac>) -> bool

Methods from Deref<Target = SeqSlice<A>>

pub fn contains(&self, rhs: &SeqSlice<Iupac>) -> bool

pub fn chain( self: &'a SeqSlice<A>, second: &'a SeqSlice<A>, ) -> Chain<SeqIter<'a, A>, SeqIter<'a, A>>

pub fn iter(&'a self) -> SeqIter<'a, A>

pub fn kmers<const K: usize>(&self) -> KmerIter<'_, A, K>

Iterate over sliding windows of size K

pub fn rev(&self) -> RevIter<'_, A>

Iterate over the sequence in reverse order

pub fn windows(&self, width: usize) -> SeqChunks<'_, A>

Iterate over the sequence in overlapping windows of a specified width

This will panic if the length of the window is greater than the length of the sequence.

Example:

use bio_seq::prelude::*;

let seq: Seq<Dna> = "ACTGATCG".try_into().unwrap();
let windows: Vec<String> = seq.windows(3).map(String::from).collect();
assert_eq!(windows, vec!["ACT", "CTG", "TGA", "GAT", "ATC", "TCG"]);

pub fn chunks(&self, width: usize) -> SeqChunks<'_, A>

Iterate over the sequence in non-overlapping chunks of a specified width

The last incomplete chunk will be excluded if the sequence length is not divisible by the specified width.

Example:

use bio_seq::prelude::*;

let seq: Seq<Dna> = "ACTGATCG".try_into().unwrap();
let chunks: Vec<Seq<Dna>> = seq.chunks(3).collect();
assert_eq!(chunks, vec![dna!("ACT"), dna!("GAT")]);

pub fn nth(&self, i: usize) -> A

unsafely index into the ith position of a sequence

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

Trait Implementations

impl<A: Codec, const N: usize, const W: usize> AsRef<SeqSlice<A>> for SeqArray<A, N, W>

fn as_ref(&self) -> &SeqSlice<A>

Converts this type into a shared reference of the (usually inferred) input type.

impl<A: Codec, const N: usize, const W: usize> BitAnd for &SeqArray<A, N, W>

type Output = Seq<A>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<A: Codec, const N: usize, const W: usize> BitOr for &SeqArray<A, N, W>

type Output = Seq<A>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<A: Debug + Codec, const N: usize, const W: usize> Debug for SeqArray<A, N, W>

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

Formats the value using the given formatter.

impl<A: Codec, const N: usize, const W: usize> Deref for SeqArray<A, N, W>

type Target = SeqSlice<A>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<A: Codec, const N: usize, const W: usize> Display for SeqArray<A, N, W>

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

Formats the value using the given formatter.

impl<A: Codec, const K: usize, S: KmerStorage> From<&SeqArray<A, K, 1>> for Kmer<A, K, S>

fn from(seq: &SeqArray<A, K, 1>) -> Self

Converts to this type from the input type.

impl<A: Codec, const N: usize> From<&SeqArray<A, N, 1>> for usize

fn from(slice: &SeqArray<A, N, 1>) -> usize

Converts to this type from the input type.

impl<A, B: Codec, const N: usize, const W: usize> From<&SeqArray<A, N, W>> for Seq<B>

where A: Into<B> + Codec,

fn from(slice: &SeqArray<A, N, W>) -> Self

Converts to this type from the input type.

impl<A, B: Codec, const N: usize, const W: usize> From<SeqArray<A, N, W>> for Seq<B>

where A: Into<B> + Codec,

fn from(slice: SeqArray<A, N, W>) -> Self

Converts to this type from the input type.

impl<A: Codec, const K: usize, const W: usize> Hash for SeqArray<A, K, W>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<A: Codec, const N: usize, const W: usize> PartialEq<&SeqArray<A, N, W>> for Seq<A>

fn eq(&self, other: &&SeqArray<A, N, W>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: Codec, const N: usize, const W: usize> PartialEq<Seq<A>> for &SeqArray<A, N, W>

fn eq(&self, other: &Seq<A>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: Codec, const N: usize, const W: usize> PartialEq<Seq<A>> for SeqArray<A, N, W>

fn eq(&self, other: &Seq<A>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: Codec, const N: usize, const W: usize> PartialEq<SeqArray<A, N, W>> for &SeqSlice<A>

fn eq(&self, other: &SeqArray<A, N, W>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: Codec, const N: usize, const W: usize> PartialEq<SeqArray<A, N, W>> for Seq<A>

fn eq(&self, other: &SeqArray<A, N, W>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: Codec, const N: usize, const W: usize, const M: usize, const V: usize> PartialEq<SeqArray<A, N, W>> for SeqArray<A, M, V>

fn eq(&self, other: &SeqArray<A, N, W>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: Codec, const N: usize, const W: usize> PartialEq<SeqArray<A, N, W>> for SeqSlice<A>

fn eq(&self, other: &SeqArray<A, N, W>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: Codec, const N: usize, const W: usize> PartialEq<SeqSlice<A>> for &SeqArray<A, N, W>

fn eq(&self, other: &SeqSlice<A>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: Codec, const N: usize, const W: usize> PartialEq<SeqSlice<A>> for SeqArray<A, N, W>

fn eq(&self, other: &SeqSlice<A>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.