fastlanes: polish signed Delta PR

Pre-merge polish across the three things a reviewer would notice:

* DeltaArray docstring: add a signed `i32` example next to the unsigned one
  so users see signed support is first-class. Verified by doctest.
* Conformance: extend `test_delta_consistency` and `test_delta_binary_numeric`
  with i32 / i64 / i8 cases (crossing zero, all-negative, single-negative).
  These run the array-trait conformance harness, so any operation that's
  silently broken for signed inputs surfaces here.
* cast.rs: expand the comment justifying why signed sources fall back to
  decompress-and-re-encode (the wrapping-add invariant breaks under
  value-preserving widening; the same hazard applies to cross-signedness).
* synthetic_workload_compression table: rename duplicate "ratio" columns
  to `FFoR x` / `+bcomp x` so the report is unambiguous.

256 -> 263 tests, all pass. Clippy clean. Fmt clean.

Signed-off-by: Claude <noreply@anthropic.com>

Author: claude

encodings/fastlanes/src/delta/array/delta_compress.rs

@@ -235,24 +235,24 @@ mod tests {
 
         println!();
         println!(
-            "{:<36} {:>10} {:>14} {:>5} {:>5} {:>5} {:>10} {:>7}  {:>10} {:>5} {:>10} {:>7}",
+            "{:<36} {:>10} {:>14} {:>5} {:>5} {:>5} {:>10} {:>9}  {:>10} {:>5} {:>10} {:>9}",
             "workload",
             "raw (B)",
             "Δ range",
             "Wnaive",
             "Wffor",
             "Wzig",
             "FFoR (B)",
-            "ratio",
+            "FFoR x",
             "bases (B)",
             "Wb",
             "+bcomp (B)",
-            "ratio",
+            "+bcomp x",
         );
         println!("{}", "-".repeat(140));
 
         for (name, values) in workloads {
-            let raw_bytes = values.len() * size_of::<i32>();
+            let raw_bytes = size_of_val(values.as_slice());
             let array = PrimitiveArray::from_iter(values);
             let (bases, deltas) = delta_compress(&array, &mut ctx)?;
             let deltas_buf: &[i32] = deltas.as_slice();
@@ -264,18 +264,30 @@ mod tests {
             // Naive width = OR of raw u32 bit-patterns of every delta. Any negative delta
             // sets the high bits and forces W = 32.
             let or: u32 = deltas_buf.iter().fold(0u32, |a, &d| a | (d as u32));
-            let naive_w = if or == 0 { 0 } else { 32 - or.leading_zeros() as usize };
+            let naive_w = if or == 0 {
+                0
+            } else {
+                32 - or.leading_zeros() as usize
+            };
 
             // FFoR width = ceil(log2(span)) where span = (max - min + 1).
             let span = (max_d as i64 - min_d as i64) as u64 + 1;
-            let ffor_w = if span <= 1 { 0 } else { 64 - (span - 1).leading_zeros() as usize };
+            let ffor_w = if span <= 1 {
+                0
+            } else {
+                64 - (span - 1).leading_zeros() as usize
+            };
 
             // ZigZag width = 1 + ceil(log2(max(|min|, |max|))) for any nonzero delta.
             let zz_mag = (min_d.unsigned_abs()).max(max_d.unsigned_abs());
-            let zz_w = if zz_mag == 0 { 0 } else { 1 + (32 - zz_mag.leading_zeros() as usize) };
+            let zz_w = if zz_mag == 0 {
+                0
+            } else {
+                1 + (32 - zz_mag.leading_zeros() as usize)
+            };
 
             // FFoR encoded byte size: bases (already unpacked) + ref + ceil(packed bits / 8).
-            let bases_bytes = bases_buf.len() * size_of::<i32>();
+            let bases_bytes = size_of_val(bases_buf);
             let ref_bytes = size_of::<i32>();
             let packed_bits = deltas_buf.len() * ffor_w;
             let ffor_packed_bytes = packed_bits.div_ceil(8);
@@ -291,32 +303,48 @@ mod tests {
             let min_b = *bases_buf.iter().min().unwrap();
             let max_b = *bases_buf.iter().max().unwrap();
             let bspan = (max_b as i64 - min_b as i64) as u64 + 1;
-            let bases_w = if bspan <= 1 { 0 } else { 64 - (bspan - 1).leading_zeros() as usize };
+            let bases_w = if bspan <= 1 {
+                0
+            } else {
+                64 - (bspan - 1).leading_zeros() as usize
+            };
             let bases_compressed = (bases_buf.len() * bases_w).div_ceil(8) + ref_bytes;
             let total_with_bcomp = bases_compressed + ref_bytes + ffor_packed_bytes;
             let ratio_with_bcomp = raw_bytes as f64 / total_with_bcomp as f64;
 
             println!(
-                "{name:<36} {raw_bytes:>10} {:>14} {naive_w:>5} {ffor_w:>5} {zz_w:>5} {ffor_total:>10} {ratio:>6.2}x  {bases_bytes:>10} {bases_w:>5} {total_with_bcomp:>10} {ratio_with_bcomp:>6.2}x",
+                "{name:<36} {raw_bytes:>10} {:>14} {naive_w:>5} {ffor_w:>5} {zz_w:>5} {ffor_total:>10} {ratio:>8.2}x  {bases_bytes:>10} {bases_w:>5} {total_with_bcomp:>10} {ratio_with_bcomp:>8.2}x",
                 format!("[{min_d}, {max_d}]"),
             );
 
             // Sanity assertions. naive_w is 32 (or near it) for any delta sequence that
             // contains a negative value; FFoR/ZigZag width must be strictly smaller for these
             // workloads.
-            assert!(ffor_w <= naive_w.max(1), "FFoR must never exceed naive for {name}");
+            assert!(
+                ffor_w <= naive_w.max(1),
+                "FFoR must never exceed naive for {name}"
+            );
             if min_d < 0 {
-                assert_eq!(naive_w, 32, "any negative delta forces naive W to 32 for {name}");
+                assert_eq!(
+                    naive_w, 32,
+                    "any negative delta forces naive W to 32 for {name}"
+                );
                 assert!(ffor_w < 32, "FFoR must compress below T for {name}");
             }
             // On the asymmetric workloads (offset, near-monotone) FFoR must beat ZigZag.
             if min_d > 0 || max_d < 0 {
-                assert!(ffor_w < zz_w, "FFoR should beat ZigZag on asymmetric {name}");
+                assert!(
+                    ffor_w < zz_w,
+                    "FFoR should beat ZigZag on asymmetric {name}"
+                );
             }
             // Sorted inputs => the bases inherit smoothness => the bases bit-width should be
             // far smaller than `T` for sorted columns.
             if name.starts_with("monotone") || name.starts_with("offset") {
-                assert!(bases_w < 16, "sorted bases should pack below 16 bits for {name}");
+                assert!(
+                    bases_w < 16,
+                    "sorted bases should pack below 16 bits for {name}"
+                );
             }
         }
 

encodings/fastlanes/src/delta/array/mod.rs

@@ -43,6 +43,21 @@ pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["bases", "deltas"];
 /// let array = Delta::try_from_primitive_array(&primitive, &mut session.create_execution_ctx()).unwrap();
 /// ```
 ///
+/// Signed inputs are also supported; deltas across negative values are encoded by
+/// `wrapping_sub` and recovered by `wrapping_add` at decompress time:
+///
+/// ```
+/// use vortex_array::arrays::PrimitiveArray;
+/// use vortex_array::VortexSessionExecute;
+/// use vortex_array::session::ArraySession;
+/// use vortex_session::VortexSession;
+/// use vortex_fastlanes::Delta;
+///
+/// let session = VortexSession::empty().with::<ArraySession>();
+/// let primitive = PrimitiveArray::from_iter([-3_i32, -2, -1, 0, 1, 2]);
+/// let array = Delta::try_from_primitive_array(&primitive, &mut session.create_execution_ctx()).unwrap();
+/// ```
+///
 /// # Details
 ///
 /// To facilitate slicing, this array accepts an `offset` and `logical_len`. The offset must be

encodings/fastlanes/src/delta/compute/cast.rs

@@ -24,9 +24,13 @@ impl CastReduce for Delta {
         if target_ptype.is_signed_int() || source_ptype.bit_width() > target_ptype.bit_width() {
             return Ok(None);
         }
-        // Signed deltas widened by per-element value-preserving cast (e.g. -1i8 -> 4294967295u32)
-        // break the wrapping-add invariant: zero-extending the delta bytes would preserve it,
-        // sign-extending the deltas does not. Fall back to full decompress + re-encode.
+        // Signed sources need a different cast policy than the lossless widening cast
+        // used here. The delta bytes are stored as the result of `wrapping_sub`, so e.g.
+        // a delta of -1i8 has the bit pattern 0xFF. Widening *as a value* (the cast op's
+        // semantics) sign-extends that to 0xFFFFFFFF, which means `wrapping_add(base, delta)`
+        // at the wider type produces a different result than at the source type — round-trip
+        // breaks. Cross-signedness widening has the same hazard for the same reason. Fall
+        // back to decompress-and-re-encode for both cases.
         if source_ptype.is_signed_int() {
             return Ok(None);
         }

encodings/fastlanes/src/delta/vtable/operations.rs

@@ -248,6 +248,11 @@ mod tests {
     #[case::delta_large_u64((0u64..2048).collect())]
     // Single element
     #[case::delta_single(PrimitiveArray::new(buffer![42u32], Validity::NonNullable))]
+    // Signed inputs (added with signed-delta support).
+    #[case::delta_i32_crossing_zero((-100i32..100).collect())]
+    #[case::delta_i64_negative((0i64..100).map(|i| -i * 10).collect())]
+    #[case::delta_large_i32((-1024i32..1024).collect())]
+    #[case::delta_single_negative(PrimitiveArray::new(buffer![-42i32], Validity::NonNullable))]
     fn test_delta_consistency(#[case] array: PrimitiveArray) {
         test_array_consistency(&da(&array).into_array());
     }
@@ -258,6 +263,8 @@ mod tests {
     #[case::delta_u32_basic(PrimitiveArray::new(buffer![1u32, 1, 1, 1, 1], Validity::NonNullable))]
     #[case::delta_u64_basic(PrimitiveArray::new(buffer![1u64, 1, 1, 1, 1], Validity::NonNullable))]
     #[case::delta_u32_large(PrimitiveArray::new(buffer![1u32; 100], Validity::NonNullable))]
+    #[case::delta_i8_basic(PrimitiveArray::new(buffer![-1i8, -1, -1, -1, -1], Validity::NonNullable))]
+    #[case::delta_i32_basic(PrimitiveArray::new(buffer![-1i32, -1, -1, -1, -1], Validity::NonNullable))]
     fn test_delta_binary_numeric(#[case] array: PrimitiveArray) {
         test_binary_numeric_array(da(&array).into_array());
     }