embeddenator-core 0.22.0

Sparse ternary VSA implementation for holographic data encoding - umbrella crate re-exporting all embeddenator components
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

use embeddenator::{EmbrFS, ReversibleVSAConfig, SparseVec};
use std::fs;

fn main() {
    let temp_dir = std::env::temp_dir().join("embr_test");
    let input_dir = temp_dir.join("input");
    let output_dir = temp_dir.join("output");

    fs::create_dir_all(&input_dir).unwrap();
    fs::create_dir_all(&output_dir).unwrap();

    // Test with byte 0
    let byte_val: u8 = 0;
    let test_path = input_dir.join("byte_0.bin");
    fs::write(&test_path, &[byte_val]).unwrap();

    let mut embrfs = EmbrFS::new();
    let config = ReversibleVSAConfig::default();

    println!("=== Testing encode/decode directly ===");
    let data = vec![0u8];
    let encoded = SparseVec::encode_data(&data, &config, Some("test.bin"));
    println!(
        "Encoded pos: {:?}",
        &encoded.pos[..encoded.pos.len().min(10)]
    );
    println!(
        "Encoded neg: {:?}",
        &encoded.neg[..encoded.neg.len().min(10)]
    );
    println!(
        "Encoded pos len: {}, neg len: {}",
        encoded.pos.len(),
        encoded.neg.len()
    );

    let decoded = encoded.decode_data(&config, Some("test.bin"), 1);
    println!("Decoded: {:?}", decoded);

    println!("\n=== Testing via EmbrFS ===");
    println!("Ingesting single byte: {}", byte_val);
    embrfs
        .ingest_file(&test_path, "byte_0.bin".to_string(), true, &config)
        .unwrap();

    println!("Manifest files: {:?}", embrfs.manifest.files);
    println!(
        "Engram codebook keys: {:?}",
        embrfs.engram.codebook.keys().collect::<Vec<_>>()
    );

    // Check the actual vector in the codebook
    if let Some(chunk_vec) = embrfs.engram.codebook.get(&0) {
        println!(
            "Chunk 0 pos len: {}, neg len: {}",
            chunk_vec.pos.len(),
            chunk_vec.neg.len()
        );
    }

    println!("Correction stats: {:?}", embrfs.correction_stats());

    println!("\nExtracting...");
    EmbrFS::extract(&embrfs.engram, &embrfs.manifest, &output_dir, true, &config).unwrap();

    let reconstructed = fs::read(output_dir.join("byte_0.bin")).unwrap();
    println!("Reconstructed: {:?}", reconstructed);

    // Cleanup
    fs::remove_dir_all(&temp_dir).ok();
}