Struct OpqCodec 

pub struct OpqCodec {
    pub dim: usize,
    pub m: usize,
    pub k: usize,
    pub sub_dim: usize,
    /* private fields */
}

Optimized Product Quantization codec.

Stores a learned rotation matrix R (dim × dim, row-major) and PQ codebooks trained on the rotated training set via Non-Para OPQ iterations.

Fields

dim: usize

m: usize

Number of PQ subspaces.

k: usize

Centroids per subspace (256 for u8 codes).

sub_dim: usize

Implementations

impl OpqCodec

pub fn train( vectors: &[&[f32]], dim: usize, m: usize, k: usize, opq_iters: usize, kmeans_iters: usize, ) -> Self

Train an OPQ codec using the Non-Para OPQ algorithm.

Alternates between a codebook step (Lloyd’s k-means on the rotated training set) and a Procrustes step (SVD-based rotation update to minimize reconstruction error) for opq_iters iterations.

• opq_iters: number of alternating Procrustes+codebook iterations.
• kmeans_iters: Lloyd’s k-means iterations per subspace per OPQ iter.

pub fn apply_rotation(&self, v: &[f32]) -> Vec<f32>

Apply the rotation matrix to v, returning R · v.

Trait Implementations

impl VectorCodec for OpqCodec

fn prepare_query(&self, q: &[f32]) -> Self::Query

Rotate the query, then build flat ADC distance table [M × K].

fn fast_symmetric_distance( &self, q: &Self::Quantized, v: &Self::Quantized, ) -> f32

Symmetric: dequantize both sides in rotated space, compute L2.

fn exact_asymmetric_distance(&self, q: &Self::Query, v: &Self::Quantized) -> f32

Asymmetric: O(M) ADC table lookups — one per subspace.

type Quantized = OpqQuantized

The packed quantized form. Must be convertible to a UnifiedQuantizedVector reference via AsRef.

type Query = OpqQuery

The prepared query form (codec-specific).

fn encode(&self, v: &[f32]) -> Self::Quantized

Encode a single FP32 vector into the codec’s packed form.

fn adc_lut(&self, q: &Self::Query) -> Option<AdcLut>

Optional: precompute ADC lookup table for codecs that use one (PQ, IVF-PQ, TurboQuant). Returns None for codecs that don’t (RaBitQ, BBQ, ternary, binary).

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

Optional: fit the codec’s learned parameters on a set of training vectors.