Add support for float fast hash when there are no zero or NaN values

Author: Genbox

Src/FastData.Generator.CPlusPlus.Tests/Verify/HashSetChainStructure_Double_5_HashZeroOrNaN.verified.txt

@@ -0,0 +1,70 @@
+// This file is auto-generated. Do not edit manually.
+// Structure: HashSet (HashSetChain)
+#pragma once
+#include <array>
+#include <cstdint>
+#include <limits>
+#include <string_view>
+
+class HashSetChainStructure_Double_5_HashZeroOrNaN final
+{
+    struct e
+    {
+        uint64_t hash_code;
+        int8_t next;
+        double value;
+
+        e(const uint64_t hash_code, const int8_t next, const double value)
+           : hash_code(hash_code), next(next), value(value) {}
+    };
+
+    static constexpr std::array<int8_t, 5> buckets = {
+        4, 0, 3, 1, 5
+     };
+
+    inline static const std::array<e, 5> entries = {
+        e(4607182418800017408, -1, 1.0), e(4611686018427387904, -1, 2.0), e(4613937818241073152, -1, 3.0), e(4616189618054758400, -1, 4.0), e(4617315517961601024, 1, 5.0)
+    };
+
+    static uint64_t get_hash(const double value) noexcept
+    {
+        uint64_t bits;
+        std::memcpy(&bits, &value, sizeof(bits));
+        return bits;
+    }
+
+public:
+    [[nodiscard]]
+    static bool contains(const double value) noexcept
+    {
+        if (value < 1.0 || value > 5.0)
+            return false;
+
+        const uint64_t hash = get_hash(value);
+        const size_t index = hash % 5;
+        int8_t i = buckets[index] - 1;
+
+        while (i >= 0)
+        {
+            const auto& [hash_code, next, value1] = entries[i];
+
+            if (hash_code == hash && value1 == value)
+                return true;
+
+            i = next;
+        }
+
+        return false;
+    }
+
+    static constexpr size_t item_count = 5;
+    static constexpr double min_value = 1.0;
+    static constexpr double max_value = 5.0;
+
+public:
+    HashSetChainStructure_Double_5_HashZeroOrNaN() = delete;
+    HashSetChainStructure_Double_5_HashZeroOrNaN(const HashSetChainStructure_Double_5_HashZeroOrNaN&) = delete;
+    HashSetChainStructure_Double_5_HashZeroOrNaN& operator=(const HashSetChainStructure_Double_5_HashZeroOrNaN&) = delete;
+    HashSetChainStructure_Double_5_HashZeroOrNaN(HashSetChainStructure_Double_5_HashZeroOrNaN&&) = delete;
+    HashSetChainStructure_Double_5_HashZeroOrNaN& operator=(HashSetChainStructure_Double_5_HashZeroOrNaN&&) = delete;
+};

Src/FastData.Generator.CPlusPlus.Tests/Verify/HashSetChainStructure_Single_5_HashZeroOrNaN.verified.txt

@@ -0,0 +1,70 @@
+// This file is auto-generated. Do not edit manually.
+// Structure: HashSet (HashSetChain)
+#pragma once
+#include <array>
+#include <cstdint>
+#include <limits>
+#include <string_view>
+
+class HashSetChainStructure_Single_5_HashZeroOrNaN final
+{
+    struct e
+    {
+        uint64_t hash_code;
+        int8_t next;
+        float value;
+
+        e(const uint64_t hash_code, const int8_t next, const float value)
+           : hash_code(hash_code), next(next), value(value) {}
+    };
+
+    static constexpr std::array<int8_t, 5> buckets = {
+        0, 1, 4, 3, 5
+     };
+
+    inline static const std::array<e, 5> entries = {
+        e(1065353216, -1, 1.0f), e(1073741824, -1, 2.0f), e(1077936128, -1, 3.0f), e(1082130432, -1, 4.0f), e(1084227584, 1, 5.0f)
+    };
+
+    static uint64_t get_hash(const float value) noexcept
+    {
+        uint32_t bits;
+        std::memcpy(&bits, &value, sizeof(bits));
+        return bits;
+    }
+
+public:
+    [[nodiscard]]
+    static bool contains(const float value) noexcept
+    {
+        if (value < 1.0f || value > 5.0f)
+            return false;
+
+        const uint64_t hash = get_hash(value);
+        const size_t index = hash % 5;
+        int8_t i = buckets[index] - 1;
+
+        while (i >= 0)
+        {
+            const auto& [hash_code, next, value1] = entries[i];
+
+            if (hash_code == hash && value1 == value)
+                return true;
+
+            i = next;
+        }
+
+        return false;
+    }
+
+    static constexpr size_t item_count = 5;
+    static constexpr float min_value = 1.0f;
+    static constexpr float max_value = 5.0f;
+
+public:
+    HashSetChainStructure_Single_5_HashZeroOrNaN() = delete;
+    HashSetChainStructure_Single_5_HashZeroOrNaN(const HashSetChainStructure_Single_5_HashZeroOrNaN&) = delete;
+    HashSetChainStructure_Single_5_HashZeroOrNaN& operator=(const HashSetChainStructure_Single_5_HashZeroOrNaN&) = delete;
+    HashSetChainStructure_Single_5_HashZeroOrNaN(HashSetChainStructure_Single_5_HashZeroOrNaN&&) = delete;
+    HashSetChainStructure_Single_5_HashZeroOrNaN& operator=(HashSetChainStructure_Single_5_HashZeroOrNaN&&) = delete;
+};

Src/FastData.Generator.CPlusPlus.Tests/Verify/HashSetLinearStructure_Double_5_HashZeroOrNaN.verified.txt

@@ -0,0 +1,73 @@
+// This file is auto-generated. Do not edit manually.
+// Structure: HashSet (HashSetLinear)
+#pragma once
+#include <array>
+#include <cstdint>
+#include <limits>
+#include <string_view>
+
+class HashSetLinearStructure_Double_5_HashZeroOrNaN final
+{
+    struct b
+    {
+        uint8_t start_index;
+        uint8_t end_index;
+
+        b(const uint8_t start_index, const uint8_t end_index)
+        : start_index(start_index), end_index(end_index) { }
+    };
+
+    inline static const std::array<b, 11> buckets = {
+        b(0, 0), b(0, 0), b(0, 0), b(0, 0), b(1, 1), b(0, 0), b(2, 2), b(0, 0), b(3, 3), b(4, 4), 
+        b(0, 0)
+    };
+
+    static constexpr std::array<double, 5> items = {
+        1.0, 2.0, 3.0, 4.0, 5.0
+    };
+
+    static constexpr std::array<uint64_t, 5> hash_codes = {
+        4607182418800017408, 4611686018427387904, 4613937818241073152, 4616189618054758400, 4617315517961601024
+    };
+
+    static uint64_t get_hash(const double value) noexcept
+    {
+        uint64_t bits;
+        std::memcpy(&bits, &value, sizeof(bits));
+        return bits;
+    }
+
+public:
+    [[nodiscard]]
+    static bool contains(const double value) noexcept
+    {
+        if (value < 1.0 || value > 5.0)
+            return false;
+
+        const uint64_t hash = get_hash(value);
+        const auto& [start_index, end_index]= buckets[hash % 11];
+
+        uint8_t index = start_index;
+
+        while (index <= end_index)
+        {
+            if (hash_codes[index] == hash && items[index] == value)
+                return true;
+
+            index++;
+        }
+
+        return false;
+    }
+
+    static constexpr size_t item_count = 5;
+    static constexpr double min_value = 1.0;
+    static constexpr double max_value = 5.0;
+
+public:
+    HashSetLinearStructure_Double_5_HashZeroOrNaN() = delete;
+    HashSetLinearStructure_Double_5_HashZeroOrNaN(const HashSetLinearStructure_Double_5_HashZeroOrNaN&) = delete;
+    HashSetLinearStructure_Double_5_HashZeroOrNaN& operator=(const HashSetLinearStructure_Double_5_HashZeroOrNaN&) = delete;
+    HashSetLinearStructure_Double_5_HashZeroOrNaN(HashSetLinearStructure_Double_5_HashZeroOrNaN&&) = delete;
+    HashSetLinearStructure_Double_5_HashZeroOrNaN& operator=(HashSetLinearStructure_Double_5_HashZeroOrNaN&&) = delete;
+};

Src/FastData.Generator.CPlusPlus.Tests/Verify/HashSetLinearStructure_Single_5_HashZeroOrNaN.verified.txt

@@ -0,0 +1,73 @@
+// This file is auto-generated. Do not edit manually.
+// Structure: HashSet (HashSetLinear)
+#pragma once
+#include <array>
+#include <cstdint>
+#include <limits>
+#include <string_view>
+
+class HashSetLinearStructure_Single_5_HashZeroOrNaN final
+{
+    struct b
+    {
+        uint8_t start_index;
+        uint8_t end_index;
+
+        b(const uint8_t start_index, const uint8_t end_index)
+        : start_index(start_index), end_index(end_index) { }
+    };
+
+    inline static const std::array<b, 11> buckets = {
+        b(0, 0), b(1, 1), b(0, 0), b(0, 0), b(2, 2), b(3, 3), b(0, 0), b(0, 0), b(0, 0), b(4, 4), 
+        b(0, 0)
+    };
+
+    static constexpr std::array<float, 5> items = {
+        5.0f, 2.0f, 1.0f, 3.0f, 4.0f
+    };
+
+    static constexpr std::array<uint64_t, 5> hash_codes = {
+        1084227584, 1073741824, 1065353216, 1077936128, 1082130432
+    };
+
+    static uint64_t get_hash(const float value) noexcept
+    {
+        uint32_t bits;
+        std::memcpy(&bits, &value, sizeof(bits));
+        return bits;
+    }
+
+public:
+    [[nodiscard]]
+    static bool contains(const float value) noexcept
+    {
+        if (value < 1.0f || value > 5.0f)
+            return false;
+
+        const uint64_t hash = get_hash(value);
+        const auto& [start_index, end_index]= buckets[hash % 11];
+
+        uint8_t index = start_index;
+
+        while (index <= end_index)
+        {
+            if (hash_codes[index] == hash && items[index] == value)
+                return true;
+
+            index++;
+        }
+
+        return false;
+    }
+
+    static constexpr size_t item_count = 5;
+    static constexpr float min_value = 1.0f;
+    static constexpr float max_value = 5.0f;
+
+public:
+    HashSetLinearStructure_Single_5_HashZeroOrNaN() = delete;
+    HashSetLinearStructure_Single_5_HashZeroOrNaN(const HashSetLinearStructure_Single_5_HashZeroOrNaN&) = delete;
+    HashSetLinearStructure_Single_5_HashZeroOrNaN& operator=(const HashSetLinearStructure_Single_5_HashZeroOrNaN&) = delete;
+    HashSetLinearStructure_Single_5_HashZeroOrNaN(HashSetLinearStructure_Single_5_HashZeroOrNaN&&) = delete;
+    HashSetLinearStructure_Single_5_HashZeroOrNaN& operator=(HashSetLinearStructure_Single_5_HashZeroOrNaN&&) = delete;
+};

Src/FastData.Generator.CPlusPlus/Internal/Framework/CPlusPlusHashDef.cs

@@ -1,23 +1,24 @@
 using Genbox.FastData.Generator.Framework.Interfaces;
+using Genbox.FastData.Generators;
 using Genbox.FastData.Generators.Extensions;
 
 namespace Genbox.FastData.Generator.CPlusPlus.Internal.Framework;
 
 internal class CPlusPlusHashDef : IHashDef
 {
-    public string GetHashSource(DataType dataType, string typeName)
+    public string GetHashSource(DataType dataType, string typeName, HashInfo info)
     {
         bool notConst = dataType is DataType.Single or DataType.Double or DataType.Int64 or DataType.UInt64;
 
         return $$"""
                      static{{(notConst ? " " : " constexpr ")}}uint64_t get_hash(const {{typeName}} value) noexcept
                      {
-                 {{GetHash(dataType)}}
+                 {{GetHash(dataType, info)}}
                      }
                  """;
     }
 
-    private static string GetHash(DataType dataType)
+    private static string GetHash(DataType dataType, HashInfo info)
     {
         if (dataType == DataType.String)
         {
@@ -41,24 +42,37 @@ private static string GetHash(DataType dataType)
 
         if (dataType == DataType.Single)
         {
-            return """
-                           uint32_t bits;
-                           std::memcpy(&bits, &value, sizeof(bits));
-                           if (((bits - 1) & ~0x80000000u) >= 0x7F800000u)
-                               bits &= 0x7F800000u;
-                           return bits;
-                   """;
+            return info.HasZeroOrNaN
+                ? """
+                          uint32_t bits;
+                          std::memcpy(&bits, &value, sizeof(bits));
+                          if (((bits - 1) & ~0x80000000u) >= 0x7F800000u)
+                              bits &= 0x7F800000u;
+                          return bits;
+                  """
+                : """
+                          uint32_t bits;
+                          std::memcpy(&bits, &value, sizeof(bits));
+                          return bits;
+                  """;
+
         }
 
         if (dataType == DataType.Double)
         {
-            return """
-                           uint64_t bits;
-                           std::memcpy(&bits, &value, sizeof(bits));
-                           if (((bits - 1) & ~0x8000000000000000ull) >= 0x7FF0000000000000ull)
-                               bits &= 0x7FF0000000000000ull;
-                           return bits;
-                   """;
+            return info.HasZeroOrNaN
+                ? """
+                          uint64_t bits;
+                          std::memcpy(&bits, &value, sizeof(bits));
+                          if (((bits - 1) & ~0x8000000000000000ull) >= 0x7FF0000000000000ull)
+                              bits &= 0x7FF0000000000000ull;
+                          return bits;
+                  """
+                : """
+                          uint64_t bits;
+                          std::memcpy(&bits, &value, sizeof(bits));
+                          return bits;
+                  """;
         }
 
         throw new InvalidOperationException("Unsupported data type: " + dataType);