use crate::error::{BarracudaError, Result as BarracudaResult};
use std::collections::HashSet;
#[derive(Debug, Clone)]
pub struct SequenceConfig {
pub complexity_window: usize,
pub min_unique_bases: usize,
pub parallel_batch: bool,
}
impl Default for SequenceConfig {
fn default() -> Self {
Self {
complexity_window: 10,
min_unique_bases: 2,
parallel_batch: true,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Region {
pub start: usize,
pub end: usize,
pub annotation: String,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct NucleotideCounts {
pub a: usize,
pub t: usize,
pub g: usize,
pub c: usize,
pub n: usize,
}
#[derive(Debug, Clone)]
pub struct CompositionReport {
pub gc_content: f32,
pub length: usize,
pub low_complexity_regions: Vec<Region>,
pub nucleotide_counts: NucleotideCounts,
}
#[derive(Debug, Clone)]
pub struct MotifMatch {
pub pattern: Vec<u8>,
pub positions: Vec<usize>,
pub count: usize,
}
#[derive(Debug, Clone)]
pub struct QualityReport {
pub passes: bool,
pub low_complexity_fraction: f32,
pub gc_content: f32,
pub n_count: usize,
pub issues: Vec<String>,
}
pub struct SequenceAnalyzer {
config: SequenceConfig,
}
impl SequenceAnalyzer {
#[must_use]
pub fn new(config: SequenceConfig) -> Self {
Self { config }
}
#[must_use]
pub fn gc_content(&self, sequence: &[u8]) -> f32 {
if sequence.is_empty() {
return 0.0;
}
let gc_count = sequence
.iter()
.filter(|&&b| matches!(b.to_ascii_uppercase(), b'G' | b'C'))
.count();
gc_count as f32 / sequence.len() as f32
}
#[must_use]
pub fn find_low_complexity_regions(&self, sequence: &[u8]) -> Vec<Region> {
let mut regions = Vec::new();
if sequence.len() < self.config.complexity_window {
return regions;
}
let mut in_region = false;
let mut region_start = 0;
for (i, window) in sequence.windows(self.config.complexity_window).enumerate() {
let unique_bases: HashSet<u8> =
window.iter().map(|&b| b.to_ascii_uppercase()).collect();
let is_low_complexity = unique_bases.len() < self.config.min_unique_bases;
if is_low_complexity && !in_region {
in_region = true;
region_start = i;
} else if !is_low_complexity && in_region {
in_region = false;
regions.push(Region {
start: region_start,
end: i,
annotation: "low_complexity".to_string(),
});
}
}
if in_region {
regions.push(Region {
start: region_start,
end: sequence.len(),
annotation: "low_complexity".to_string(),
});
}
regions
}
#[must_use]
pub fn count_nucleotides(&self, sequence: &[u8]) -> NucleotideCounts {
let mut counts = NucleotideCounts::default();
for &base in sequence {
match base.to_ascii_uppercase() {
b'A' => counts.a += 1,
b'T' | b'U' => counts.t += 1,
b'G' => counts.g += 1,
b'C' => counts.c += 1,
b'N' => counts.n += 1,
_ => {} }
}
counts
}
pub fn analyze_composition(&self, sequence: &[u8]) -> BarracudaResult<CompositionReport> {
if sequence.is_empty() {
return Err(BarracudaError::InvalidInput {
message: "Sequence cannot be empty".to_string(),
});
}
let gc_content = self.gc_content(sequence);
let low_complexity_regions = self.find_low_complexity_regions(sequence);
let nucleotide_counts = self.count_nucleotides(sequence);
Ok(CompositionReport {
gc_content,
length: sequence.len(),
low_complexity_regions,
nucleotide_counts,
})
}
#[must_use]
pub fn find_pattern(&self, sequence: &[u8], pattern: &[u8]) -> Vec<usize> {
if pattern.is_empty() || pattern.len() > sequence.len() {
return Vec::new();
}
let mut positions = Vec::new();
for (i, window) in sequence.windows(pattern.len()).enumerate() {
let matches = window
.iter()
.zip(pattern.iter())
.all(|(&a, &b)| a.eq_ignore_ascii_case(&b));
if matches {
positions.push(i);
}
}
positions
}
pub fn find_motifs(
&self,
sequence: &[u8],
patterns: &[&[u8]],
) -> BarracudaResult<Vec<MotifMatch>> {
if sequence.is_empty() {
return Err(BarracudaError::InvalidInput {
message: "Sequence cannot be empty".to_string(),
});
}
if patterns.is_empty() {
return Err(BarracudaError::InvalidInput {
message: "At least one pattern required".to_string(),
});
}
let mut matches = Vec::new();
for pattern in patterns {
if pattern.is_empty() {
continue;
}
let positions = self.find_pattern(sequence, pattern);
matches.push(MotifMatch {
pattern: pattern.to_vec(),
positions: positions.clone(),
count: positions.len(),
});
}
Ok(matches)
}
#[must_use]
pub fn find_motifs_batch(
&self,
sequences: &[&[u8]],
patterns: &[&[u8]],
) -> Vec<BarracudaResult<Vec<MotifMatch>>> {
if self.config.parallel_batch {
use rayon::prelude::*;
sequences
.par_iter()
.map(|seq| self.find_motifs(seq, patterns))
.collect()
} else {
sequences
.iter()
.map(|seq| self.find_motifs(seq, patterns))
.collect()
}
}
pub fn quality_filter(&self, sequence: &[u8]) -> BarracudaResult<QualityReport> {
if sequence.is_empty() {
return Ok(QualityReport {
passes: false,
low_complexity_fraction: 0.0,
gc_content: 0.0,
n_count: 0,
issues: vec!["Empty sequence".to_string()],
});
}
let composition = self.analyze_composition(sequence)?;
let low_complexity_bases: usize = composition
.low_complexity_regions
.iter()
.map(|r| r.end - r.start)
.sum();
let low_complexity_fraction = low_complexity_bases as f32 / sequence.len() as f32;
let mut issues = Vec::new();
if sequence.len() < 50 {
issues.push("Sequence too short (< 50 bp)".to_string());
}
if low_complexity_fraction > 0.5 {
issues.push(format!(
"High low-complexity content: {:.1}%",
low_complexity_fraction * 100.0
));
}
if composition.gc_content < 0.2 || composition.gc_content > 0.8 {
issues.push(format!("GC bias: {:.1}%", composition.gc_content * 100.0));
}
if composition.nucleotide_counts.n > sequence.len() / 10 {
issues.push(format!(
"Too many N bases: {}",
composition.nucleotide_counts.n
));
}
let passes = sequence.len() >= 50
&& low_complexity_fraction <= 0.5
&& composition.nucleotide_counts.n <= sequence.len() / 10;
Ok(QualityReport {
passes,
low_complexity_fraction,
gc_content: composition.gc_content,
n_count: composition.nucleotide_counts.n,
issues,
})
}
#[must_use]
pub fn quality_filter_batch(&self, sequences: &[&[u8]]) -> Vec<BarracudaResult<QualityReport>> {
if self.config.parallel_batch {
use rayon::prelude::*;
sequences
.par_iter()
.map(|seq| self.quality_filter(seq))
.collect()
} else {
sequences
.iter()
.map(|seq| self.quality_filter(seq))
.collect()
}
}
#[must_use]
pub fn gc_content_batch(&self, sequences: &[&[u8]]) -> Vec<f32> {
if self.config.parallel_batch {
use rayon::prelude::*;
sequences
.par_iter()
.map(|seq| self.gc_content(seq))
.collect()
} else {
sequences.iter().map(|seq| self.gc_content(seq)).collect()
}
}
}
#[cfg(test)]
#[path = "genomics_tests.rs"]
mod tests;