Refactor BitSetStructure and test for negative to positive span values

Author: Genbox

Src/FastData.Tests/FastDataGeneratorTests.cs

@@ -169,6 +169,21 @@ public void Generate_Overloads_Int32_Work()
         AssertKeysAndValues(generator, keys, values);
     }
 
+    [Fact]
+    public void Generate_Auto_UsesBitSetForNegativeRanges()
+    {
+        int[] keys = [-2, -1, 0, 2];
+        FastDataConfig config = new FastDataConfig();
+
+        ContextCaptureGenerator generator = new ContextCaptureGenerator();
+        FastDataGenerator.Generate(keys, config, generator);
+
+        BitSetContext<int, byte> ctx = Assert.IsType<BitSetContext<int, byte>>(generator.Context);
+        Assert.True(ctx.Values.IsEmpty);
+        Assert.Single(ctx.BitSet);
+        Assert.Equal(23UL, ctx.BitSet[0]);
+    }
+
     [Fact]
     public void GenerateKeyed_HashTablePerfect_ReordersValuesToMatchSlots()
     {
@@ -298,4 +313,4 @@ private static void AssertKeysAndValues<TKey, TValue>(ContextCaptureGenerator ge
         Assert.True(ctx.Keys.Span.SequenceEqual(keys));
         Assert.True(ctx.Values.Span.SequenceEqual(values));
     }
-}
+}

Src/FastData/FastDataGenerator.cs

@@ -228,7 +228,7 @@ private static string GenerateNumericInternal<TKey, TValue>(ReadOnlyMemory<TKey>
                 if (props.IsConsecutive && values.IsEmpty)
                     return GenerateWrapper(tempState, new RangeStructure<TKey, TValue>(props));
 
-                if (props.Range <= fdCfg.BitSetStructureMaxRange && keySpan.Length / (double)props.Range >= fdCfg.BitSetStructureMinDensity)
+                if ((keyType != KeyType.Single && keyType != KeyType.Double) && props.Range <= fdCfg.BitSetStructureMaxRange && keySpan.Length / (double)props.Range >= fdCfg.BitSetStructureMinDensity)
                     return GenerateWrapper(tempState, new BitSetStructure<TKey, TValue>(props, keyType));
 
                 // For small amounts of data, logic is the fastest. However, it increases the assembly size, so we want to try some special cases first.
@@ -518,4 +518,4 @@ private static void Benchmark(byte[] data, int iterations, Candidate candidate)
 
     private readonly record struct TempStringState<TKey, TValue>(ReadOnlyMemory<TKey> Keys, ReadOnlyMemory<TValue> Values, FastDataConfig Config, ICodeGenerator Generator, StringKeyProperties StringKeyProperties, HashDetails HashDetails, string TrimPrefix, string TrimSuffix);
     private readonly record struct TempNumericState<TKey, TValue>(ReadOnlyMemory<TKey> Keys, ReadOnlyMemory<TValue> Values, FastDataConfig Config, ICodeGenerator Generator, NumericKeyProperties<TKey> NumericKeyProperties, HashDetails HashDetails, KeyType KeyType);
-}
+}

Src/FastData/Internal/Structures/BitSetStructure.cs

@@ -9,15 +9,22 @@ internal sealed class BitSetStructure<TKey, TValue>(NumericKeyProperties<TKey> p
 {
     public BitSetContext<TKey, TValue> Create(ReadOnlyMemory<TKey> keys, ReadOnlyMemory<TValue> values)
     {
-        int range = (int)props.Range + 1;
-        ulong[] bitset = new ulong[(range + 63) / 64];
-        TValue[]? denseValues = values.IsEmpty ? null : new TValue[range];
+        if (keyType is KeyType.Single or KeyType.Double)
+            throw new InvalidOperationException("Floating point values are not supported for BitSets");
+
         ReadOnlySpan<TKey> keySpan = keys.Span;
         ReadOnlySpan<TValue> valueSpan = values.Span;
 
+        int range = (int)(props.Range + 1);
+        ulong[] bitset = new ulong[(range + 63) / 64];
+        TValue[]? denseValues = values.IsEmpty ? null : new TValue[range];
+
+        Func<TKey, long> func = GetLongConverter(keyType);
+        long minKey = func(props.MinKeyValue);
+
         for (int i = 0; i < keySpan.Length; i++)
         {
-            ulong offset = GetOffset(keyType, keySpan[i], props.MinKeyValue);
+            ulong offset = (ulong)(func(keySpan[i]) - minKey);
             int word = (int)(offset >> 6);
             bitset[word] |= 1UL << (int)(offset & 63);
 
@@ -28,17 +35,17 @@ public BitSetContext<TKey, TValue> Create(ReadOnlyMemory<TKey> keys, ReadOnlyMem
         return new BitSetContext<TKey, TValue>(bitset, denseValues);
     }
 
-    private static ulong GetOffset(KeyType keyType, TKey key, TKey min) => keyType switch
+    private static Func<TKey, long> GetLongConverter(KeyType keyType) => keyType switch
     {
-        KeyType.Char => (char)(object)key - (uint)(char)(object)min,
-        KeyType.SByte => (ulong)((long)(sbyte)(object)key - (sbyte)(object)min),
-        KeyType.Byte => (ulong)((byte)(object)key - (byte)(object)min),
-        KeyType.Int16 => (ulong)((long)(short)(object)key - (short)(object)min),
-        KeyType.UInt16 => (ulong)((ushort)(object)key - (ushort)(object)min),
-        KeyType.Int32 => (ulong)((long)(int)(object)key - (int)(object)min),
-        KeyType.UInt32 => (uint)(object)key - (uint)(object)min,
-        KeyType.Int64 => (ulong)((long)(object)key - (long)(object)min),
-        KeyType.UInt64 => (ulong)(object)key - (ulong)(object)min,
+        KeyType.SByte => static key => (sbyte)(object)key,
+        KeyType.Int16 => static key => (short)(object)key,
+        KeyType.Int32 => static key => (int)(object)key,
+        KeyType.Int64 => static key => (long)(object)key,
+        KeyType.Byte => static key => (byte)(object)key,
+        KeyType.UInt16 => static key => (ushort)(object)key,
+        KeyType.UInt32 => static key => (uint)(object)key,
+        KeyType.UInt64 => static key => (long)(object)key,
+        KeyType.Char => static key => (ushort)(object)key,
         _ => throw new InvalidOperationException($"Unsupported key type: {keyType}")
     };
 }