zoe 0.0.31

A nightly library for viral genomics
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208

//! Byte mappings for nucleotides.

use crate::data::{
    ByteValidator,
    alphas::*,
    array_types::make_lowercase,
    mappings::{ByteIndexMap, ByteMap},
};

//
// Typically used by:   RetainSequence::retain_by_validation, std::slice::Iter::all
// Mapping:             u8 -> bool
//

/// A boolean mapping of valid IUPAC nucleotide codes without gaps.
pub(crate) const IS_DNA_IUPAC_NO_GAPS: ByteValidator = ByteValidator::none().add(DNA_IUPAC);

/// A boolean mapping of uppercase IUPAC nucleotide codes without gaps.
pub(crate) const IS_DNA_IUPAC_NO_GAPS_UC: ByteValidator = ByteValidator::none().add(DNA_IUPAC_UC);

/// A boolean mapping of all valid IUPAC nucleotide codes inluding gaps.
pub(crate) const IS_DNA_IUPAC_WITH_GAPS: ByteValidator = IS_DNA_IUPAC_NO_GAPS.add(b"-.");

/// A boolean mapping of uppercase IUPAC nucleotide codes including gaps.
pub(crate) const IS_DNA_IUPAC_WITH_GAPS_UC: ByteValidator = IS_DNA_IUPAC_NO_GAPS_UC.add(b"-.");

/// A boolean mapping of strictly canonical nucleotides + `n`/`N` without gaps.
pub(crate) const IS_DNA_ACGTN_NO_GAPS: ByteValidator = ByteValidator::none().add(DNA_ACGTN);

/// A boolean mapping of uppercase `ACGTN` bytes without gaps.
pub(crate) const IS_DNA_ACGTN_NO_GAPS_UC: ByteValidator = ByteValidator::none().add(DNA_ACGTN_UC);

/// A boolean mapping of uppercase `ACGTN-` bytes.
pub(crate) const IS_DNA_ACGTN_STD_GAPS_UC: ByteValidator = IS_DNA_ACGTN_NO_GAPS_UC.add(b"-");

/// A boolean mapping of `ACGT` bytes without gaps.
pub(crate) const IS_DNA_ACGT_NO_GAPS: ByteValidator = ByteValidator::none().add(b"acgtACGT");

/// A boolean mapping of uppercase `ACGT` bytes without gaps.
pub(crate) const IS_DNA_ACGT_NO_GAPS_UC: ByteValidator = ByteValidator::none().add(b"ACGT");

//
// Typically used by:   RetainSequence::retain_by_recoding
// Mapping:             u8 -> u8 else 0
//

/// Converts to uppercase IUPAC DNA without gaps. The 0-byte is used for
/// filtering out unwanted patterns.
pub const RETAIN_DNA_IUPAC_NO_GAPS_UC: ByteMap = ByteMap::all(0)
    .preserve(DNA_IUPAC_UC)
    .map(&make_lowercase(DNA_IUPAC_UC), DNA_IUPAC_UC)
    .map(b"Uu", b"TT");

/// Converts to uppercase IUPAC DNA with gaps preserved. The 0-byte is used for
/// filtering out unwanted patterns.
pub const RETAIN_DNA_IUPAC_WITH_GAPS_UC: ByteMap = RETAIN_DNA_IUPAC_NO_GAPS_UC.preserve(b".-");

/// Converts to uppercase `ACGTN` without gaps. The 0-byte is used for filtering
/// out unwanted patterns.
pub const RETAIN_DNA_ACGTN_NO_GAPS_UC: ByteMap = ByteMap::all(0)
    .preserve(DNA_ACGTN_UC)
    .map(&make_lowercase(DNA_ACGTN_UC), DNA_ACGTN_UC)
    .map(b"Uu", b"TT");

/// Converts to uppercase `ACGTN` with gaps preserved. The 0-byte is used for
/// filtering out unwanted patterns.
pub const RETAIN_DNA_ACGTN_WITH_GAPS_UC: ByteMap = RETAIN_DNA_ACGTN_NO_GAPS_UC.preserve(b".-");

/// Converts to uppercase IUPAC DNA with standard gaps preserved and
/// non-standard gaps corrected. The 0-byte is used for filtering out unwanted
/// patterns.
pub(crate) const RETAIN_DNA_IUPAC_CORRECT_GAPS_UC: ByteMap = RETAIN_DNA_IUPAC_WITH_GAPS_UC.map_to_one(b":~", b'-');

/// Converts to uppercase `ACGT` without gaps. The 0-byte is used for filtering
/// out unwanted patterns.
pub(crate) const RETAIN_DNA_ACGT_NO_GAPS_UC: ByteMap = RETAIN_DNA_ACGTN_NO_GAPS_UC.map_to_one(b"Nn", 0);

/// Converts to uppercase `ACGTN` with all gaps standardized to `-`. The 0-byte
/// is used for filtering out unwanted patterns.
pub(crate) const RETAIN_DNA_ACGTN_STD_GAPS_UC: ByteMap = RETAIN_DNA_ACGTN_WITH_GAPS_UC.map_to_one(b".-:~", b'-');

//
// Typically used by:   Recode::recode
// Mapping:             u8 -> u8 else self
//

/// Converts any IUPAC DNA to uppercase `ACGTN`.
pub(crate) const IUPAC_TO_DNA_ACGTN_UC: ByteMap = ByteMap::identity()
    .map(&make_lowercase(DNA_IUPAC_UC), DNA_IUPAC_UC)
    .map(b"Uu", b"TT")
    .map_to_one(b"RYSWKMBDHVN", b'N')
    .map_to_one(b"ryswkmbdhvn", b'N');

/// Converts any IUPAC DNA to `ACGTN`.
pub(crate) const IUPAC_TO_DNA_ACGTN: ByteMap = ByteMap::identity()
    .map(b"Uu", b"Tt")
    .map_to_one(b"RYSWKMBDHVN", b'N')
    .map_to_one(b"ryswkmbdhvn", b'n');

/// Maps bytes to themselves but valid IUPAC nucleotides to their complements.
#[rustfmt::skip]
pub(crate) const TO_COMPLEMENT: ByteMap = ByteMap::identity()
    .map(
        b"GCATRYKMBVDHU",
        b"CGTAYRMKVBHDA"
    ).map(
        b"gcatrykmbvdhu", 
        b"cgtayrmkvbhda"
    );

//
// Typically used by:   Recode::recode
// Mapping:             u8 -> u8 else default
//

/// Converts to uppercase `ACGTN` without gaps. `N` is used for invalid data.
pub const RECODE_TO_DNA_ACGTN_NO_GAPS_UC: ByteMap = ByteMap::all(b'N')
    .preserve(DNA_ACGTN_UC)
    .map(&make_lowercase(DNA_ACGTN_UC), DNA_ACGTN_UC)
    .map(b"Uu", b"TT");

/// Converts to uppercase `ACGTN` with gaps preserved. `N` is used for invalid
/// data.
pub const RECODE_TO_DNA_ACGTN_WITH_GAPS_UC: ByteMap = RECODE_TO_DNA_ACGTN_NO_GAPS_UC.preserve(b".-");

/// Converts to `ACGTN` without gaps while preserving case. Capital `N` is used
/// for invalid data.
pub const RECODE_TO_DNA_ACGTN_NO_GAPS: ByteMap = ByteMap::all(b'N')
    .preserve(DNA_ACGTN_UC)
    .preserve(&make_lowercase(DNA_ACGTN_UC))
    .map(b"Uu", b"Tt");

/// Converts to `ACGTN` with gaps and case preserved. Capital `N` is used for
/// invalid data.
pub const RECODE_TO_DNA_ACGTN_WITH_GAPS: ByteMap = RECODE_TO_DNA_ACGTN_NO_GAPS.preserve(b".-");

/// Converts to uppercase IUPAC DNA without gaps. `N` is used for invalid data.
pub const RECODE_TO_DNA_IUPAC_NO_GAPS_UC: ByteMap = ByteMap::all(b'N')
    .preserve(DNA_IUPAC_UC)
    .map(&make_lowercase(DNA_IUPAC_UC), DNA_IUPAC_UC)
    .map(b"Uu", b"TT");

/// Converts to uppercase IUPAC DNA with gaps preserved. `N` is used for invalid
/// data.
pub const RECODE_TO_DNA_IUPAC_WITH_GAPS_UC: ByteMap = RECODE_TO_DNA_IUPAC_NO_GAPS_UC.preserve(b".-");

/// Converts to IUPAC DNA without gaps while preserving case. Capital `N` is
/// used for invalid data.
pub const RECODE_TO_DNA_IUPAC_NO_GAPS: ByteMap = ByteMap::all(b'N')
    .preserve(DNA_IUPAC_UC)
    .preserve(&make_lowercase(DNA_IUPAC_UC))
    .map(b"Uu", b"Tt");

/// Converts to IUPAC DNA with gaps and case preserved. Capital `N` is used for
/// invalid data.
pub const RECODE_TO_DNA_IUPAC_WITH_GAPS: ByteMap = RECODE_TO_DNA_IUPAC_NO_GAPS.preserve(b".-");

/// Converts any byte to RNA while preserving case, replacing `T` with `U`.
/// Capital `N` is used for invalid data.
pub(crate) const TO_RNA: ByteMap = ByteMap::all(b'N').preserve(b"ACGUNacgun").map(b"Tt", b"Uu");

/// Converts any byte to uppercase RNA, replacing `T` with `U`. `N` is used for
/// invalid data.
pub(crate) const TO_RNA_UC: ByteMap = ByteMap::all(b'N').map(b"ACGUT", b"ACGUU").map(b"acgut", b"ACGUU");

/// Converts to upprecase IUPAC DNA, allowing for and correcting non-standard
/// gaps. `N` is used for invalid data.
pub(crate) const RECODE_TO_DNA_IUPAC_CORRECT_GAPS_UC: ByteMap = RECODE_TO_DNA_IUPAC_WITH_GAPS_UC.map(b":~", b"--");

//
// Typically used by:   ByteIndexMap
// Mapping:             u8 -> usize
//

/// Used to convert any byte to `u8` indices where {0: A, 1: C, 2: G, 3: T, 4: N}.
/// N is used as a catch-all. U is treated as T.
pub const DNA_PROFILE_MAP: ByteIndexMap<5> =
    ByteIndexMap::new_ignoring_case(*b"ACGTN", b'N').add_synonym_ignore_case(b'U', b'T');

/// Used to convert any byte to `u8` indices where {0: A, 1: C, 2: G, 3: T}.
/// A is used as a catch-all. U is treated as T.
pub const DNA_UNAMBIG_PROFILE_MAP: ByteIndexMap<4> =
    ByteIndexMap::new_ignoring_case(*b"ACGT", b'A').add_synonym_ignore_case(b'U', b'T');

/// Used by [`ThreeBitKmerEncoder`] to convert any byte to `u8` indices where
/// {3: N, 4: A, 5: C, 6: G, 7: T}. N is used as a catch-all. U is treated as T.
///
/// [`ThreeBitKmerEncoder`]:
///     crate::kmer::encoders::three_bit::ThreeBitKmerEncoder
pub(crate) const THREE_BIT_MAPPING: ByteMap = ByteMap::all(3)
    .map(b"ACG", &[4, 5, 6])
    .map(b"acg", &[4, 5, 6])
    .map_to_one(b"TUtu", 7);

/// Used by [`TwoBitKmerEncoder`] to convert any byte to `u8` indices where {0:
/// A, 1: C, 2: G, 3: T}. A is used as a catch-all. U is treated as T.
///
/// [`TwoBitKmerEncoder`]: crate::kmer::encoders::two_bit::TwoBitKmerEncoder
pub(crate) const TWO_BIT_MAPPING: ByteMap = ByteMap::all(0).map(b"CG", &[1, 2]).map(b"cg", &[1, 2]).map_to_one(b"TUtu", 3);

/// Used to convert any byte to `u8` indices where {0: A, 1: C, 2: G, 3: T, 4:
/// N, 5: Gap, 6: Other IUPAC, 7: Invalid}. U is treated as T.
pub(crate) const DNA_COUNT_PROFILE_MAP: ByteMap = ByteMap::all(7)
    .map_to_one(DNA_IUPAC, 6)
    .map(b".", &[6])
    .map(b"-", &[5])
    .map(b"ACGTUN", &[0, 1, 2, 3, 3, 4])
    .map(b"acgtun", &[0, 1, 2, 3, 3, 4]);