Struct BitEnc 

pub struct BitEnc { /* private fields */ }

A 2-bit encoded DNA sequence stored in a u64.

Supports sequences up to 32 bases (64 bits). Each base is encoded as: A=0, C=1, G=2, T=3.

Implementations

impl BitEnc

pub fn from_bytes(seq: &[u8]) -> Option<BitEnc>

Create a BitEnc from a byte slice.

Returns None if the sequence contains non-ACGT bases or exceeds 32 bases.

pub fn from_umi_str(umi: &str) -> Option<BitEnc>

Create a BitEnc from a UMI string, skipping non-ACGT characters (e.g., dashes in paired UMIs).

This is useful for paired UMIs like “ACGT-TGCA” where the dash should be ignored. Returns None if the sequence contains invalid bases (not ACGT or dash) or exceeds 32 bases.

pub const fn len(&self) -> usize

Get the number of bases in this sequence.

pub const fn is_empty(&self) -> bool

Check if the sequence is empty.

pub fn hamming_distance(&self, other: &BitEnc) -> u32

Compute the Hamming distance between two encoded sequences.

Both sequences must have the same length (debug assertion).

pub fn base_at(&self, pos: usize) -> u8

Get the 2-bit encoded base at the given position.

Returns a value in 0..4 representing A, C, G, T respectively.

pub fn with_base_at(&self, pos: usize, base: u8) -> BitEnc

Return a copy of this sequence with a different base at the given position.

base must be in 0..4 (A=0, C=1, G=2, T=3).

pub fn extract_bits(&self, start_base: usize, num_bases: usize) -> u32

Extract bits for bases [start_base, start_base + len) as a u32.

Each base is 2 bits, so this can extract up to 16 bases into a u32. Used for N-gram partitioning in similarity search.

Trait Implementations

impl Clone for BitEnc

fn clone(&self) -> BitEnc

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BitEnc

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

Formats the value using the given formatter.

impl Hash for BitEnc

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

where __H: Hasher,

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 PartialEq for BitEnc

fn eq(&self, other: &BitEnc) -> 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 Copy for BitEnc

impl Eq for BitEnc

impl StructuralPartialEq for BitEnc