Struct PackedSeqBase 

pub struct PackedSeqBase<'s, const B: usize>
where
    Bits<B>: SupportedBits,
{ /* private fields */ }

A variable-bit-width packed non-owned slice of DNA bases.

Implementations

impl<'s, const B: usize> PackedSeqBase<'s, B>

where Bits<B>: SupportedBits,

pub fn from_raw_parts(seq: &'s [u8], offset: usize, len: usize) -> Self

Creates a Seq from a slice of packed bytes, an offset in bp and a length in bp.

The slice should have at least 48 bytes of padding after offset + len. Otherwise, the function will panic.

pub fn normalize(&self) -> Self

Shrink seq to only just cover the data.

pub fn unpack(&self) -> Vec<u8>

Return a Vec<u8> of ASCII ACTG characters.

impl<'s, const B: usize> PackedSeqBase<'s, B>

where Bits<B>: SupportedBits,

pub fn par_iter_bp_with_buf<BUF: DerefMut<Target = [S; 8]>>( self, context: usize, buf: BUF, ) -> PaddedIt<impl ChunkIt<S> + use<'s, B, BUF>>

pub fn par_iter_bp_delayed_with_factor( self, context: usize, delay: Delay, factor: usize, ) -> PaddedIt<impl ChunkIt<(S, S)> + use<'s, B>>

pub fn par_iter_bp_delayed_with_buf<BUF: DerefMut<Target = Vec<S>>>( self, context: usize, delay: Delay, buf: BUF, ) -> PaddedIt<impl ChunkIt<(S, S)> + use<'s, B, BUF>>

pub fn par_iter_bp_delayed_with_factor_and_buf<BUF: DerefMut<Target = Vec<S>>>( self, context: usize, Delay: Delay, factor: usize, buf: BUF, ) -> PaddedIt<impl ChunkIt<(S, S)> + use<'s, B, BUF>>

pub fn par_iter_bp_delayed_2_with_factor( self, context: usize, delay1: Delay, delay2: Delay, factor: usize, ) -> PaddedIt<impl ChunkIt<(S, S, S)> + use<'s, B>>

pub fn par_iter_bp_delayed_2_with_buf<BUF: DerefMut<Target = Vec<S>>>( self, context: usize, delay1: Delay, delay2: Delay, buf: BUF, ) -> PaddedIt<impl ChunkIt<(S, S, S)> + use<'s, B, BUF>>

pub fn par_iter_bp_delayed_2_with_factor_and_buf<BUF: DerefMut<Target = Vec<S>>>( self, context: usize, Delay: Delay, Delay: Delay, factor: usize, buf: BUF, ) -> PaddedIt<impl ChunkIt<(S, S, S)> + use<'s, B, BUF>>

When iterating over 2-bit and 1-bit encoded data in parallel, one must ensure that they have the same stride. On the larger type, set factor as the ratio to the smaller one, so that the stride in bytes is a multiple of factor, so that the smaller type also has a byte-aligned stride.

impl<'s> PackedSeqBase<'s, 1>

pub fn iter_kmer_ambiguity( self, k: usize, ) -> impl ExactSizeIterator<Item = bool> + use<'s>

An iterator indicating for each kmer whether it contains ambiguous bases.

Returns n-(k-1) elements.

pub fn par_iter_kmer_ambiguity( self, k: usize, context: usize, skip: usize, ) -> PaddedIt<impl ChunkIt<S> + use<'s>>

A parallel iterator indicating for each kmer whether it contains ambiguous bases.

First element is the ‘kmer’ consisting only of the first character of each chunk.

k: length of windows to check context: number of overlapping iterations +1. To determine stride of each lane. skip: Set to context-1 to skip the iterations added by the context.

pub fn par_iter_kmer_ambiguity_with_buf( self, k: usize, context: usize, skip: usize, buf: &'s mut Vec<S>, ) -> PaddedIt<impl ChunkIt<S> + use<'s>>

Trait Implementations

impl<'s, const B: usize> Clone for PackedSeqBase<'s, B>

where Bits<B>: SupportedBits,

fn clone(&self) -> PackedSeqBase<'s, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'s, const B: usize> CopyType for PackedSeqBase<'s, B>

where Bits<B>: SupportedBits, &'s [u8]: MemSize, usize: MemSize,

type Copy = False

impl<'s, const B: usize> Debug for PackedSeqBase<'s, B>

where Bits<B>: SupportedBits,

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

Formats the value using the given formatter.

impl<'s, const B: usize> MemDbgImpl for PackedSeqBase<'s, B>

where Bits<B>: SupportedBits, &'s [u8]: MemDbgImpl, usize: MemDbgImpl,

fn _mem_dbg_rec_on( &self, _memdbg_writer: &mut impl Write, _memdbg_total_size: usize, _memdbg_max_depth: usize, _memdbg_prefix: &mut String, _memdbg_is_last: bool, _memdbg_flags: DbgFlags, ) -> Result

fn _mem_dbg_depth_on( &self, writer: &mut impl Write, total_size: usize, max_depth: usize, prefix: &mut String, field_name: Option<&str>, is_last: bool, padded_size: usize, flags: DbgFlags, ) -> Result<(), Error>

impl<'s, const B: usize> MemSize for PackedSeqBase<'s, B>

where Bits<B>: SupportedBits, &'s [u8]: MemSize, usize: MemSize,

fn mem_size(&self, _memsize_flags: SizeFlags) -> usize

Returns the (recursively computed) overall memory size of the structure in bytes.

impl<const B: usize> Ord for PackedSeqBase<'_, B>

where Bits<B>: SupportedBits,

fn cmp(&self, other: &Self) -> Ordering

Compares 29 characters at a time.

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<const B: usize> PartialEq for PackedSeqBase<'_, B>

where Bits<B>: SupportedBits,

fn eq(&self, other: &Self) -> bool

Compares 29 characters at a time.

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<const B: usize> PartialOrd for PackedSeqBase<'_, B>

where Bits<B>: SupportedBits,

fn partial_cmp(&self, other: &Self) -> 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<'s, const B: usize> Seq<'s> for PackedSeqBase<'s, B>

where Bits<B>: SupportedBits,

fn as_u64(&self) -> u64

Convert a short sequence (kmer) to a packed representation as u64. Panics if self is longer than 32 characters.

fn revcomp_as_u64(&self) -> u64

Convert a short sequence (kmer) to a packed representation of its reverse complement as usize. Panics if self is longer than 32 characters.

fn as_u128(&self) -> u128

Convert a short sequence (kmer) to a packed representation as u128. Panics if self is longer than 64 characters.

fn revcomp_as_u128(&self) -> u128

Convert a short sequence (kmer) to a packed representation of its reverse complement as usize. Panics if self is longer than 64 characters.

fn par_iter_bp_delayed_2( self, context: usize, delay1: Delay, delay2: Delay, ) -> PaddedIt<impl ChunkIt<(S, S, S)>>

NOTE: When self starts does not start at a byte boundary, the ‘delayed’ character is not guaranteed to be 0.

fn cmp_lcp(&self, other: &Self) -> (Ordering, usize)

Compares 29 characters at a time.

const BITS_PER_CHAR: usize = B

Number of bits b to represent each character returned by iter_bp and variants..

const BASES_PER_BYTE: usize = Self::C8

Number of encoded characters per byte of memory of the Seq.

type SeqVec = PackedSeqVecBase<B>

The corresponding owned sequence type.

fn len(&self) -> usize

The length of the sequence in characters.

fn is_empty(&self) -> bool

Returns true if the sequence is empty.

fn get_ascii(&self, index: usize) -> u8

Get the ASCII character at the given index, without mapping to b-bit values.

fn to_vec(&self) -> PackedSeqVecBase<B>

Convert to an owned version.

fn to_revcomp(&self) -> PackedSeqVecBase<B>

Compute the reverse complement of this sequence.

fn slice(&self, range: Range<usize>) -> Self

Get a sub-slice of the sequence. range indicates character indices.

fn iter_bp(self) -> impl ExactSizeIterator<Item = u8>

Iterate over the b-bit characters of the sequence.

fn par_iter_bp(self, context: usize) -> PaddedIt<impl ChunkIt<S>>

Iterate over 8 chunks of b-bit characters of the sequence in parallel.

fn par_iter_bp_delayed( self, context: usize, delay: Delay, ) -> PaddedIt<impl ChunkIt<(S, S)>>

Iterate over 8 chunks of the sequence in parallel, returning two characters offset by delay positions.

fn get(&self, index: usize) -> u8

Get the character at the given index.

fn bits_per_char(&self) -> usize

Convenience function that returns b=Self::BITS_PER_CHAR.

fn to_word(&self) -> usize

👎Deprecated: Prefer to_u64.

Convert a short sequence (kmer) to a packed representation as usize.

fn to_word_revcomp(&self) -> usize

👎Deprecated: Prefer revcomp_to_u64.

Convert a short sequence (kmer) to a packed representation of its reverse complement as usize.

fn read_kmer(&self, k: usize, pos: usize) -> u64

Extract a k-mer from this sequence.

fn read_revcomp_kmer(&self, k: usize, pos: usize) -> u64

Extract a reverse complement k-mer from this sequence.

fn read_kmer_u128(&self, k: usize, pos: usize) -> u128

Extract a k-mer from this sequence.

fn read_revcomp_kmer_u128(&self, k: usize, pos: usize) -> u128

Extract a reverse complement k-mer from this sequence.

impl<'s, const B: usize> Copy for PackedSeqBase<'s, B>

where Bits<B>: SupportedBits,

impl<const B: usize> Eq for PackedSeqBase<'_, B>

where Bits<B>: SupportedBits,