Struct FibQuantizer 

pub struct FibQuantizer { /* private fields */ }

FibQuant encoder/decoder bound to one profile and codebook.

Implementations

impl FibQuantizer

pub fn new(profile: FibQuantProfileV1) -> Result<Self>

Build a quantizer by constructing the profile codebook.

pub fn from_codebook(codebook: FibCodebookV1) -> Result<Self>

Build a quantizer from a validated codebook.

pub fn profile(&self) -> &FibQuantProfileV1

Access the profile.

pub fn codebook(&self) -> &FibCodebookV1

Access the codebook.

pub fn encode(&self, x: &[f32]) -> Result<FibCodeV1>

Encode a vector into a fixed-rate artifact.

pub fn decode(&self, code: &FibCodeV1) -> Result<Vec<f32>>

Decode a fixed-rate artifact.

pub fn encode_with_receipt( &self, x: &[f32], ) -> Result<(FibCodeV1, FibQuantCompressionReceiptV1)>

Encode and emit a receipt.

pub fn reconstruction_mse(&self, x: &[f32]) -> Result<f64>

Reconstruction MSE for one vector.

pub fn cosine_similarity(&self, x: &[f32]) -> Result<f64>

Reconstruction cosine similarity for one vector.

pub fn encode_batch(&self, vectors: &[&[f32]]) -> Result<Vec<FibCodeV1>>

Encode a batch of vectors. Uses gpu-backend for the Hadamard + Lloyd-Max portions when available, keeping the FibCodeV1 format identical to single encode.

pub fn decode_batch(&self, codes: &[FibCodeV1]) -> Result<Vec<Vec<f32>>>

Decode a batch of codes.

pub fn decode_batch_fast(&self, codes: &[FibCodeV1]) -> Result<Vec<Vec<f32>>>

Fast batch decode. Optimized for the case where many small codes share the same profile (so the codebook + rotation are reused).

Key wins over decode_batch:

1. No per-index Vec<f64> allocation in the codeword gather — each codeword is copied in place into a single Vec<f32>.
2. The rotation matrix is converted to f32 once for the whole batch, then apply_inverse_f32 is called per code (no f32→f64 roundtrip on the rotation or the input).
3. The unpacked indices are reused via as_f32_slice() where possible.

Output is byte-identical to calling decode per code, modulo the final as f32 cast in decode (we also cast to f32 at the end; intermediate precision is below the codebook quantization noise floor and matches the original as f32 step exactly).

pub fn is_gpu_accelerated(&self) -> bool

Check if GPU acceleration is available.

This is a device-availability probe: it returns true if a CUDA device was found at init time. Whether an individual encode_batch call actually dispatches to GPU depends on the call’s batch size and vector dimension crossing the runtime thresholds.

Use Self::is_gpu_accelerated_for for an honest per-call check.

pub fn is_gpu_accelerated_for(&self, n: usize, d: usize) -> bool

Check if a batch of n vectors of dimension d would actually dispatch to GPU. Returns true only when:

• the gpu feature is compiled in,
• a CUDA device is available at runtime,
• n >= GPU_MIN_BATCH_SIZE and d >= GPU_MIN_DIM, AND
• the codebook size N is <= 32 (the codebook_lookup kernel is one warp wide and falls back to CPU otherwise).

This is the honest gate for receipts: a 4-doc corpus with dim 64 returns false even with --features gpu, because the batch is too small to overcome GPU launch overhead. A corpus with a codebook larger than 32 also returns false.

pub fn gpu_steps_for(&self, n: usize, d: usize) -> GpuStepReport

Per-step GPU dispatch report. hadamard is true if a batch of size n at dim d would dispatch the Hadamard rotation to GPU. codebook_lookup is true only if both the Hadamard AND the codebook-lookup step would dispatch (additionally requires codebook size <= 32). The latter is independent of the gpu_codebook_lookup feature gate — the feature controls whether the dispatch is enabled in encode_batch, not whether the kernel would be a win.

Trait Implementations

impl Clone for FibQuantizer

fn clone(&self) -> FibQuantizer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FibQuantizer

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

Formats the value using the given formatter.