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
170
171

// Test segment splitting - Seventh micro-replacement

#include <iostream>
#include <cstdint>

using namespace std;

extern "C" {
    uint32_t ragc_calculate_seg2_start_pos(uint32_t left_size, uint32_t kmer_length);
    uint32_t ragc_calculate_segment1_size(uint32_t seg2_start_pos, uint32_t kmer_length);

    struct SegmentSplitInfo {
        uint32_t seg2_start_pos;
        uint32_t segment1_new_size;
    };

    SegmentSplitInfo ragc_calculate_segment_split(uint32_t left_size, uint32_t kmer_length);
}

// C++ AGC version (from agc_compressor.cpp:1434-1438)
uint32_t cpp_calculate_seg2_start_pos(uint32_t left_size, uint32_t kmer_length) {
    return left_size - kmer_length / 2;
}

uint32_t cpp_calculate_segment1_size(uint32_t seg2_start_pos, uint32_t kmer_length) {
    return seg2_start_pos + kmer_length;
}

int main() {
    cout << "=== Testing Rust segment split vs C++ AGC ===\n\n";

    // Test 1: Standard case with k=21
    cout << "Test 1: Standard case (left_size=100, k=21)\n";
    uint32_t left_size = 100;
    uint32_t k = 21;

    uint32_t cpp_seg2_start = cpp_calculate_seg2_start_pos(left_size, k);
    uint32_t rust_seg2_start = ragc_calculate_seg2_start_pos(left_size, k);

    cout << "  seg2_start_pos: C++=" << cpp_seg2_start << " Rust=" << rust_seg2_start;
    if (cpp_seg2_start == rust_seg2_start) {
        cout << " ✅\n";
    } else {
        cout << " ❌ MISMATCH\n";
        return 1;
    }

    uint32_t cpp_seg1_size = cpp_calculate_segment1_size(cpp_seg2_start, k);
    uint32_t rust_seg1_size = ragc_calculate_segment1_size(rust_seg2_start, k);

    cout << "  segment1_size: C++=" << cpp_seg1_size << " Rust=" << rust_seg1_size;
    if (cpp_seg1_size == rust_seg1_size) {
        cout << " ✅\n";
    } else {
        cout << " ❌ MISMATCH\n";
        return 1;
    }
    cout << "\n";

    // Test 2: k=25
    cout << "Test 2: Different k-mer length (left_size=200, k=25)\n";
    left_size = 200;
    k = 25;

    cpp_seg2_start = cpp_calculate_seg2_start_pos(left_size, k);
    rust_seg2_start = ragc_calculate_seg2_start_pos(left_size, k);

    cout << "  seg2_start_pos: C++=" << cpp_seg2_start << " Rust=" << rust_seg2_start;
    if (cpp_seg2_start == rust_seg2_start) {
        cout << " ✅\n";
    } else {
        cout << " ❌ MISMATCH\n";
        return 1;
    }

    cpp_seg1_size = cpp_calculate_segment1_size(cpp_seg2_start, k);
    rust_seg1_size = ragc_calculate_segment1_size(rust_seg2_start, k);

    cout << "  segment1_size: C++=" << cpp_seg1_size << " Rust=" << rust_seg1_size;
    if (cpp_seg1_size == rust_seg1_size) {
        cout << " ✅\n";
    } else {
        cout << " ❌ MISMATCH\n";
        return 1;
    }
    cout << "\n";

    // Test 3: Complete split calculation with k=21
    cout << "Test 3: Complete split calculation (left_size=100, k=21)\n";
    SegmentSplitInfo rust_info = ragc_calculate_segment_split(100, 21);
    uint32_t cpp_start = cpp_calculate_seg2_start_pos(100, 21);
    uint32_t cpp_size = cpp_calculate_segment1_size(cpp_start, 21);

    cout << "  C++ - seg2_start=" << cpp_start << " seg1_size=" << cpp_size << "\n";
    cout << "  Rust - seg2_start=" << rust_info.seg2_start_pos
         << " seg1_size=" << rust_info.segment1_new_size << "\n";

    if (rust_info.seg2_start_pos == cpp_start && rust_info.segment1_new_size == cpp_size) {
        cout << "  ✅ MATCH\n";
    } else {
        cout << "  ❌ MISMATCH\n";
        return 1;
    }
    cout << "\n";

    // Test 4: Realistic scenario (500bp segment, split at 250, k=21)
    cout << "Test 4: Realistic scenario (left_size=250, k=21)\n";
    rust_info = ragc_calculate_segment_split(250, 21);
    cpp_start = cpp_calculate_seg2_start_pos(250, 21);
    cpp_size = cpp_calculate_segment1_size(cpp_start, 21);

    cout << "  C++ - seg2_start=" << cpp_start << " seg1_size=" << cpp_size << "\n";
    cout << "  Rust - seg2_start=" << rust_info.seg2_start_pos
         << " seg1_size=" << rust_info.segment1_new_size << "\n";

    // Verify overlap
    uint32_t overlap = rust_info.segment1_new_size - rust_info.seg2_start_pos;
    cout << "  Overlap size: " << overlap << " (should equal k=" << 21 << ")\n";

    if (rust_info.seg2_start_pos == cpp_start &&
        rust_info.segment1_new_size == cpp_size &&
        overlap == 21) {
        cout << "  ✅ MATCH\n";
    } else {
        cout << "  ❌ MISMATCH\n";
        return 1;
    }
    cout << "\n";

    // Test 5: Various k-mer lengths
    cout << "Test 5: Multiple k-mer lengths\n";
    uint32_t test_k_values[] = {15, 17, 19, 21, 23, 25, 27, 29, 31};
    for (uint32_t test_k : test_k_values) {
        rust_info = ragc_calculate_segment_split(300, test_k);
        cpp_start = cpp_calculate_seg2_start_pos(300, test_k);
        cpp_size = cpp_calculate_segment1_size(cpp_start, test_k);

        cout << "  k=" << test_k << ": C++=(" << cpp_start << "," << cpp_size << ") "
             << "Rust=(" << rust_info.seg2_start_pos << "," << rust_info.segment1_new_size << ")";

        if (rust_info.seg2_start_pos == cpp_start && rust_info.segment1_new_size == cpp_size) {
            cout << " ✅\n";
        } else {
            cout << " ❌ MISMATCH\n";
            return 1;
        }
    }
    cout << "\n";

    // Test 6: Edge case - small left_size
    cout << "Test 6: Edge case - small left_size (left_size=5, k=21)\n";
    // In C++ this would underflow, Rust saturates to 0
    // We need to test what C++ actually does
    cout << "  Note: C++ may underflow (undefined behavior), Rust saturates to 0\n";
    rust_info = ragc_calculate_segment_split(5, 21);
    cout << "  Rust - seg2_start=" << rust_info.seg2_start_pos
         << " seg1_size=" << rust_info.segment1_new_size << "\n";

    if (rust_info.seg2_start_pos == 0 && rust_info.segment1_new_size == 21) {
        cout << "  ✅ Rust handles underflow safely\n";
    } else {
        cout << "  ❌ Unexpected Rust behavior\n";
        return 1;
    }
    cout << "\n";

    cout << "=== All tests passed! ===\n";
    cout << "✅ Rust segment split matches C++ AGC exactly\n";

    return 0;
}