Use unsigned lengths and refactor to use lengthmap

Genbox · Genbox · commit 2be9d0e782c7 · 2025-12-23T19:18:09.000+01:00
diff --git a/Src/FastData.Tests/KeyAnalyzerTests.cs b/Src/FastData.Tests/KeyAnalyzerTests.cs
@@ -57,11 +57,11 @@ public void GetStringProperties_LengthMap_Test(string[] data)
 
         foreach (string str in data)
         {
-            Assert.True(map.Get(str.Length));
+            Assert.True(map.Get((uint)str.Length));
         }
 
-        Assert.Equal((uint)data.Min(x => x.Length), res.LengthData.Min);
-        Assert.Equal((uint)data.Max(x => x.Length), res.LengthData.Max);
+        Assert.Equal((uint)data.Min(x => x.Length), res.LengthData.LengthMap.Min);
+        Assert.Equal((uint)data.Max(x => x.Length), res.LengthData.LengthMap.Max);
     }
 
     [Theory]
diff --git a/Src/FastData.Tests/LengthBitArrayTests.cs b/Src/FastData.Tests/LengthBitArrayTests.cs
@@ -22,28 +22,10 @@ public void DefaultBitsAreFalse()
     public void CustomLength_AllBitsFalseWithinRange()
     {
         LengthBitArray bits = new LengthBitArray(128);
-        for (int i = 0; i < 128; i += 15)
+        for (uint i = 0; i < 128; i += 15)
             Assert.False(bits.Get(i));
     }
 
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(-100)]
-    public void Get_OutOfRange_Throws(int index)
-    {
-        LengthBitArray bits = new LengthBitArray();
-        Assert.Throws<ArgumentException>(() => bits.Get(index));
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(-50)]
-    public void SetTrue_NegativeIndex_Throws(int index)
-    {
-        LengthBitArray bits = new LengthBitArray();
-        Assert.Throws<ArgumentException>(() => bits.SetTrue(index));
-    }
-
     [Fact]
     public void SetTrue_SetsBitAndReturnsCorrectFlag()
     {
diff --git a/Src/FastData/FastDataGenerator.cs b/Src/FastData/FastDataGenerator.cs
@@ -120,7 +120,7 @@ private static string GenerateStringInternal<TValue>(ReadOnlyMemory<string> keys
             keySpan = keyMemory.Span;
         }
 
-        LogMinMaxLength(logger, strProps.LengthData.Min, strProps.LengthData.Max);
+        LogMinMaxLength(logger, strProps.LengthData.LengthMap.Min, strProps.LengthData.LengthMap.Max);
 
         HashDetails hashDetails = new HashDetails();
         GeneratorConfig<string> genCfg = new GeneratorConfig<string>(fdCfg.StructureType, keyType, (uint)keySpan.Length, strProps, DefaultStringComparison, hashDetails, generator.Encoding, strProps.CharacterData.AllAscii ? GeneratorFlags.AllAreASCII : GeneratorFlags.None, trimPrefix, trimSuffix);
@@ -133,7 +133,7 @@ private static string GenerateStringInternal<TValue>(ReadOnlyMemory<string> keys
                     return GenerateWrapper(generator, genCfg, new SingleValueStructure<string, TValue>(), keyMemory, values);
 
                 // For small amounts of data, logic is the fastest. However, it increases the assembly size, so we want to try some special cases first.
-                double density = (double)keySpan.Length / (strProps.LengthData.Max - strProps.LengthData.Min + 1);
+                double density = (double)keySpan.Length / (strProps.LengthData.LengthMap.Max - strProps.LengthData.LengthMap.Min + 1);
 
                 // Use KeyLengthStructure only when string lengths are unique and density >= 75%
                 if (strProps.LengthData.Unique && density >= 0.75)
@@ -346,7 +346,7 @@ internal static Candidate GetBestHash(ReadOnlySpan<string> data, StringPropertie
         perfect.Sort(static (a, b) => b.Fitness.CompareTo(a.Fitness));
         notPerfect.Sort(static (a, b) => b.Fitness.CompareTo(a.Fitness));
 
-        string test = new string('a', (int)props.LengthData.Max);
+        string test = new string('a', (int)props.LengthData.LengthMap.Max);
         byte[] testBytes = encoding == GeneratorEncoding.UTF8 ? Encoding.UTF8.GetBytes(test) : Encoding.Unicode.GetBytes(test);
 
         //We start with the perfect results (if any)
diff --git a/Src/FastData/Generators/GeneratorConfig.cs b/Src/FastData/Generators/GeneratorConfig.cs
@@ -79,8 +79,8 @@ private static Constants<T> CreateConstants(KeyProperties<T> props, uint itemCou
     private static Constants<T> CreateConstants(StringProperties props, uint itemCount)
     {
         Constants<T> constants = new Constants<T>(itemCount);
-        constants.MinStringLength = props.LengthData.Min;
-        constants.MaxStringLength = props.LengthData.Max;
+        constants.MinStringLength = props.LengthData.LengthMap.Min;
+        constants.MaxStringLength = props.LengthData.LengthMap.Max;
         return constants;
     }
 
@@ -108,7 +108,7 @@ private static IEnumerable<IEarlyExit> GetEarlyExits(StringProperties props, uin
             uint minByteCount = enc == GeneratorEncoding.UTF8 ? lengthData.MinUtf8ByteCount : lengthData.MinUtf16ByteCount;
             uint maxByteCount = enc == GeneratorEncoding.UTF8 ? lengthData.MaxUtf8ByteCount : lengthData.MaxUtf16ByteCount;
 
-            yield return new MinMaxLengthEarlyExit(lengthData.Min, lengthData.Max, minByteCount, maxByteCount); //Also handles same lengths
+            yield return new MinMaxLengthEarlyExit(lengthData.LengthMap.Min, lengthData.LengthMap.Max, minByteCount, maxByteCount); //Also handles same lengths
         }
     }
 
@@ -136,7 +136,7 @@ private static bool ShouldUseBitSet(LengthData lengthData)
         if (lengthData.LengthMap.Values.Length > MaxLengthBitSetWords)
             return false;
 
-        uint range = lengthData.Max - lengthData.Min + 1;
+        uint range = lengthData.LengthMap.Max - lengthData.LengthMap.Min + 1;
         double density = lengthData.LengthMap.BitCount / (double)range;
         return density <= MaxLengthBitSetDensity;
     }
diff --git a/Src/FastData/Internal/Analysis/Analyzers/GPerfAnalyzer.cs b/Src/FastData/Internal/Analysis/Analyzers/GPerfAnalyzer.cs
@@ -36,7 +36,7 @@ internal sealed partial class GPerfAnalyzer(int dataLength, StringProperties pro
     public IEnumerable<Candidate> GetCandidates(ReadOnlySpan<string> data)
     {
         // We cannot work on empty strings
-        if (props.LengthData.Min == 0)
+        if (props.LengthData.LengthMap.Min == 0)
             return [];
 
         // Step1: Find positions
@@ -47,7 +47,7 @@ public IEnumerable<Candidate> GetCandidates(ReadOnlySpan<string> data)
         if (positions.Length == 0)
             return [];
 
-        int maxLen = (int)props.LengthData.Max;
+        int maxLen = (int)props.LengthData.LengthMap.Max;
 
         // TODO: For now, we keep regenerating state within Keyword. In the future, I hope to do this more efficiently
         List<Keyword> keywords = new List<Keyword>(data.Length);
@@ -136,7 +136,7 @@ public IEnumerable<Candidate> GetCandidates(ReadOnlySpan<string> data)
 #endif
 
         // We convert keywords to KeyValuePair to keep Keyword internal
-        GPerfStringHash stringHash = new GPerfStringHash(table.Values, alphaInc, positions.OrderByDescending(x => x).ToArray(), props.LengthData.Min);
+        GPerfStringHash stringHash = new GPerfStringHash(table.Values, alphaInc, positions.OrderByDescending(x => x).ToArray(), props.LengthData.LengthMap.Min);
 
         Candidate candidate = sim.Run(data, stringHash);
         LogCandidate(logger, candidate.Fitness, candidate.Collisions);
@@ -180,7 +180,7 @@ the hash is a perfect hash.
             - Case-sensitivity (alpha_unify)
         */
 
-        int max = (int)Math.Min(props.LengthData.Max - 1, config.MaxPositions - 1);
+        int max = (int)Math.Min(props.LengthData.LengthMap.Max - 1, config.MaxPositions - 1);
 
         // Stage 1: Find all positions that are mandatory. If two items are the same length, but differ only on one character, then we must include that character.
         DirectMap mandatory = new DirectMap(max + 1);
diff --git a/Src/FastData/Internal/Analysis/Data/LengthBitArray.cs b/Src/FastData/Internal/Analysis/Data/LengthBitArray.cs
@@ -7,8 +7,8 @@ internal sealed class LengthBitArray(int length = 64)
 {
     private readonly SwitchingBitSet _tracker = new SwitchingBitSet(length, true);
 
-    public int Min { get; private set; } = int.MaxValue;
-    public int Max { get; private set; } = int.MinValue;
+    public uint Min { get; private set; } = uint.MaxValue;
+    public uint Max { get; private set; } = uint.MinValue;
 
     internal ulong[] Values => _tracker.BitSet;
     internal int BitCount { get; private set; }
@@ -26,16 +26,11 @@ internal bool Consecutive
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    internal bool Get(int index) => _tracker.Contains(index);
+    internal bool Get(uint index) => _tracker.Contains(index);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    internal bool SetTrue(int index)
+    internal bool SetTrue(uint index)
     {
-        if (index < 0)
-            throw new ArgumentException("Index must be non-negative: " + index, nameof(index));
-
-        unchecked
-        {
             bool added = _tracker.Add(index);
 
             if (added)
@@ -46,6 +41,5 @@ internal bool SetTrue(int index)
             }
 
             return !added;
-        }
     }
 }
diff --git a/Src/FastData/Internal/Analysis/Data/LengthData.cs b/Src/FastData/Internal/Analysis/Data/LengthData.cs
@@ -3,4 +3,4 @@
 namespace Genbox.FastData.Internal.Analysis.Data;
 
 [StructLayout(LayoutKind.Auto)]
-internal record struct LengthData(uint Min, uint Max, uint MinUtf8ByteCount, uint MaxUtf8ByteCount, uint MinUtf16ByteCount, uint MaxUtf16ByteCount, bool Unique, LengthBitArray LengthMap);
+internal record struct LengthData(uint MinUtf8ByteCount, uint MaxUtf8ByteCount, uint MinUtf16ByteCount, uint MaxUtf16ByteCount, bool Unique, LengthBitArray LengthMap);
diff --git a/Src/FastData/Internal/Analysis/KeyAnalyzer.cs b/Src/FastData/Internal/Analysis/KeyAnalyzer.cs
@@ -61,7 +61,7 @@ internal static StringProperties GetStringProperties(ReadOnlySpan<string> keys,
             minUtf16ByteLength = Math.Min(utf16ByteCount, minUtf16ByteLength);
             maxUtf16ByteLength = Math.Max(utf16ByteCount, maxUtf16ByteLength);
 
-            uniq &= !lengthMap.SetTrue(str.Length);
+            uniq &= !lengthMap.SetTrue((uint)str.Length);
 
             foreach (char c in str)
             {
@@ -145,7 +145,7 @@ internal static StringProperties GetStringProperties(ReadOnlySpan<string> keys,
             // }
         }
 
-        return new StringProperties(new LengthData((uint)lengthMap.Min, (uint)maxStr.Length, (uint)minUtf8ByteLength, (uint)maxUtf8ByteLength, (uint)minUtf16ByteLength, (uint)maxUtf16ByteLength, uniq, lengthMap), new DeltaData(left, right), new CharacterData(allAscii));
+        return new StringProperties(new LengthData((uint)minUtf8ByteLength, (uint)maxUtf8ByteLength, (uint)minUtf16ByteLength, (uint)maxUtf16ByteLength, uniq, lengthMap), new DeltaData(left, right), new CharacterData(allAscii));
     }
 
     private static KeyProperties<char> GetCharProperties(ReadOnlySpan<char> keys)
diff --git a/Src/FastData/Internal/Analysis/SegmentGenerators/BruteForceGenerator.cs b/Src/FastData/Internal/Analysis/SegmentGenerators/BruteForceGenerator.cs
@@ -12,7 +12,7 @@ internal sealed class BruteForceGenerator(int maxLength) : ISegmentGenerator
 
     public IEnumerable<ArraySegment> Generate(StringProperties props)
     {
-        int max = (int)Math.Min(props.LengthData.Min, maxLength); //We cannot segment above the shortest string.
+        int max = (int)Math.Min(props.LengthData.LengthMap.Min, maxLength); //We cannot segment above the shortest string.
 
         //Generates:
         //[t]est
diff --git a/Src/FastData/Internal/Analysis/SegmentGenerators/DeltaGenerator.cs b/Src/FastData/Internal/Analysis/SegmentGenerators/DeltaGenerator.cs
@@ -73,7 +73,7 @@ public IEnumerable<ArraySegment> Generate(StringProperties props)
             foreach (ArraySegment segment in CalculateSegments(props.DeltaData.Left))
             {
                 // Left Alignment: offset + length <= Min
-                int maxLength = (int)(props.LengthData.Min - segment.Offset);
+                int maxLength = (int)(props.LengthData.LengthMap.Min - segment.Offset);
                 int length = maxLength < 0 ? 0 : Math.Min(segment.Length, maxLength);
 
                 if (length > 0)
@@ -87,7 +87,7 @@ public IEnumerable<ArraySegment> Generate(StringProperties props)
             foreach (ArraySegment segment in CalculateSegments(props.DeltaData.Right))
             {
                 // Right Alignment: offset + length <= Min
-                int maxLength = (int)(props.LengthData.Min - segment.Offset);
+                int maxLength = (int)(props.LengthData.LengthMap.Min - segment.Offset);
                 int length = maxLength < 0 ? 0 : Math.Min(segment.Length, maxLength);
 
                 if (length > 0)
diff --git a/Src/FastData/Internal/Analysis/SegmentGenerators/EdgeGramGenerator.cs b/Src/FastData/Internal/Analysis/SegmentGenerators/EdgeGramGenerator.cs
@@ -14,7 +14,7 @@ public IEnumerable<ArraySegment> Generate(StringProperties props)
     {
         int len;
 
-        int max = (int)Math.Min(props.LengthData.Min, maxLength); //We cannot segment above the shortest string.
+        int max = (int)Math.Min(props.LengthData.LengthMap.Min, maxLength); //We cannot segment above the shortest string.
 
         //Generates:
         //[t]est
diff --git a/Src/FastData/Internal/Analysis/SegmentGenerators/OffsetGenerator.cs b/Src/FastData/Internal/Analysis/SegmentGenerators/OffsetGenerator.cs
@@ -18,7 +18,7 @@ public IEnumerable<ArraySegment> Generate(StringProperties props)
         //te[st]
         //tes[t]
 
-        for (uint offset = 0; offset < props.LengthData.Min; offset++)
+        for (uint offset = 0; offset < props.LengthData.LengthMap.Min; offset++)
         {
             yield return new ArraySegment(offset, -1, Alignment.Left);
         }
diff --git a/Src/FastData/Internal/Helpers/FitnessHelper.cs b/Src/FastData/Internal/Helpers/FitnessHelper.cs
@@ -10,7 +10,7 @@ internal static class FitnessHelper
     internal static double CalculateFitness(StringProperties props, ArraySegment segment, Expression expression)
     {
         //The length of segment is a factor
-        int minLen = (int)props.LengthData.Min;
+        int minLen = (int)props.LengthData.LengthMap.Min;
         int segLen = segment.Length;
         double segFit;
 
diff --git a/Src/FastData/Internal/Misc/HashData.cs b/Src/FastData/Internal/Misc/HashData.cs
@@ -38,7 +38,7 @@ internal static HashData Create<T>(ReadOnlySpan<T> data, int capacityFactor, Has
             if (uniq && !uniqSet.Add(hash)) //The unique check is first so that when it is false, we don't try the other conditions
                 uniq = false;
 
-            if (perfect && !perfectTracker.Add((int)(hash % size)))
+            if (perfect && !perfectTracker.Add((uint)(hash % size)))
                 perfect = false;
         }
 
diff --git a/Src/FastData/Internal/Misc/SwitchingBitSet.cs b/Src/FastData/Internal/Misc/SwitchingBitSet.cs
@@ -6,7 +6,7 @@ internal sealed class SwitchingBitSet
     private readonly int _maxBitSetWords;
     private readonly bool _offByOneMode; // "Off by one mode" is needed for length bitarrays as we occupy the first bit as length = 1
     private ulong[]? _bits;
-    private HashSet<int>? _set;
+    private HashSet<uint>? _set;
 
     internal SwitchingBitSet(int length, bool offByOneMode, int maxBitSetWords = 131072)
     {
@@ -21,25 +21,22 @@ internal SwitchingBitSet(int length, bool offByOneMode, int maxBitSetWords = 131
         if (wordLength <= maxBitSetWords)
             _bits = new ulong[wordLength];
         else
-            _set = new HashSet<int>();
+            _set = new HashSet<uint>();
     }
 
     internal bool IsBitSet => _bits != null;
     internal ulong[] BitSet => _bits ?? [];
 
-    internal bool Add(int index)
+    internal bool Add(uint index)
     {
-        if (index < 0)
-            throw new ArgumentException("Index must be non-negative: " + index, nameof(index));
-
         if (_bits != null)
         {
             EnsureCapacityForIndex(index);
 
             if (_bits == null)
                 return _set!.Add(index);
 
-            GetPosition(index, out int wordIndex, out ulong mask);
+            GetPosition(index, out uint wordIndex, out ulong mask);
 
             if ((_bits[wordIndex] & mask) != 0)
                 return false;
@@ -51,14 +48,11 @@ internal bool Add(int index)
         return _set!.Add(index);
     }
 
-    internal bool Contains(int index)
+    internal bool Contains(uint index)
     {
-        if (index < 0)
-            throw new ArgumentException("Index must be non-negative: " + index, nameof(index));
-
         if (_bits != null)
         {
-            GetPosition(index, out int wordIndex, out ulong mask);
+            GetPosition(index, out uint wordIndex, out ulong mask);
 
             if (wordIndex >= _bits.Length)
                 return false;
@@ -71,25 +65,25 @@ internal bool Contains(int index)
 
     private static int GetWordLength(int length) => (int)(((long)length + 63) >> 6);
 
-    private void GetPosition(int index, out int wordIndex, out ulong mask)
+    private void GetPosition(uint index, out uint wordIndex, out ulong mask)
     {
         wordIndex = index >> 6;
 
         if (_offByOneMode)
         {
-            ulong remainder = (ulong)(index & 63);
+            ulong remainder = index & 63;
             int bitIndex = remainder == 0 ? 63 : (int)remainder - 1;
             mask = 1UL << bitIndex;
         }
         else
         {
-            mask = 1UL << (index & 63);
+            mask = 1UL << ((int)index & 63);
         }
     }
 
     private void SwitchToSet()
     {
-        HashSet<int> set = new HashSet<int>();
+        HashSet<uint> set = new HashSet<uint>();
 
         for (int wordIndex = 0; wordIndex < _bits!.Length; wordIndex++)
         {
@@ -110,17 +104,17 @@ private void SwitchToSet()
         _bits = null;
     }
 
-    private int GetIndex(int wordIndex, int bitIndex)
+    private uint GetIndex(int wordIndex, int bitIndex)
     {
         if (_offByOneMode)
-            return (int)(((ulong)wordIndex << 6) + (bitIndex == 63 ? 0UL : (uint)bitIndex + 1));
+            return (uint)(((ulong)wordIndex << 6) + (bitIndex == 63 ? 0UL : (uint)bitIndex + 1));
 
-        return (int)(((ulong)wordIndex << 6) + (uint)bitIndex);
+        return (uint)(((ulong)wordIndex << 6) + (uint)bitIndex);
     }
 
-    private void EnsureCapacityForIndex(int index)
+    private void EnsureCapacityForIndex(uint index)
     {
-        int wordLength = (index >> 6) + 1;
+        uint wordLength = (index >> 6) + 1;
         if (wordLength <= _bits!.Length)
             return;
 
@@ -130,6 +124,6 @@ private void EnsureCapacityForIndex(int index)
             return;
         }
 
-        Array.Resize(ref _bits, wordLength);
+        Array.Resize(ref _bits, (int)wordLength);
     }
 }
diff --git a/Src/FastData/Internal/Structures/KeyLengthStructure.cs b/Src/FastData/Internal/Structures/KeyLengthStructure.cs
@@ -14,8 +14,8 @@ public KeyLengthContext<TValue> Create(ReadOnlyMemory<TKey> keys, ReadOnlyMemory
         if (!props.LengthData.Unique)
             throw new InvalidOperationException("We can only use this structure when all lengths are unique");
 
-        uint minLen = props.LengthData.Min;
-        uint maxLen = props.LengthData.Max;
+        uint minLen = props.LengthData.LengthMap.Min;
+        uint maxLen = props.LengthData.LengthMap.Max;
         int range = (int)(maxLen - minLen + 1); //+1 because we need a place for zero
 
         string?[] lengths = new string?[range];

Original file line number	Diff line number	Diff line change
`@@ -57,11 +57,11 @@ public void GetStringProperties_LengthMap_Test(string[] data)`
`57`	`57`
`58`	`58`	`foreach (string str in data)`
`59`	`59`	`{`
`60`		`- Assert.True(map.Get(str.Length));`
	`60`	`+ Assert.True(map.Get((uint)str.Length));`
`61`	`61`	`}`
`62`	`62`
`63`		`- Assert.Equal((uint)data.Min(x => x.Length), res.LengthData.Min);`
`64`		`- Assert.Equal((uint)data.Max(x => x.Length), res.LengthData.Max);`
	`63`	`+ Assert.Equal((uint)data.Min(x => x.Length), res.LengthData.LengthMap.Min);`
	`64`	`+ Assert.Equal((uint)data.Max(x => x.Length), res.LengthData.LengthMap.Max);`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`[Theory]`
Original file line number	Diff line number	Diff line change
`@@ -79,8 +79,8 @@ private static Constants<T> CreateConstants(KeyProperties<T> props, uint itemCou`
`79`	`79`	`private static Constants<T> CreateConstants(StringProperties props, uint itemCount)`
`80`	`80`	`{`
`81`	`81`	`Constants<T> constants = new Constants<T>(itemCount);`
`82`		`- constants.MinStringLength = props.LengthData.Min;`
`83`		`- constants.MaxStringLength = props.LengthData.Max;`
	`82`	`+ constants.MinStringLength = props.LengthData.LengthMap.Min;`
	`83`	`+ constants.MaxStringLength = props.LengthData.LengthMap.Max;`
`84`	`84`	`return constants;`
`85`	`85`	`}`
`86`	`86`
`@@ -108,7 +108,7 @@ private static IEnumerable<IEarlyExit> GetEarlyExits(StringProperties props, uin`
`108`	`108`	`uint minByteCount = enc == GeneratorEncoding.UTF8 ? lengthData.MinUtf8ByteCount : lengthData.MinUtf16ByteCount;`
`109`	`109`	`uint maxByteCount = enc == GeneratorEncoding.UTF8 ? lengthData.MaxUtf8ByteCount : lengthData.MaxUtf16ByteCount;`
`110`	`110`
`111`		`- yield return new MinMaxLengthEarlyExit(lengthData.Min, lengthData.Max, minByteCount, maxByteCount); //Also handles same lengths`
	`111`	`+ yield return new MinMaxLengthEarlyExit(lengthData.LengthMap.Min, lengthData.LengthMap.Max, minByteCount, maxByteCount); //Also handles same lengths`
`112`	`112`	`}`
`113`	`113`	`}`
`114`	`114`
`@@ -136,7 +136,7 @@ private static bool ShouldUseBitSet(LengthData lengthData)`
`136`	`136`	`if (lengthData.LengthMap.Values.Length > MaxLengthBitSetWords)`
`137`	`137`	`return false;`
`138`	`138`
`139`		`- uint range = lengthData.Max - lengthData.Min + 1;`
	`139`	`+ uint range = lengthData.LengthMap.Max - lengthData.LengthMap.Min + 1;`
`140`	`140`	`double density = lengthData.LengthMap.BitCount / (double)range;`
`141`	`141`	`return density <= MaxLengthBitSetDensity;`
`142`	`142`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,8 @@ internal sealed class LengthBitArray(int length = 64)`
`7`	`7`	`{`
`8`	`8`	`private readonly SwitchingBitSet _tracker = new SwitchingBitSet(length, true);`
`9`	`9`
`10`		`- public int Min { get; private set; } = int.MaxValue;`
`11`		`- public int Max { get; private set; } = int.MinValue;`
	`10`	`+ public uint Min { get; private set; } = uint.MaxValue;`
	`11`	`+ public uint Max { get; private set; } = uint.MinValue;`
`12`	`12`
`13`	`13`	`internal ulong[] Values => _tracker.BitSet;`
`14`	`14`	`internal int BitCount { get; private set; }`
`@@ -26,16 +26,11 @@ internal bool Consecutive`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`29`		`- internal bool Get(int index) => _tracker.Contains(index);`
	`29`	`+ internal bool Get(uint index) => _tracker.Contains(index);`
`30`	`30`
`31`	`31`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`32`		`- internal bool SetTrue(int index)`
	`32`	`+ internal bool SetTrue(uint index)`
`33`	`33`	`{`
`34`		`- if (index < 0)`
`35`		`- throw new ArgumentException("Index must be non-negative: " + index, nameof(index));`
`36`		`-`
`37`		`- unchecked`
`38`		`- {`
`39`	`34`	`bool added = _tracker.Add(index);`
`40`	`35`
`41`	`36`	`if (added)`
`@@ -46,6 +41,5 @@ internal bool SetTrue(int index)`
`46`	`41`	`}`
`47`	`42`
`48`	`43`	`return !added;`
`49`		`- }`
`50`	`44`	`}`
`51`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ internal static StringProperties GetStringProperties(ReadOnlySpan<string> keys,`
`61`	`61`	`minUtf16ByteLength = Math.Min(utf16ByteCount, minUtf16ByteLength);`
`62`	`62`	`maxUtf16ByteLength = Math.Max(utf16ByteCount, maxUtf16ByteLength);`
`63`	`63`
`64`		`- uniq &= !lengthMap.SetTrue(str.Length);`
	`64`	`+ uniq &= !lengthMap.SetTrue((uint)str.Length);`
`65`	`65`
`66`	`66`	`foreach (char c in str)`
`67`	`67`	`{`
`@@ -145,7 +145,7 @@ internal static StringProperties GetStringProperties(ReadOnlySpan<string> keys,`
`145`	`145`	`// }`
`146`	`146`	`}`
`147`	`147`
`148`		`- return new StringProperties(new LengthData((uint)lengthMap.Min, (uint)maxStr.Length, (uint)minUtf8ByteLength, (uint)maxUtf8ByteLength, (uint)minUtf16ByteLength, (uint)maxUtf16ByteLength, uniq, lengthMap), new DeltaData(left, right), new CharacterData(allAscii));`
	`148`	`+ return new StringProperties(new LengthData((uint)minUtf8ByteLength, (uint)maxUtf8ByteLength, (uint)minUtf16ByteLength, (uint)maxUtf16ByteLength, uniq, lengthMap), new DeltaData(left, right), new CharacterData(allAscii));`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`private static KeyProperties<char> GetCharProperties(ReadOnlySpan<char> keys)`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ internal sealed class BruteForceGenerator(int maxLength) : ISegmentGenerator`
`12`	`12`
`13`	`13`	`public IEnumerable<ArraySegment> Generate(StringProperties props)`
`14`	`14`	`{`
`15`		`- int max = (int)Math.Min(props.LengthData.Min, maxLength); //We cannot segment above the shortest string.`
	`15`	`+ int max = (int)Math.Min(props.LengthData.LengthMap.Min, maxLength); //We cannot segment above the shortest string.`
`16`	`16`
`17`	`17`	`//Generates:`
`18`	`18`	`//[t]est`