Struct ScalarQuantizer 

pub struct ScalarQuantizer { /* private fields */ }

Scalar quantization (SQ8): f32 → u8

Maps each dimension independently to [0, 255] range based on min/max values from training data. Provides 4x memory reduction with minimal quality loss.

Example

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

// Fit quantizer on training data
let training_vectors = vec![
    vec![0.1, 0.5, 0.9],
    vec![0.2, 0.4, 0.8],
    vec![0.3, 0.6, 0.7],
];
let quantizer = ScalarQuantizer::fit(&training_vectors);

// Quantize new vectors
let query = vec![0.15, 0.45, 0.85];
let quantized = quantizer.quantize(&query);

// Compute distance efficiently
let db_vec = quantizer.quantize(&training_vectors[0]);
let distance = quantizer.distance_quantized(&quantized, &db_vec);

Implementations

impl ScalarQuantizer

pub fn fit(training_vectors: &[Vec<f32>]) -> Self

Fit quantizer parameters from training vectors

Computes min/max for each dimension across all training vectors.

Panics

Panics if training vectors have inconsistent dimensions.

pub fn with_bounds(dim: usize, min: f32, max: f32) -> Self

Create quantizer with known min/max bounds

Use this when you know the expected value range (e.g., normalized embeddings).

pub fn for_normalized(dim: usize) -> Self

Create quantizer for normalized vectors ([-1, 1] range)

pub fn dim(&self) -> usize

Get the dimensionality

pub fn params(&self) -> &[ScalarQuantizationParams]

Get quantization parameters for analysis

Trait Implementations

impl Clone for ScalarQuantizer

fn clone(&self) -> ScalarQuantizer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ScalarQuantizer

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ScalarQuantizer

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Quantizer for ScalarQuantizer

type Quantized = ScalarQuantizedVector

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 ScalarQuantizer

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

where __S: Serializer,

Serialize this value into the given Serde serializer.