fix(phase8.1): Improve Gorilla and XOR codecs - handle 64-bit meaningful bits, 2-value tests passing

Author: MPCoreDeveloper

src/SharpCoreDB/TimeSeries/GorillaCodec.cs

@@ -79,14 +79,26 @@ public byte[] Compress(ReadOnlySpan<double> values)
                 int trailingZeros = CountTrailingZeros(xor);
                 int meaningfulBits = 64 - leadingZeros - trailingZeros;
 
+                // Ensure meaningful bits is at least 1 (xor != 0 guaranteed by earlier check)
+                if (meaningfulBits <= 0)
+                {
+                    meaningfulBits = 64;
+                    leadingZeros = 0;
+                    trailingZeros = 0;
+                }
+
                 if (prevLeadingZeros >= 0 && leadingZeros >= prevLeadingZeros && trailingZeros >= prevTrailingZeros)
                 {
                     // Same or more leading/trailing zeros: write '0' + meaningful bits
                     writer.WriteBit(false);
 
                     // Use previous control block
                     int blockSize = 64 - prevLeadingZeros - prevTrailingZeros;
-                    ulong meaningfulValue = (xor >> prevTrailingZeros) & ((1UL << blockSize) - 1);
+                    ulong meaningfulValue = (xor >> prevTrailingZeros);
+                    if (blockSize < 64)
+                    {
+                        meaningfulValue &= (1UL << blockSize) - 1;
+                    }
                     writer.WriteBits(meaningfulValue, blockSize);
                 }
                 else
@@ -95,11 +107,16 @@ public byte[] Compress(ReadOnlySpan<double> values)
                     writer.WriteBit(true);
 
                     // Write control block: 5 bits for leading zeros, 6 bits for meaningful bits length
+                    // Note: 6 bits can represent 0-63, so we store (meaningfulBits - 1) to represent 1-64
                     writer.WriteBits((ulong)leadingZeros, 5);
-                    writer.WriteBits((ulong)meaningfulBits, 6);
+                    writer.WriteBits((ulong)(meaningfulBits - 1), 6);
 
                     // Write meaningful bits
-                    ulong meaningfulValue = (xor >> trailingZeros) & ((1UL << meaningfulBits) - 1);
+                    ulong meaningfulValue = (xor >> trailingZeros);
+                    if (meaningfulBits < 64)
+                    {
+                        meaningfulValue &= (1UL << meaningfulBits) - 1;
+                    }
                     writer.WriteBits(meaningfulValue, meaningfulBits);
 
                     prevLeadingZeros = leadingZeros;
@@ -165,7 +182,7 @@ public double[] Decompress(ReadOnlySpan<byte> compressed, int count)
             {
                 // '11' -> new control block
                 int leadingZeros = (int)reader.ReadBits(5);
-                int meaningfulBits = (int)reader.ReadBits(6);
+                int meaningfulBits = (int)reader.ReadBits(6) + 1; // Add 1 to get 1-64 range
                 int trailingZeros = 64 - leadingZeros - meaningfulBits;
 
                 ulong meaningfulValue = reader.ReadBits(meaningfulBits);

src/SharpCoreDB/TimeSeries/XorFloatCodec.cs

@@ -68,12 +68,24 @@ public byte[] Compress(ReadOnlySpan<double> values)
                 int trailingZeros = CountTrailingZeros(xor);
                 int meaningfulBits = 64 - leadingZeros - trailingZeros;
 
-                // Write control: 6 bits for leading zeros, 6 bits for length
+                // Ensure meaningful bits is at least 1
+                if (meaningfulBits <= 0)
+                {
+                    meaningfulBits = 64;
+                    leadingZeros = 0;
+                    trailingZeros = 0;
+                }
+
+                // Write control: 6 bits for leading zeros, 6 bits for length (store length - 1)
                 writer.WriteBits((ulong)leadingZeros, 6);
-                writer.WriteBits((ulong)meaningfulBits, 6);
+                writer.WriteBits((ulong)(meaningfulBits - 1), 6);
 
                 // Write meaningful bits
-                ulong meaningfulValue = (xor >> trailingZeros) & ((1UL << meaningfulBits) - 1);
+                ulong meaningfulValue = (xor >> trailingZeros);
+                if (meaningfulBits < 64)
+                {
+                    meaningfulValue &= (1UL << meaningfulBits) - 1;
+                }
                 writer.WriteBits(meaningfulValue, meaningfulBits);
             }
 
@@ -116,7 +128,7 @@ public double[] Decompress(ReadOnlySpan<byte> compressed, int count)
 
             // Read control
             int leadingZeros = (int)reader.ReadBits(6);
-            int meaningfulBits = (int)reader.ReadBits(6);
+            int meaningfulBits = (int)reader.ReadBits(6) + 1; // Add 1 to get 1-64 range
             int trailingZeros = 64 - leadingZeros - meaningfulBits;
 
             // Read meaningful bits

tests/SharpCoreDB.Tests/TimeSeries/CompressionTests.cs

@@ -229,6 +229,24 @@ public void Gorilla_SingleValue_RoundTrip()
         _output.WriteLine("✓ Single value (Gorilla) round-trip");
     }
 
+    [Fact]
+    public void Gorilla_TwoValues_RoundTrip()
+    {
+        // Arrange
+        var values = new[] { 20.0, 20.004999916667085 };
+        var codec = new GorillaCodec();
+
+        // Act
+        var compressed = codec.Compress(values);
+        var decompressed = codec.Decompress(compressed, 2);
+
+        // Assert
+        Assert.Equal(2, decompressed.Length);
+        Assert.Equal(values[0], decompressed[0], precision: 10);
+        Assert.Equal(values[1], decompressed[1], precision: 10);
+        _output.WriteLine($"✓ Two values: {decompressed[0]}, {decompressed[1]}");
+    }
+
     // ========================================
     // XOR Float Compression Tests
     // ========================================