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);
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);
}