use std::fmt::Debug;
use std::fmt::Display;
use super::word::{ENCODE, KmerWord, Spelled, decode_word, mask, rev_comp_word};
use crate::core::core_types::Orientation;
use crate::error::{PanGraphXError, PanResult};
pub const MAX_K: usize = 63;
pub fn validate_k(k: usize) -> PanResult<()> {
if (1..=MAX_K).contains(&k) {
Ok(())
} else {
Err(PanGraphXError::DeBruijn(format!(
"k-mer size must be between 1 and {MAX_K}, got {k}"
)))
}
}
#[inline]
const fn encode_lossy(b: u8) -> u8 {
ENCODE[b as usize] & 3
}
#[must_use]
pub fn roll_kmer(code: u128, k: usize, next_base: u8) -> u128 {
let next_code = u128::from(encode_lossy(next_base));
((code & mask::<u128>(k - 1)) << 2) | next_code
}
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct Kmer {
pub code: u128,
pub k: usize,
}
impl Debug for Kmer {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let bytes = self.to_bytes();
write!(f, "Kmer({})", String::from_utf8_lossy(&bytes))
}
}
impl Kmer {
#[inline]
#[must_use]
pub fn from_bases(bases: &[u8]) -> Self {
let mut code: u128 = 0;
for &b in bases {
code = (code << 2) | u128::from(encode_lossy(b));
}
Self {
code,
k: bases.len(),
}
}
#[inline]
#[must_use]
pub fn rev_comp(&self) -> Self {
Self {
code: rev_comp_word(self.code, self.k),
k: self.k,
}
}
#[inline]
#[must_use]
pub fn canonical(&self) -> Self {
let rc = self.rev_comp();
if self.code <= rc.code { *self } else { rc }
}
#[must_use]
pub fn to_bytes(&self) -> Vec<u8> {
decode_word(self.code, self.k)
}
}
impl Display for Kmer {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let bytes = self.to_bytes();
write!(f, "{}", String::from_utf8_lossy(&bytes))
}
}
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct OrientedKmer {
pub kmer: Kmer,
pub direction: Orientation,
}
impl Debug for OrientedKmer {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let bytes = self.to_bytes();
write!(
f,
"OrientedKmer{{Sequence {}, Orientation {}}}",
String::from_utf8_lossy(&bytes),
self.direction
)
}
}
impl OrientedKmer {
#[must_use]
pub fn from_code(code: u128, k: usize) -> Self {
let raw = Kmer { code, k };
let canonical = raw.canonical();
let direction = Orientation::from(canonical.code != raw.code);
Self {
kmer: canonical,
direction,
}
}
#[inline]
#[must_use]
pub fn from_bases(bases: &[u8]) -> Self {
let raw = Kmer::from_bases(bases);
Self::from_code(raw.code, raw.k)
}
pub(crate) fn from_spelled<W: KmerWord>(spelled: Spelled<W>, k: usize) -> Self {
Self {
kmer: Kmer {
code: spelled.canonical().to_u128(),
k,
},
direction: spelled.orientation(),
}
}
#[must_use]
pub fn to_bytes(&self) -> Vec<u8> {
if self.direction == Orientation::Forward {
self.kmer.to_bytes()
} else {
self.kmer.rev_comp().to_bytes()
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_validate_k() {
assert!(validate_k(0).is_err());
assert!(validate_k(1).is_ok());
assert!(validate_k(MAX_K).is_ok());
assert!(validate_k(MAX_K + 1).is_err());
}
#[test]
fn test_kmer_round_trip() {
let seq = b"ACGTACGT";
let kmer = Kmer::from_bases(seq);
let output = kmer.to_bytes();
assert_eq!(output, seq, "Round trip encoding/decoding failed");
}
#[test]
fn test_kmer_rev_comp() {
let seq = b"TTCG";
let kmer = Kmer::from_bases(seq);
let rc = kmer.rev_comp();
assert_eq!(rc.to_bytes(), b"CGAA");
}
#[test]
fn test_canonicalization() {
let kmer_fwd = Kmer::from_bases(b"AAAA");
assert_eq!(kmer_fwd.canonical().to_bytes(), b"AAAA");
let kmer_rev = Kmer::from_bases(b"TTTT");
assert_eq!(kmer_rev.canonical().to_bytes(), b"AAAA");
let palindrome = Kmer::from_bases(b"TGCA");
assert_eq!(palindrome.canonical().to_bytes(), b"TGCA");
}
#[test]
fn test_orientation_detection() {
let ok_fwd = OrientedKmer::from_bases(b"AAAA");
assert_eq!(ok_fwd.direction, Orientation::Forward);
assert_eq!(ok_fwd.kmer.to_bytes(), b"AAAA");
let ok_rev = OrientedKmer::from_bases(b"TTTT");
assert_eq!(ok_rev.direction, Orientation::Reverse);
assert_eq!(ok_rev.kmer.to_bytes(), b"AAAA");
}
#[test]
fn test_roll_kmer_logic() {
let k = 4;
let start_seq = b"ACGT";
let start_kmer = Kmer::from_bases(start_seq);
let next_code = roll_kmer(start_kmer.code, k, b'A');
let next_kmer = Kmer { code: next_code, k };
assert_eq!(next_kmer.to_bytes(), b"CGTA");
}
}