genhdc 0.1.0

Hyperdimensional Computing (HDC/VSA) engine with genetic operators — extracted from the production Mimer agent
Documentation
//! Integration tests for the GenHDC HDC engine.

use genhdc::{pack_bipolar, unpack_bipolar, HdcEngine, DIMENSIONS};

#[test]
fn bind_unbind_roundtrip() {
    let mut h = HdcEngine::with_seed(1024, 99);
    let a = h.encode("alpha");
    let b = h.encode("beta");
    let bound = h.bind(&a, &b);
    let recovered = h.unbind(&bound, &b);
    let sim = h.similarity(&recovered, &a);
    assert!(sim > 0.8, "unbind(bind(A,B),B) ≈ A, sim={sim}");
}

#[test]
fn bind_self_is_ones() {
    let mut h = HdcEngine::with_seed(256, 3);
    let a = h.encode("solo");
    let self_bound = h.bind(&a, &a);
    // bipolar self-bind → all +1
    assert!(self_bound.iter().all(|x| (*x - 1.0).abs() < 1e-6));
}

#[test]
fn bundle_more_similar_than_random() {
    let mut h = HdcEngine::with_seed(2048, 11);
    let a = h.encode("left");
    let b = h.encode("right");
    let bundled = h.bundle(&[a.clone(), b.clone()]);
    let noise = h.encode("unrelated_noise_token_xyz");
    let sim_a = h.similarity(&bundled, &a);
    let sim_b = h.similarity(&bundled, &b);
    let sim_n = h.similarity(&bundled, &noise);
    assert!(sim_a > sim_n, "bundle~A ({sim_a}) should beat noise ({sim_n})");
    assert!(sim_b > sim_n, "bundle~B ({sim_b}) should beat noise ({sim_n})");
}

#[test]
fn pack_unpack_roundtrip() {
    let mut h = HdcEngine::with_seed(512, 5);
    let v = h.encode("packme");
    let packed = pack_bipolar(&v);
    let unpacked = unpack_bipolar(&packed, 512);
    assert_eq!(unpacked.len(), 512);
    for (a, b) in v.iter().zip(unpacked.iter()) {
        assert_eq!(*a >= 0.0, *b >= 0.0);
    }
}

#[test]
fn dimensions_constant_consistent() {
    assert_eq!(DIMENSIONS, 10_000);
    let packed = pack_bipolar(&vec![1.0f32; DIMENSIONS]);
    assert_eq!(packed.len(), DIMENSIONS.div_ceil(8));
    let unpacked = unpack_bipolar(&packed, DIMENSIONS);
    assert_eq!(unpacked.len(), DIMENSIONS);
    assert!(unpacked.iter().all(|x| *x == 1.0));
}

#[test]
fn determinism_same_seed_same_vector() {
    let mut a = HdcEngine::with_seed(1024, 12345);
    let mut b = HdcEngine::with_seed(1024, 12345);
    let va = a.encode("determinism_probe");
    let vb = b.encode("determinism_probe");
    assert_eq!(va, vb);
    assert!((a.similarity(&va, &vb) - 1.0).abs() < 1e-6);
}

#[test]
fn zero_vector_similarity_no_nan() {
    let h = HdcEngine::with_seed(128, 1);
    let z = vec![0.0f32; 128];
    let ones = vec![1.0f32; 128];
    let s = h.similarity(&z, &ones);
    assert!(s.is_finite());
    assert_eq!(s, 0.0);
    assert_eq!(h.similarity(&z, &z), 0.0);
}