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

// Extended C++ AGC compressor with Rust integration
// MINIMAL VERSION - just test that fork works

#include "agc_compressor_rust.h"
#include <iostream>

using namespace std;

void CAGCCompressorRust::SetPrecomputedSplitters(
    const std::vector<uint64_t>& splitters,
    const std::vector<uint64_t>& singletons,
    const std::vector<uint64_t>& duplicates
) {
    // Clear existing data
    v_candidate_kmers.clear();
    v_duplicated_kmers.clear();
    v_candidate_kmers_offset = 0;
    hs_splitters.clear();

    // Set singletons (for adaptive mode and splitter finding if needed)
    v_candidate_kmers = singletons;
    v_duplicated_kmers = duplicates;

    // Populate hs_splitters with actual splitters
    for (const auto& splitter : splitters) {
        hs_splitters.insert(splitter);
    }

    // Populate bloom filter for fast splitter lookup
    // Using same sizing as C++ AGC (line 554 of agc_compressor.cpp)
    bloom_splitters.resize((uint64_t)(hs_splitters.size() / 0.25));
    bloom_splitters.insert(hs_splitters.begin(), hs_splitters.end());

    splitters_precomputed = true;

    cerr << "[RAGC FORK] Loaded " << singletons.size() << " singletons, "
         << duplicates.size() << " duplicates, "
         << splitters.size() << " splitters" << endl;
}

bool CAGCCompressorRust::CreateWithRustSplitters(
    const std::string& _file_name,
    const uint32_t _pack_cardinality,
    const uint32_t _kmer_length,
    const std::string& reference_file_name,
    const uint32_t _segment_size,
    const uint32_t _min_match_len,
    const bool _concatenated_genomes,
    const bool _adaptive_compression,
    const uint32_t _verbosity,
    const uint32_t _no_threads,
    double _fallback_frac
) {
    cerr << "[RAGC FORK] CreateWithRustSplitters - computing splitters with Rust FFI" << endl;

    // Get splitters from Rust
    SplitterResult* rust_result = ragc_determine_splitters(
        reference_file_name.c_str(),
        _kmer_length,
        _segment_size,
        _verbosity
    );

    if (!rust_result) {
        cerr << "[RAGC FORK] Error: Rust splitter detection failed" << endl;
        return false;
    }

    // Convert to C++ vectors
    std::vector<uint64_t> splitters(
        rust_result->splitters,
        rust_result->splitters + rust_result->n_splitters
    );

    std::vector<uint64_t> singletons(
        rust_result->singletons,
        rust_result->singletons + rust_result->n_singletons
    );

    std::vector<uint64_t> duplicates(
        rust_result->duplicates,
        rust_result->duplicates + rust_result->n_duplicates
    );

    ragc_free_splitters(rust_result);

    cerr << "[RAGC FORK] Rust found: " << singletons.size() << " singletons, "
         << splitters.size() << " splitters" << endl;

    // Set the splitters BEFORE calling Create()
    SetPrecomputedSplitters(splitters, singletons, duplicates);

    // Now call normal Create(), which will detect pre-set splitters and skip determine_splitters()
    cerr << "[RAGC FORK] Calling Create() with pre-computed splitters..." << endl;

    bool result = CAGCCompressor::Create(
        _file_name,
        _pack_cardinality,
        _kmer_length,
        reference_file_name,  // Still needed for file path but won't be read
        _segment_size,
        _min_match_len,
        _concatenated_genomes,
        _adaptive_compression,
        _verbosity,
        _no_threads,
        _fallback_frac
    );

    if (result) {
        cerr << "[RAGC FORK] Create() succeeded with Rust splitters!" << endl;
    } else {
        cerr << "[RAGC FORK] Create() failed" << endl;
    }

    return result;
}