Exclude float columns from delta encoding

Delta encoding violated spec §2.3's MUST round-trip requirement for float
columns: prev + (cur - prev) in IEEE-754 does not recover the original
double's bit pattern for arbitrary values, and round(diff, 10) at the
encode step compounded the loss. Benchmark data exposed this as e.g.
1865.43 decoding to 1865.4299999999994.

Restrict SparseMode.DELTA eligibility to int-only columns. Float columns
now fall through to standard value encoding, which round-trips exactly
via Python's shortest-round-trip str(float). Int delta encoding (the
common case: IDs, counts, timestamps) is unchanged.

Regression test covers multiple precision regimes — benchmark values,
math.pi/math.e, 0.1+0.2, extreme exponents, negatives — so a future
round-to-N workaround cannot sneak through.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Toomas Ormisson

zon-format/src/zon/core/encoder.py

@@ -173,13 +173,17 @@ def _analyze_optimal_sparse_mode(self, values: List[Any]) -> SparseMode:
         if len(values) < 5:
             return SparseMode.NONE
 
-        is_numeric = True
+        # Only int columns are eligible for delta encoding. Float delta
+        # encoding cannot satisfy the spec §2.3 MUST round-trip requirement:
+        # prev + (cur - prev) in IEEE-754 does not preserve the original
+        # double's bit pattern for arbitrary floats.
+        is_int_only = True
         for val in values:
-            if not isinstance(val, (int, float)) or isinstance(val, bool):
-                is_numeric = False
+            if not isinstance(val, int) or isinstance(val, bool):
+                is_int_only = False
                 break
-        
-        if is_numeric:
+
+        if is_int_only:
             return SparseMode.DELTA
 
         return SparseMode.NONE

zon-format/tests/unit/test_delta.py

@@ -1,3 +1,4 @@
+import math
 import unittest
 from zon import ZonEncoder, ZonDecoder
 
@@ -107,12 +108,41 @@ def test_deep_nesting(self):
         data = [
             {'a': {'b': {'c': {'d': {'e': 1}}}}}
         ]
-        
+
         encoded = self.encoder.encode(data)
         self.assertIn('a.b.c.d.e', encoded)
-        
+
         decoded = self.decoder.decode(encoded)
         self.assertEqual(decoded, data)
 
+    def test_float_column_roundtrip_is_lossless(self):
+        """Float columns must round-trip bit-exactly (spec §2.3 MUST).
+
+        Covers multiple precision regimes so a partial fix (e.g. round-to-N)
+        cannot sneak through.
+        """
+        data = [
+            {'v': 1865.43},     # benchmark regression case
+            {'v': 3579.16},     # benchmark regression case
+            {'v': math.pi},     # 17-sig-digit irrational
+            {'v': math.e},      # 17-sig-digit irrational
+            {'v': 0.1 + 0.2},   # classic non-terminating binary: 0.30000000000000004
+            {'v': -42.5},       # negative, crosses zero in deltas
+            {'v': 1e-10},       # small exponent
+            {'v': 1e15},        # large exponent
+        ]
+
+        decoded = self.decoder.decode(self.encoder.encode(data))
+
+        for original, got in zip(data, decoded):
+            # repr(float) is the shortest string that round-trips to the same
+            # double, so repr equality is equivalent to bit equality.
+            self.assertEqual(
+                repr(original['v']),
+                repr(got['v']),
+                f"float roundtrip lost precision: {original['v']!r} -> {got['v']!r}",
+            )
+
+
 if __name__ == "__main__":
     unittest.main()