fix review comments

Signed-off-by: Will Manning <will@willmanning.io>

Author: lwwmanning

encodings/turboquant/src/centroids.rs

@@ -103,17 +103,16 @@ fn conditional_mean(lo: f64, hi: f64, exponent: f64) -> f64 {
         return (lo + hi) / 2.0;
     }
 
-    let num_points = INTEGRATION_POINTS;
-    let dx = (hi - lo) / num_points as f64;
+    let dx = (hi - lo) / INTEGRATION_POINTS as f64;
 
     let mut numerator = 0.0;
     let mut denominator = 0.0;
 
-    for step in 0..=num_points {
+    for step in 0..=INTEGRATION_POINTS {
         let x_val = lo + (step as f64) * dx;
         let weight = pdf_unnormalized(x_val, exponent);
 
-        let trap_weight = if step == 0 || step == num_points {
+        let trap_weight = if step == 0 || step == INTEGRATION_POINTS {
             0.5
         } else {
             1.0

encodings/turboquant/src/compress.rs

@@ -138,11 +138,11 @@ fn turboquant_quantize_core(
 
 /// Build a `TurboQuantArray` (MSE-only) from quantization results.
 fn build_turboquant_mse(
-    dtype: &FixedSizeListArray,
+    fsl: &FixedSizeListArray,
     core: MseQuantizationResult,
     bit_width: u8,
 ) -> VortexResult<TurboQuantArray> {
-    let dimension = dtype.list_size();
+    let dimension = fsl.list_size();
 
     let codes =
         PrimitiveArray::new::<u8>(core.all_indices.freeze(), Validity::NonNullable).into_array();
@@ -159,7 +159,7 @@ fn build_turboquant_mse(
     let rotation_signs = bitpack_rotation_signs(&core.rotation)?;
 
     TurboQuantArray::try_new_mse(
-        dtype.dtype().clone(),
+        fsl.dtype().clone(),
         codes,
         norms_array,
         centroids_array,

encodings/turboquant/src/lib.rs

@@ -772,4 +772,77 @@ mod tests {
         );
         Ok(())
     }
+
+    /// Verify serde roundtrip for QJL: serialize metadata + children, then rebuild.
+    #[test]
+    fn qjl_serde_roundtrip() -> VortexResult<()> {
+        use vortex_array::DynArray;
+        use vortex_array::vtable::VTable;
+
+        let fsl = make_fsl(10, 128, 42);
+        let config = TurboQuantConfig {
+            bit_width: 4,
+            seed: Some(456),
+        };
+        let encoded = turboquant_encode_qjl(&fsl, &config)?;
+        let encoded = TurboQuant::try_match(&*encoded).unwrap();
+
+        // Serialize metadata.
+        let metadata = <TurboQuant as VTable>::metadata(encoded)?;
+        let serialized =
+            <TurboQuant as VTable>::serialize(metadata)?.expect("metadata should serialize");
+
+        // Collect children — QJL has 7 (4 MSE + 3 QJL).
+        let nchildren = <TurboQuant as VTable>::nchildren(encoded);
+        assert_eq!(nchildren, 7);
+        let children: Vec<ArrayRef> = (0..nchildren)
+            .map(|i| <TurboQuant as VTable>::child(encoded, i))
+            .collect();
+
+        // Deserialize metadata.
+        let deserialized = <TurboQuant as VTable>::deserialize(
+            &serialized,
+            encoded.dtype(),
+            encoded.len(),
+            &[],
+            &SESSION,
+        )?;
+
+        assert!(deserialized.has_qjl);
+        assert_eq!(deserialized.dimension, encoded.dimension());
+
+        // Verify decode: original vs rebuilt from children.
+        let mut ctx = SESSION.create_execution_ctx();
+        let decoded_original = encoded
+            .clone()
+            .into_array()
+            .execute::<FixedSizeListArray>(&mut ctx)?;
+        let original_elements = decoded_original.elements().to_canonical()?.into_primitive();
+
+        // Rebuild with QJL children.
+        let rebuilt = crate::array::TurboQuantArray::try_new_qjl(
+            encoded.dtype().clone(),
+            children[0].clone(),
+            children[1].clone(),
+            children[2].clone(),
+            children[3].clone(),
+            crate::array::QjlCorrection {
+                signs: children[4].clone(),
+                residual_norms: children[5].clone(),
+                rotation_signs: children[6].clone(),
+            },
+            deserialized.dimension,
+            deserialized.bit_width as u8,
+        )?;
+        let decoded_rebuilt = rebuilt
+            .into_array()
+            .execute::<FixedSizeListArray>(&mut ctx)?;
+        let rebuilt_elements = decoded_rebuilt.elements().to_canonical()?.into_primitive();
+
+        assert_eq!(
+            original_elements.as_slice::<f32>(),
+            rebuilt_elements.as_slice::<f32>()
+        );
+        Ok(())
+    }
 }

encodings/turboquant/src/rotation.rs

@@ -129,7 +129,7 @@ impl RotationMatrix {
         let mut out = Vec::with_capacity(total);
 
         // Store in inverse order: sign_masks[2] (D₃), sign_masks[1] (D₂), sign_masks[0] (D₁)
-        for &sign_idx in &[2, 1, 0] {
+        for sign_idx in [2, 1, 0] {
             for &mask in &self.sign_masks[sign_idx] {
                 out.push(if mask == 0 { 1u8 } else { 0u8 });
             }
@@ -157,9 +157,9 @@ impl RotationMatrix {
         // Reconstruct in storage order (inverse): [D₃, D₂, D₁] → sign_masks[2], [1], [0]
         let mut sign_masks: [Vec<u32>; 3] = std::array::from_fn(|_| Vec::with_capacity(padded_dim));
 
-        for (round, sign_idx) in [2, 1, 0].iter().enumerate() {
+        for (round, sign_idx) in [2, 1, 0].into_iter().enumerate() {
             let offset = round * padded_dim;
-            sign_masks[*sign_idx] = signs_u8[offset..offset + padded_dim]
+            sign_masks[sign_idx] = signs_u8[offset..offset + padded_dim]
                 .iter()
                 .map(|&v| if v != 0 { 0u32 } else { F32_SIGN_BIT })
                 .collect();

vortex/benches/single_encoding_throughput.rs

@@ -509,8 +509,8 @@ macro_rules! turboquant_bench {
 
 turboquant_bench!(compress, 128, 4, bench_tq_compress_128_4);
 turboquant_bench!(decompress, 128, 4, bench_tq_decompress_128_4);
-turboquant_bench!(compress, 768, 4, bench_tq_compress_768_2);
-turboquant_bench!(decompress, 768, 4, bench_tq_decompress_768_2);
+turboquant_bench!(compress, 768, 4, bench_tq_compress_768_4);
+turboquant_bench!(decompress, 768, 4, bench_tq_decompress_768_4);
 turboquant_bench!(compress, 1024, 2, bench_tq_compress_1024_2);
 turboquant_bench!(decompress, 1024, 2, bench_tq_decompress_1024_2);
 turboquant_bench!(compress, 1024, 4, bench_tq_compress_1024_4);