Struct BinaryQuantizer 

pub struct BinaryQuantizer { /* private fields */ }

Binary quantizer compressing f32 vectors to binary (u8) representation.

Memory Layout

• Input: [f32; 768] (3072 bytes)
• Output: [u8; 96] (96 bytes, 64-byte aligned)
• Compression: 8x

Algorithm

Sign-based quantization: each bit represents whether the corresponding f32 value is positive (1) or non-positive (0).

Example

use edgevec::quantization::binary::BinaryQuantizer;

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

// 768 dimensions compressed to 96 bytes
assert_eq!(quantized.data().len(), 96);

Implementations

impl BinaryQuantizer

pub const fn new() -> Self

Creates a new BinaryQuantizer.

The quantizer is stateless - no training or configuration required for simple sign-based quantization.

Example

use edgevec::quantization::binary::BinaryQuantizer;

let quantizer = BinaryQuantizer::new();

pub fn quantize(&self, vector: &[f32]) -> QuantizedVector

Quantizes a 768-dimensional f32 vector to binary representation.

Arguments

• vector - A 768-dimensional f32 vector.

Panics

Panics if the input vector length is not exactly 768.

Algorithm

For each dimension i in [0, 768):

• If vector[i] > 0.0, set bit i to 1
• Else, set bit i to 0

Bits are packed into bytes in little-endian order:

• Byte 0 contains bits [0..8]
• Byte 1 contains bits [8..16]
• …
• Byte 95 contains bits [760..768]

Performance

Target: <1ms per vector.

Example

use edgevec::quantization::binary::BinaryQuantizer;

let quantizer = BinaryQuantizer::new();

// All positive -> all bits 1
let positive = vec![1.0f32; 768];
let q_pos = quantizer.quantize(&positive);
assert_eq!(q_pos.data()[0], 0xFF);

// All negative -> all bits 0
let negative = vec![-1.0f32; 768];
let q_neg = quantizer.quantize(&negative);
assert_eq!(q_neg.data()[0], 0x00);

pub fn quantize_flexible(&self, vector: &[f32]) -> QuantizedVector

Quantizes a vector of arbitrary dimension.

Unlike quantize, this method accepts vectors of any length and pads or truncates as needed. Primarily for testing and flexibility.

Arguments

• vector - An f32 vector of any length.

Returns

A QuantizedVector where:

• If input is shorter than 768, remaining bits are 0
• If input is longer than 768, extra values are ignored

Examples

use edgevec::quantization::binary::BinaryQuantizer;

let quantizer = BinaryQuantizer::new();

// Short vector (16 elements) - remaining bits are 0
let short = vec![1.0f32; 16];
let q_short = quantizer.quantize_flexible(&short);
assert_eq!(q_short.data()[0], 0xFF); // First 8 bits set
assert_eq!(q_short.data()[1], 0xFF); // Next 8 bits set
assert_eq!(q_short.data()[2], 0x00); // Rest are 0

// Long vector (1000 elements) - truncated to 768
let long = vec![1.0f32; 1000];
let q_long = quantizer.quantize_flexible(&long);
assert_eq!(q_long.data().len(), 96); // Always 96 bytes

Trait Implementations

impl Clone for BinaryQuantizer

fn clone(&self) -> BinaryQuantizer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BinaryQuantizer

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

Formats the value using the given formatter.

impl Default for BinaryQuantizer

fn default() -> BinaryQuantizer

Returns the “default value” for a type.