ragc-core 0.1.1

Core compression and decompression algorithms for the AGC genome compression format
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

#![allow(clippy::all)]
// Integration test for segmentation
// Should produce output identical to C++ test_segment

use ahash::AHashSet;
use ragc_core::{split_at_splitters, Kmer, KmerMode};

fn print_segment(seg: &ragc_core::Segment, max_data_len: usize) {
    print!("front_kmer:{:x}", seg.front_kmer);
    print!(" back_kmer:{:x}", seg.back_kmer);
    print!(" len:{}", seg.len());
    print!(" data:");
    for (i, &byte) in seg.data.iter().enumerate() {
        if i >= max_data_len {
            break;
        }
        print!(" {byte}");
    }
    if seg.data.len() > max_data_len {
        print!(" ...");
    }
    println!();
}

fn main() {
    // Test 1: No splitters
    println!("# Test 1: No splitters (entire contig)");
    {
        let contig = vec![0, 1, 2, 3, 0, 1, 2, 3];
        let splitters = AHashSet::new();
        let segments = split_at_splitters(&contig, &splitters, 3);

        println!("num_segments:{}", segments.len());
        for (i, seg) in segments.iter().enumerate() {
            print!("seg{i} ");
            print_segment(seg, 20);
        }
    }

    // Test 2: With one splitter
    println!("\n# Test 2: With one splitter");
    {
        let contig = vec![0, 0, 0, 1, 1, 1, 2, 2, 2];

        // Get the first k-mer as a splitter
        let mut kmer = Kmer::new(3, KmerMode::Canonical);
        kmer.insert(0);
        kmer.insert(0);
        kmer.insert(0);
        let first_kmer = kmer.data();

        let mut splitters = AHashSet::new();
        splitters.insert(first_kmer);

        let segments = split_at_splitters(&contig, &splitters, 3);

        println!("num_segments:{}", segments.len());
        for (i, seg) in segments.iter().enumerate() {
            print!("seg{i} ");
            print_segment(seg, 20);
        }
    }

    // Test 3: Multiple splitters
    println!("\n# Test 3: Multiple splitters");
    {
        let contig = vec![0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2];

        // Get AAA and CCC as splitters
        let mut kmer_aaa = Kmer::new(3, KmerMode::Canonical);
        kmer_aaa.insert(0);
        kmer_aaa.insert(0);
        kmer_aaa.insert(0);

        let mut kmer_ccc = Kmer::new(3, KmerMode::Canonical);
        kmer_ccc.insert(1);
        kmer_ccc.insert(1);
        kmer_ccc.insert(1);

        let mut splitters = AHashSet::new();
        splitters.insert(kmer_aaa.data());
        splitters.insert(kmer_ccc.data());

        let segments = split_at_splitters(&contig, &splitters, 3);

        println!("num_segments:{}", segments.len());
        for (i, seg) in segments.iter().enumerate() {
            print!("seg{i} ");
            print_segment(seg, 20);
        }
    }

    // Test 4: Short contig (too short for k-mers)
    println!("\n# Test 4: Short contig");
    {
        let contig = vec![0, 1];
        let mut splitters = AHashSet::new();
        splitters.insert(12345);

        let segments = split_at_splitters(&contig, &splitters, 3);

        println!("num_segments:{}", segments.len());
        for (i, seg) in segments.iter().enumerate() {
            print!("seg{i} ");
            print_segment(seg, 20);
        }
    }

    // Test 5: Splitter at start
    println!("\n# Test 5: Splitter at start");
    {
        let contig = vec![0, 0, 0, 1, 2, 3];

        let mut kmer = Kmer::new(3, KmerMode::Canonical);
        kmer.insert(0);
        kmer.insert(0);
        kmer.insert(0);

        let mut splitters = AHashSet::new();
        splitters.insert(kmer.data());

        let segments = split_at_splitters(&contig, &splitters, 3);

        println!("num_segments:{}", segments.len());
        for (i, seg) in segments.iter().enumerate() {
            print!("seg{i} ");
            print_segment(seg, 20);
        }
    }

    // Test 6: Consecutive splitters
    println!("\n# Test 6: Consecutive splitters");
    {
        let contig = vec![0, 0, 0, 0, 0, 0];

        let mut kmer = Kmer::new(3, KmerMode::Canonical);
        kmer.insert(0);
        kmer.insert(0);
        kmer.insert(0);

        let mut splitters = AHashSet::new();
        splitters.insert(kmer.data());

        let segments = split_at_splitters(&contig, &splitters, 3);

        println!("num_segments:{}", segments.len());
        for (i, seg) in segments.iter().enumerate() {
            print!("seg{i} ");
            print_segment(seg, 20);
        }
    }

    // Test 7: With N bases (non-ACGT)
    println!("\n# Test 7: With N bases");
    {
        let contig = vec![0, 0, 0, 4, 1, 1, 1];

        let mut splitters = AHashSet::new();
        splitters.insert(12345); // Some random splitter

        let segments = split_at_splitters(&contig, &splitters, 3);

        println!("num_segments:{}", segments.len());
        for (i, seg) in segments.iter().enumerate() {
            print!("seg{i} ");
            print_segment(seg, 20);
        }
    }
}