papasmurf 0.1.1

Platform-Accelerated Package for Alignment-free SMURF analysis.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

mod builder;
mod kmers;
mod mapper;

use serde::Deserialize;
use serde::Serialize;

use crate::matrix::CsrMatrix;
use crate::matrix::MatrixDimensions;
use crate::primer::Primer;
use crate::utils::OrderedSet;
use crate::utils::Paired;
use crate::utils::Rc;

pub use self::builder::Builder;
pub use self::kmers::Kmers;
pub use self::mapper::Mapper;
pub use self::mapper::MapperResult;

#[derive(Debug, Clone, Serialize, Deserialize)]
struct UnindexedRegion {
    /// The pair of primers defining this region in the database.
    primer: Paired<Primer>,
    /// The set of unique k-mer pairs in this region.
    unique_pairs: OrderedSet<Paired<usize>>,
    /// The set of forward and backward k-mers in this region.
    unique_kmers: Paired<OrderedSet<Rc<str>>>,
    /// A sparse matrix storing the k-mer pair for each database reference.
    matrix: CsrMatrix<f32>,
}

impl From<UnindexedRegion> for Region {
    fn from(region: UnindexedRegion) -> Self {
        let _k = region
            .unique_kmers
            .forward
            .iter()
            .next()
            .map(|kmer| kmer.len())
            .unwrap_or_default();
        let block = region
            .unique_kmers
            .map(|kmers| Kmers::new(kmers.iter().map(|r| r.as_bytes())).unwrap());
        Self {
            primer: region.primer,
            unique_pairs: region.unique_pairs,
            matrix: region.matrix,
            block,
        }
    }
}

impl From<Region> for UnindexedRegion {
    fn from(region: Region) -> Self {
        let unique_kmers = region.block.map(|kmers| {
            let mut unique_kmers = Vec::with_capacity(kmers.columns());
            let mut s = String::with_capacity(kmers.rows());
            for j in 0..kmers.columns() {
                s.clear();
                for i in 0..kmers.rows() {
                    s.push(kmers[i][j] as char);
                }
                unique_kmers.push(Rc::from(s.as_str()));
            }
            unique_kmers.into()
        });
        Self {
            primer: region.primer,
            unique_pairs: region.unique_pairs,
            unique_kmers,
            matrix: region.matrix,
        }
    }
}

/// A single 16S region from a database, defined by a pair of primers.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(from = "UnindexedRegion", into = "UnindexedRegion")]
pub struct Region {
    /// The pair of primers defining this region in the database.
    primer: Paired<Primer>,
    /// The set of unique k-mer pairs in this region.
    unique_pairs: OrderedSet<Paired<usize>>,
    /// A pair of blocks storing the unique kmers for the forward and backward region.
    block: Paired<Kmers>,
    /// A sparse matrix storing the k-mer pair for each database reference.
    matrix: CsrMatrix<f32>,
}

impl Region {
    /// Get a reference to the primer pair used to define this region.
    #[inline]
    pub fn primer(&self) -> &Paired<Primer> {
        &self.primer
    }

    /// Get a reference to the reference matrix for this region, `M`.
    #[inline]
    pub fn matrix(&self) -> &CsrMatrix<f32> {
        &self.matrix
    }
}

/// A database storing forward and backward k-mers for each region.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Database {
    /// The size of the k-mers to extract from the reference sequences.
    k: usize,
    /// The regions this database contains.
    regions: Vec<Region>,
    /// The identifiers of the individual references in the database.
    names: OrderedSet<Rc<str>>,
    /// The number of k-mers extracted from each database reference (R vector).
    amplified: Vec<u8>,
}

impl Database {
    /// Get the length of the k-mers stored in the database.
    #[inline]
    pub fn k(&self) -> usize {
        self.k
    }

    /// Get a reference to the names of the database members.
    #[inline]
    pub fn names(&self) -> &[Rc<str>] {
        self.names.as_slice()
    }

    /// Get a reference to the regions stored in the database.
    #[inline]
    pub fn regions(&self) -> &[Region] {
        self.regions.as_slice()
    }
}

impl AsRef<Database> for &Database {
    #[inline]
    fn as_ref(&self) -> &Database {
        *self
    }
}

impl AsRef<[Region]> for &Database {
    #[inline]
    fn as_ref(&self) -> &[Region] {
        self.regions()
    }
}