BadHashCode.cs

Go to the documentation of this file.

using System.Runtime.CompilerServices;
 
namespace BadScript2.Utility;
 
public static class BadHashCode
{
    private const uint PRIME1 = 2654435761U;
    private const uint PRIME2 = 2246822519U;
    private const uint PRIME3 = 3266489917U;
    private const uint PRIME4 = 668265263U;
    private const uint PRIME5 = 374761393U;
    private static readonly uint s_Seed = GenerateGlobalSeed();
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static uint RotateLeft(uint value, int offset)
    {
        return (value << offset) | (value >> (32 - offset));
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static ulong RotateLeft(ulong value, int offset)
    {
        return (value << offset) | (value >> (64 - offset));
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static uint RotateRight(uint value, int offset)
    {
        return (value >> offset) | (value << (32 - offset));
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static ulong RotateRight(ulong value, int offset)
    {
        return (value >> offset) | (value << (64 - offset));
    }
 
    private static uint GenerateGlobalSeed()
    {
        return (uint)new Random().Next();
    }
 
    public static int Combine<T1>(T1 value1)
    {
        // Provide a way of diffusing bits from something with a limited
        // input hash space. For example, many enums only have a few
        // possible hashes, only using the bottom few bits of the code. Some
        // collections are built on the assumption that hashes are spread
        // over a larger space, so diffusing the bits may help the
        // collection work more efficiently.
 
        uint hc1 = (uint)(value1?.GetHashCode() ?? 0);
 
        uint hash = MixEmptyState();
        hash += 4;
 
        hash = QueueRound(hash, hc1);
 
        hash = MixFinal(hash);
 
        return (int)hash;
    }
 
    public static int Combine<T1, T2>(T1 value1, T2 value2)
    {
        uint hc1 = (uint)(value1?.GetHashCode() ?? 0);
        uint hc2 = (uint)(value2?.GetHashCode() ?? 0);
 
        uint hash = MixEmptyState();
        hash += 8;
 
        hash = QueueRound(hash, hc1);
        hash = QueueRound(hash, hc2);
 
        hash = MixFinal(hash);
 
        return (int)hash;
    }
 
    public static int Combine<T1, T2, T3>(T1 value1, T2 value2, T3 value3)
    {
        uint hc1 = (uint)(value1?.GetHashCode() ?? 0);
        uint hc2 = (uint)(value2?.GetHashCode() ?? 0);
        uint hc3 = (uint)(value3?.GetHashCode() ?? 0);
 
        uint hash = MixEmptyState();
        hash += 12;
 
        hash = QueueRound(hash, hc1);
        hash = QueueRound(hash, hc2);
        hash = QueueRound(hash, hc3);
 
        hash = MixFinal(hash);
 
        return (int)hash;
    }
 
    public static int Combine<T1, T2, T3, T4>(T1 value1, T2 value2, T3 value3, T4 value4)
    {
        uint hc1 = (uint)(value1?.GetHashCode() ?? 0);
        uint hc2 = (uint)(value2?.GetHashCode() ?? 0);
        uint hc3 = (uint)(value3?.GetHashCode() ?? 0);
        uint hc4 = (uint)(value4?.GetHashCode() ?? 0);
 
        Initialize(out uint v1, out uint v2, out uint v3, out uint v4);
 
        v1 = Round(v1, hc1);
        v2 = Round(v2, hc2);
        v3 = Round(v3, hc3);
        v4 = Round(v4, hc4);
 
        uint hash = MixState(v1, v2, v3, v4);
        hash += 16;
 
        hash = MixFinal(hash);
 
        return (int)hash;
    }
 
    public static int Combine<T1, T2, T3, T4, T5>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5)
    {
        uint hc1 = (uint)(value1?.GetHashCode() ?? 0);
        uint hc2 = (uint)(value2?.GetHashCode() ?? 0);
        uint hc3 = (uint)(value3?.GetHashCode() ?? 0);
        uint hc4 = (uint)(value4?.GetHashCode() ?? 0);
        uint hc5 = (uint)(value5?.GetHashCode() ?? 0);
 
        Initialize(out uint v1, out uint v2, out uint v3, out uint v4);
 
        v1 = Round(v1, hc1);
        v2 = Round(v2, hc2);
        v3 = Round(v3, hc3);
        v4 = Round(v4, hc4);
 
        uint hash = MixState(v1, v2, v3, v4);
        hash += 20;
 
        hash = QueueRound(hash, hc5);
 
        hash = MixFinal(hash);
 
        return (int)hash;
    }
 
    public static int Combine<T1, T2, T3, T4, T5, T6>(T1 value1,
                                                      T2 value2,
                                                      T3 value3,
                                                      T4 value4,
                                                      T5 value5,
                                                      T6 value6)
    {
        uint hc1 = (uint)(value1?.GetHashCode() ?? 0);
        uint hc2 = (uint)(value2?.GetHashCode() ?? 0);
        uint hc3 = (uint)(value3?.GetHashCode() ?? 0);
        uint hc4 = (uint)(value4?.GetHashCode() ?? 0);
        uint hc5 = (uint)(value5?.GetHashCode() ?? 0);
        uint hc6 = (uint)(value6?.GetHashCode() ?? 0);
 
        Initialize(out uint v1, out uint v2, out uint v3, out uint v4);
 
        v1 = Round(v1, hc1);
        v2 = Round(v2, hc2);
        v3 = Round(v3, hc3);
        v4 = Round(v4, hc4);
 
        uint hash = MixState(v1, v2, v3, v4);
        hash += 24;
 
        hash = QueueRound(hash, hc5);
        hash = QueueRound(hash, hc6);
 
        hash = MixFinal(hash);
 
        return (int)hash;
    }
 
    public static int Combine<T1, T2, T3, T4, T5, T6, T7>(T1 value1,
                                                          T2 value2,
                                                          T3 value3,
                                                          T4 value4,
                                                          T5 value5,
                                                          T6 value6,
                                                          T7 value7)
    {
        uint hc1 = (uint)(value1?.GetHashCode() ?? 0);
        uint hc2 = (uint)(value2?.GetHashCode() ?? 0);
        uint hc3 = (uint)(value3?.GetHashCode() ?? 0);
        uint hc4 = (uint)(value4?.GetHashCode() ?? 0);
        uint hc5 = (uint)(value5?.GetHashCode() ?? 0);
        uint hc6 = (uint)(value6?.GetHashCode() ?? 0);
        uint hc7 = (uint)(value7?.GetHashCode() ?? 0);
 
        Initialize(out uint v1, out uint v2, out uint v3, out uint v4);
 
        v1 = Round(v1, hc1);
        v2 = Round(v2, hc2);
        v3 = Round(v3, hc3);
        v4 = Round(v4, hc4);
 
        uint hash = MixState(v1, v2, v3, v4);
        hash += 28;
 
        hash = QueueRound(hash, hc5);
        hash = QueueRound(hash, hc6);
        hash = QueueRound(hash, hc7);
 
        hash = MixFinal(hash);
 
        return (int)hash;
    }
 
    public static int Combine<T1, T2, T3, T4, T5, T6, T7, T8>(T1 value1,
                                                              T2 value2,
                                                              T3 value3,
                                                              T4 value4,
                                                              T5 value5,
                                                              T6 value6,
                                                              T7 value7,
                                                              T8 value8)
    {
        uint hc1 = (uint)(value1?.GetHashCode() ?? 0);
        uint hc2 = (uint)(value2?.GetHashCode() ?? 0);
        uint hc3 = (uint)(value3?.GetHashCode() ?? 0);
        uint hc4 = (uint)(value4?.GetHashCode() ?? 0);
        uint hc5 = (uint)(value5?.GetHashCode() ?? 0);
        uint hc6 = (uint)(value6?.GetHashCode() ?? 0);
        uint hc7 = (uint)(value7?.GetHashCode() ?? 0);
        uint hc8 = (uint)(value8?.GetHashCode() ?? 0);
 
        Initialize(out uint v1, out uint v2, out uint v3, out uint v4);
 
        v1 = Round(v1, hc1);
        v2 = Round(v2, hc2);
        v3 = Round(v3, hc3);
        v4 = Round(v4, hc4);
 
        v1 = Round(v1, hc5);
        v2 = Round(v2, hc6);
        v3 = Round(v3, hc7);
        v4 = Round(v4, hc8);
 
        uint hash = MixState(v1, v2, v3, v4);
        hash += 32;
 
        hash = MixFinal(hash);
 
        return (int)hash;
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static void Initialize(out uint v1, out uint v2, out uint v3, out uint v4)
    {
        v1 = s_Seed + PRIME1 + PRIME2;
        v2 = s_Seed + PRIME2;
        v3 = s_Seed;
        v4 = s_Seed - PRIME1;
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static uint Round(uint hash, uint input)
    {
        return RotateLeft(hash + input * PRIME2, 13) * PRIME1;
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static uint QueueRound(uint hash, uint queuedValue)
    {
        return RotateLeft(hash + queuedValue * PRIME3, 17) * PRIME4;
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static uint MixState(uint v1, uint v2, uint v3, uint v4)
    {
        return RotateLeft(v1, 1) + RotateLeft(v2, 7) + RotateLeft(v3, 12) + RotateLeft(v4, 18);
    }
 
    private static uint MixEmptyState()
    {
        return s_Seed + PRIME5;
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static uint MixFinal(uint hash)
    {
        hash ^= hash >> 15;
        hash *= PRIME2;
        hash ^= hash >> 13;
        hash *= PRIME3;
        hash ^= hash >> 16;
 
        return hash;
    }
}