add a new lookup map

Author: LoneWandererProductions

CommonLibraryGuiTests/Image/example Polaris.png

@@ -0,0 +1,14 @@
+namespace ExtendedSystemObjects.Helper
+{
+    internal static class SharedResources
+    {
+        /// <summary>
+        ///     The small primes
+        /// </summary>
+        internal static readonly int[] SmallPrimes =
+        {
+            2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101,
+            103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199
+        };
+    }
+}

CommonLibraryGuiTests/Image/example.png

@@ -13,6 +13,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
+using ExtendedSystemObjects.Helper;
 
 namespace ExtendedSystemObjects
 {
@@ -23,15 +24,6 @@ namespace ExtendedSystemObjects
     public sealed class ImmutableLookupMap<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
         where TKey : struct, IEquatable<TKey>
     {
-        /// <summary>
-        ///     The small primes
-        /// </summary>
-        private static readonly int[] SmallPrimes =
-        {
-            2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101,
-            103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199
-        };
-
         /// <summary>
         ///     The key presence
         /// </summary>
@@ -219,7 +211,7 @@ private static bool IsPrime(int number)
                 return false;
             }
 
-            foreach (var prime in SmallPrimes)
+            foreach (var prime in SharedResources.SmallPrimes)
             {
                 if (number == prime)
                 {

ExtendedSystemObjects/Helper/SharedResources.cs

@@ -0,0 +1,145 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using ExtendedSystemObjects.Helper;
+using ExtendedSystemObjects.Interfaces;
+
+namespace ExtendedSystemObjects
+{
+    /// <summary>
+    /// A high-performance, immutable lookup map using unmanaged arrays.
+    /// </summary>
+    public sealed unsafe class ImmutableLookupMapUnmanaged<TKey, TValue> : IDisposable, IEnumerable<KeyValuePair<TKey, TValue>>
+        where TKey : unmanaged, IEquatable<TKey>
+        where TValue : unmanaged
+    {
+        private readonly UnmanagedArray<TKey> _keys;
+        private readonly UnmanagedArray<TValue> _values;
+        private readonly UnmanagedArray<byte> _keyPresence;
+
+        private readonly int _capacity;
+
+        public int Count { get; }
+
+        public ImmutableLookupMapUnmanaged(IDictionary<TKey, TValue> data)
+        {
+            if (data == null)
+                throw new ArgumentNullException(nameof(data));
+
+            Count = data.Count;
+            _capacity = FindNextPrime(Count * 2);
+
+            _keys = new UnmanagedArray<TKey>(_capacity);
+            _values = new UnmanagedArray<TValue>(_capacity);
+            _keyPresence = new UnmanagedArray<byte>(_capacity);
+
+            foreach (var (key, value) in data)
+            {
+                for (var i = 0; i < _capacity; i++)
+                {
+                    var hash = (GetHash(key, _capacity) + i * i) % _capacity;
+
+                    if (_keyPresence[hash] == 0)
+                    {
+                        _keys[hash] = key;
+                        _values[hash] = value;
+                        _keyPresence[hash] = 1;
+                        break;
+                    }
+
+                    if (_keys[hash].Equals(key))
+                        throw new InvalidOperationException($"Duplicate key detected: {key}");
+                }
+            }
+        }
+
+        public TValue Get(TKey key)
+        {
+            var hash = GetHash(key, _capacity);
+            var originalHash = hash;
+
+            while (_keyPresence[hash] != 0)
+            {
+                if (_keys[hash].Equals(key))
+                    return _values[hash];
+
+                hash = (hash + 1) % _capacity;
+                if (hash == originalHash)
+                    break;
+            }
+
+            throw new KeyNotFoundException($"Key '{key}' not found in lookup.");
+        }
+
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            var hash = GetHash(key, _capacity);
+            var originalHash = hash;
+
+            while (_keyPresence[hash] != 0)
+            {
+                if (_keys[hash].Equals(key))
+                {
+                    value = _values[hash];
+                    return true;
+                }
+
+                hash = (hash + 1) % _capacity;
+                if (hash == originalHash)
+                    break;
+            }
+
+            value = default;
+            return false;
+        }
+
+        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
+        {
+            for (var i = 0; i < _capacity; i++)
+            {
+                if (_keyPresence[i] != 0)
+                    yield return new KeyValuePair<TKey, TValue>(_keys[i], _values[i]);
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        public void Dispose()
+        {
+            _keys.Dispose();
+            _values.Dispose();
+            _keyPresence.Dispose();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int GetHash(TKey key, int capacity)
+        {
+            return Math.Abs(key.GetHashCode() % capacity);
+        }
+
+        private static int FindNextPrime(int number)
+        {
+            while (!IsPrime(number))
+                number++;
+            return number;
+        }
+
+        private static bool IsPrime(int number)
+        {
+            if (number < 2) return false;
+
+            foreach (var prime in SharedResources.SmallPrimes)
+            {
+                if (number == prime) return true;
+                if (number % prime == 0) return false;
+            }
+
+            for (var i = 201; i * i <= number; i += 2)
+                if (number % i == 0)
+                    return false;
+
+            return true;
+        }
+    }
+}

ExtendedSystemObjects/ImmutableLookupMap.cs

@@ -190,7 +190,6 @@ public void Resize(int newSize)
             }
         }
 
-
         /// <inheritdoc />
         /// <summary>
         ///     Clears the array by setting all elements to zero.