Struct Kmer 

#[repr(transparent)]
pub struct Kmer<C: Codec, const K: usize, S: KmerStorage = usize> {
    pub _p: PhantomData<C>,
    pub bs: S,
}

By default k-mers are backed by usize and Codec::BITS * K must be <= 64 on 64-bit platforms

Fields

_p: PhantomData<C>

bs: S

Implementations

impl<A: Codec, const K: usize, S: KmerStorage> Kmer<A, K, S>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn rotated_left(&self, n: u32) -> Self

pub fn rotated_right(&self, n: u32) -> Self

pub fn pushr(self, base: A) -> Self

Shift bases to the right and push a base onto the end.

use bio_seq::prelude::*;
use bio_seq::codec::dna::Dna;

let k = kmer!("ACGAT");
assert_eq!(k.pushr(Dna::T).to_string(), "CGATT");

pub fn pushl(self, base: A) -> Self

Push a base from the left

pub fn unsafe_from_seqslice(seq: &SeqSlice<A>) -> Self

Create Kmer from sequence without checking length

Methods from Deref<Target = SeqSlice<A>>

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 length K

pub fn rev_iter(&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

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.

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 get(&self, i: usize) -> Option<A>

Get the ith element of a Seq. Returns None if index out of range.

pub fn is_empty(&self) -> bool

Trait Implementations

impl<A: Codec, const K: usize> AsRef<SeqSlice<A>> for Kmer<A, K, usize>

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

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

impl<C: Clone + Codec, const K: usize, S: Clone + KmerStorage> Clone for Kmer<C, K, S>

fn clone(&self) -> Kmer<C, K, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const K: usize> Complement for Kmer<Dna, K, usize>

fn to_comp(&self) -> <Self as ToOwned>::Owned

impl<const K: usize> ComplementMut for Kmer<Dna, K, usize>

fn comp(&mut self)

impl<C: Debug + Codec, const K: usize, S: Debug + KmerStorage> Debug for Kmer<C, K, S>

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

Formats the value using the given formatter.

impl<A: Codec, const K: usize> Deref for Kmer<A, K, usize>

type Target = SeqSlice<A>

The resulting type after dereferencing.

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

Dereferences the value.

impl<'de, C: Codec, const K: usize, S> Deserialize<'de> for Kmer<C, K, S>

where S: Deserialize<'de> + KmerStorage,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: Codec, const K: usize, S: KmerStorage> Display for Kmer<A, K, S>

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

Formats the value using the given formatter.

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

fn from(kmer: &Kmer<A, K, S>) -> usize

Converts to this type from the input type.

impl<A: Codec, const K: usize> From<Kmer<A, K>> for Seq<A>

fn from(kmer: Kmer<A, K, usize>) -> Self

Converts to this type from the input type.

impl<A: Codec, const K: usize> From<u64> for Kmer<A, K, u64>

fn from(i: u64) -> Kmer<A, K, u64>

Converts to this type from the input type.

impl<A: Codec, const K: usize> From<usize> for Kmer<A, K, usize>

fn from(i: usize) -> Kmer<A, K, usize>

Converts to this type from the input type.

impl<A: Codec, const K: usize> From<usize> for Kmer<A, K, u64>

fn from(i: usize) -> Kmer<A, K, u64>

Converts to this type from the input type.

impl<A: Codec, const K: usize, S: KmerStorage> FromStr for Kmer<A, K, S>

type Err = ParseBioError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<A: Codec, const K: usize, S: KmerStorage> Hash for Kmer<A, K, S>

use bio_seq::prelude::*;
use std::hash::{Hash, Hasher, DefaultHasher};

let mut hasher1 = DefaultHasher::new();
kmer!("AAA").hash(&mut hasher1);
let hash1 = hasher1.finish();

let mut hasher2 = DefaultHasher::new();
kmer!("AAAA").hash(&mut hasher2);
let hash2 = hasher2.finish();

assert_ne!(hash1, hash2);

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<C: Ord + Codec, const K: usize, S: Ord + KmerStorage> Ord for Kmer<C, K, S>

fn cmp(&self, other: &Kmer<C, K, S>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

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

fn eq(&self, seq: &&SeqArray<A, K, 1>) -> 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 K: usize, S: KmerStorage> PartialEq<&SeqSlice<A>> for Kmer<A, K, S>

fn eq(&self, seq: &&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 K: usize> PartialEq<&str> for Kmer<A, K>

fn eq(&self, seq: &&str) -> 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 K: usize> PartialEq<Seq<A>> for Kmer<A, K>

fn eq(&self, seq: &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 K: usize, S: KmerStorage> PartialEq<SeqArray<A, K, 1>> for Kmer<A, K, S>

fn eq(&self, seq: &SeqArray<A, K, 1>) -> 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 K: usize, S: KmerStorage> PartialEq<SeqSlice<A>> for Kmer<A, K, S>

fn eq(&self, seq: &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<C: PartialEq + Codec, const K: usize, S: PartialEq + KmerStorage> PartialEq for Kmer<C, K, S>

fn eq(&self, other: &Kmer<C, K, S>) -> 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<C: PartialOrd + Codec, const K: usize, S: PartialOrd + KmerStorage> PartialOrd for Kmer<C, K, S>

fn partial_cmp(&self, other: &Kmer<C, K, S>) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<A: Codec, const K: usize> Reverse for Kmer<A, K, usize>

fn to_rev(&self) -> <Self as ToOwned>::Owned

impl<const K: usize> ReverseComplement for Kmer<Dna, K, usize>

fn to_revcomp(&self) -> <Self as ToOwned>::Owned

impl<const K: usize> ReverseComplementMut for Kmer<Dna, K, usize>

fn revcomp(&mut self)

Reverse complement a sequence in place

impl<A: Codec, const K: usize> ReverseMut for Kmer<A, K, usize>

fn rev(&mut self)

Reverse sequence in place

impl<C: Codec, const K: usize, S> Serialize for Kmer<C, K, S>

where S: Serialize + KmerStorage,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A: Codec, const K: usize, S: KmerStorage> TryFrom<&SeqSlice<A>> for Kmer<A, K, S>

type Error = ParseBioError

The type returned in the event of a conversion error.

fn try_from(seq: &SeqSlice<A>) -> Result<Self, Self::Error>

Performs the conversion.

impl<A: Codec, const K: usize> TryFrom<Seq<A>> for Kmer<A, K>

type Error = ParseBioError

The type returned in the event of a conversion error.

fn try_from(seq: Seq<A>) -> Result<Self, Self::Error>

Performs the conversion.

impl<C: Copy + Codec, const K: usize, S: Copy + KmerStorage> Copy for Kmer<C, K, S>

impl<C: Eq + Codec, const K: usize, S: Eq + KmerStorage> Eq for Kmer<C, K, S>

impl<C: Codec, const K: usize, S: KmerStorage> StructuralPartialEq for Kmer<C, K, S>