Struct MinMaxCompensation 

#[repr(C)]
pub struct MinMaxCompensation {
    pub dim: u32,
    pub b: f32,
    pub n: f32,
    pub a: f32,
    pub norm_squared: f32,
}

A per-vector precomputed coefficients to help compute inner products and squared L2 distances for the MinMax quantized vectors.

The inner product between X = ax * X' + bx and Y = ay * Y' + by for d-dimensional vectors X and Y is:

<X, Y> = <ax * X' + bx, ay * Y' + by>
       = ax * ay * <X', Y'> + ax * <X', by> + ay * <Y', bx> + d * bx * by.

Let us define a grouping of these terms to make it easier to understand:

 Nx = ax * sum_i X'[i],     Ny = ay * sum_i Y'[i],

We can then simplify the dot product calculation as follows:

<X, Y> = ax * ay * <X', Y'> + Nx * by + Ny * bx +  d * bx * by
                   --------
                      |
              Integer Dot Product

To compute the squared L2 distance,

|X - Y|^2 = |ax * X' + bx|^2 + |ay * Y' + by|^2 - 2 * <X, Y>

we can re-use the computation for inner-product from above.

Fields

dim: u32

b: f32

n: f32

a: f32

norm_squared: f32

Implementations

impl MinMaxCompensation

pub fn read_dimension(bytes: &[u8]) -> Result<usize, MetaParseError>

Reads the dimension from the first 4 bytes of a MinMax quantized vector’s metadata.

This function is used to extract the vector dimension from serialized MinMax quantized vector data without fully deserializing the entire vector structure.

Arguments

• bytes - A byte slice containing the serialized MinMax vector data

Returns

• Ok(dimension) - The dimension of the vector as a usize
• Err(MetaParseError::NotCanonical(size)) - If the byte slice is shorter than 20 bytes (META_BYTES)

Usage

Use this when you need to determine the vector dimension from serialized data before creating a DataRef or allocating appropriately sized buffers for decompression.

Trait Implementations

impl Clone for MinMaxCompensation

fn clone(&self) -> MinMaxCompensation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MinMaxCompensation

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

Formats the value using the given formatter.

impl Default for MinMaxCompensation

fn default() -> MinMaxCompensation

Returns the “default value” for a type.

impl PartialEq for MinMaxCompensation

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

fn zeroed() -> Self

Calls zeroed.

impl Copy for MinMaxCompensation

impl Pod for MinMaxCompensation

impl StructuralPartialEq for MinMaxCompensation