Add experimental compact hashset

Author: Genbox

Src/FastData.Generator.CPlusPlus.Tests/Vectors/HashTableCompactStructure_Byte_3.verified.txt

@@ -0,0 +1,60 @@
+// This file is auto-generated. Do not edit manually.
+// Structure: Auto (HashTableCompact)
+#pragma once
+#include <array>
+#include <cstdint>
+#include <limits>
+#include <string_view>
+
+class HashTableCompactStructure_Byte_3 final {
+    struct e {
+        uint8_t key;
+        
+        
+        e(const uint8_t key)
+           : key(key) {}
+    };
+
+    static constexpr std::array<uint8_t, 3> bucket_starts = {
+        0, 2, 3
+     };
+
+    static constexpr std::array<uint8_t, 3> bucket_counts = {
+        2, 1, 0
+     };
+
+    inline static const std::array<e, 3> entries = {
+        e(0), e(std::numeric_limits<uint8_t>::max()), e(1)
+    };
+
+    static constexpr uint64_t get_hash(const uint8_t value) noexcept
+    {
+        return static_cast<uint64_t>(value);
+    }
+
+public:
+    [[nodiscard]]
+    static constexpr bool contains(const uint8_t key) noexcept {
+        if (key < 0 || key > std::numeric_limits<uint8_t>::max())
+            return false;
+
+        const uint64_t hash = get_hash(key);
+        const size_t index = hash % 3;
+        const size_t start = static_cast<size_t>(bucket_starts[index]);
+        const size_t count = static_cast<size_t>(bucket_counts[index]);
+        const size_t end = start + count;
+
+        for (size_t i = start; i < end; i++) {
+            const auto& entry = entries[i];
+
+            if (entry.key == key)
+                return true;
+        }
+
+        return false;
+    }
+
+    static constexpr size_t item_count = 3;
+    static constexpr uint8_t min_key = 0;
+    static constexpr uint8_t max_key = std::numeric_limits<uint8_t>::max();
+};

Src/FastData.Generator.CPlusPlus.Tests/Vectors/HashTableCompactStructure_Char_3.verified.txt

@@ -0,0 +1,60 @@
+// This file is auto-generated. Do not edit manually.
+// Structure: Auto (HashTableCompact)
+#pragma once
+#include <array>
+#include <cstdint>
+#include <limits>
+#include <string_view>
+
+class HashTableCompactStructure_Char_3 final {
+    struct e {
+        char key;
+        
+        
+        e(const char key)
+           : key(key) {}
+    };
+
+    static constexpr std::array<uint8_t, 3> bucket_starts = {
+        0, 1, 3
+     };
+
+    static constexpr std::array<uint8_t, 3> bucket_counts = {
+        1, 2, 0
+     };
+
+    inline static const std::array<e, 3> entries = {
+        e(0), e(97), e(127)
+    };
+
+    static constexpr uint64_t get_hash(const char value) noexcept
+    {
+        return static_cast<uint64_t>(value);
+    }
+
+public:
+    [[nodiscard]]
+    static constexpr bool contains(const char key) noexcept {
+        if (key < 0 || key > 127)
+            return false;
+
+        const uint64_t hash = get_hash(key);
+        const size_t index = hash % 3;
+        const size_t start = static_cast<size_t>(bucket_starts[index]);
+        const size_t count = static_cast<size_t>(bucket_counts[index]);
+        const size_t end = start + count;
+
+        for (size_t i = start; i < end; i++) {
+            const auto& entry = entries[i];
+
+            if (entry.key == key)
+                return true;
+        }
+
+        return false;
+    }
+
+    static constexpr size_t item_count = 3;
+    static constexpr char min_key = 0;
+    static constexpr char max_key = 127;
+};

Src/FastData.Generator.CPlusPlus.Tests/Vectors/HashTableCompactStructure_Double_4.verified.txt

@@ -0,0 +1,64 @@
+// This file is auto-generated. Do not edit manually.
+// Structure: Auto (HashTableCompact)
+#pragma once
+#include <array>
+#include <cstdint>
+#include <limits>
+#include <string_view>
+
+class HashTableCompactStructure_Double_4 final {
+    struct e {
+        double key;
+        uint64_t hash_code;
+        
+        e(const double key, const uint64_t hash_code)
+           : key(key), hash_code(hash_code) {}
+    };
+
+    static constexpr std::array<uint8_t, 4> bucket_starts = {
+        0, 2, 2, 2
+     };
+
+    static constexpr std::array<uint8_t, 4> bucket_counts = {
+        2, 0, 0, 2
+     };
+
+    inline static const std::array<e, 4> entries = {
+        e(0.0, 0), e(1.0, 4607182418800017408), e(std::numeric_limits<double>::lowest(), 18442240474082181119), e(std::numeric_limits<double>::max(), 9218868437227405311)
+    };
+
+    static uint64_t get_hash(const double value) noexcept
+    {
+        uint64_t bits;
+        std::memcpy(&bits, &value, sizeof(bits));
+        if (((bits - 1) & ~0x8000000000000000ull) >= 0x7FF0000000000000ull)
+            bits &= 0x7FF0000000000000ull;
+        return bits;
+    }
+
+public:
+    [[nodiscard]]
+    static constexpr bool contains(const double key) noexcept {
+        if (key < std::numeric_limits<double>::lowest() || key > std::numeric_limits<double>::max())
+            return false;
+
+        const uint64_t hash = get_hash(key);
+        const size_t index = hash % 4;
+        const size_t start = static_cast<size_t>(bucket_starts[index]);
+        const size_t count = static_cast<size_t>(bucket_counts[index]);
+        const size_t end = start + count;
+
+        for (size_t i = start; i < end; i++) {
+            const auto& entry = entries[i];
+
+            if (entry.hash_code == hash && entry.key == key)
+                return true;
+        }
+
+        return false;
+    }
+
+    static constexpr size_t item_count = 4;
+    static constexpr double min_key = std::numeric_limits<double>::lowest();
+    static constexpr double max_key = std::numeric_limits<double>::max();
+};

Src/FastData.Generator.CPlusPlus.Tests/Vectors/HashTableCompactStructure_Int16_5.verified.txt

@@ -0,0 +1,60 @@
+// This file is auto-generated. Do not edit manually.
+// Structure: Auto (HashTableCompact)
+#pragma once
+#include <array>
+#include <cstdint>
+#include <limits>
+#include <string_view>
+
+class HashTableCompactStructure_Int16_5 final {
+    struct e {
+        int16_t key;
+        
+        
+        e(const int16_t key)
+           : key(key) {}
+    };
+
+    static constexpr std::array<uint8_t, 5> bucket_starts = {
+        0, 2, 3, 4, 5
+     };
+
+    static constexpr std::array<uint8_t, 5> bucket_counts = {
+        2, 1, 1, 1, 0
+     };
+
+    inline static const std::array<e, 5> entries = {
+        e(-1), e(0), e(1), e(std::numeric_limits<int16_t>::max()), e(std::numeric_limits<int16_t>::lowest())
+    };
+
+    static constexpr uint64_t get_hash(const int16_t value) noexcept
+    {
+        return static_cast<uint64_t>(value);
+    }
+
+public:
+    [[nodiscard]]
+    static constexpr bool contains(const int16_t key) noexcept {
+        if (key < std::numeric_limits<int16_t>::lowest() || key > std::numeric_limits<int16_t>::max())
+            return false;
+
+        const uint64_t hash = get_hash(key);
+        const size_t index = hash % 5;
+        const size_t start = static_cast<size_t>(bucket_starts[index]);
+        const size_t count = static_cast<size_t>(bucket_counts[index]);
+        const size_t end = start + count;
+
+        for (size_t i = start; i < end; i++) {
+            const auto& entry = entries[i];
+
+            if (entry.key == key)
+                return true;
+        }
+
+        return false;
+    }
+
+    static constexpr size_t item_count = 5;
+    static constexpr int16_t min_key = std::numeric_limits<int16_t>::lowest();
+    static constexpr int16_t max_key = std::numeric_limits<int16_t>::max();
+};

Src/FastData.Generator.CPlusPlus.Tests/Vectors/HashTableCompactStructure_Int32_100.verified.txt

@@ -0,0 +1,87 @@
+// This file is auto-generated. Do not edit manually.
+// Structure: Auto (HashTableCompact)
+#pragma once
+#include <array>
+#include <cstdint>
+#include <limits>
+#include <string_view>
+
+class HashTableCompactStructure_Int32_100 final {
+    struct e {
+        int32_t key;
+        
+        
+        e(const int32_t key)
+           : key(key) {}
+    };
+
+    static constexpr std::array<uint8_t, 100> bucket_starts = {
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 
+        10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 
+        20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 
+        30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 
+        40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 
+        50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 
+        60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 
+        70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 
+        80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 
+        90, 91, 92, 93, 94, 95, 96, 97, 98, 99
+     };
+
+    static constexpr std::array<uint8_t, 100> bucket_counts = {
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1
+     };
+
+    inline static const std::array<e, 100> entries = {
+        e(0), e(1), e(2), e(3), e(4), e(5), e(6), e(7), e(8), e(9), 
+        e(10), e(11), e(12), e(13), e(14), e(15), e(16), e(17), e(18), e(19), 
+        e(20), e(21), e(22), e(23), e(24), e(25), e(26), e(27), e(28), e(29), 
+        e(30), e(31), e(32), e(33), e(34), e(35), e(36), e(37), e(38), e(39), 
+        e(40), e(41), e(42), e(43), e(44), e(45), e(46), e(47), e(48), e(49), 
+        e(50), e(51), e(52), e(53), e(54), e(55), e(56), e(57), e(58), e(59), 
+        e(60), e(61), e(62), e(63), e(64), e(65), e(66), e(67), e(68), e(69), 
+        e(70), e(71), e(72), e(73), e(74), e(75), e(76), e(77), e(78), e(79), 
+        e(80), e(81), e(82), e(83), e(84), e(85), e(86), e(87), e(88), e(89), 
+        e(90), e(91), e(92), e(93), e(94), e(95), e(96), e(97), e(98), e(99)
+    };
+
+    static constexpr uint64_t get_hash(const int32_t value) noexcept
+    {
+        return static_cast<uint64_t>(value);
+    }
+
+public:
+    [[nodiscard]]
+    static constexpr bool contains(const int32_t key) noexcept {
+        if (key < 0 || key > 99)
+            return false;
+
+        const uint64_t hash = get_hash(key);
+        const size_t index = hash % 100;
+        const size_t start = static_cast<size_t>(bucket_starts[index]);
+        const size_t count = static_cast<size_t>(bucket_counts[index]);
+        const size_t end = start + count;
+
+        for (size_t i = start; i < end; i++) {
+            const auto& entry = entries[i];
+
+            if (entry.key == key)
+                return true;
+        }
+
+        return false;
+    }
+
+    static constexpr size_t item_count = 100;
+    static constexpr int32_t min_key = 0;
+    static constexpr int32_t max_key = 99;
+};