Struct ScalarQuantizer 

pub struct ScalarQuantizer { /* private fields */ }

Scalar quantizer: f32 -> u8 with per-dimension min/max scaling.

Training learns the min/max value for each dimension, then quantizes values to [0, 255] range. This achieves 4x compression with typically

97% recall retention.

Example

use grafeo_core::index::vector::quantization::ScalarQuantizer;

// Training vectors
let vectors = vec![
    vec![0.0f32, 0.5, 1.0],
    vec![0.2, 0.3, 0.8],
    vec![0.1, 0.6, 0.9],
];

// Train quantizer
let refs: Vec<&[f32]> = vectors.iter().map(|v| v.as_slice()).collect();
let quantizer = ScalarQuantizer::train(&refs);

// Quantize a vector
let quantized = quantizer.quantize(&[0.1, 0.4, 0.85]);
assert_eq!(quantized.len(), 3);

// Compute approximate distance
let q2 = quantizer.quantize(&[0.15, 0.45, 0.9]);
let dist = quantizer.distance_squared_u8(&quantized, &q2);
assert!(dist < 1000.0);

Implementations

impl ScalarQuantizer

pub fn train(vectors: &[&[f32]]) -> Self

Trains a scalar quantizer from sample vectors.

Learns the min/max value per dimension from the training data. The more representative the training data, the better the quantization.

Arguments

• vectors - Training vectors (should be representative of the dataset)

Panics

Panics if vectors is empty or if vectors have different dimensions.

pub fn with_ranges(min: Vec<f32>, max: Vec<f32>) -> Self

Creates a quantizer with explicit ranges (useful for testing).

pub fn dimensions(&self) -> usize

Returns the number of dimensions.

pub fn min_values(&self) -> &[f32]

Returns the min values per dimension.

pub fn quantize(&self, vector: &[f32]) -> Vec<u8>

Quantizes an f32 vector to u8.

Values are clamped to the learned [min, max] range.

pub fn quantize_batch(&self, vectors: &[&[f32]]) -> Vec<Vec<u8>>

Quantizes multiple vectors in batch.

pub fn dequantize(&self, quantized: &[u8]) -> Vec<f32>

Dequantizes a u8 vector back to f32 (approximate).

pub fn distance_squared_u8(&self, a: &[u8], b: &[u8]) -> f32

Computes squared Euclidean distance between quantized vectors.

This is an approximation that works well for ranking nearest neighbors. The returned distance is scaled back to the original space.

pub fn distance_u8(&self, a: &[u8], b: &[u8]) -> f32

Computes Euclidean distance between quantized vectors.

pub fn cosine_distance_u8(&self, a: &[u8], b: &[u8]) -> f32

Computes approximate cosine distance using quantized vectors.

This is less accurate than exact computation but much faster.

pub fn asymmetric_distance_squared( &self, query: &[f32], quantized: &[u8], ) -> f32

Computes distance between a f32 query and a quantized vector.

This is useful for search where we keep the query in full precision.

pub fn asymmetric_distance(&self, query: &[f32], quantized: &[u8]) -> f32

Computes asymmetric Euclidean distance.

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 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.