Struct ScalarQuantizer 

pub struct ScalarQuantizer { /* private fields */ }

Scalar quantizer (SQ8): one u8 per dimension, 4× compression.

Build one with ScalarQuantizer::new (or Default), train it once with a representative sample, then quantize and compare. The trained quantizer is callable from multiple threads — it owns its calibration by value and exposes no interior mutability.

Examples

use iqdb_quantize::{Quantizer, ScalarQuantizer};
use iqdb_types::DistanceMetric;

let mut sq = ScalarQuantizer::new();
sq.train(&[&[0.0_f32, 1.0, 2.0][..], &[1.0_f32, 0.0, 1.0][..]])
    .expect("two non-empty, finite vectors of equal dim");

let code = sq.quantize(&[0.5_f32, 0.5, 1.5]).expect("dim matches");
let d = sq
    .distance(&[0.5_f32, 0.5, 1.5], &code, DistanceMetric::Euclidean)
    .expect("dim matches");
assert!(d.is_finite());

Implementations

impl ScalarQuantizer

pub fn new() -> Self

Build an untrained scalar quantizer.

Every hot method returns IqdbError::InvalidConfig until Quantizer::train succeeds.

Examples

use iqdb_quantize::ScalarQuantizer;
let _sq = ScalarQuantizer::new();

pub fn dim(&self) -> Option<usize>

The trained dimension, if any.

Examples

use iqdb_quantize::{Quantizer, ScalarQuantizer};

let mut sq = ScalarQuantizer::new();
assert_eq!(sq.dim(), None);
sq.train(&[&[0.0_f32, 1.0][..]]).expect("ok");
assert_eq!(sq.dim(), Some(2));

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 Default for ScalarQuantizer

fn default() -> ScalarQuantizer

Returns the “default value” for a type.

impl PartialEq for ScalarQuantizer

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

type Quantized = Sq8Code

The compact code produced by Quantizer::quantize.

fn train(&mut self, vectors: &[&[f32]]) -> Result<()>

Train the quantizer from a sample of representative vectors.

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

Encode vector as a compact code.

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

Decode quantized back to an f32 vector.

fn distance( &self, query: &[f32], quantized: &Self::Quantized, metric: DistanceMetric, ) -> Result<f32>

Compute the asymmetric distance between a raw f32 query and a stored code under metric.

impl StructuralPartialEq for ScalarQuantizer