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

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,8 +46,13 @@
                 );
             }
 
-            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
@@ -64,21 +60,12 @@
 
         public uint NextUint(uint max)
         {
-            /*
-                https://github.com/libevent/libevent/blob/3807a30b03ab42f2f503f2db62b1ef5876e2be80/arc4random.c#L531
-
-                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)
+            if (max == 0)
             {
-                uint randomValue = NextUint();
-                if (threshold <= randomValue)
-                {
-                    return randomValue % max;
-                }
+                throw new ArgumentException("Max cannot be zero");
             }
+
+            return (uint)(NextDouble() * max);
         }
 
         public uint NextUint(uint min, uint max)
@@ -127,12 +114,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) & 0x7FFFFFFFFFFFFFFF);
             }
-            return unchecked((long)((ulong)lower << 32) | upper);
         }
 
         public long NextLong(long max)
@@ -142,17 +127,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 +139,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,44 +169,46 @@
                 );
             }
 
-            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;
         }
 
         public void NextBytes(byte[] buffer)
         {
-            if (ReferenceEquals(buffer, null))
+            if (buffer == null)
             {
                 throw new ArgumentException(nameof(buffer));
             }
 
-            const byte sizeOfInt = 4; // May differ on some platforms
+            const int sizeOfInt = 4; // May differ on some platforms
 
             // See how many ints we can slap into it.
             int chunks = buffer.Length / sizeOfInt;
-            byte spare = unchecked((byte)(buffer.Length - (chunks * sizeOfInt)));
+            int spare = buffer.Length - chunks * sizeOfInt;
             for (int i = 0; i < chunks; ++i)
             {
-                int offset = i * chunks;
-                int random = Next();
-                buffer[offset] = unchecked((byte)(random & 0xFF000000));
-                buffer[offset + 1] = unchecked((byte)(random & 0x00FF0000));
-                buffer[offset + 2] = unchecked((byte)(random & 0x0000FF00));
-                buffer[offset + 3] = unchecked((byte)(random & 0x000000FF));
+                int offset = i * sizeOfInt;
+                uint random = NextUint();
+                for (int j = 0; j < sizeOfInt; ++j)
+                {
+                    buffer[offset + j] = unchecked(
+                        (byte)((random >> (j * sizeOfInt)) & 0x000000FF)
+                    );
+                }
             }
 
+            if (0 < spare)
             {
-                /*
-                    This could be implemented more optimally by generating a single int and
-                    bit shifting along the position, but that is too much for me right now.
-                 */
-                for (byte i = 0; i < spare; ++i)
+                uint spareRandom = NextUint();
+                for (int i = 0; i < spare; ++i)
                 {
-                    buffer[buffer.Length - 1 - i] = unchecked((byte)Next());
+                    buffer[buffer.Length - 1 - i] = unchecked(
+                        (byte)((spareRandom >> (i * sizeOfInt)) & 0x000000FF)
+                    );
                 }
             }
         }
@@ -233,8 +218,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 +244,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 +314,7 @@
                 x = 2 * NextDouble() - 1;
                 y = 2 * NextDouble() - 1;
                 square = x * x + y * y;
-            } while (square > 1 || square == 0);
+            } while (square is 0 or > 1);
 
             double fac = Math.Sqrt(-2 * Math.Log(square) / square);
             _cachedGaussian = x * fac;
@@ -297,9 +326,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,52 +351,45 @@
                 );
             }
 
-            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 (float)NextDouble(min, max);
             }
 
-            return Next((IReadOnlyList<T>)enumerable.ToList());
+            return min + NextFloat(range);
         }
 
-        public T Next<T>(ICollection<T> collection)
+        public T NextOf<T>(IEnumerable<T> enumerable)
         {
-            int count = collection.Count;
-            if (count <= 0)
+            return enumerable switch
             {
-                throw new ArgumentException("Collection size cannot be less-than or equal-to 0");
-            }
+                IReadOnlyList<T> list => NextOf(list),
+                IReadOnlyCollection<T> collection => NextOf(collection),
+                null => throw new ArgumentNullException(nameof(enumerable)),
+                _ => NextOf(enumerable.ToArray()),
+            };
+        }
 
-            switch (collection)
+        public T NextOf<T>(IReadOnlyCollection<T> collection)
+        {
+            if (collection is not { Count: > 0 })
             {
-                case IList<T> list:
-                    return Next(list);
-                case IReadOnlyList<T> readOnlyList:
-                    return Next(readOnlyList);
+                throw new ArgumentException("Collection cannot be empty");
             }
 
-            int index = Next(count);
-            int i = 0;
-            foreach (T element in collection)
+            if (collection is IReadOnlyList<T> list)
             {
-                if (i++ == index)
-                {
-                    return element;
-                }
+                return NextOf(list);
             }
 
-            // Should never happen
-            return default;
+            int index = Next(collection.Count);
+            return collection.ElementAt(index);
         }
 
-        public T Next<T>(IList<T> list)
+        public T NextOf<T>(IReadOnlyList<T> list)
         {
-            if (ReferenceEquals(list, null))
+            if (list is not { Count: > 0 })
             {
                 throw new ArgumentNullException(nameof(list));
             }
@@ -377,52 +398,15 @@
                 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
+            return list.Count switch
             {
-                enumValues = (T[])Enum.GetValues(enumType);
-            }
-
-            return RandomOf(enumValues);
+                1 => list[0],
+                2 => NextBool() ? list[0] : list[1],
+                _ => list[Next(list.Count)],
+            };
         }
 
-        public T NextCachedEnum<T>()
+        public T NextEnum<T>()
             where T : struct, Enum
         {
             Type enumType = typeof(T);
@@ -447,7 +431,13 @@
 
         // 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,
+            PerlinNoise noise = null,
+            float scale = 2.5f,
+            int octaves = 8
+        )
         {
             if (width <= 0)
             {
@@ -469,6 +459,7 @@
                 throw new ArgumentException(nameof(octaves));
             }
 
+            noise ??= PerlinNoise.Instance;
             float[,] noiseMap = new float[width, height];
 
             Vector2[] octaveOffsets = new Vector2[octaves];
@@ -497,8 +488,7 @@
                         float sampleX = (x - halfWidth) / scale * frequency + octaveOffsets[i].x;
                         float sampleY = (y - halfHeight) / scale * frequency + octaveOffsets[i].y;
 
-                        // Use unity's implementation of perlin noise
-                        float perlinValue = Mathf.PerlinNoise(sampleX, sampleY) * 2 - 1;
+                        float perlinValue = noise.Noise(sampleX, sampleY) * 2 - 1;
                         noiseHeight += perlinValue * amplitude;
                     }
 
@@ -533,17 +523,13 @@
 
         protected T RandomOf<T>(T[] values)
         {
-            switch (values.Length)
+            return values.Length switch
             {
-                case 0:
-                    return default;
-                case 1:
-                    return values[0];
-                case 2:
-                    return NextBool() ? values[0] : values[1];
-                default:
-                    return values[Next(values.Length)];
-            }
+                0 => default,
+                1 => values[0],
+                2 => NextBool() ? values[0] : values[1],
+                _ => values[Next(values.Length)],
+            };
         }
 
         public abstract IRandom Copy();

package/Runtime/Core/Random/IRandom.cs

@@ -27,10 +27,12 @@
         /// </summary>
         /// <returns>A number within the range [0, uint.MaxValue].</returns>
         uint NextUint();
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [0, max).</returns>
         uint NextUint(uint max);
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [min, max).</returns>
@@ -45,6 +47,7 @@
         /// </summary>
         /// <returns>A number within the range [0, max).</returns>
         short NextShort(short max);
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [min, max).</returns>
@@ -54,10 +57,12 @@
         /// </summary>
         /// <returns>A number within the range [0, byte.MaxValue).</returns>
         byte NextByte();
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [0, max).</returns>
         byte NextByte(byte max);
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [min, max).</returns>
@@ -67,10 +72,12 @@
         /// </summary>
         /// <returns>A number within the range [0, long.MaxValue).</returns>
         long NextLong();
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [0, max).</returns>
         long NextLong(long max);
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [min, max).</returns>
@@ -80,10 +87,12 @@
         /// </summary>
         /// <returns>A number within the range [0, ulong.MaxValue).</returns>
         ulong NextUlong();
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [0, max).</returns>
         ulong NextUlong(ulong max);
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [min, max).</returns>
@@ -100,10 +109,12 @@
         /// </summary>
         /// <returns>A number within the range [0, 1).</returns>
         float NextFloat();
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [0, max).</returns>
         float NextFloat(float max);
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range min, max).</returns>
@@ -113,10 +124,12 @@
         /// </summary>
         /// <returns>A number within the range [0, 1).</returns>
         double NextDouble();
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [0, max).</returns>
         double NextDouble(double max);
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range min, max).</returns>
@@ -127,15 +140,21 @@
         Guid NextGuid();
         KGuid NextKGuid();
 
-        T Next<T>(IEnumerable<T> enumerable);
-        T Next<T>(ICollection<T> collection);
-        T Next<T>(IList<T> list);
+        T NextOf<T>(IEnumerable<T> enumerable);
+        T NextOf<T>(IReadOnlyCollection<T> collection);
+        T NextOf<T>(IReadOnlyList<T> list);
 
-        T Next<T>() where T : struct, Enum;
-        T NextCachedEnum<T>() where T : struct, Enum;
+        T NextEnum<T>()
+            where T : struct, Enum;
 
-        float[,] NextNoiseMap(int width, int height, float scale = 2.5f, int octaves = 8);
+        float[,] NextNoiseMap(
+            int width,
+            int height,
+            PerlinNoise noise = null,
+            float scale = 2.5f,
+            int octaves = 8
+        );
 
         IRandom Copy();
     }
-}
+}