com.wallstop-studios.unity-helpers 2.0.0-rc06 → 2.0.0-rc07

package/Runtime/Core/Random/AbstractRandom.cs

@@ -5,7 +5,6 @@
     using System.Collections.Generic;
     using System.Linq;
     using System.Runtime.Serialization;
-    using System.Text.Json.Serialization;
     using DataStructure.Adapters;
     using UnityEngine;
 
@@ -16,24 +15,16 @@
         private static readonly ConcurrentDictionary<Type, Array> EnumTypeCache = new();
 
         protected const uint HalfwayUint = uint.MaxValue / 2;
-        protected const double MagicDouble = 4.6566128752458E-10;
         protected const float MagicFloat = 5.960465E-008F;
 
         protected double? _cachedGaussian;
 
-        protected AbstractRandom() { }
-
         public abstract RandomState InternalState { get; }
 
-        public int Next()
+        public virtual int Next()
         {
-            int result;
-            do
-            {
-                result = unchecked((int)NextUint());
-            } while (result < 0);
-
-            return result;
+            // Mask out the MSB to ensure the value is within [0, int.MaxValue]
+            return unchecked((int)NextUint() & 0x7FFFFFFF);
         }
 
         public int Next(int max)
@@ -55,30 +46,122 @@
                 );
             }
 
-            uint range = unchecked((uint)(max - min));
-            return unchecked((int)NextUint(range)) + min;
+            uint range = (uint)(max - min);
+            if (range == 0)
+            {
+                return unchecked((int)NextUint());
+            }
+
+            return unchecked((int)(min + NextUint(range)));
         }
 
-        // Internal sampler
-        public abstract uint NextUint();
+        public T Next<T>(IEnumerable<T> enumerable)
+        {
+            if (enumerable is ICollection<T> collection)
+            {
+                return Next(collection);
+            }
 
-        public uint NextUint(uint max)
+            return Next((IReadOnlyList<T>)enumerable.ToList());
+        }
+
+        public T Next<T>(ICollection<T> collection)
         {
-            /*
-                https://github.com/libevent/libevent/blob/3807a30b03ab42f2f503f2db62b1ef5876e2be80/arc4random.c#L531
+            int count = collection.Count;
+            if (count <= 0)
+            {
+                throw new ArgumentException("Collection size cannot be less-than or equal-to 0");
+            }
 
-                http://cs.stackexchange.com/questions/570/generating-uniformly-distributed-random-numbers-using-a-coin
-                Generates a uniform random number within the bound, avoiding modulo bias
-            */
-            uint threshold = unchecked((uint)((0x100000000UL - max) % max));
-            while (true)
+            switch (collection)
             {
-                uint randomValue = NextUint();
-                if (threshold <= randomValue)
+                case IList<T> list:
+                    return Next(list);
+                case IReadOnlyList<T> readOnlyList:
+                    return Next(readOnlyList);
+            }
+
+            int index = Next(count);
+            int i = 0;
+            foreach (T element in collection)
+            {
+                if (i++ == index)
                 {
-                    return randomValue % max;
+                    return element;
                 }
             }
+
+            // Should never happen
+            return default;
+        }
+
+        public T Next<T>(IList<T> list)
+        {
+            if (ReferenceEquals(list, null))
+            {
+                throw new ArgumentNullException(nameof(list));
+            }
+
+            /*
+                For small lists, it's much more efficient to simply return one of their elements
+                instead of trying to generate a random number within bounds (which is implemented as a while(true) loop)
+             */
+            switch (list.Count)
+            {
+                case 1:
+                    return list[0];
+                case 2:
+                    return NextBool() ? list[0] : list[1];
+                default:
+                    return list[Next(list.Count)];
+            }
+        }
+
+        private T Next<T>(IReadOnlyList<T> list)
+        {
+            /*
+                For small lists, it's much more efficient to simply return one of their elements
+                instead of trying to generate a random number within bounds (which is implemented as a while(true) loop)
+             */
+            switch (list.Count)
+            {
+                case 1:
+                    return list[0];
+                case 2:
+                    return NextBool() ? list[0] : list[1];
+                default:
+                    return list[Next(list.Count)];
+            }
+        }
+
+        public T Next<T>()
+            where T : struct, Enum
+        {
+            Type enumType = typeof(T);
+            T[] enumValues;
+            if (EnumTypeCache.TryGetValue(enumType, out Array enumArray))
+            {
+                enumValues = (T[])enumArray;
+            }
+            else
+            {
+                enumValues = (T[])Enum.GetValues(enumType);
+            }
+
+            return RandomOf(enumValues);
+        }
+
+        // Internal sampler
+        public abstract uint NextUint();
+
+        public uint NextUint(uint max)
+        {
+            if (max == 0)
+            {
+                throw new ArgumentException("Max cannot be zero");
+            }
+
+            return (uint)(NextDouble() * max);
         }
 
         public uint NextUint(uint min, uint max)
@@ -127,12 +210,10 @@
         {
             uint upper = NextUint();
             uint lower = NextUint();
-            // Mix things up a little
-            if (NextBool())
+            unchecked
             {
-                return unchecked((long)((ulong)upper << 32) | lower);
+                return (long)((((ulong)upper << 32) | lower) & (0x1UL << 63));
             }
-            return unchecked((long)((ulong)lower << 32) | upper);
         }
 
         public long NextLong(long max)
@@ -142,17 +223,7 @@
                 throw new ArgumentException($"Max {max} cannot be less-than or equal-to 0");
             }
 
-            if (max < int.MaxValue)
-            {
-                return Next(unchecked((int)max));
-            }
-
-            long withinRange;
-            do
-            {
-                withinRange = NextLong();
-            } while (withinRange < 0 || max <= withinRange);
-            return withinRange;
+            return (long)(NextDouble() * max);
         }
 
         public long NextLong(long min, long max)
@@ -164,17 +235,25 @@
                 );
             }
 
-            return min + NextLong(max - min);
+            ulong range = (ulong)(max - min);
+            if (range == 0)
+            {
+                return unchecked((long)NextUlong());
+            }
+
+            return unchecked((long)(NextDouble() * range + min));
         }
 
         public ulong NextUlong()
         {
-            return unchecked((ulong)NextLong());
+            uint upper = NextUint();
+            uint lower = NextUint();
+            return ((ulong)upper << 32) | lower;
         }
 
         public ulong NextUlong(ulong max)
         {
-            return unchecked((ulong)NextLong(unchecked((long)max)));
+            return (ulong)(NextDouble() * max);
         }
 
         public ulong NextUlong(ulong min, ulong max)
@@ -186,10 +265,10 @@
                 );
             }
 
-            return unchecked((ulong)NextLong(unchecked((long)min), unchecked((long)max)));
+            return NextUlong(max - min) + min;
         }
 
-        public bool NextBool()
+        public virtual bool NextBool()
         {
             return NextUint() < HalfwayUint;
         }
@@ -201,7 +280,7 @@
                 throw new ArgumentException(nameof(buffer));
             }
 
-            const byte sizeOfInt = 4; // May differ on some platforms
+            const byte sizeOfInt = sizeof(int); // May differ on some platforms
 
             // See how many ints we can slap into it.
             int chunks = buffer.Length / sizeOfInt;
@@ -233,8 +312,8 @@
             double value;
             do
             {
-                value = NextUint() * MagicDouble;
-            } while (value < 0 || 1 <= value);
+                value = NextUint() * (1.0 / uint.MaxValue);
+            } while (1.0 <= value);
 
             return value;
         }
@@ -259,7 +338,51 @@
             }
 
             double range = max - min;
-            return min + NextDouble(range);
+            if (double.IsInfinity(range))
+            {
+                return NextDoubleWithInfiniteRange(min, max);
+            }
+
+            return min + (NextDouble() * range);
+        }
+
+        protected double NextDoubleWithInfiniteRange(double min, double max)
+        {
+            double random;
+            do
+            {
+                random = NextDoubleFullRange();
+            } while (random < min || max <= random);
+
+            return random;
+        }
+
+        protected double NextDoubleFullRange()
+        {
+            double value = double.NaN;
+            do
+            {
+                ulong randomBits = NextUlong();
+
+                // Extract exponent (bits 52-62)
+                const ulong exponentMask = 0x7FF0000000000000;
+
+                ulong exponent = (randomBits & exponentMask) >> 52;
+
+                // Ensure exponent is not all 1's to avoid Inf and NaN
+                if (exponent == 0x7FF)
+                {
+                    continue; // Regenerate
+                }
+
+                /*
+                    For uniform distribution over all finite doubles, no further masking is necessary,
+                    reassemble the bits
+                 */
+                value = BitConverter.Int64BitsToDouble(unchecked((long)randomBits));
+            } while (double.IsInfinity(value) || double.IsNaN(value));
+
+            return value;
         }
 
         public double NextGaussian(double mean = 0, double stdDev = 1)
@@ -285,7 +408,7 @@
                 x = 2 * NextDouble() - 1;
                 y = 2 * NextDouble() - 1;
                 square = x * x + y * y;
-            } while (square > 1 || square == 0);
+            } while (square == 0 || 1 < square);
 
             double fac = Math.Sqrt(-2 * Math.Log(square) / square);
             _cachedGaussian = x * fac;
@@ -297,9 +420,8 @@
             float value;
             do
             {
-                uint floatAsInt = NextUint();
-                value = (floatAsInt >> 8) * MagicFloat;
-            } while (value < 0 || 1 <= value);
+                value = NextUint() / (1f * uint.MaxValue);
+            } while (1f <= value);
 
             return value;
         }
@@ -323,103 +445,13 @@
                 );
             }
 
-            return min + NextFloat(max - min);
-        }
-
-        public T Next<T>(IEnumerable<T> enumerable)
-        {
-            if (enumerable is ICollection<T> collection)
+            float range = max - min;
+            if (float.IsInfinity(range))
             {
-                return Next(collection);
-            }
-
-            return Next((IReadOnlyList<T>)enumerable.ToList());
-        }
-
-        public T Next<T>(ICollection<T> collection)
-        {
-            int count = collection.Count;
-            if (count <= 0)
-            {
-                throw new ArgumentException("Collection size cannot be less-than or equal-to 0");
-            }
-
-            switch (collection)
-            {
-                case IList<T> list:
-                    return Next(list);
-                case IReadOnlyList<T> readOnlyList:
-                    return Next(readOnlyList);
-            }
-
-            int index = Next(count);
-            int i = 0;
-            foreach (T element in collection)
-            {
-                if (i++ == index)
-                {
-                    return element;
-                }
+                return (float)NextDouble(min, max);
             }
 
-            // Should never happen
-            return default;
-        }
-
-        public T Next<T>(IList<T> list)
-        {
-            if (ReferenceEquals(list, null))
-            {
-                throw new ArgumentNullException(nameof(list));
-            }
-
-            /*
-                For small lists, it's much more efficient to simply return one of their elements
-                instead of trying to generate a random number within bounds (which is implemented as a while(true) loop)
-             */
-            switch (list.Count)
-            {
-                case 1:
-                    return list[0];
-                case 2:
-                    return NextBool() ? list[0] : list[1];
-                default:
-                    return list[Next(list.Count)];
-            }
-        }
-
-        private T Next<T>(IReadOnlyList<T> list)
-        {
-            /*
-                For small lists, it's much more efficient to simply return one of their elements
-                instead of trying to generate a random number within bounds (which is implemented as a while(true) loop)
-             */
-            switch (list.Count)
-            {
-                case 1:
-                    return list[0];
-                case 2:
-                    return NextBool() ? list[0] : list[1];
-                default:
-                    return list[Next(list.Count)];
-            }
-        }
-
-        public T Next<T>()
-            where T : struct, Enum
-        {
-            Type enumType = typeof(T);
-            T[] enumValues;
-            if (EnumTypeCache.TryGetValue(enumType, out Array enumArray))
-            {
-                enumValues = (T[])enumArray;
-            }
-            else
-            {
-                enumValues = (T[])Enum.GetValues(enumType);
-            }
-
-            return RandomOf(enumValues);
+            return min + NextFloat(range);
         }
 
         public T NextCachedEnum<T>()
@@ -447,7 +479,7 @@
 
         // Advances the RNG
         // https://code2d.wordpress.com/2020/07/21/perlin-noise/
-        public float[,] NextNoiseMap(int width, int height, float scale, int octaves)
+        public float[,] NextNoiseMap(int width, int height, float scale = 2.5f, int octaves = 8)
         {
             if (width <= 0)
             {

package/Runtime/Core/Random/SquirrelRandom.cs

@@ -37,7 +37,7 @@
 
         public override uint NextUint()
         {
-            return _position = NextUintInternal(_position);
+            return NextUintInternal(ref _position);
         }
 
         // Does not advance the RNG
@@ -51,16 +51,15 @@
             return new SquirrelRandom(InternalState);
         }
 
-        private static uint NextUintInternal(uint seed)
+        private static uint NextUintInternal(ref uint seed)
         {
-            uint result = seed;
-            result *= BitNoise1;
-            result ^= (result >> 8);
-            result += BitNoise2;
-            result ^= (result << 8);
-            result *= BitNoise3;
-            result ^= (result >> 8);
-            return result;
+            seed *= BitNoise1;
+            seed ^= (seed >> 8);
+            seed += BitNoise2;
+            seed ^= (seed << 8);
+            seed *= BitNoise3;
+            seed ^= (seed >> 8);
+            return seed;
         }
 
         // https://youtu.be/LWFzPP8ZbdU?t=2906

package/Runtime/Core/Random/SystemRandom.cs

@@ -12,14 +12,18 @@
     [DataContract]
     public sealed class SystemRandom : AbstractRandom
     {
+        private const int HalfwayInt = int.MaxValue / 2;
+        private const int SeedArraySize = 56;
+        private const int LastSeedIndex = SeedArraySize - 1;
+
         public static IRandom Instance => ThreadLocalRandom<SystemRandom>.Instance;
 
         public override RandomState InternalState =>
             new(
-                unchecked((ulong)inext),
-                unchecked((ulong)inextp),
+                unchecked((ulong)_inext),
+                unchecked((ulong)_inextp),
                 _cachedGaussian,
-                ArrayConverter.IntArrayToByteArrayBlockCopy(SeedArray)
+                ArrayConverter.IntArrayToByteArrayBlockCopy(_seedArray)
             );
 
         /*
@@ -27,9 +31,9 @@
             same across platforms, a fact which defeats the purpose of these serializable
             randoms.
          */
-        private int inext;
-        private int inextp;
-        private readonly int[] SeedArray = new int[56];
+        private int _inext;
+        private int _inextp;
+        private readonly int[] _seedArray = new int[SeedArraySize];
 
         public SystemRandom()
             : this(Guid.NewGuid().GetHashCode()) { }
@@ -37,28 +41,34 @@
         public SystemRandom(int seed)
         {
             int num1 = 161803398 - (seed == int.MinValue ? int.MaxValue : Math.Abs(seed));
-            this.SeedArray[55] = num1;
+            _seedArray[LastSeedIndex] = num1;
             int num2 = 1;
-            for (int index1 = 1; index1 < 55; ++index1)
+            for (int index1 = 1; index1 < LastSeedIndex; ++index1)
             {
-                int index2 = 21 * index1 % 55;
-                this.SeedArray[index2] = num2;
+                int index2 = 21 * index1 % LastSeedIndex;
+                _seedArray[index2] = num2;
                 num2 = num1 - num2;
                 if (num2 < 0)
+                {
                     num2 += int.MaxValue;
-                num1 = this.SeedArray[index2];
+                }
+
+                num1 = _seedArray[index2];
             }
             for (int index3 = 1; index3 < 5; ++index3)
             {
-                for (int index4 = 1; index4 < 56; ++index4)
+                for (int index4 = 1; index4 < SeedArraySize; ++index4)
                 {
-                    this.SeedArray[index4] -= this.SeedArray[1 + (index4 + 30) % 55];
-                    if (this.SeedArray[index4] < 0)
-                        this.SeedArray[index4] += int.MaxValue;
+                    int value = _seedArray[index4] -= _seedArray[1 + (index4 + 30) % LastSeedIndex];
+                    if (value < 0)
+                    {
+                        _seedArray[index4] += int.MaxValue;
+                    }
                 }
             }
-            this.inext = 0;
-            this.inextp = 21;
+
+            _inext = 0;
+            _inextp = 21;
         }
 
         [JsonConstructor]
@@ -66,59 +76,86 @@
         {
             unchecked
             {
-                inext = (int)internalState.State1;
-                inextp = (int)internalState.State2;
+                _inext = (int)internalState.State1;
+                _inextp = (int)internalState.State2;
             }
             _cachedGaussian = internalState.Gaussian;
-            SeedArray = ArrayConverter.ByteArrayToIntArrayBlockCopy(internalState.Payload);
+            _seedArray = ArrayConverter.ByteArrayToIntArrayBlockCopy(internalState.Payload);
         }
 
-        public override uint NextUint()
+        public override int Next()
         {
-            int inext = this.inext;
-            int inextp = this.inextp;
+            int localINext = _inext;
+            int localINextP = _inextp;
             int index1;
-            if ((index1 = inext + 1) >= 56)
+            if ((index1 = localINext + 1) >= SeedArraySize)
+            {
                 index1 = 1;
+            }
+
             int index2;
-            if ((index2 = inextp + 1) >= 56)
+            if ((index2 = localINextP + 1) >= SeedArraySize)
+            {
                 index2 = 1;
-            int num = this.SeedArray[index1] - this.SeedArray[index2];
+            }
+
+            int num = _seedArray[index1] - _seedArray[index2];
             if (num == int.MaxValue)
+            {
                 --num;
+            }
+
             if (num < 0)
+            {
                 num += int.MaxValue;
-            this.SeedArray[index1] = num;
-            this.inext = index1;
-            this.inextp = index2;
-            return unchecked((uint)num);
+            }
+
+            _seedArray[index1] = num;
+            _inext = index1;
+            _inextp = index2;
+            return num;
+        }
+
+        public override uint NextUint()
+        {
+            if (NextBool())
+            {
+                return unchecked((uint)(Next() ^ 0x80000000));
+            }
+            return unchecked((uint)Next());
+        }
+
+        public override bool NextBool()
+        {
+            return Next() < HalfwayInt;
         }
 
         public override double NextDouble()
         {
-            double generated;
+            double random;
             do
             {
-                generated = unchecked((int)NextUint()) * 4.6566128752458E-10;
-            } while (generated < 0 || 1 <= generated);
+                random = Next() / (1.0 * int.MaxValue);
+            } while (1.0 <= random);
 
-            return generated;
+            return random;
         }
 
         public override float NextFloat()
         {
-            return (float)NextDouble();
+            float random;
+            do
+            {
+                random = Next() * (1f / int.MaxValue);
+            } while (1f <= random);
+
+            return random;
         }
 
         public override IRandom Copy()
         {
             SystemRandom copy = new(InternalState);
-
-            for (int i = 0; i < SeedArray.Length; ++i)
-            {
-                copy.SeedArray[i] = SeedArray[i];
-            }
-
+            Array.Copy(_seedArray, copy._seedArray, _seedArray.Length);
             return copy;
         }
     }