packed-seq 4.0.1

Constructing and iterating packed DNA sequences using SIMD
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

# packed-seq

[![crates.io](https://img.shields.io/crates/v/packed-seq)](https://crates.io/crates/packed-seq)
[![docs](https://img.shields.io/docsrs/packed-seq)](https://docs.rs/packed-seq)

A library for constructing and iterating packed `PackedSeq` DNA sequences that
handles the encoding, decoding, and complements of packed bases.

ASCII `ACTG` representations of DNA and general ASCII text are also supported via the `Seq` trait.

Fast SIMD-based iteration over sequences is supported by splitting the sequence
into 8 (slightly overlapping) chunks and iterating those in parallel in a
memory-efficient way.

**Paper:**
Please cite the
[`simd-minimizers`](https://github.com/rust-seq/simd-minimizers) paper, for which this
crate was developed:

- SimdMinimizers: Computing Random Minimizers, fast.  
  Ragnar Groot Koerkamp, Igor Martayan.
  SEA 2025 [https://doi.org/10.4230/LIPIcs.SEA.2025.20](doi.org/10.4230/LIPIcs.SEA.2025.20)

## Requirements

This library supports AVX2 and NEON instruction sets.
Make sure to set `RUSTFLAGS="-C target-cpu=native"` when compiling to use the instruction sets available on your architecture.

``` sh
RUSTFLAGS="-C target-cpu=native" cargo run --release
```

Enable the `-F scalar` feature flag to fall back to a scalar implementation with
reduced performance.

## Usage example

Full documentation can be found on [docs.rs](https://docs.rs/packed-seq).

```rust
use packed_seq::{SeqVec, Seq, AsciiSeqVec, PackedSeqVec, pack_char};
// Plain ASCII sequence.
let seq = b"ACTGCAGCGCATATGTAGT";
// ASCII DNA sequence.
let ascii_seq = AsciiSeqVec::from_ascii(seq);
// Packed DNA sequence.
let packed_seq = PackedSeqVec::from_ascii(seq);
assert_eq!(ascii_seq.len(), packed_seq.len());
// Iterate the ASCII characters.
let characters: Vec<u8> = seq.iter_bp().collect();
assert_eq!(characters, seq);

// Iterate the bases with 0..4 values.
let bases: Vec<u8> = seq.iter().copied().map(pack_char).collect();
assert_eq!(bases, vec![0,1,2,3,1,0,3,1,3,1,0,2,0,2,3,2,0,3,2]);
let ascii_bases: Vec<u8> = ascii_seq.as_slice().iter_bp().collect();
assert_eq!(ascii_bases, bases);
let packed_bases: Vec<u8> = ascii_seq.as_slice().iter_bp().collect();
assert_eq!(packed_bases, bases);

// Iterate over 8 chunks at the same time.
let seq = b"AAAACCTTGGTTACTG"; // plain ASCII sequence
// chunks:  ^ ^ ^ ^ ^ ^ ^ ^
let (par_iter, padding) = seq.as_slice().par_iter_bp(1);
let mut par_iter_u8 = par_iter.map(|x| x.as_array_ref().map(|c| c as u8));
assert_eq!(par_iter_u8.next(), Some(*b"AACTGTAT"));
assert_eq!(par_iter_u8.next(), Some(*b"AACTGTCG"));
assert_eq!(par_iter_u8.next(), None);
```