Struct Hypervector 

pub struct Hypervector { /* private fields */ }

A binary hypervector with 10,000 bits packed into 156 u64 words

Performance

• Memory: 156 * 8 = 1,248 bytes per vector
• XOR binding: <50ns (single CPU cycle per u64)
• Similarity: <100ns (SIMD popcount)

Example

use ruvector_nervous_system::hdc::Hypervector;

let v1 = Hypervector::random();
let v2 = Hypervector::random();
let bound = v1.bind(&v2);
let sim = v1.similarity(&v2);

Implementations

impl Hypervector

pub fn zero() -> Self

Creates a new hypervector with all bits set to zero

Example

use ruvector_nervous_system::hdc::Hypervector;

let zero = Hypervector::zero();
assert_eq!(zero.popcount(), 0);

pub fn random() -> Self

Creates a random hypervector with ~50% bits set

Uses thread-local RNG for performance.

Example

use ruvector_nervous_system::hdc::Hypervector;

let random = Hypervector::random();
let count = random.popcount();
// Should be around 5000 ± 150
assert!(count > 4500 && count < 5500);

pub fn from_seed(seed: u64) -> Self

Creates a hypervector from a seed for reproducibility

Example

use ruvector_nervous_system::hdc::Hypervector;

let v1 = Hypervector::from_seed(42);
let v2 = Hypervector::from_seed(42);
assert_eq!(v1, v2);

pub fn bind(&self, other: &Self) -> Self

Binds two hypervectors using XOR

Binding is associative, commutative, and self-inverse:

• a.bind(b) == b.bind(a)
• a.bind(b).bind(b) == a

Performance

<50ns on modern CPUs (single cycle XOR per u64)

Example

use ruvector_nervous_system::hdc::Hypervector;

let a = Hypervector::random();
let b = Hypervector::random();
let bound = a.bind(&b);

// Self-inverse property
assert_eq!(bound.bind(&b), a);

pub fn similarity(&self, other: &Self) -> f32

Computes similarity between two hypervectors

Returns a value in [0.0, 1.0] where:

• 1.0 = identical vectors
• 0.5 = random/orthogonal vectors
• 0.0 = completely opposite vectors

Performance

<100ns with SIMD popcount

Example

use ruvector_nervous_system::hdc::Hypervector;

let a = Hypervector::random();
let b = a.clone();
assert!((a.similarity(&b) - 1.0).abs() < 0.001);

pub fn hamming_distance(&self, other: &Self) -> u32

Computes Hamming distance (number of differing bits)

Performance

<50ns with SIMD popcount instruction and loop unrolling

Example

use ruvector_nervous_system::hdc::Hypervector;

let a = Hypervector::random();
assert_eq!(a.hamming_distance(&a), 0);

pub fn popcount(&self) -> u32

Counts the number of set bits (population count)

Example

use ruvector_nervous_system::hdc::Hypervector;

let zero = Hypervector::zero();
assert_eq!(zero.popcount(), 0);

let random = Hypervector::random();
let count = random.popcount();
// Should be around 5000 for random vectors
assert!(count > 4500 && count < 5500);

pub fn bundle(vectors: &[Self]) -> Result<Self, HdcError>

Bundles multiple vectors by majority voting on each bit

Performance

Optimized word-level implementation: O(n * 157 words) instead of O(n * 10000 bits)

Example

use ruvector_nervous_system::hdc::Hypervector;

let v1 = Hypervector::random();
let v2 = Hypervector::random();
let v3 = Hypervector::random();

let bundled = Hypervector::bundle(&[v1.clone(), v2, v3]).unwrap();
// Bundled vector is similar to all inputs
assert!(bundled.similarity(&v1) > 0.3);

pub fn bundle_3(a: &Self, b: &Self, c: &Self) -> Self

Fast bundle for exactly 3 vectors using bitwise majority

Performance

Single-pass bitwise operation: ~500ns for 10,000 bits

pub fn bits(&self) -> &[u64; 157]

Returns the internal bit array (for advanced use cases)

Trait Implementations

impl Clone for Hypervector

fn clone(&self) -> Hypervector

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Hypervector

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Hypervector

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for Hypervector

fn eq(&self, other: &Hypervector) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Hypervector

impl StructuralPartialEq for Hypervector