Struct QuantizedVector 

pub struct QuantizedVector { /* private fields */ }

Quantized binary vector (96 bytes, 768 bits).

Each bit represents the sign of the original f32 value:

• Bit = 1 if f32 > 0.0
• Bit = 0 if f32 <= 0.0

Memory Layout

The struct is aligned to 64 bytes for SIMD compatibility.

Example

use edgevec::quantization::binary::{BinaryQuantizer, QuantizedVector};

let quantizer = BinaryQuantizer::new();
let vector = vec![1.0f32; 768];
let quantized = quantizer.quantize(&vector);

// All positive values result in all bits set
assert_eq!(quantized.data()[0], 0xFF);

Implementations

impl QuantizedVector

pub const fn from_bytes(data: [u8; 96]) -> Self

Creates a new QuantizedVector from raw bytes.

Arguments

• data - Exactly 96 bytes of packed binary data.

Example

use edgevec::quantization::binary::QuantizedVector;

let data = [0u8; 96];
let qv = QuantizedVector::from_bytes(data);
assert_eq!(qv.data(), &[0u8; 96]);

pub const fn data(&self) -> &[u8; 96]

Returns a reference to the underlying byte data.

Returns

A reference to the 96-byte array containing the packed binary representation. Each byte contains 8 bits of quantized data in little-endian bit order.

Example

use edgevec::quantization::binary::QuantizedVector;

let qv = QuantizedVector::from_bytes([0xAA; 96]);
let data = qv.data();
assert_eq!(data.len(), 96);
assert_eq!(data[0], 0xAA);

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

Computes the Hamming distance to another quantized vector.

Hamming distance is the number of differing bits between two vectors.

Algorithm

1. XOR the two binary vectors (differing bits become 1)
2. Count the number of 1 bits (popcount)

Performance

Automatically uses the fastest available implementation:

• AVX2 (x86_64 with AVX2): ~47 CPU cycles
• Portable fallback: ~300 CPU cycles

Implementation uses runtime CPU feature detection for optimal performance across all platforms.

Example

use edgevec::quantization::binary::QuantizedVector;

let v1 = QuantizedVector::from_bytes([0x00; 96]);
let v2 = QuantizedVector::from_bytes([0xFF; 96]);

// All 768 bits differ
assert_eq!(v1.hamming_distance(&v2), 768);

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

Returns the Hamming distance as a normalized similarity score [0, 1].

• 1.0 = identical vectors (distance = 0)
• 0.0 = completely opposite vectors (distance = 768)

Example

use edgevec::quantization::binary::QuantizedVector;

let v1 = QuantizedVector::from_bytes([0xAA; 96]); // 10101010...
let v2 = QuantizedVector::from_bytes([0xAA; 96]); // same pattern

assert!((v1.similarity(&v2) - 1.0).abs() < f32::EPSILON);

Trait Implementations

impl Clone for QuantizedVector

fn clone(&self) -> QuantizedVector

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QuantizedVector

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

Formats the value using the given formatter.

impl Default for QuantizedVector

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for QuantizedVector

fn eq(&self, other: &QuantizedVector) -> 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 QuantizedVector

impl StructuralPartialEq for QuantizedVector