compact_genome/implementation/
bit_vec_sequence.rs

1//! A representation of a genome as `Vec<usize>` where each character is encoded as bits.
2
3use crate::interface::alphabet::{Alphabet, AlphabetCharacter};
4use crate::interface::sequence::{EditableGenomeSequence, GenomeSequence, OwnedGenomeSequence};
5use bitvec::prelude::*;
6use ref_cast::RefCast;
7use std::borrow::Borrow;
8use std::hash::Hash;
9use std::iter::FromIterator;
10use std::marker::PhantomData;
11use std::mem;
12use std::ops::{Index, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive};
13use traitsequence::interface::{EditableSequence, OwnedSequence, Sequence};
14
15/// A genome sequence stored as vector of minimum-bit characters.
16#[derive(Debug)]
17pub struct BitVectorGenome<AlphabetType: Alphabet, BitStoreType = usize>
18where
19    BitStoreType: BitStore,
20{
21    phantom_data: PhantomData<AlphabetType>,
22    /// Stores the sequence as minimum-bit characters.
23    pub(crate) bits: BitVec<BitStoreType>,
24}
25
26/// The subsequence of a genome sequence stored as vector of minimum-bit characters.
27#[derive(RefCast, Debug, Eq, PartialEq, Hash)]
28#[repr(transparent)]
29pub struct BitVectorSubGenome<AlphabetType: Alphabet, BitStoreType = usize>
30where
31    BitStoreType: BitStore,
32{
33    phantom_data: PhantomData<AlphabetType>,
34    pub(crate) bits: BitSlice<BitStoreType>,
35}
36
37/// An iterator over a [BitVectorGenome].
38pub struct BitVectorGenomeIterator<AlphabetType: Alphabet, BitStoreType = usize>
39where
40    BitStoreType: BitStore,
41{
42    current: usize,
43    sequence: BitVectorGenome<AlphabetType, BitStoreType>,
44}
45
46/// An iterator over a [BitVectorSubGenome].
47pub struct BitVectorSubGenomeIterator<'a, AlphabetType: Alphabet, BitStoreType = usize>
48where
49    BitStoreType: BitStore,
50{
51    slice: &'a BitVectorSubGenome<AlphabetType, BitStoreType>,
52}
53
54impl<AlphabetType: Alphabet, BitStoreType: BitStore> BitVectorGenome<AlphabetType, BitStoreType> {
55    /// Returns the amount of memory this genome sequence uses in bytes.
56    /// This is meant to be accurate, but might be off by a constant number of bytes.
57    pub fn size_in_memory(&self) -> usize {
58        std::mem::size_of::<BitVec>() + self.bits.capacity() / 8
59    }
60}
61
62impl<AlphabetType: Alphabet, BitStoreType: BitStore>
63    Sequence<AlphabetType::CharacterType, BitVectorSubGenome<AlphabetType, BitStoreType>>
64    for BitVectorGenome<AlphabetType, BitStoreType>
65{
66    type Iterator<'a>
67        = BitVectorSubGenomeIterator<'a, AlphabetType, BitStoreType>
68    where
69        AlphabetType: 'a;
70
71    fn iter(&self) -> Self::Iterator<'_> {
72        self.as_genome_subsequence().iter()
73    }
74
75    fn len(&self) -> usize {
76        self.as_genome_subsequence().len()
77    }
78}
79
80impl<AlphabetType: Alphabet, BitStoreType: BitStore>
81    Sequence<AlphabetType::CharacterType, BitVectorSubGenome<AlphabetType, BitStoreType>>
82    for BitVectorSubGenome<AlphabetType, BitStoreType>
83{
84    type Iterator<'a>
85        = BitVectorSubGenomeIterator<'a, AlphabetType, BitStoreType>
86    where
87        AlphabetType: 'a;
88
89    fn iter(&self) -> Self::Iterator<'_> {
90        BitVectorSubGenomeIterator { slice: self }
91    }
92
93    fn len(&self) -> usize {
94        self.bits.len() / alphabet_character_bit_width(AlphabetType::SIZE)
95    }
96}
97
98impl<AlphabetType: Alphabet, BitStoreType: BitStore>
99    EditableSequence<AlphabetType::CharacterType, BitVectorSubGenome<AlphabetType, BitStoreType>>
100    for BitVectorGenome<AlphabetType, BitStoreType>
101{
102    fn set(&mut self, index: usize, character: <AlphabetType as Alphabet>::CharacterType) {
103        let bit_width = alphabet_character_bit_width(AlphabetType::SIZE);
104        let value = character.index();
105        self.bits[index * bit_width..(index + 1) * bit_width]
106            .clone_from_bitslice(&value.view_bits::<Lsb0>()[0..bit_width]);
107    }
108
109    fn split_off(&mut self, at: usize) -> Self {
110        Self {
111            phantom_data: self.phantom_data,
112            bits: self.bits.split_off(at),
113        }
114    }
115
116    fn reserve(&mut self, additional: usize) {
117        let bit_width = alphabet_character_bit_width(AlphabetType::SIZE);
118        self.bits.reserve(additional * bit_width)
119    }
120
121    fn resize(&mut self, new_len: usize, default: AlphabetType::CharacterType) {
122        let bit_width = alphabet_character_bit_width(AlphabetType::SIZE);
123        if self.len() >= new_len {
124            self.bits.resize(new_len * bit_width, false);
125        } else {
126            let difference = new_len - self.len();
127            let value = default.index();
128            for _ in 0..difference {
129                self.bits
130                    .extend_from_bitslice(&value.view_bits::<Lsb0>()[0..bit_width]);
131            }
132        }
133    }
134
135    fn resize_with(
136        &mut self,
137        new_len: usize,
138        mut generator: impl FnMut() -> AlphabetType::CharacterType,
139    ) {
140        let bit_width = alphabet_character_bit_width(AlphabetType::SIZE);
141        if self.len() >= new_len {
142            self.bits.resize(new_len * bit_width, false);
143        } else {
144            let difference = new_len - self.len();
145            let value = generator().index();
146            for _ in 0..difference {
147                self.bits
148                    .extend_from_bitslice(&value.view_bits::<Lsb0>()[0..bit_width]);
149            }
150        }
151    }
152
153    fn push(&mut self, character: AlphabetType::CharacterType) {
154        let bit_width = alphabet_character_bit_width(AlphabetType::SIZE);
155        let value = character.index();
156        self.bits
157            .extend_from_bitslice(&value.view_bits::<Lsb0>()[0..bit_width])
158    }
159
160    fn splice(
161        &mut self,
162        range: Range<usize>,
163        replace_with: impl IntoIterator<Item = AlphabetType::CharacterType>,
164    ) {
165        assert!(range.end <= self.len());
166
167        let suffix: Self = self.iter().skip(range.end).cloned().collect();
168        self.resize_with(range.start, || unreachable!());
169        self.extend(replace_with);
170        self.extend(suffix);
171
172        // Bitvec's splice implementation is broken: https://github.com/ferrilab/bitvec/issues/280
173        /*
174        let bit_width = alphabet_character_bit_width(AlphabetType::SIZE);
175
176        self.bits.splice(
177            range.start * bit_width..range.end * bit_width,
178            replace_with.into_iter().flat_map(|character| {
179                let index = character.index();
180                let array = BitArray::<_, Lsb0>::from(index);
181                array.into_iter().take(bit_width)
182            }),
183        ); */
184    }
185}
186
187impl<AlphabetType: Alphabet, BitStoreType: BitStore> Index<Range<usize>>
188    for BitVectorGenome<AlphabetType, BitStoreType>
189{
190    type Output = BitVectorSubGenome<AlphabetType, BitStoreType>;
191
192    fn index(&self, index: Range<usize>) -> &Self::Output {
193        self.as_genome_subsequence().index(index)
194    }
195}
196
197impl<AlphabetType: Alphabet, BitStoreType: BitStore> Index<RangeFrom<usize>>
198    for BitVectorGenome<AlphabetType, BitStoreType>
199{
200    type Output = BitVectorSubGenome<AlphabetType, BitStoreType>;
201
202    fn index(&self, index: RangeFrom<usize>) -> &Self::Output {
203        self.as_genome_subsequence().index(index)
204    }
205}
206
207impl<AlphabetType: Alphabet, BitStoreType: BitStore> Index<RangeTo<usize>>
208    for BitVectorGenome<AlphabetType, BitStoreType>
209{
210    type Output = BitVectorSubGenome<AlphabetType, BitStoreType>;
211
212    fn index(&self, index: RangeTo<usize>) -> &Self::Output {
213        self.as_genome_subsequence().index(index)
214    }
215}
216
217impl<AlphabetType: Alphabet, BitStoreType: BitStore> Index<RangeFull>
218    for BitVectorGenome<AlphabetType, BitStoreType>
219{
220    type Output = BitVectorSubGenome<AlphabetType, BitStoreType>;
221
222    fn index(&self, index: RangeFull) -> &Self::Output {
223        self.as_genome_subsequence().index(index)
224    }
225}
226
227impl<AlphabetType: Alphabet, BitStoreType: BitStore> Index<RangeInclusive<usize>>
228    for BitVectorGenome<AlphabetType, BitStoreType>
229{
230    type Output = BitVectorSubGenome<AlphabetType, BitStoreType>;
231
232    fn index(&self, index: RangeInclusive<usize>) -> &Self::Output {
233        self.as_genome_subsequence().index(index)
234    }
235}
236
237impl<AlphabetType: Alphabet, BitStoreType: BitStore> Index<RangeToInclusive<usize>>
238    for BitVectorGenome<AlphabetType, BitStoreType>
239{
240    type Output = BitVectorSubGenome<AlphabetType, BitStoreType>;
241
242    fn index(&self, index: RangeToInclusive<usize>) -> &Self::Output {
243        self.as_genome_subsequence().index(index)
244    }
245}
246
247impl<AlphabetType: Alphabet, BitStoreType: BitStore> Index<usize>
248    for BitVectorGenome<AlphabetType, BitStoreType>
249{
250    type Output = AlphabetType::CharacterType;
251
252    fn index(&self, index: usize) -> &Self::Output {
253        self.as_genome_subsequence().index(index)
254    }
255}
256
257impl<AlphabetType: Alphabet, BitStoreType: BitStore> Index<Range<usize>>
258    for BitVectorSubGenome<AlphabetType, BitStoreType>
259{
260    type Output = BitVectorSubGenome<AlphabetType, BitStoreType>;
261
262    fn index(&self, index: Range<usize>) -> &Self::Output {
263        let bit_width = alphabet_character_bit_width(AlphabetType::SIZE);
264        BitVectorSubGenome::ref_cast(&self.bits[index.start * bit_width..index.end * bit_width])
265    }
266}
267
268impl<AlphabetType: Alphabet, BitStoreType: BitStore> Index<RangeFrom<usize>>
269    for BitVectorSubGenome<AlphabetType, BitStoreType>
270{
271    type Output = BitVectorSubGenome<AlphabetType, BitStoreType>;
272
273    fn index(&self, index: RangeFrom<usize>) -> &Self::Output {
274        self.index(index.start..self.len())
275    }
276}
277
278impl<AlphabetType: Alphabet, BitStoreType: BitStore> Index<RangeTo<usize>>
279    for BitVectorSubGenome<AlphabetType, BitStoreType>
280{
281    type Output = BitVectorSubGenome<AlphabetType, BitStoreType>;
282
283    fn index(&self, index: RangeTo<usize>) -> &Self::Output {
284        self.index(0..index.end)
285    }
286}
287
288impl<AlphabetType: Alphabet, BitStoreType: BitStore> Index<RangeFull>
289    for BitVectorSubGenome<AlphabetType, BitStoreType>
290{
291    type Output = BitVectorSubGenome<AlphabetType, BitStoreType>;
292
293    fn index(&self, _index: RangeFull) -> &Self::Output {
294        self.index(0..self.len())
295    }
296}
297
298impl<AlphabetType: Alphabet, BitStoreType: BitStore> Index<RangeInclusive<usize>>
299    for BitVectorSubGenome<AlphabetType, BitStoreType>
300{
301    type Output = BitVectorSubGenome<AlphabetType, BitStoreType>;
302
303    fn index(&self, index: RangeInclusive<usize>) -> &Self::Output {
304        let bit_width = alphabet_character_bit_width(AlphabetType::SIZE);
305        BitVectorSubGenome::ref_cast(
306            &self.bits[index.start() * bit_width..=index.end() * bit_width],
307        )
308    }
309}
310
311impl<AlphabetType: Alphabet, BitStoreType: BitStore> Index<RangeToInclusive<usize>>
312    for BitVectorSubGenome<AlphabetType, BitStoreType>
313{
314    type Output = BitVectorSubGenome<AlphabetType, BitStoreType>;
315
316    fn index(&self, index: RangeToInclusive<usize>) -> &Self::Output {
317        self.index(0..=index.end)
318    }
319}
320
321impl<AlphabetType: Alphabet, BitStoreType: BitStore> Index<usize>
322    for BitVectorSubGenome<AlphabetType, BitStoreType>
323{
324    type Output = AlphabetType::CharacterType;
325
326    fn index(&self, index: usize) -> &Self::Output {
327        let bit_width = alphabet_character_bit_width(AlphabetType::SIZE);
328        let offset = index * bit_width;
329        let limit = (index + 1) * bit_width;
330        let value: u8 = self.bits[offset..limit].load();
331        Self::Output::from_index_ref(value).expect("bitvec contains invalid character")
332    }
333}
334
335impl<AlphabetType: Alphabet, BitStoreType: BitStore> FromIterator<AlphabetType::CharacterType>
336    for BitVectorGenome<AlphabetType, BitStoreType>
337{
338    fn from_iter<T: IntoIterator<Item = AlphabetType::CharacterType>>(iter: T) -> Self {
339        let mut result = Self::default();
340        result.extend(iter);
341        result
342    }
343}
344
345impl<AlphabetType: Alphabet, BitStoreType: BitStore> Extend<AlphabetType::CharacterType>
346    for BitVectorGenome<AlphabetType, BitStoreType>
347{
348    fn extend<T: IntoIterator<Item = AlphabetType::CharacterType>>(&mut self, iter: T) {
349        let iter = iter.into_iter();
350        let (size, _) = iter.size_hint();
351        let bit_width = alphabet_character_bit_width(AlphabetType::SIZE);
352        self.bits.reserve(size * bit_width);
353
354        for character in iter {
355            let value = character.index();
356            self.bits
357                .extend_from_bitslice(&value.view_bits::<Lsb0>()[0..bit_width]);
358        }
359    }
360}
361
362impl<AlphabetType: Alphabet, BitStoreType: BitStore> IntoIterator
363    for BitVectorGenome<AlphabetType, BitStoreType>
364{
365    type Item = AlphabetType::CharacterType;
366    type IntoIter = BitVectorGenomeIterator<AlphabetType, BitStoreType>;
367
368    fn into_iter(self) -> Self::IntoIter {
369        BitVectorGenomeIterator {
370            sequence: self,
371            current: 0,
372        }
373    }
374}
375
376impl<AlphabetType: Alphabet, BitStoreType: BitStore> Iterator
377    for BitVectorGenomeIterator<AlphabetType, BitStoreType>
378{
379    type Item = AlphabetType::CharacterType;
380
381    fn next(&mut self) -> Option<Self::Item> {
382        if self.current < self.sequence.len() {
383            let result = self.sequence[self.current].clone();
384            self.current += 1;
385            Some(result)
386        } else {
387            None
388        }
389    }
390}
391
392impl<'iter, AlphabetType: Alphabet, BitStoreType: BitStore> Iterator
393    for BitVectorSubGenomeIterator<'iter, AlphabetType, BitStoreType>
394{
395    type Item = &'iter AlphabetType::CharacterType;
396
397    fn next(&mut self) -> Option<Self::Item> {
398        if self.slice.len() > 0 {
399            let result = &self.slice[0];
400            self.slice = &self.slice[1..self.slice.len()];
401            Some(result)
402        } else {
403            None
404        }
405    }
406}
407
408impl<AlphabetType: Alphabet, BitStoreType: BitStore> DoubleEndedIterator
409    for BitVectorSubGenomeIterator<'_, AlphabetType, BitStoreType>
410{
411    fn next_back(&mut self) -> Option<Self::Item> {
412        if self.slice.len() > 0 {
413            let result = &self.slice[self.slice.len() - 1];
414            self.slice = &self.slice[0..self.slice.len() - 1];
415            Some(result)
416        } else {
417            None
418        }
419    }
420}
421
422impl<AlphabetType: Alphabet, BitStoreType: BitStore>
423    Borrow<BitVectorSubGenome<AlphabetType, BitStoreType>>
424    for BitVectorGenome<AlphabetType, BitStoreType>
425{
426    fn borrow(&self) -> &BitVectorSubGenome<AlphabetType, BitStoreType> {
427        self.as_genome_subsequence()
428    }
429}
430
431impl<AlphabetType: Alphabet, BitStoreType: BitStore> ToOwned
432    for BitVectorSubGenome<AlphabetType, BitStoreType>
433{
434    type Owned = BitVectorGenome<AlphabetType, BitStoreType>;
435
436    fn to_owned(&self) -> Self::Owned {
437        self.iter().cloned().collect()
438    }
439}
440
441impl<AlphabetType: Alphabet, BitStoreType: BitStore>
442    GenomeSequence<AlphabetType, BitVectorSubGenome<AlphabetType, BitStoreType>>
443    for BitVectorGenome<AlphabetType, BitStoreType>
444{
445    fn as_genome_subsequence(&self) -> &BitVectorSubGenome<AlphabetType, BitStoreType> {
446        BitVectorSubGenome::ref_cast(&self.bits[..])
447    }
448}
449
450impl<AlphabetType: Alphabet, BitStoreType: BitStore>
451    OwnedGenomeSequence<AlphabetType, BitVectorSubGenome<AlphabetType, BitStoreType>>
452    for BitVectorGenome<AlphabetType, BitStoreType>
453{
454}
455
456impl<AlphabetType: Alphabet, BitStoreType: BitStore>
457    EditableGenomeSequence<AlphabetType, BitVectorSubGenome<AlphabetType, BitStoreType>>
458    for BitVectorGenome<AlphabetType, BitStoreType>
459{
460}
461
462impl<AlphabetType: Alphabet, BitStoreType: BitStore>
463    GenomeSequence<AlphabetType, BitVectorSubGenome<AlphabetType, BitStoreType>>
464    for BitVectorSubGenome<AlphabetType, BitStoreType>
465{
466}
467
468impl<AlphabetType: Alphabet, BitStoreType: BitStore>
469    OwnedSequence<AlphabetType::CharacterType, BitVectorSubGenome<AlphabetType, BitStoreType>>
470    for BitVectorGenome<AlphabetType, BitStoreType>
471{
472}
473
474impl<AlphabetType: Alphabet, BitStoreType: BitStore> Default
475    for BitVectorGenome<AlphabetType, BitStoreType>
476{
477    fn default() -> Self {
478        Self {
479            phantom_data: Default::default(),
480            bits: Default::default(),
481        }
482    }
483}
484
485impl<AlphabetType: Alphabet, BitStoreType: BitStore> Clone
486    for BitVectorGenome<AlphabetType, BitStoreType>
487{
488    fn clone(&self) -> Self {
489        Self {
490            phantom_data: PhantomData,
491            bits: self.bits.clone(),
492        }
493    }
494}
495
496impl<AlphabetType: Alphabet, BitStoreType: BitStore> Eq
497    for BitVectorGenome<AlphabetType, BitStoreType>
498{
499}
500
501impl<AlphabetType: Alphabet, BitStoreType: BitStore> PartialEq
502    for BitVectorGenome<AlphabetType, BitStoreType>
503{
504    fn eq(&self, other: &Self) -> bool {
505        self.bits.eq(&other.bits)
506    }
507}
508
509impl<AlphabetType: Alphabet, BitStoreType: BitStore> Hash
510    for BitVectorGenome<AlphabetType, BitStoreType>
511{
512    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
513        self.bits.hash(state)
514    }
515}
516
517pub(crate) const fn alphabet_character_bit_width(size: u8) -> usize {
518    mem::size_of::<u8>() * 8 - ((size - 1).leading_zeros() as usize)
519}
520
521#[cfg(test)]
522mod tests {
523    use crate::implementation::alphabets::dna_alphabet::DnaAlphabet;
524    use crate::implementation::bit_vec_sequence::BitVectorGenome;
525    use crate::interface::alphabet::Alphabet;
526    use crate::interface::sequence::{EditableGenomeSequence, GenomeSequence, OwnedGenomeSequence};
527    use traitsequence::interface::{EditableSequence, Sequence};
528
529    #[test]
530    fn test_reverse_complement() {
531        let genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"ATTCGGT").unwrap();
532        let reverse_complement = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"ACCGAAT").unwrap();
533        assert_eq!(genome.clone_as_reverse_complement(), reverse_complement);
534        assert_eq!(genome, reverse_complement.clone_as_reverse_complement());
535    }
536
537    #[test]
538    fn test_display() {
539        let genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"ATTCGGT").unwrap();
540        let display_string = genome.as_string();
541        let expected_string = "ATTCGGT";
542        assert_eq!(display_string, expected_string);
543    }
544
545    #[test]
546    fn test_substrings() {
547        let genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"ATTCGGT").unwrap();
548
549        let display_string = genome[1..4].as_string();
550        let expected_string = "TTC";
551        assert_eq!(display_string, expected_string);
552
553        let display_string = genome.clone_as_reverse_complement()[1..4].as_string();
554        let expected_string = "CCG";
555        assert_eq!(display_string, expected_string);
556
557        let display_string =
558            genome[1..6].to_owned().clone_as_reverse_complement()[1..4].as_string();
559        let expected_string = "CGA";
560        assert_eq!(display_string, expected_string);
561    }
562
563    #[test]
564    fn test_empty_substring_after_end() {
565        let genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"ATTCGGT").unwrap();
566        let display_string = genome[7..7].as_string();
567        let expected_string = "";
568        assert_eq!(display_string, expected_string);
569    }
570
571    #[test]
572    #[should_panic]
573    fn test_empty_substring_after_end2() {
574        let genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"ATTCGGT").unwrap();
575        let display_string = genome[8..8].as_string();
576        let expected_string = "";
577        assert_eq!(display_string, expected_string);
578    }
579
580    #[test]
581    fn test_canonical() {
582        let genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"ATTCGGT").unwrap();
583        assert!(!genome.is_canonical());
584        assert!(genome.clone_as_reverse_complement().is_canonical());
585        let genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"ATAT").unwrap();
586        assert!(genome.is_canonical());
587        assert!(genome.clone_as_reverse_complement().is_canonical());
588        let genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"CGTA").unwrap();
589        assert!(genome.is_canonical());
590        assert!(!genome.clone_as_reverse_complement().is_canonical());
591        let genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"").unwrap();
592        assert!(genome.is_canonical());
593        assert!(genome.clone_as_reverse_complement().is_canonical());
594    }
595
596    #[test]
597    fn test_self_complemental() {
598        let genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"ATTCGGT").unwrap();
599        assert!(!genome.is_self_complemental());
600        assert!(!genome.clone_as_reverse_complement().is_self_complemental());
601        let genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"ATAT").unwrap();
602        assert!(genome.is_self_complemental());
603        assert!(genome.clone_as_reverse_complement().is_self_complemental());
604        let genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"CGTA").unwrap();
605        assert!(!genome.is_self_complemental());
606        assert!(!genome.clone_as_reverse_complement().is_self_complemental());
607        let genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"").unwrap();
608        assert!(genome.is_self_complemental());
609        assert!(genome.clone_as_reverse_complement().is_self_complemental());
610    }
611
612    #[test]
613    fn test_extend() {
614        let mut genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"ATT").unwrap();
615        genome.extend_from_slice_u8(b"CGT").unwrap();
616        assert_eq!(
617            genome,
618            BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"ATTCGT").unwrap()
619        );
620        assert_eq!(genome[0], DnaAlphabet::ascii_to_character(b'A').unwrap());
621        assert_eq!(genome[1], DnaAlphabet::ascii_to_character(b'T').unwrap());
622        assert_eq!(genome[2], DnaAlphabet::ascii_to_character(b'T').unwrap());
623        assert_eq!(genome[3], DnaAlphabet::ascii_to_character(b'C').unwrap());
624        assert_eq!(genome[4], DnaAlphabet::ascii_to_character(b'G').unwrap());
625        assert_eq!(genome[5], DnaAlphabet::ascii_to_character(b'T').unwrap());
626    }
627
628    #[test]
629    fn test_splice() {
630        let mut genome = BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"ATCTGT").unwrap();
631        let insertion: BitVectorGenome<DnaAlphabet> =
632            genome.iter().skip(1).take(3).cloned().collect();
633        genome.splice(3..3, insertion);
634        assert_eq!(
635            genome,
636            BitVectorGenome::<DnaAlphabet>::from_slice_u8(b"ATCTCTTGT").unwrap()
637        );
638    }
639}
compact_genome/implementation/bit_vec_sequence.rs

compact_genome/implementation/
bit_vec_sequence.rs
