Update HashTable verify results

Author: Genbox

Src/FastData.Generator.CSharp.Tests/Vectors/HashTableStructure_Byte_3.verified.txt

@@ -0,0 +1,70 @@
+// <auto-generated />
+// This file is auto-generated. Do not edit manually.
+// Structure: HashTable
+#nullable enable
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+internal static class HashTableStructure_Byte_3
+{
+    private static readonly sbyte[] _buckets = new sbyte[] {
+        3, 2, 0
+     };
+
+    private static readonly E[] _entries = {
+        new E(-1, byte.MinValue), new E(-1, 1), new E(0, byte.MaxValue)
+    };
+
+    
+    public static bool Contains(byte key)
+    {
+        if (key < byte.MinValue || key > byte.MaxValue)
+            return false;
+
+        ulong hash = Hash(key);
+        uint index = (uint)(hash % 3);
+        sbyte i = (sbyte)(_buckets[index] - 1);
+
+        while (i >= 0)
+        {
+            ref E entry = ref _entries[i];
+
+            if (key == entry.Key)
+                return true;
+
+            i = entry.Next;
+        }
+
+        return false;
+    }
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ulong Hash(byte value)
+    {
+        return (ulong)value;
+    }
+
+    [StructLayout(LayoutKind.Auto)]
+    private readonly struct E
+    {
+        
+        internal readonly sbyte Next;
+        internal readonly byte Key;
+        
+
+        internal E(sbyte next, byte key)
+        {
+            
+            Next = next;
+            Key = key;
+            
+        }
+    }
+
+
+    public const uint ItemCount = 3;
+    public const byte MinKey = byte.MinValue;
+    public const byte MaxKey = byte.MaxValue;
+}

Src/FastData.Generator.CSharp.Tests/Vectors/HashTableStructure_Char_3.verified.txt

@@ -0,0 +1,70 @@
+// <auto-generated />
+// This file is auto-generated. Do not edit manually.
+// Structure: HashTable
+#nullable enable
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+internal static class HashTableStructure_Char_3
+{
+    private static readonly sbyte[] _buckets = new sbyte[] {
+        1, 3, 0
+     };
+
+    private static readonly E[] _entries = {
+        new E(-1, char.MinValue), new E(-1, 'a'), new E(1, '')
+    };
+
+    
+    public static bool Contains(char key)
+    {
+        if (key < char.MinValue || key > '')
+            return false;
+
+        ulong hash = Hash(key);
+        uint index = (uint)(hash % 3);
+        sbyte i = (sbyte)(_buckets[index] - 1);
+
+        while (i >= 0)
+        {
+            ref E entry = ref _entries[i];
+
+            if (key == entry.Key)
+                return true;
+
+            i = entry.Next;
+        }
+
+        return false;
+    }
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ulong Hash(char value)
+    {
+        return (ulong)value;
+    }
+
+    [StructLayout(LayoutKind.Auto)]
+    private readonly struct E
+    {
+        
+        internal readonly sbyte Next;
+        internal readonly char Key;
+        
+
+        internal E(sbyte next, char key)
+        {
+            
+            Next = next;
+            Key = key;
+            
+        }
+    }
+
+
+    public const uint ItemCount = 3;
+    public const char MinKey = char.MinValue;
+    public const char MaxKey = '';
+}

Src/FastData.Generator.CSharp.Tests/Vectors/HashTableStructure_Double_4.verified.txt

@@ -0,0 +1,75 @@
+// <auto-generated />
+// This file is auto-generated. Do not edit manually.
+// Structure: HashTable
+#nullable enable
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+internal static class HashTableStructure_Double_4
+{
+    private static readonly sbyte[] _buckets = new sbyte[] {
+        3, 0, 0, 4
+     };
+
+    private static readonly E[] _entries = {
+        new E(18442240474082181119, -1, double.MinValue), new E(0, -1, 0.0), new E(4607182418800017408, 1, 1.0), new E(9218868437227405311, 0, double.MaxValue)
+    };
+
+    
+    public static bool Contains(double key)
+    {
+        if (key < double.MinValue || key > double.MaxValue)
+            return false;
+
+        ulong hash = Hash(key);
+        uint index = (uint)(hash & 3);
+        sbyte i = (sbyte)(_buckets[index] - 1);
+
+        while (i >= 0)
+        {
+            ref E entry = ref _entries[i];
+
+            if (entry.HashCode == hash && key == entry.Key)
+                return true;
+
+            i = entry.Next;
+        }
+
+        return false;
+    }
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ulong Hash(double value)
+    {
+        ulong bits = Unsafe.ReadUnaligned<ulong>(ref Unsafe.As<double, byte>(ref value));
+
+        if (((bits - 1) & ~(0x8000_0000_0000_0000)) >= 0x7FF0_0000_0000_0000)
+            bits &= 0x7FF0_0000_0000_0000;
+
+        return bits;
+    }
+
+    [StructLayout(LayoutKind.Auto)]
+    private readonly struct E
+    {
+        internal readonly ulong HashCode;
+        internal readonly sbyte Next;
+        internal readonly double Key;
+        
+
+        internal E(ulong hashCode, sbyte next, double key)
+        {
+            HashCode = hashCode;
+            Next = next;
+            Key = key;
+            
+        }
+    }
+
+
+    public const uint ItemCount = 4;
+    public const double MinKey = double.MinValue;
+    public const double MaxKey = double.MaxValue;
+}

Src/FastData.Generator.CSharp.Tests/Vectors/HashTableStructure_Double_5_HashZeroOrNaN.verified.txt

@@ -0,0 +1,70 @@
+// <auto-generated />
+// This file is auto-generated. Do not edit manually.
+// Structure: HashTable
+#nullable enable
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+internal static class HashTableStructure_Double_5_HashZeroOrNaN
+{
+    private static readonly sbyte[] _buckets = new sbyte[] {
+        4, 0, 3, 1, 5
+     };
+
+    private static readonly E[] _entries = {
+        new E(4607182418800017408, -1, 1.0), new E(4611686018427387904, -1, 2.0), new E(4613937818241073152, -1, 3.0), new E(4616189618054758400, -1, 4.0), new E(4617315517961601024, 1, 5.0)
+    };
+
+    
+    public static bool Contains(double key)
+    {
+        if (key < 1.0 || key > 5.0)
+            return false;
+
+        ulong hash = Hash(key);
+        uint index = (uint)(hash % 5);
+        sbyte i = (sbyte)(_buckets[index] - 1);
+
+        while (i >= 0)
+        {
+            ref E entry = ref _entries[i];
+
+            if (entry.HashCode == hash && key == entry.Key)
+                return true;
+
+            i = entry.Next;
+        }
+
+        return false;
+    }
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ulong Hash(double value)
+    {
+        return Unsafe.ReadUnaligned<ulong>(ref Unsafe.As<double, byte>(ref value));
+    }
+
+    [StructLayout(LayoutKind.Auto)]
+    private readonly struct E
+    {
+        internal readonly ulong HashCode;
+        internal readonly sbyte Next;
+        internal readonly double Key;
+        
+
+        internal E(ulong hashCode, sbyte next, double key)
+        {
+            HashCode = hashCode;
+            Next = next;
+            Key = key;
+            
+        }
+    }
+
+
+    public const uint ItemCount = 5;
+    public const double MinKey = 1.0;
+    public const double MaxKey = 5.0;
+}

Src/FastData.Generator.CSharp.Tests/Vectors/HashTableStructure_Int16_5.verified.txt

@@ -0,0 +1,70 @@
+// <auto-generated />
+// This file is auto-generated. Do not edit manually.
+// Structure: HashTable
+#nullable enable
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+internal static class HashTableStructure_Int16_5
+{
+    private static readonly sbyte[] _buckets = new sbyte[] {
+        3, 4, 5, 1, 0
+     };
+
+    private static readonly E[] _entries = {
+        new E(-1, short.MinValue), new E(-1, -1), new E(1, 0), new E(-1, 1), new E(-1, short.MaxValue)
+    };
+
+    
+    public static bool Contains(short key)
+    {
+        if (key < short.MinValue || key > short.MaxValue)
+            return false;
+
+        ulong hash = Hash(key);
+        uint index = (uint)(hash % 5);
+        sbyte i = (sbyte)(_buckets[index] - 1);
+
+        while (i >= 0)
+        {
+            ref E entry = ref _entries[i];
+
+            if (key == entry.Key)
+                return true;
+
+            i = entry.Next;
+        }
+
+        return false;
+    }
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ulong Hash(short value)
+    {
+        return (ulong)value;
+    }
+
+    [StructLayout(LayoutKind.Auto)]
+    private readonly struct E
+    {
+        
+        internal readonly sbyte Next;
+        internal readonly short Key;
+        
+
+        internal E(sbyte next, short key)
+        {
+            
+            Next = next;
+            Key = key;
+            
+        }
+    }
+
+
+    public const uint ItemCount = 5;
+    public const short MinKey = short.MinValue;
+    public const short MaxKey = short.MaxValue;
+}