Struct BinaryQuantizer 

pub struct BinaryQuantizer { /* private fields */ }

Binary quantization: f32 → bit

Maps each dimension to a single bit based on sign (positive = 1, negative = 0). Provides 32x memory reduction. Best used for initial filtering with reranking.

Distance is computed using Hamming distance (number of differing bits).

Example

use foxstash_core::vector::quantize::{BinaryQuantizer, Quantizer};

let quantizer = BinaryQuantizer::new(128);

let vec_a = vec![0.5; 128];  // All positive → all 1s
let vec_b = vec![-0.5; 128]; // All negative → all 0s

let qa = quantizer.quantize(&vec_a);
let qb = quantizer.quantize(&vec_b);

// Maximum Hamming distance (all bits differ)
let distance = quantizer.distance_quantized(&qa, &qb);
assert_eq!(distance, 128.0);

Implementations

impl BinaryQuantizer

pub fn new(dim: usize) -> Self

Create a binary quantizer for vectors of given dimension

pub fn dim(&self) -> usize

Get the dimensionality

pub fn byte_len(&self) -> usize

Get the byte length of quantized vectors

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<'de> Deserialize<'de> for BinaryQuantizer

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Quantizer for BinaryQuantizer

type Quantized = BinaryQuantizedVector

Quantized representation type

fn quantize(&self, vector: &[f32]) -> Self::Quantized

Quantize a vector

fn dequantize(&self, quantized: &Self::Quantized) -> Vec<f32>

Dequantize back to f32 (lossy)

fn distance_quantized(&self, a: &Self::Quantized, b: &Self::Quantized) -> f32

Compute distance between quantized vectors (fast path)

fn distance_asymmetric(&self, query: &[f32], quantized: &Self::Quantized) -> f32

Compute distance between f32 query and quantized vector (asymmetric)

impl Serialize for BinaryQuantizer

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.