pub(crate) mod simd;
use std::f32::consts::TAU;
use std::f64::consts::FRAC_PI_2;
use crate::codec::VectorCodec;
use crate::codec::prng::SplitMix64;
use crate::error::{Error, Result};
use crate::format::Checksum;
use crate::format::catalog::VectorMetric;
use crate::format::qam_lloyd_max_params::{QAM_BITS_MAX, QAM_BITS_MIN, QamLloydMaxParams};
const DEFAULT_BLOCK_SIZE: u32 = 1024;
const DEFAULT_ROTATION_SEED: u64 = 0x6C61_6D61_5F71_616D; pub(crate) const DEFAULT_AMP_BITS: u8 = 5;
pub(crate) const DEFAULT_PHASE_BITS: u8 = 6;
const DEFAULT_RENORMALIZE: bool = true;
const fn align_up(n: usize, align: usize) -> usize {
n.div_ceil(align) * align
}
const STREAM_ALIGN: usize = 64;
const fn packed_bytes(count: usize, bits: u8) -> usize {
let total_bits = count * bits as usize;
total_bits.div_ceil(8)
}
const fn padded_stream_bytes(count: usize, bits: u8) -> usize {
align_up(packed_bytes(count, bits), STREAM_ALIGN)
}
fn erf(x: f64) -> f64 {
let a1 = 0.254_829_592;
let a2 = -0.284_496_736;
let a3 = 1.421_413_741;
let a4 = -1.453_152_027;
let a5 = 1.061_405_429;
let p = 0.327_591_1;
let sign = if x < 0.0 { -1.0 } else { 1.0 };
let xa = x.abs();
let t = 1.0 / (1.0 + p * xa);
let y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * (-xa * xa).exp();
sign * y
}
const RAYLEIGH_R_MAX: f64 = 8.0;
const RAYLEIGH_GRID_POINTS: usize = 8192;
const LM_MAX_ITER: usize = 200;
const LM_TOL: f64 = 1e-10;
fn rayleigh_partial_moments(a: f64, b: f64) -> (f64, f64) {
let ea = (-a * a / 2.0).exp();
let eb = (-b * b / 2.0).exp();
let p = ea - eb;
let sqrt_half_pi = FRAC_PI_2.sqrt();
let sqrt_half = (0.5_f64).sqrt();
let m = sqrt_half_pi * (erf(b * sqrt_half) - erf(a * sqrt_half)) + a * ea - b * eb;
(p, m)
}
fn interp_ascending(target: f64, xs: &[f64], ys: &[f64]) -> f64 {
debug_assert_eq!(xs.len(), ys.len());
if target <= xs[0] {
return ys[0];
}
if target >= *xs.last().unwrap() {
return *ys.last().unwrap();
}
let mut lo = 0usize;
let mut hi = xs.len() - 1;
while hi - lo > 1 {
let mid = (lo + hi) / 2;
if xs[mid] <= target {
lo = mid;
} else {
hi = mid;
}
}
let span = xs[hi] - xs[lo];
if span <= 0.0 {
return ys[lo];
}
let t = (target - xs[lo]) / span;
ys[lo] + t * (ys[hi] - ys[lo])
}
fn lloyd_max_rayleigh(num_levels: u32) -> (Vec<f32>, Vec<f32>) {
let n = num_levels as usize;
debug_assert!(n >= 1);
let mut rs = vec![0.0_f64; RAYLEIGH_GRID_POINTS];
let dx = RAYLEIGH_R_MAX / (RAYLEIGH_GRID_POINTS - 1) as f64;
for (i, r) in rs.iter_mut().enumerate() {
*r = i as f64 * dx;
}
let mut f: Vec<f64> = rs.iter().map(|&r| r * (-r * r / 2.0).exp()).collect();
let mut total = 0.0_f64;
for i in 0..RAYLEIGH_GRID_POINTS - 1 {
total += 0.5 * (f[i] + f[i + 1]) * dx;
}
for v in &mut f {
*v /= total;
}
let f13: Vec<f64> = f.iter().map(|&v| v.max(1e-30).powf(1.0 / 3.0)).collect();
let mut cum = vec![0.0_f64; RAYLEIGH_GRID_POINTS];
cum[0] = f13[0];
for i in 1..RAYLEIGH_GRID_POINTS {
cum[i] = cum[i - 1] + f13[i];
}
let cum_max = *cum.last().unwrap();
for v in &mut cum {
*v /= cum_max;
}
let mut levels = vec![0.0_f64; n];
for (i, lev) in levels.iter_mut().enumerate() {
let target = (i as f64 + 0.5) / n as f64;
*lev = interp_ascending(target, &cum, &rs);
}
let mut boundaries = vec![0.0_f64; n + 1];
boundaries[n] = RAYLEIGH_R_MAX;
for _ in 0..LM_MAX_ITER {
for i in 1..n {
boundaries[i] = 0.5 * (levels[i - 1] + levels[i]);
}
let mut max_delta = 0.0_f64;
for i in 0..n {
let a = boundaries[i];
let b = boundaries[i + 1];
let (p, m) = rayleigh_partial_moments(a, b);
let new_level = if p > 1e-15 { m / p } else { levels[i] };
let lo = a + 1e-9;
let hi = b - 1e-9;
let new_level = if new_level < lo {
lo
} else if new_level > hi {
hi
} else {
new_level
};
let delta = (new_level - levels[i]).abs();
if delta > max_delta {
max_delta = delta;
}
levels[i] = new_level;
}
if max_delta < LM_TOL {
break;
}
}
let levels_f32 = levels.iter().map(|&v| v as f32).collect();
let boundaries_f32 = boundaries.iter().map(|&v| v as f32).collect();
(levels_f32, boundaries_f32)
}
#[cfg(test)]
fn lloyd_max_rayleigh_distortion(levels: &[f32], boundaries: &[f32]) -> f64 {
debug_assert_eq!(levels.len() + 1, boundaries.len());
let mut total = 0.0_f64;
for (i, &l_f32) in levels.iter().enumerate() {
let l = l_f32 as f64;
let a = boundaries[i] as f64;
let b = boundaries[i + 1] as f64;
let (p, m) = rayleigh_partial_moments(a, b);
let s = (a * a + 2.0) * (-a * a / 2.0).exp() - (b * b + 2.0) * (-b * b / 2.0).exp();
total += s - 2.0 * l * m + l * l * p;
}
total
}
fn signs_from_seed(seed: u64, dim: usize) -> Vec<f32> {
let mut prng = SplitMix64::new(seed);
let mut signs = Vec::with_capacity(dim);
let mut bits: u64 = 0;
let mut bits_left: u32 = 0;
for _ in 0..dim {
if bits_left == 0 {
bits = prng.next_u64();
bits_left = 64;
}
let s = if bits & 1 == 0 { 1.0_f32 } else { -1.0_f32 };
bits >>= 1;
bits_left -= 1;
signs.push(s);
}
signs
}
pub(super) fn block_hadamard_forward(
data: &mut [f32],
signs: &[f32],
block_size: usize,
) -> Result<()> {
if data.len() != signs.len() {
return Err(Error::Format(format!(
"block_hadamard_forward: data len {} != signs len {}",
data.len(),
signs.len()
)));
}
if block_size == 0 || !block_size.is_power_of_two() {
return Err(Error::Format(format!(
"block_hadamard_forward: block_size {block_size} must be a positive power of two"
)));
}
if !data.len().is_multiple_of(block_size) {
return Err(Error::Format(format!(
"block_hadamard_forward: data len {} is not a multiple of block_size {block_size}",
data.len()
)));
}
simd::block_hadamard_forward(data, signs, block_size);
Ok(())
}
pub(super) fn block_hadamard_inverse(
data: &mut [f32],
signs: &[f32],
block_size: usize,
) -> Result<()> {
if data.len() != signs.len() {
return Err(Error::Format(format!(
"block_hadamard_inverse: data len {} != signs len {}",
data.len(),
signs.len()
)));
}
if block_size == 0 || !block_size.is_power_of_two() {
return Err(Error::Format(format!(
"block_hadamard_inverse: block_size {block_size} must be a positive power of two"
)));
}
if !data.len().is_multiple_of(block_size) {
return Err(Error::Format(format!(
"block_hadamard_inverse: data len {} is not a multiple of block_size {block_size}",
data.len()
)));
}
simd::block_hadamard_inverse(data, signs, block_size);
Ok(())
}
fn pack_bits(values: &[u32], bits: u8, out: &mut [u8]) {
debug_assert!((1..=32).contains(&bits));
debug_assert!(out.len() >= packed_bytes(values.len(), bits));
for b in out.iter_mut() {
*b = 0;
}
let bits_u32 = bits as u32;
let mask: u64 = if bits_u32 == 32 {
u32::MAX as u64
} else {
(1u64 << bits_u32) - 1
};
let mut acc: u64 = 0;
let mut acc_bits: u32 = 0;
let mut byte_idx = 0usize;
for &v in values {
let v = (v as u64) & mask;
acc |= v << acc_bits;
acc_bits += bits_u32;
while acc_bits >= 8 {
out[byte_idx] = (acc & 0xFF) as u8;
byte_idx += 1;
acc >>= 8;
acc_bits -= 8;
}
}
if acc_bits > 0 {
out[byte_idx] = (acc & 0xFF) as u8;
}
}
fn unpack_bits(bytes: &[u8], bits: u8, count: usize, out: &mut [u32]) {
debug_assert!((1..=32).contains(&bits));
debug_assert_eq!(out.len(), count);
debug_assert!(bytes.len() >= packed_bytes(count, bits));
let bits_u32 = bits as u32;
let mask: u64 = if bits_u32 == 32 {
u32::MAX as u64
} else {
(1u64 << bits_u32) - 1
};
let mut acc: u64 = 0;
let mut acc_bits: u32 = 0;
let mut byte_idx = 0usize;
for slot in out.iter_mut().take(count) {
while acc_bits < bits_u32 {
acc |= (bytes[byte_idx] as u64) << acc_bits;
byte_idx += 1;
acc_bits += 8;
}
*slot = (acc & mask) as u32;
acc >>= bits_u32;
acc_bits -= bits_u32;
}
}
#[derive(Debug)]
pub(crate) struct QamLloydMaxCodec {
pub(crate) dim: usize,
pub(crate) num_pairs: usize,
pub(crate) block_size: usize,
pub(crate) rotation_seed: u64,
pub(crate) amp_bits: u8,
pub(crate) phase_bits: u8,
pub(crate) renormalize_at_decode: bool,
pub(crate) sigma_per_pair: Vec<f32>,
pub(crate) base_bytes_per_vector: usize,
pub(crate) query_bytes_per_vector: usize,
pub(crate) amp_stream_offset: usize,
pub(crate) amp_stream_bytes: usize,
pub(crate) phase_stream_offset: usize,
pub(crate) phase_stream_bytes: usize,
pub(crate) signs: Vec<f32>,
pub(crate) amp_levels_unit: Vec<f32>,
pub(crate) amp_boundaries_unit: Vec<f32>,
pub(crate) phase_cos_lut: Vec<f32>,
pub(crate) phase_sin_lut: Vec<f32>,
pub(crate) sliding_engine: std::sync::OnceLock<crate::codec::qam_sliding::QamSlidingEngine>,
}
impl QamLloydMaxCodec {
#[cfg(any(test, feature = "bench"))]
pub(crate) fn new(dim: usize) -> Result<Self> {
Self::with_config(
dim,
DEFAULT_BLOCK_SIZE as usize,
DEFAULT_AMP_BITS,
DEFAULT_PHASE_BITS,
DEFAULT_RENORMALIZE,
)
}
pub(crate) fn for_calibration_with_bits(
dim: usize,
amp_bits: u8,
phase_bits: u8,
) -> Result<Self> {
if dim == 0 || !dim.is_multiple_of(2) {
return Self::with_config(
dim,
DEFAULT_BLOCK_SIZE as usize,
amp_bits,
phase_bits,
DEFAULT_RENORMALIZE,
);
}
let block_size = (1usize << dim.trailing_zeros()).min(DEFAULT_BLOCK_SIZE as usize);
Self::with_config(dim, block_size, amp_bits, phase_bits, DEFAULT_RENORMALIZE)
}
pub(crate) fn with_config(
dim: usize,
block_size: usize,
amp_bits: u8,
phase_bits: u8,
renormalize_at_decode: bool,
) -> Result<Self> {
if dim == 0 || !dim.is_multiple_of(2) {
return Err(Error::Format(format!(
"QamLloydMaxCodec: dim {dim} must be a positive even number"
)));
}
if block_size == 0 || !block_size.is_power_of_two() {
return Err(Error::Format(format!(
"QamLloydMaxCodec: block_size {block_size} must be a power of two"
)));
}
if !dim.is_multiple_of(block_size) {
return Err(Error::Format(format!(
"QamLloydMaxCodec: block_size {block_size} must divide dim {dim}"
)));
}
if !(QAM_BITS_MIN..=QAM_BITS_MAX).contains(&_bits) {
return Err(Error::Format(format!(
"QamLloydMaxCodec: amp_bits {amp_bits} out of range"
)));
}
if !(QAM_BITS_MIN..=QAM_BITS_MAX).contains(&phase_bits) {
return Err(Error::Format(format!(
"QamLloydMaxCodec: phase_bits {phase_bits} out of range"
)));
}
let num_pairs = dim / 2;
let prior_sigma = (1.0_f32 / dim as f32).sqrt();
let sigma_per_pair = vec![prior_sigma; num_pairs];
Self::from_validated(
dim,
num_pairs,
block_size,
DEFAULT_ROTATION_SEED,
amp_bits,
phase_bits,
renormalize_at_decode,
sigma_per_pair,
)
}
pub(crate) fn from_params(params: &QamLloydMaxParams) -> Result<Self> {
Self::from_validated(
params.dimension as usize,
params.num_pairs as usize,
params.block_size as usize,
params.rotation_seed,
params.amp_bits,
params.phase_bits,
params.renormalize_at_decode,
params.sigma_per_pair.clone(),
)
}
#[allow(clippy::too_many_arguments)]
fn from_validated(
dim: usize,
num_pairs: usize,
block_size: usize,
rotation_seed: u64,
amp_bits: u8,
phase_bits: u8,
renormalize_at_decode: bool,
sigma_per_pair: Vec<f32>,
) -> Result<Self> {
if num_pairs * 2 != dim {
return Err(Error::Format(format!(
"QamLloydMaxCodec: num_pairs ({num_pairs}) * 2 must equal dim ({dim})"
)));
}
if sigma_per_pair.len() != num_pairs {
return Err(Error::Format(format!(
"QamLloydMaxCodec: sigma_per_pair length {} must equal num_pairs {num_pairs}",
sigma_per_pair.len()
)));
}
for (i, s) in sigma_per_pair.iter().enumerate() {
if !s.is_finite() || *s <= 0.0 {
return Err(Error::Format(format!(
"QamLloydMaxCodec: sigma_per_pair[{i}] = {s} must be finite and positive"
)));
}
}
let amp_stream_bytes = padded_stream_bytes(num_pairs, amp_bits);
let phase_stream_bytes = padded_stream_bytes(num_pairs, phase_bits);
let amp_stream_offset = 0;
let phase_stream_offset = amp_stream_bytes;
let base_bytes_per_vector = amp_stream_bytes + phase_stream_bytes;
let query_bytes_per_vector = dim * 4 + 4;
let signs = signs_from_seed(rotation_seed, dim);
let (amp_levels_unit, amp_boundaries_unit) = lloyd_max_rayleigh(1u32 << amp_bits);
let n_phase = 1usize << phase_bits;
let mut phase_cos_lut = Vec::with_capacity(n_phase);
let mut phase_sin_lut = Vec::with_capacity(n_phase);
let phase_step = TAU / n_phase as f32;
for i in 0..n_phase {
let theta = i as f32 * phase_step;
let (s, c) = theta.sin_cos();
phase_cos_lut.push(c);
phase_sin_lut.push(s);
}
Ok(Self {
dim,
num_pairs,
block_size,
rotation_seed,
amp_bits,
phase_bits,
renormalize_at_decode,
sigma_per_pair,
base_bytes_per_vector,
query_bytes_per_vector,
amp_stream_offset,
amp_stream_bytes,
phase_stream_offset,
phase_stream_bytes,
signs,
amp_levels_unit,
amp_boundaries_unit,
phase_cos_lut,
phase_sin_lut,
sliding_engine: std::sync::OnceLock::new(),
})
}
pub(crate) fn to_params(&self, calibration_id: Checksum) -> QamLloydMaxParams {
QamLloydMaxParams {
dimension: self.dim as u32,
num_pairs: self.num_pairs as u32,
block_size: self.block_size as u32,
rotation_seed: self.rotation_seed,
amp_bits: self.amp_bits,
phase_bits: self.phase_bits,
renormalize_at_decode: self.renormalize_at_decode,
sigma_per_pair: self.sigma_per_pair.clone(),
calibration_id,
}
}
pub(crate) fn calibrate(&mut self, sample: &[Vec<f32>]) -> Result<()> {
if sample.is_empty() {
return Err(Error::Format(
"QamLloydMaxCodec::calibrate: empty sample".into(),
));
}
for (i, v) in sample.iter().enumerate() {
if v.len() != self.dim {
return Err(Error::Format(format!(
"QamLloydMaxCodec::calibrate: sample[{i}] dim mismatch ({} vs {})",
v.len(),
self.dim
)));
}
for (j, x) in v.iter().enumerate() {
if !x.is_finite() {
return Err(Error::Format(format!(
"QamLloydMaxCodec::calibrate: sample[{i}][{j}] is non-finite"
)));
}
}
}
let mut sums = vec![0.0_f64; self.num_pairs];
let mut scratch = vec![0.0_f32; self.dim];
for v in sample {
scratch.copy_from_slice(v);
block_hadamard_forward(&mut scratch, &self.signs, self.block_size)?;
for k in 0..self.num_pairs {
let re = scratch[2 * k];
let im = scratch[2 * k + 1];
sums[k] += ((re * re + im * im).sqrt()) as f64;
}
}
let inv_denom = 1.0_f64 / (sample.len() as f64 * FRAC_PI_2.sqrt());
for (k, s) in sums.iter().enumerate() {
let sigma = ((s * inv_denom) as f32).max(1e-12);
self.sigma_per_pair[k] = sigma;
}
Ok(())
}
pub(crate) fn encode(&self, values: &[f32]) -> Result<Vec<u8>> {
if values.len() != self.dim {
return Err(Error::Format(format!(
"QamLloydMaxCodec::encode: dim mismatch (expected {}, got {})",
self.dim,
values.len()
)));
}
for &v in values {
if !v.is_finite() {
return Err(Error::Format(
"QamLloydMaxCodec::encode: non-finite input".into(),
));
}
}
let mut x = values.to_vec();
block_hadamard_forward(&mut x, &self.signs, self.block_size)?;
let n_amp = 1u32 << self.amp_bits;
let n_phase = 1u32 << self.phase_bits;
let phase_index_scale = (n_phase as f32) / TAU;
let mut amps_raw = vec![0.0_f32; self.num_pairs];
simd::pair_magnitudes(&x, &mut amps_raw);
let mut amp_indices = vec![0u32; self.num_pairs];
let mut phase_indices = vec![0u32; self.num_pairs];
for k in 0..self.num_pairs {
let re = x[2 * k];
let im = x[2 * k + 1];
let amp = amps_raw[k];
let theta = im.atan2(re); let norm_amp = amp / self.sigma_per_pair[k];
amp_indices[k] = self.amp_index(norm_amp, n_amp);
let rounded = (theta * phase_index_scale).round() as i64;
let p_idx = rounded.rem_euclid(n_phase as i64) as u32;
phase_indices[k] = p_idx;
}
let mut out = vec![0u8; self.base_bytes_per_vector];
let amp_dst =
&mut out[self.amp_stream_offset..self.amp_stream_offset + self.amp_stream_bytes];
pack_bits(&_indices, self.amp_bits, amp_dst);
let phase_dst =
&mut out[self.phase_stream_offset..self.phase_stream_offset + self.phase_stream_bytes];
pack_bits(&phase_indices, self.phase_bits, phase_dst);
Ok(out)
}
pub(crate) fn sign_sketch(&self, base: &[u8]) -> Result<Vec<u64>> {
if base.len() != self.base_bytes_per_vector {
return Err(Error::Format(format!(
"QamLloydMaxCodec::sign_sketch: base length mismatch (expected {}, got {})",
self.base_bytes_per_vector,
base.len()
)));
}
let phase_src =
&base[self.phase_stream_offset..self.phase_stream_offset + self.phase_stream_bytes];
let mut phase_idx = vec![0u32; self.num_pairs];
unpack_bits(phase_src, self.phase_bits, self.num_pairs, &mut phase_idx);
let mut sk = vec![0u64; self.dim.div_ceil(64)];
for (k, &pi) in phase_idx.iter().enumerate() {
let pi = pi as usize;
let (d0, d1) = (2 * k, 2 * k + 1);
if self.phase_cos_lut[pi] >= 0.0 {
sk[d0 >> 6] |= 1u64 << (d0 & 63);
}
if self.phase_sin_lut[pi] >= 0.0 {
sk[d1 >> 6] |= 1u64 << (d1 & 63);
}
}
Ok(sk)
}
pub(crate) fn decode_lossy(&self, base: &[u8]) -> Result<Vec<f32>> {
if base.len() != self.base_bytes_per_vector {
return Err(Error::Format(format!(
"QamLloydMaxCodec::decode_lossy: base length mismatch (expected {}, got {})",
self.base_bytes_per_vector,
base.len()
)));
}
let amp_src = &base[self.amp_stream_offset..self.amp_stream_offset + self.amp_stream_bytes];
let phase_src =
&base[self.phase_stream_offset..self.phase_stream_offset + self.phase_stream_bytes];
let mut amp_indices = vec![0u32; self.num_pairs];
let mut phase_indices = vec![0u32; self.num_pairs];
unpack_bits(amp_src, self.amp_bits, self.num_pairs, &mut amp_indices);
unpack_bits(
phase_src,
self.phase_bits,
self.num_pairs,
&mut phase_indices,
);
let n_amp = 1u32 << self.amp_bits;
let n_phase = 1u32 << self.phase_bits;
let mut x = vec![0.0_f32; self.dim];
for k in 0..self.num_pairs {
let ai = amp_indices[k];
if ai >= n_amp {
return Err(Error::Integrity(format!(
"QamLloydMaxCodec::decode_lossy: pair {k} amp_index {ai} >= {n_amp}"
)));
}
let pi = phase_indices[k];
if pi >= n_phase {
return Err(Error::Integrity(format!(
"QamLloydMaxCodec::decode_lossy: pair {k} phase_index {pi} >= {n_phase}"
)));
}
let amp = self.amp_levels_unit[ai as usize] * self.sigma_per_pair[k];
let c = self.phase_cos_lut[pi as usize];
let s = self.phase_sin_lut[pi as usize];
x[2 * k] = amp * c;
x[2 * k + 1] = amp * s;
}
block_hadamard_inverse(&mut x, &self.signs, self.block_size)?;
if self.renormalize_at_decode {
let norm_sq: f32 = x.iter().map(|&v| v * v).sum();
let norm = norm_sq.sqrt();
if norm > 1e-12 {
let inv = 1.0 / norm;
for v in x.iter_mut() {
*v *= inv;
}
}
}
Ok(x)
}
#[cfg(any(test, feature = "bench"))]
pub(crate) fn symmetric_distance(
&self,
a: &[u8],
b: &[u8],
metric: VectorMetric,
) -> Result<f32> {
if a.len() != self.base_bytes_per_vector {
return Err(Error::Format(format!(
"QamLloydMaxCodec::symmetric_distance: base 'a' length mismatch (expected {}, got {})",
self.base_bytes_per_vector,
a.len()
)));
}
if b.len() != self.base_bytes_per_vector {
return Err(Error::Format(format!(
"QamLloydMaxCodec::symmetric_distance: base 'b' length mismatch (expected {}, got {})",
self.base_bytes_per_vector,
b.len()
)));
}
let mut amp_a = vec![0u32; self.num_pairs];
let mut phase_a = vec![0u32; self.num_pairs];
let mut amp_b = vec![0u32; self.num_pairs];
let mut phase_b = vec![0u32; self.num_pairs];
unpack_bits(
&a[self.amp_stream_offset..self.amp_stream_offset + self.amp_stream_bytes],
self.amp_bits,
self.num_pairs,
&mut amp_a,
);
unpack_bits(
&a[self.phase_stream_offset..self.phase_stream_offset + self.phase_stream_bytes],
self.phase_bits,
self.num_pairs,
&mut phase_a,
);
unpack_bits(
&b[self.amp_stream_offset..self.amp_stream_offset + self.amp_stream_bytes],
self.amp_bits,
self.num_pairs,
&mut amp_b,
);
unpack_bits(
&b[self.phase_stream_offset..self.phase_stream_offset + self.phase_stream_bytes],
self.phase_bits,
self.num_pairs,
&mut phase_b,
);
let n_amp = 1u32 << self.amp_bits;
let n_phase = 1u32 << self.phase_bits;
for (k, &v) in amp_a.iter().enumerate() {
if v >= n_amp {
return Err(Error::Integrity(format!(
"symmetric_distance: a.amp[{k}]={v} >= {n_amp}"
)));
}
}
for (k, &v) in amp_b.iter().enumerate() {
if v >= n_amp {
return Err(Error::Integrity(format!(
"symmetric_distance: b.amp[{k}]={v} >= {n_amp}"
)));
}
}
for (k, &v) in phase_a.iter().enumerate() {
if v >= n_phase {
return Err(Error::Integrity(format!(
"symmetric_distance: a.phase[{k}]={v} >= {n_phase}"
)));
}
}
for (k, &v) in phase_b.iter().enumerate() {
if v >= n_phase {
return Err(Error::Integrity(format!(
"symmetric_distance: b.phase[{k}]={v} >= {n_phase}"
)));
}
}
let (dot, na_sq, nb_sq) = simd::symmetric_dot_pairs(
&_a,
&phase_a,
&_b,
&phase_b,
&self.sigma_per_pair,
&self.amp_levels_unit,
&self.phase_cos_lut,
&self.phase_sin_lut,
);
let na = na_sq.sqrt();
let nb = nb_sq.sqrt();
match metric {
VectorMetric::Cosine => {
let denom = (na * nb).max(1e-12);
Ok(1.0 - dot / denom)
}
VectorMetric::InnerProduct => {
if self.renormalize_at_decode {
let inv = if na > 1e-12 && nb > 1e-12 {
1.0 / (na * nb)
} else {
0.0
};
Ok(-dot * inv)
} else {
Ok(-dot)
}
}
VectorMetric::L2 => {
if self.renormalize_at_decode {
let inv = if na > 1e-12 && nb > 1e-12 {
1.0 / (na * nb)
} else {
0.0
};
Ok(2.0 - 2.0 * dot * inv)
} else {
Ok(na_sq + nb_sq - 2.0 * dot)
}
}
}
}
pub(crate) fn prepare_query_blob(&self, query: &[f32]) -> Result<Vec<u8>> {
let (q_rot, q_norm) = self.prepare_query_rotated(query)?;
let mut blob = Vec::with_capacity(self.query_bytes_per_vector);
for &v in &q_rot {
blob.extend_from_slice(&v.to_le_bytes());
}
blob.extend_from_slice(&q_norm.to_le_bytes());
debug_assert_eq!(blob.len(), self.query_bytes_per_vector);
Ok(blob)
}
pub(crate) fn prepare_query_rotated(&self, query: &[f32]) -> Result<(Vec<f32>, f32)> {
if query.len() != self.dim {
return Err(Error::Format(format!(
"QamLloydMaxCodec::prepare_query_rotated: dim mismatch (expected {}, got {})",
self.dim,
query.len()
)));
}
for &v in query {
if !v.is_finite() {
return Err(Error::Format(
"QamLloydMaxCodec::prepare_query_rotated: non-finite input".into(),
));
}
}
let mut q_rot = query.to_vec();
block_hadamard_forward(&mut q_rot, &self.signs, self.block_size)?;
let q_norm: f32 = (q_rot.iter().map(|&v| v * v).sum::<f32>()).sqrt();
Ok((q_rot, q_norm))
}
pub(crate) fn asymmetric_distance_with_rotated(
&self,
q_rot: &[f32],
q_norm: f32,
base: &[u8],
metric: VectorMetric,
) -> Result<f32> {
let mut amp_indices = vec![0u32; self.num_pairs];
let mut phase_indices = vec![0u32; self.num_pairs];
self.asymmetric_distance_with_rotated_scratch(
q_rot,
q_norm,
base,
metric,
&mut amp_indices,
&mut phase_indices,
)
}
pub(crate) fn asymmetric_distance_with_rotated_scratch(
&self,
q_rot: &[f32],
q_norm: f32,
base: &[u8],
metric: VectorMetric,
amp_indices: &mut [u32],
phase_indices: &mut [u32],
) -> Result<f32> {
if q_rot.len() != self.dim {
return Err(Error::Format(format!(
"QamLloydMaxCodec::asymmetric_distance_with_rotated: q_rot length mismatch (expected {}, got {})",
self.dim,
q_rot.len()
)));
}
if base.len() != self.base_bytes_per_vector {
return Err(Error::Format(format!(
"QamLloydMaxCodec::asymmetric_distance_with_rotated: base length mismatch (expected {}, got {})",
self.base_bytes_per_vector,
base.len()
)));
}
if amp_indices.len() != self.num_pairs || phase_indices.len() != self.num_pairs {
return Err(Error::Format(format!(
"QamLloydMaxCodec::asymmetric_distance_with_rotated_scratch: scratch length mismatch (expected {}, got amp={} phase={})",
self.num_pairs,
amp_indices.len(),
phase_indices.len()
)));
}
let amp_src = &base[self.amp_stream_offset..self.amp_stream_offset + self.amp_stream_bytes];
let phase_src =
&base[self.phase_stream_offset..self.phase_stream_offset + self.phase_stream_bytes];
unpack_bits(amp_src, self.amp_bits, self.num_pairs, amp_indices);
unpack_bits(phase_src, self.phase_bits, self.num_pairs, phase_indices);
let n_amp = 1u32 << self.amp_bits;
let n_phase = 1u32 << self.phase_bits;
for (k, &ai) in amp_indices.iter().enumerate() {
if ai >= n_amp {
return Err(Error::Integrity(format!(
"asymmetric_distance: pair {k} amp_index {ai} >= {n_amp}"
)));
}
}
for (k, &pi) in phase_indices.iter().enumerate() {
if pi >= n_phase {
return Err(Error::Integrity(format!(
"asymmetric_distance: pair {k} phase_index {pi} >= {n_phase}"
)));
}
}
let (dot, y_hat_norm_sq) = simd::asymmetric_dot_pairs(
q_rot,
amp_indices,
phase_indices,
&self.sigma_per_pair,
&self.amp_levels_unit,
&self.phase_cos_lut,
&self.phase_sin_lut,
);
let y_hat_norm = y_hat_norm_sq.sqrt();
match metric {
VectorMetric::Cosine => {
let denom = (q_norm * y_hat_norm).max(1e-12);
Ok(1.0 - dot / denom)
}
VectorMetric::InnerProduct => {
if self.renormalize_at_decode {
let inv = if y_hat_norm > 1e-12 {
1.0 / y_hat_norm
} else {
0.0
};
Ok(-dot * inv)
} else {
Ok(-dot)
}
}
VectorMetric::L2 => {
let q_norm_sq = q_norm * q_norm;
if self.renormalize_at_decode {
let inv = if y_hat_norm > 1e-12 {
1.0 / y_hat_norm
} else {
0.0
};
Ok(q_norm_sq + 1.0 - 2.0 * dot * inv)
} else {
Ok(q_norm_sq + y_hat_norm_sq - 2.0 * dot)
}
}
}
}
pub(crate) fn asymmetric_distance_prepared_blob(
&self,
q_blob: &[u8],
base: &[u8],
metric: VectorMetric,
) -> Result<f32> {
if q_blob.len() != self.query_bytes_per_vector {
return Err(Error::Format(format!(
"QamLloydMaxCodec::asymmetric_distance_prepared_blob: q_blob length mismatch (expected {}, got {})",
self.query_bytes_per_vector,
q_blob.len()
)));
}
if base.len() != self.base_bytes_per_vector {
return Err(Error::Format(format!(
"QamLloydMaxCodec::asymmetric_distance_prepared_blob: base length mismatch (expected {}, got {})",
self.base_bytes_per_vector,
base.len()
)));
}
let mut q_rot = vec![0.0_f32; self.dim];
for (k, slot) in q_rot.iter_mut().enumerate() {
*slot = f32::from_le_bytes(
q_blob[k * 4..k * 4 + 4]
.try_into()
.map_err(|_| Error::Integrity("q_rot read".into()))?,
);
}
let q_norm = f32::from_le_bytes(
q_blob[self.dim * 4..self.dim * 4 + 4]
.try_into()
.map_err(|_| Error::Integrity("q_blob truncated".into()))?,
);
let amp_src = &base[self.amp_stream_offset..self.amp_stream_offset + self.amp_stream_bytes];
let phase_src =
&base[self.phase_stream_offset..self.phase_stream_offset + self.phase_stream_bytes];
let mut amp_indices = vec![0u32; self.num_pairs];
let mut phase_indices = vec![0u32; self.num_pairs];
unpack_bits(amp_src, self.amp_bits, self.num_pairs, &mut amp_indices);
unpack_bits(
phase_src,
self.phase_bits,
self.num_pairs,
&mut phase_indices,
);
let n_amp = 1u32 << self.amp_bits;
let n_phase = 1u32 << self.phase_bits;
for (k, &ai) in amp_indices.iter().enumerate() {
if ai >= n_amp {
return Err(Error::Integrity(format!(
"asymmetric_distance: pair {k} amp_index {ai} >= {n_amp}"
)));
}
}
for (k, &pi) in phase_indices.iter().enumerate() {
if pi >= n_phase {
return Err(Error::Integrity(format!(
"asymmetric_distance: pair {k} phase_index {pi} >= {n_phase}"
)));
}
}
let (dot, y_hat_norm_sq) = simd::asymmetric_dot_pairs(
&q_rot,
&_indices,
&phase_indices,
&self.sigma_per_pair,
&self.amp_levels_unit,
&self.phase_cos_lut,
&self.phase_sin_lut,
);
let y_hat_norm = y_hat_norm_sq.sqrt();
match metric {
VectorMetric::Cosine => {
let denom = (q_norm * y_hat_norm).max(1e-12);
Ok(1.0 - dot / denom)
}
VectorMetric::InnerProduct => {
if self.renormalize_at_decode {
let inv = if y_hat_norm > 1e-12 {
1.0 / y_hat_norm
} else {
0.0
};
Ok(-dot * inv)
} else {
Ok(-dot)
}
}
VectorMetric::L2 => {
let q_norm_sq = q_norm * q_norm;
if self.renormalize_at_decode {
let inv = if y_hat_norm > 1e-12 {
1.0 / y_hat_norm
} else {
0.0
};
Ok(q_norm_sq + 1.0 - 2.0 * dot * inv)
} else {
Ok(q_norm_sq + y_hat_norm_sq - 2.0 * dot)
}
}
}
}
fn amp_index(&self, norm_amp: f32, n_amp: u32) -> u32 {
if !norm_amp.is_finite() || norm_amp <= 0.0 {
return 0;
}
let last = (n_amp as usize).saturating_sub(1);
if norm_amp >= self.amp_boundaries_unit[n_amp as usize] {
return last as u32;
}
let mut lo = 1usize;
let mut hi = n_amp as usize;
while lo < hi {
let mid = (lo + hi) / 2;
if self.amp_boundaries_unit[mid] <= norm_amp {
lo = mid + 1;
} else {
hi = mid;
}
}
((lo - 1) as u32).min(last as u32)
}
}
pub(crate) struct QamPreparedQuery {
pub(crate) q_rot: Vec<f32>,
pub(crate) q_norm: f32,
}
impl VectorCodec for QamLloydMaxCodec {
fn as_any(&self) -> &dyn std::any::Any {
self
}
fn family(&self) -> crate::format::catalog::CodecFamily {
crate::format::catalog::CodecFamily::QamLloydMax
}
fn dimension(&self) -> u32 {
self.dim as u32
}
fn sign_sketch(&self, base: &[u8]) -> Result<Vec<u64>> {
QamLloydMaxCodec::sign_sketch(self, base)
}
fn base_bytes_per_vector(&self) -> usize {
self.base_bytes_per_vector
}
fn encode(&self, values: &[f32]) -> Result<Vec<u8>> {
QamLloydMaxCodec::encode(self, values)
}
fn decode_lossy(&self, base: &[u8]) -> Result<Vec<f32>> {
QamLloydMaxCodec::decode_lossy(self, base)
}
fn asymmetric_distance(&self, query: &[f32], base: &[u8], metric: VectorMetric) -> Result<f32> {
let q_blob = self.prepare_query_blob(query)?;
self.asymmetric_distance_prepared_blob(&q_blob, base, metric)
}
fn prepare_query(&self, query: &[f32]) -> Result<Box<dyn std::any::Any + Send + Sync>> {
if self.amp_bits == 5 && self.phase_bits == 6 {
let engine = self.sliding_engine.get_or_init(|| {
crate::codec::qam_sliding::QamSlidingEngine::from_codec(self)
.expect("BUG: QamSlidingEngine::from_codec failed for 5+6 codec")
});
let prep = engine.prepare_query(query)?;
return Ok(Box::new(prep));
}
let (q_rot, q_norm) = self.prepare_query_rotated(query)?;
Ok(Box::new(QamPreparedQuery { q_rot, q_norm }))
}
fn asymmetric_distance_prepared(
&self,
ctx: &(dyn std::any::Any + Send + Sync),
base: &[u8],
metric: VectorMetric,
) -> Result<f32> {
if let Some(prepared) =
ctx.downcast_ref::<crate::codec::qam_sliding::QamSlidingPreparedQuery>()
{
let engine = self.sliding_engine.get().ok_or_else(|| {
Error::Integrity(
"QamLloydMaxCodec::asymmetric_distance_prepared: sliding ctx without engine"
.into(),
)
})?;
return engine.asymmetric_distance(prepared, base, metric);
}
let prepared = ctx.downcast_ref::<QamPreparedQuery>().ok_or_else(|| {
Error::Integrity(
"QamLloydMaxCodec: asymmetric_distance_prepared expects QamPreparedQuery ctx"
.into(),
)
})?;
self.asymmetric_distance_with_rotated(&prepared.q_rot, prepared.q_norm, base, metric)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn new_default_dim_3072() {
let codec = QamLloydMaxCodec::new(3072).expect("construct");
assert_eq!(codec.dim, 3072);
assert_eq!(codec.num_pairs, 1536);
assert_eq!(codec.block_size, 1024);
assert_eq!(codec.amp_bits, 5);
assert_eq!(codec.phase_bits, 6);
assert!(codec.renormalize_at_decode);
assert_eq!(codec.amp_stream_bytes, 960);
assert_eq!(codec.phase_stream_bytes, 1152);
assert_eq!(codec.base_bytes_per_vector, 2112);
assert_eq!(codec.query_bytes_per_vector, 3072 * 4 + 4);
assert_eq!(codec.amp_stream_offset, 0);
assert_eq!(codec.phase_stream_offset, 960);
assert_eq!(codec.signs.len(), 3072);
assert_eq!(codec.amp_levels_unit.len(), 32);
assert_eq!(codec.amp_boundaries_unit.len(), 33);
assert_eq!(codec.phase_cos_lut.len(), 64);
assert_eq!(codec.phase_sin_lut.len(), 64);
}
#[test]
fn new_default_sigma_is_prior() {
let codec = QamLloydMaxCodec::new(3072).expect("construct");
let expected = (1.0_f32 / 3072.0).sqrt();
for s in &codec.sigma_per_pair {
assert!((s - expected).abs() < 1e-7);
}
}
#[test]
fn rejects_zero_dim() {
let err = QamLloydMaxCodec::new(0).expect_err("zero dim");
assert!(err.to_string().contains("dim"));
}
#[test]
fn rejects_odd_dim() {
let err = QamLloydMaxCodec::new(3071).expect_err("odd dim");
assert!(err.to_string().contains("even"));
}
#[test]
fn rejects_non_power_of_two_block_size() {
let err = QamLloydMaxCodec::with_config(3072, 768, 5, 6, true).expect_err("block size");
assert!(err.to_string().contains("power of two"));
}
#[test]
fn rejects_block_not_dividing_dim() {
let err = QamLloydMaxCodec::with_config(3072, 2048, 5, 6, true).expect_err("divides");
assert!(err.to_string().contains("divide"));
}
#[test]
fn rejects_amp_bits_out_of_range() {
let err = QamLloydMaxCodec::with_config(3072, 1024, 0, 6, true).expect_err("amp");
assert!(err.to_string().contains("amp_bits"));
let err = QamLloydMaxCodec::with_config(3072, 1024, 9, 6, true).expect_err("amp");
assert!(err.to_string().contains("amp_bits"));
}
#[test]
fn rejects_phase_bits_out_of_range() {
let err = QamLloydMaxCodec::with_config(3072, 1024, 5, 9, true).expect_err("phase");
assert!(err.to_string().contains("phase_bits"));
}
#[test]
fn to_params_round_trip_through_from_params() {
let codec = QamLloydMaxCodec::new(3072).expect("construct");
let params = codec.to_params([0xCDu8; 32]);
let restored = QamLloydMaxCodec::from_params(¶ms).expect("restore");
assert_eq!(restored.dim, codec.dim);
assert_eq!(restored.amp_levels_unit, codec.amp_levels_unit);
assert_eq!(restored.amp_boundaries_unit, codec.amp_boundaries_unit);
assert_eq!(restored.signs, codec.signs);
}
#[test]
fn lloyd_max_distortion_matches_reference() {
let cases = [
(2u32, 0.146_293_f64),
(4, 0.044_727),
(8, 0.012_612),
(16, 0.003_374),
(32, 0.000_875),
(64, 0.000_223),
];
for (n, expected) in cases {
let (levels, boundaries) = lloyd_max_rayleigh(n);
assert_eq!(levels.len(), n as usize);
assert_eq!(boundaries.len() as u32, n + 1);
let d = lloyd_max_rayleigh_distortion(&levels, &boundaries);
let rel = (d - expected).abs() / expected;
assert!(
rel < 0.01,
"N={n}: expected {expected:.6}, got {d:.6}, rel err {rel:.2e}"
);
}
}
#[test]
fn lloyd_max_levels_are_sorted_in_their_bins() {
let (levels, boundaries) = lloyd_max_rayleigh(32);
for i in 0..levels.len() {
assert!(boundaries[i] < boundaries[i + 1]);
assert!(levels[i] >= boundaries[i]);
assert!(levels[i] <= boundaries[i + 1]);
}
}
#[test]
fn erf_basic_values() {
assert!((erf(0.0)).abs() < 1e-9);
assert!((erf(1.0) - 0.842_700_793).abs() < 2e-7);
assert!((erf(-1.0) + 0.842_700_793).abs() < 2e-7);
assert!((erf(2.0) - 0.995_322_265).abs() < 2e-7);
}
#[test]
fn signs_are_plus_or_minus_one() {
let s = signs_from_seed(0xABCDEF, 1024);
assert_eq!(s.len(), 1024);
for v in s {
assert!(v == 1.0 || v == -1.0);
}
}
#[test]
fn signs_are_deterministic() {
let a = signs_from_seed(42, 256);
let b = signs_from_seed(42, 256);
assert_eq!(a, b);
let c = signs_from_seed(43, 256);
assert_ne!(a, c);
}
#[test]
fn block_hadamard_round_trip_is_identity() {
let mut data: Vec<f32> = (0..3072).map(|i| ((i as f32) * 0.001) - 1.0).collect();
let original = data.clone();
let signs = signs_from_seed(17, 3072);
block_hadamard_forward(&mut data, &signs, 1024).expect("forward");
block_hadamard_inverse(&mut data, &signs, 1024).expect("inverse");
for (a, b) in data.iter().zip(original.iter()) {
assert!((a - b).abs() < 5e-5, "round-trip drift: {a} vs {b}");
}
}
#[test]
fn block_hadamard_preserves_l2_norm() {
let mut data: Vec<f32> = (0..3072).map(|i| ((i % 17) as f32) - 8.0).collect();
let n0_sq: f32 = data.iter().map(|&v| v * v).sum();
let signs = signs_from_seed(99, 3072);
block_hadamard_forward(&mut data, &signs, 1024).expect("forward");
let n1_sq: f32 = data.iter().map(|&v| v * v).sum();
assert!(((n0_sq - n1_sq).abs() / n0_sq) < 1e-5);
}
fn bitpack_round_trip(values: &[u32], bits: u8) {
let mut buf = vec![0u8; packed_bytes(values.len(), bits) + 8];
pack_bits(values, bits, &mut buf);
let mut got = vec![0u32; values.len()];
unpack_bits(&buf, bits, values.len(), &mut got);
assert_eq!(got, values);
}
#[test]
fn pack_unpack_round_trip_widths_1_to_8() {
for bits in 1u8..=8 {
let n = 1u32 << bits;
let values: Vec<u32> = (0..200).map(|i| (i as u32) % n).collect();
bitpack_round_trip(&values, bits);
}
}
#[test]
fn pack_unpack_round_trip_5bit_1536_pairs() {
let values: Vec<u32> = (0..1536).map(|i| (i as u32) & 0x1F).collect();
bitpack_round_trip(&values, 5);
}
#[test]
fn pack_unpack_round_trip_6bit_1536_pairs() {
let values: Vec<u32> = (0..1536).map(|i| (i as u32) & 0x3F).collect();
bitpack_round_trip(&values, 6);
}
#[test]
fn pack_clears_destination_bytes() {
let values = [1u32, 2, 3, 4];
let mut buf = vec![0xFFu8; 16];
pack_bits(&values, 4, &mut buf);
for &b in &buf[2..] {
assert_eq!(b, 0);
}
}
fn synthetic_unit_dataset(n: usize, dim: usize, seed: u64) -> Vec<Vec<f32>> {
let mut prng = SplitMix64::new(seed);
let mut out = Vec::with_capacity(n);
for _ in 0..n {
let mut v = vec![0.0_f32; dim];
let mut i = 0;
while i + 1 < dim {
let u1 = (prng.next_u64() >> 11) as f64 / (1u64 << 53) as f64;
let u2 = (prng.next_u64() >> 11) as f64 / (1u64 << 53) as f64;
let u1 = u1.max(1e-300);
let r = (-2.0 * u1.ln()).sqrt();
let theta = 2.0 * std::f64::consts::PI * u2;
v[i] = (r * theta.cos()) as f32;
v[i + 1] = (r * theta.sin()) as f32;
i += 2;
}
let n2: f32 = v.iter().map(|&x| x * x).sum();
let inv = 1.0 / n2.sqrt();
for x in v.iter_mut() {
*x *= inv;
}
out.push(v);
}
out
}
#[test]
fn calibrate_rejects_dim_mismatch() {
let mut codec = QamLloydMaxCodec::with_config(64, 32, 5, 6, true).expect("construct");
let bad = vec![vec![0.0_f32; 63]];
let err = codec.calibrate(&bad).expect_err("dim mismatch");
assert!(err.to_string().contains("dim mismatch"));
}
fn sliding_style_sketch_5_6(codec: &QamLloydMaxCodec, base: &[u8]) -> Vec<u64> {
let phase =
&base[codec.phase_stream_offset..codec.phase_stream_offset + codec.phase_stream_bytes];
let mut sk = vec![0u64; codec.dim.div_ceil(64)];
for k in 0..codec.num_pairs {
let bitpos = k * 6;
let bytepos = bitpos >> 3;
let shift = bitpos & 7;
let lo = phase[bytepos] as u32;
let hi = *phase.get(bytepos + 1).unwrap_or(&0) as u32;
let pi = (((lo | (hi << 8)) >> shift) & 0x3F) as usize;
let (d0, d1) = (2 * k, 2 * k + 1);
if codec.phase_cos_lut[pi] >= 0.0 {
sk[d0 >> 6] |= 1u64 << (d0 & 63);
}
if codec.phase_sin_lut[pi] >= 0.0 {
sk[d1 >> 6] |= 1u64 << (d1 & 63);
}
}
sk
}
#[test]
fn sign_sketch_matches_sliding_engine_for_5_6() {
let dim = 96;
let mut codec = QamLloydMaxCodec::with_config(dim, 32, 5, 6, true).expect("construct");
let sample = synthetic_unit_dataset(64, dim, 0xBEEF);
codec.calibrate(&sample).expect("calibrate");
for v in &sample {
let base = codec.encode(v).expect("encode");
assert_eq!(
codec.sign_sketch(&base).expect("codec sketch"),
sliding_style_sketch_5_6(&codec, &base),
"general codec sign_sketch must equal the (5,6) sliding-engine sketch"
);
}
}
#[test]
fn sign_sketch_generalizes_to_other_bit_widths() {
let dim = 128;
for (amp, phase) in [(4u8, 4u8), (6, 7), (8, 8)] {
let mut codec =
QamLloydMaxCodec::with_config(dim, 64, amp, phase, true).expect("construct");
let sample = synthetic_unit_dataset(64, dim, 0x1234 ^ amp as u64);
codec.calibrate(&sample).expect("calibrate");
let base = codec.encode(&sample[0]).expect("encode");
let sk = codec.sign_sketch(&base).expect("sketch");
assert_eq!(
sk.len(),
dim.div_ceil(64),
"({amp},{phase}) sketch word count"
);
}
}
#[test]
fn calibrate_rejects_empty_sample() {
let mut codec = QamLloydMaxCodec::with_config(64, 32, 5, 6, true).expect("construct");
let err = codec.calibrate(&[]).expect_err("empty");
assert!(err.to_string().contains("empty sample"));
}
#[test]
fn calibrate_recovers_unit_sigma() {
let dim = 256;
let codec = QamLloydMaxCodec::with_config(dim, 64, 5, 6, true).expect("construct");
let dataset = synthetic_unit_dataset(2000, dim, 0xC0FFEE);
let mut codec_cal = codec;
codec_cal.calibrate(&dataset).expect("calibrate");
let expected = (1.0_f32 / dim as f32).sqrt();
let mean_sigma: f32 =
codec_cal.sigma_per_pair.iter().sum::<f32>() / codec_cal.num_pairs as f32;
assert!(
(mean_sigma - expected).abs() / expected < 0.05,
"mean σ = {mean_sigma}, expected ≈ {expected}"
);
}
#[test]
fn encode_is_deterministic() {
let codec = QamLloydMaxCodec::with_config(128, 64, 5, 6, true).expect("construct");
let v: Vec<f32> = (0..128).map(|i| ((i as f32) * 0.01) - 0.5).collect();
let a = codec.encode(&v).expect("encode a");
let b = codec.encode(&v).expect("encode b");
assert_eq!(a, b);
assert_eq!(a.len(), codec.base_bytes_per_vector);
}
#[test]
fn encode_rejects_dim_mismatch() {
let codec = QamLloydMaxCodec::with_config(128, 64, 5, 6, true).expect("construct");
let err = codec.encode(&vec![0.0_f32; 127]).expect_err("dim");
assert!(err.to_string().contains("dim mismatch"));
}
#[test]
fn encode_rejects_non_finite_input() {
let codec = QamLloydMaxCodec::with_config(128, 64, 5, 6, true).expect("construct");
let mut v = vec![0.0_f32; 128];
v[7] = f32::NAN;
let err = codec.encode(&v).expect_err("nan");
assert!(err.to_string().contains("non-finite"));
}
#[test]
fn decode_rejects_length_mismatch() {
let codec = QamLloydMaxCodec::with_config(128, 64, 5, 6, true).expect("construct");
let err = codec.decode_lossy(&[0u8; 7]).expect_err("len");
assert!(err.to_string().contains("base length"));
}
#[test]
fn round_trip_mse_close_to_predicted_bound() {
let dim = 512;
let codec = QamLloydMaxCodec::with_config(dim, 256, 5, 6, false).expect("construct");
let dataset = synthetic_unit_dataset(1000, dim, 0xBADC0DE);
let mut codec = codec;
codec.calibrate(&dataset).expect("calibrate");
let mut total_mse = 0.0_f64;
for v in &dataset {
let bytes = codec.encode(v).expect("encode");
let decoded = codec.decode_lossy(&bytes).expect("decode");
let mse: f64 = v
.iter()
.zip(decoded.iter())
.map(|(&a, &b)| ((a - b) as f64).powi(2))
.sum();
total_mse += mse;
}
let obs_mse = total_mse / dataset.len() as f64;
let (levels, boundaries) = lloyd_max_rayleigh(32);
let c_lm = lloyd_max_rayleigh_distortion(&levels, &boundaries);
let d_phase = std::f64::consts::PI.powi(2) / (3.0 * 64.0_f64.powi(2));
let pred_mse = 0.5 * c_lm + d_phase;
let ratio = obs_mse / pred_mse;
assert!(
(0.7..=1.3).contains(&ratio),
"round-trip MSE ratio out of expected band: obs={obs_mse:.5}, pred={pred_mse:.5}, ratio={ratio:.3}"
);
}
#[test]
fn renormalize_produces_unit_vector() {
let dim = 64;
let codec = QamLloydMaxCodec::with_config(dim, 32, 5, 6, true).expect("construct");
let dataset = synthetic_unit_dataset(50, dim, 0xFEEDFACE);
let mut codec = codec;
codec.calibrate(&dataset).expect("calibrate");
for v in &dataset {
let bytes = codec.encode(v).expect("encode");
let decoded = codec.decode_lossy(&bytes).expect("decode");
let n2: f32 = decoded.iter().map(|&x| x * x).sum();
assert!((n2.sqrt() - 1.0).abs() < 1e-5, "renorm: {}", n2.sqrt());
}
}
#[test]
fn no_renormalize_norm_close_to_unity_but_not_exact() {
let dim = 64;
let codec = QamLloydMaxCodec::with_config(dim, 32, 5, 6, false).expect("construct");
let dataset = synthetic_unit_dataset(50, dim, 0x12345678);
let mut codec = codec;
codec.calibrate(&dataset).expect("calibrate");
let mut any_off = false;
for v in &dataset {
let bytes = codec.encode(v).expect("encode");
let decoded = codec.decode_lossy(&bytes).expect("decode");
let n2: f32 = decoded.iter().map(|&x| x * x).sum();
assert!((n2.sqrt() - 1.0).abs() < 0.1);
if (n2.sqrt() - 1.0).abs() > 1e-5 {
any_off = true;
}
}
assert!(
any_off,
"renormalize=false should not produce exactly-unit vectors"
);
}
#[test]
fn phase_wrap_pi_and_minus_pi_collapse() {
let codec = QamLloydMaxCodec::with_config(64, 32, 5, 6, false).expect("construct");
let mut a = vec![0.0_f32; 64];
let mut b = vec![0.0_f32; 64];
a[0] = 1e-4;
a[1] = 0.0;
b[0] = -1e-4;
b[1] = 0.0;
let _ea = codec.encode(&a).expect("encode a");
let _eb = codec.encode(&b).expect("encode b");
}
#[test]
fn encode_phase_index_in_range() {
let codec = QamLloydMaxCodec::with_config(128, 64, 5, 6, true).expect("construct");
let dataset = synthetic_unit_dataset(100, 128, 0xC0DE_BABE);
let n_phase = 1u32 << codec.phase_bits;
let n_amp = 1u32 << codec.amp_bits;
for v in &dataset {
let bytes = codec.encode(v).expect("encode");
let mut amp_indices = vec![0u32; codec.num_pairs];
let mut phase_indices = vec![0u32; codec.num_pairs];
unpack_bits(
&bytes[codec.amp_stream_offset..codec.amp_stream_offset + codec.amp_stream_bytes],
codec.amp_bits,
codec.num_pairs,
&mut amp_indices,
);
unpack_bits(
&bytes[codec.phase_stream_offset
..codec.phase_stream_offset + codec.phase_stream_bytes],
codec.phase_bits,
codec.num_pairs,
&mut phase_indices,
);
for &i in &_indices {
assert!(i < n_amp);
}
for &i in &phase_indices {
assert!(i < n_phase);
}
}
}
#[test]
fn phase_lut_is_populated() {
let codec = QamLloydMaxCodec::with_config(64, 32, 5, 6, true).expect("construct");
assert_eq!(codec.phase_cos_lut.len(), 64);
assert_eq!(codec.phase_sin_lut.len(), 64);
assert!((codec.phase_cos_lut[0] - 1.0).abs() < 1e-6);
assert!(codec.phase_sin_lut[0].abs() < 1e-6);
assert!((codec.phase_cos_lut[32] + 1.0).abs() < 1e-6);
assert!(codec.phase_sin_lut[32].abs() < 1e-5);
}
#[test]
fn query_bytes_per_vector_includes_norm_tail() {
let codec = QamLloydMaxCodec::with_config(3072, 1024, 5, 6, true).expect("construct");
assert_eq!(codec.query_bytes_per_vector, 3072 * 4 + 4);
}
#[test]
fn prepare_query_blob_round_trips_q_rot_and_norm() {
let codec = QamLloydMaxCodec::with_config(128, 64, 5, 6, true).expect("construct");
let q: Vec<f32> = (0..128).map(|i| ((i as f32) * 0.0123) - 0.7).collect();
let blob = codec.prepare_query_blob(&q).expect("prep");
assert_eq!(blob.len(), codec.query_bytes_per_vector);
let q_norm = f32::from_le_bytes(blob[128 * 4..128 * 4 + 4].try_into().unwrap());
let q_norm_ref = (q.iter().map(|&v| v * v).sum::<f32>()).sqrt();
assert!((q_norm - q_norm_ref).abs() / q_norm_ref < 1e-5);
}
#[test]
fn prepare_query_is_deterministic() {
let codec = QamLloydMaxCodec::with_config(128, 64, 5, 6, true).expect("construct");
let q: Vec<f32> = (0..128).map(|i| ((i as f32) * 0.05) - 1.0).collect();
let a = codec.prepare_query_blob(&q).expect("a");
let b = codec.prepare_query_blob(&q).expect("b");
assert_eq!(a, b);
}
#[test]
fn prepare_query_rejects_dim_mismatch() {
let codec = QamLloydMaxCodec::with_config(128, 64, 5, 6, true).expect("construct");
let err = codec.prepare_query_blob(&vec![0f32; 127]).expect_err("dim");
assert!(err.to_string().contains("dim mismatch"));
}
#[test]
fn prepare_query_rejects_nonfinite() {
let codec = QamLloydMaxCodec::with_config(128, 64, 5, 6, true).expect("construct");
let mut q = vec![0f32; 128];
q[3] = f32::INFINITY;
let err = codec.prepare_query_blob(&q).expect_err("inf");
assert!(err.to_string().contains("non-finite"));
}
fn reference_distance(query: &[f32], decoded: &[f32], metric: VectorMetric) -> f32 {
let dot: f32 = query.iter().zip(decoded.iter()).map(|(&a, &b)| a * b).sum();
let q_n = (query.iter().map(|&v| v * v).sum::<f32>()).sqrt();
let d_n = (decoded.iter().map(|&v| v * v).sum::<f32>()).sqrt();
match metric {
VectorMetric::Cosine => 1.0 - dot / ((q_n * d_n).max(1e-12)),
VectorMetric::InnerProduct => -dot,
VectorMetric::L2 => query
.iter()
.zip(decoded.iter())
.map(|(&a, &b)| (a - b) * (a - b))
.sum(),
}
}
#[test]
fn asymmetric_distance_matches_decode_then_dot_renorm_true() {
let dim = 128;
let mut codec = QamLloydMaxCodec::with_config(dim, 64, 5, 6, true).expect("construct");
let dataset = synthetic_unit_dataset(50, dim, 0xA1B2_C3D4);
codec.calibrate(&dataset).expect("calibrate");
let queries = synthetic_unit_dataset(10, dim, 0xDEAD_BEEF);
for q in &queries {
let q_blob = codec.prepare_query_blob(q).expect("prep");
for v in &dataset {
let bytes = codec.encode(v).expect("encode");
let decoded = codec.decode_lossy(&bytes).expect("decode");
for metric in [
VectorMetric::Cosine,
VectorMetric::InnerProduct,
VectorMetric::L2,
] {
let asym = codec
.asymmetric_distance_prepared_blob(&q_blob, &bytes, metric)
.expect("asym");
let refd = reference_distance(q, &decoded, metric);
let tol = match metric {
VectorMetric::Cosine => 5e-5,
VectorMetric::InnerProduct => 5e-5,
VectorMetric::L2 => 5e-4,
};
assert!(
(asym - refd).abs() < tol,
"{metric:?}: asym={asym}, ref={refd}, diff={}",
(asym - refd).abs()
);
}
}
}
}
#[test]
fn asymmetric_distance_rotated_scratch_matches_allocating_path() {
let dim = 128;
let mut codec = QamLloydMaxCodec::with_config(dim, 64, 5, 6, true).expect("construct");
let dataset = synthetic_unit_dataset(8, dim, 0xBADC_0FFE);
codec.calibrate(&dataset).expect("calibrate");
let query = &synthetic_unit_dataset(1, dim, 0xFACE_FEED)[0];
let (q_rot, q_norm) = codec.prepare_query_rotated(query).expect("q_rot");
let mut amp_scratch = vec![0u32; codec.num_pairs];
let mut phase_scratch = vec![0u32; codec.num_pairs];
for v in &dataset {
let bytes = codec.encode(v).expect("encode");
for metric in [
VectorMetric::Cosine,
VectorMetric::InnerProduct,
VectorMetric::L2,
] {
let allocating = codec
.asymmetric_distance_with_rotated(&q_rot, q_norm, &bytes, metric)
.expect("allocating");
let scratch = codec
.asymmetric_distance_with_rotated_scratch(
&q_rot,
q_norm,
&bytes,
metric,
&mut amp_scratch,
&mut phase_scratch,
)
.expect("scratch");
assert_eq!(allocating.to_bits(), scratch.to_bits());
}
}
}
#[test]
fn asymmetric_distance_matches_decode_then_dot_renorm_false() {
let dim = 128;
let mut codec = QamLloydMaxCodec::with_config(dim, 64, 5, 6, false).expect("construct");
let dataset = synthetic_unit_dataset(50, dim, 0xCAFE_F00D);
codec.calibrate(&dataset).expect("calibrate");
let queries = synthetic_unit_dataset(10, dim, 0x5EED_FACE);
for q in &queries {
let q_blob = codec.prepare_query_blob(q).expect("prep");
for v in &dataset {
let bytes = codec.encode(v).expect("encode");
let decoded = codec.decode_lossy(&bytes).expect("decode");
for metric in [
VectorMetric::Cosine,
VectorMetric::InnerProduct,
VectorMetric::L2,
] {
let asym = codec
.asymmetric_distance_prepared_blob(&q_blob, &bytes, metric)
.expect("asym");
let refd = reference_distance(q, &decoded, metric);
let tol = match metric {
VectorMetric::Cosine => 5e-5,
VectorMetric::InnerProduct => 5e-5,
VectorMetric::L2 => 5e-4,
};
assert!(
(asym - refd).abs() < tol,
"{metric:?}: asym={asym}, ref={refd}, diff={}",
(asym - refd).abs()
);
}
}
}
}
#[test]
fn cosine_invariant_to_renormalize_choice() {
let dim = 128;
let dataset = synthetic_unit_dataset(40, dim, 0x77F0_F00D);
let queries = synthetic_unit_dataset(8, dim, 0x33A2_B5C6);
let mut codec_t = QamLloydMaxCodec::with_config(dim, 64, 5, 6, true).expect("c-t");
let mut codec_f = QamLloydMaxCodec::with_config(dim, 64, 5, 6, false).expect("c-f");
codec_t.calibrate(&dataset).expect("calibrate t");
codec_f.calibrate(&dataset).expect("calibrate f");
for q in &queries {
let blob_t = codec_t.prepare_query_blob(q).expect("blob t");
let blob_f = codec_f.prepare_query_blob(q).expect("blob f");
for v in &dataset {
let bt = codec_t.encode(v).expect("encode t");
let bf = codec_f.encode(v).expect("encode f");
let cos_t = codec_t
.asymmetric_distance_prepared_blob(&blob_t, &bt, VectorMetric::Cosine)
.expect("cos t");
let cos_f = codec_f
.asymmetric_distance_prepared_blob(&blob_f, &bf, VectorMetric::Cosine)
.expect("cos f");
assert!(
(cos_t - cos_f).abs() < 5e-5,
"cos diverges across renormalize: t={cos_t}, f={cos_f}"
);
}
}
}
#[test]
fn inner_product_differs_with_renormalize() {
let dim = 128;
let dataset = synthetic_unit_dataset(40, dim, 0xBADD_C0DE);
let queries = synthetic_unit_dataset(4, dim, 0xC001_FACE);
let mut codec_t = QamLloydMaxCodec::with_config(dim, 64, 5, 6, true).expect("c-t");
let mut codec_f = QamLloydMaxCodec::with_config(dim, 64, 5, 6, false).expect("c-f");
codec_t.calibrate(&dataset).expect("calibrate t");
codec_f.calibrate(&dataset).expect("calibrate f");
let mut any_diff = false;
for q in &queries {
let blob_t = codec_t.prepare_query_blob(q).expect("blob t");
let blob_f = codec_f.prepare_query_blob(q).expect("blob f");
for v in &dataset {
let bt = codec_t.encode(v).expect("encode t");
let bf = codec_f.encode(v).expect("encode f");
let ip_t = codec_t
.asymmetric_distance_prepared_blob(&blob_t, &bt, VectorMetric::InnerProduct)
.expect("ip t");
let ip_f = codec_f
.asymmetric_distance_prepared_blob(&blob_f, &bf, VectorMetric::InnerProduct)
.expect("ip f");
if (ip_t - ip_f).abs() > 1e-5 {
any_diff = true;
break;
}
}
if any_diff {
break;
}
}
assert!(any_diff, "renormalize flag had no effect on InnerProduct");
}
#[test]
fn asymmetric_self_distance_cosine_near_zero() {
let dim = 128;
let mut codec = QamLloydMaxCodec::with_config(dim, 64, 5, 6, true).expect("construct");
let dataset = synthetic_unit_dataset(50, dim, 0x9999_AAAA);
codec.calibrate(&dataset).expect("calibrate");
for v in &dataset {
let bytes = codec.encode(v).expect("encode");
let blob = codec.prepare_query_blob(v).expect("prep");
let cos = codec
.asymmetric_distance_prepared_blob(&blob, &bytes, VectorMetric::Cosine)
.expect("cos");
assert!(
cos < 0.05,
"self-cosine distance too large: {cos} (expected <0.05)"
);
}
}
#[test]
fn asymmetric_rejects_qblob_length_mismatch() {
let codec = QamLloydMaxCodec::with_config(64, 32, 5, 6, true).expect("construct");
let bad = vec![0u8; 7];
let base = vec![0u8; codec.base_bytes_per_vector];
let err = codec
.asymmetric_distance_prepared_blob(&bad, &base, VectorMetric::Cosine)
.expect_err("len");
assert!(err.to_string().contains("q_blob length"));
}
#[test]
fn asymmetric_rejects_base_length_mismatch() {
let codec = QamLloydMaxCodec::with_config(64, 32, 5, 6, true).expect("construct");
let q = vec![0f32; 64];
let blob = codec.prepare_query_blob(&q).expect("prep");
let err = codec
.asymmetric_distance_prepared_blob(&blob, &[0u8; 5], VectorMetric::Cosine)
.expect_err("len");
assert!(err.to_string().contains("base length"));
}
#[test]
fn symmetric_self_distance_is_zero() {
let dim = 64;
let mut codec = QamLloydMaxCodec::with_config(dim, 32, 5, 6, true).expect("construct");
let dataset = synthetic_unit_dataset(20, dim, 0x4444_5555);
codec.calibrate(&dataset).expect("calibrate");
for v in &dataset {
let bytes = codec.encode(v).expect("encode");
let cos = codec
.symmetric_distance(&bytes, &bytes, VectorMetric::Cosine)
.expect("cos");
assert!(cos.abs() < 1e-5, "self-symmetric cos = {cos}");
let ip = codec
.symmetric_distance(&bytes, &bytes, VectorMetric::InnerProduct)
.expect("ip");
assert!((ip + 1.0).abs() < 1e-3);
let l2 = codec
.symmetric_distance(&bytes, &bytes, VectorMetric::L2)
.expect("l2");
assert!(l2.abs() < 1e-5, "self-symmetric L2 = {l2}");
}
}
#[test]
fn symmetric_distance_matches_decode_reference() {
let dim = 64;
let mut codec = QamLloydMaxCodec::with_config(dim, 32, 5, 6, false).expect("construct");
let dataset = synthetic_unit_dataset(30, dim, 0xAB_CD_EF);
codec.calibrate(&dataset).expect("calibrate");
let bytes_a = codec.encode(&dataset[0]).expect("a");
let bytes_b = codec.encode(&dataset[1]).expect("b");
let da = codec.decode_lossy(&bytes_a).expect("dec a");
let db = codec.decode_lossy(&bytes_b).expect("dec b");
for metric in [
VectorMetric::Cosine,
VectorMetric::InnerProduct,
VectorMetric::L2,
] {
let got = codec
.symmetric_distance(&bytes_a, &bytes_b, metric)
.expect("sym");
let expect = reference_distance(&da, &db, metric);
let tol = match metric {
VectorMetric::Cosine => 1e-5,
VectorMetric::InnerProduct => 1e-5,
VectorMetric::L2 => 1e-4,
};
assert!(
(got - expect).abs() < tol,
"{metric:?}: got {got}, expect {expect}"
);
}
}
#[test]
fn vector_codec_trait_prepare_and_distance() {
let dim = 64;
let mut codec = QamLloydMaxCodec::with_config(dim, 32, 5, 6, true).expect("construct");
let dataset = synthetic_unit_dataset(40, dim, 0xFA_CE_AC_AD);
codec.calibrate(&dataset).expect("calibrate");
let q = &dataset[3];
let mut trait_scores: Vec<(usize, f32)> = Vec::new();
let mut blob_scores: Vec<(usize, f32)> = Vec::new();
let ctx = <QamLloydMaxCodec as VectorCodec>::prepare_query(&codec, q).expect("ctx");
let q_blob = codec.prepare_query_blob(q).expect("blob");
for i in 0..dataset.len() {
let bytes = codec.encode(&dataset[i]).expect("encode");
let s_trait = <QamLloydMaxCodec as VectorCodec>::asymmetric_distance_prepared(
&codec,
ctx.as_ref(),
&bytes,
VectorMetric::Cosine,
)
.expect("trait dist");
let s_blob = codec
.asymmetric_distance_prepared_blob(&q_blob, &bytes, VectorMetric::Cosine)
.expect("blob dist");
trait_scores.push((i, s_trait));
blob_scores.push((i, s_blob));
}
trait_scores.sort_by(|a, b| a.1.total_cmp(&b.1));
blob_scores.sort_by(|a, b| a.1.total_cmp(&b.1));
let trait_top5: std::collections::HashSet<usize> =
trait_scores.iter().take(5).map(|(i, _)| *i).collect();
let blob_top5: std::collections::HashSet<usize> =
blob_scores.iter().take(5).map(|(i, _)| *i).collect();
let overlap = trait_top5.intersection(&blob_top5).count();
assert!(
overlap >= 4,
"trait fast path ranking diverges from canonical blob path \
(top-5 overlap = {overlap}); trait_top5={trait_top5:?} blob_top5={blob_top5:?}"
);
}
#[test]
fn vector_codec_trait_rejects_wrong_ctx_type() {
let codec = QamLloydMaxCodec::with_config(64, 32, 5, 6, true).expect("construct");
let bytes = vec![0u8; codec.base_bytes_per_vector];
let bogus: Box<dyn std::any::Any + Send + Sync> = Box::new(vec![0f32; 64]);
let err = <QamLloydMaxCodec as VectorCodec>::asymmetric_distance_prepared(
&codec,
bogus.as_ref(),
&bytes,
VectorMetric::Cosine,
)
.expect_err("wrong ctx");
assert!(err.to_string().contains("QamPreparedQuery"));
}
#[test]
fn align_up_basics() {
assert_eq!(align_up(0, 64), 0);
assert_eq!(align_up(1, 64), 64);
assert_eq!(align_up(63, 64), 64);
assert_eq!(align_up(64, 64), 64);
assert_eq!(align_up(65, 64), 128);
assert_eq!(align_up(960, 64), 960);
}
#[test]
fn packed_bytes_basics() {
assert_eq!(packed_bytes(1536, 5), 960);
assert_eq!(packed_bytes(1536, 6), 1152);
assert_eq!(packed_bytes(64, 4), 32);
assert_eq!(packed_bytes(7, 5), 5);
}
#[test]
fn from_params_rejects_sigma_length_mismatch() {
let codec = QamLloydMaxCodec::with_config(64, 32, 5, 6, true).expect("construct");
let mut params = codec.to_params([0u8; 32]);
params.sigma_per_pair.pop();
let err = QamLloydMaxCodec::from_params(¶ms).expect_err("length");
assert!(err.to_string().contains("sigma_per_pair"));
}
#[test]
fn from_params_rejects_nonpositive_sigma() {
let codec = QamLloydMaxCodec::with_config(64, 32, 5, 6, true).expect("construct");
let mut params = codec.to_params([0u8; 32]);
params.sigma_per_pair[0] = -1.0;
let err = QamLloydMaxCodec::from_params(¶ms).expect_err("nonpositive");
assert!(err.to_string().contains("positive"));
}
#[test]
fn with_config_alt_budget_padding() {
let codec = QamLloydMaxCodec::with_config(128, 64, 4, 4, false).expect("construct");
assert_eq!(codec.amp_stream_bytes, 64);
assert_eq!(codec.phase_stream_bytes, 64);
assert_eq!(codec.base_bytes_per_vector, 128);
assert!(!codec.renormalize_at_decode);
}
#[test]
fn with_config_8bit_budget() {
let codec = QamLloydMaxCodec::with_config(3072, 1024, 8, 8, true).expect("construct");
assert_eq!(codec.amp_stream_bytes, 1536);
assert_eq!(codec.phase_stream_bytes, 1536);
assert_eq!(codec.base_bytes_per_vector, 3072);
}
}