com.wallstop-studios.unity-helpers 2.0.0-rc13 → 2.0.0-rc15

package/Runtime/Core/Random/PcgRandom.cs

@@ -17,6 +17,8 @@
     {
         public static IRandom Instance => ThreadLocalRandom<PcgRandom>.Instance;
 
+        public override RandomState InternalState => new(_state, _increment, _cachedGaussian);
+
         internal readonly ulong _increment;
 
         internal ulong _state;
@@ -53,8 +55,6 @@
             _increment = NextUlong();
         }
 
-        public override RandomState InternalState => new(_state, _increment, _cachedGaussian);
-
         public override uint NextUint()
         {
             unchecked

package/Runtime/Core/Random/RomuDuo.cs

@@ -0,0 +1,116 @@
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
+    using System.Text.Json.Serialization;
+    using Extension;
+    using Helper;
+
+    [Serializable]
+    [DataContract]
+    public sealed class RomuDuo
+        : AbstractRandom,
+            IEquatable<RomuDuo>,
+            IComparable,
+            IComparable<RomuDuo>
+    {
+        public static IRandom Instance => ThreadLocalRandom<RomuDuo>.Instance;
+        public override RandomState InternalState => new(_x, _y, _cachedGaussian);
+
+        internal ulong _x;
+        internal ulong _y;
+
+        public RomuDuo()
+            : this(Guid.NewGuid()) { }
+
+        public RomuDuo(Guid guid)
+        {
+            byte[] bytes = guid.ToByteArray();
+            _x = BitConverter.ToUInt64(bytes, 0);
+            _y = BitConverter.ToUInt64(bytes, sizeof(ulong));
+        }
+
+        public RomuDuo(ulong seedX, ulong seedY)
+        {
+            _x = seedX;
+            _y = seedY;
+        }
+
+        [JsonConstructor]
+        public RomuDuo(RandomState internalState)
+        {
+            _x = internalState.State1;
+            _y = internalState.State2;
+            _cachedGaussian = internalState.Gaussian;
+        }
+
+        public override uint NextUint()
+        {
+            unchecked
+            {
+                ulong xp = _x;
+                _x = 15241094284759029579UL * _y;
+                _y = Rol64(_y, 27) + xp;
+                return (uint)xp;
+            }
+        }
+
+        public override IRandom Copy()
+        {
+            return new RomuDuo(InternalState);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong Rol64(ulong x, int k)
+        {
+            return (x << k) | (x >> (64 - k));
+        }
+
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as RomuDuo);
+        }
+
+        public bool Equals(RomuDuo other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            return _x == other._x && _y == other._y;
+        }
+
+        public override int GetHashCode()
+        {
+            return Objects.ValueTypeHashCode(_x, _y);
+        }
+
+        public override string ToString()
+        {
+            return this.ToJson();
+        }
+
+        public int CompareTo(object obj)
+        {
+            return CompareTo(obj as RomuDuo);
+        }
+
+        public int CompareTo(RomuDuo other)
+        {
+            if (other == null)
+            {
+                return -1;
+            }
+
+            int comparison = _x.CompareTo(other._x);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            return _y.CompareTo(other._y);
+        }
+    }
+}

package/Runtime/Core/Random/RomuDuo.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 562c2538ef434c048b1fd0816dcc2369
+timeCreated: 1735610205

package/Runtime/Core/Random/SplitMix64.cs

@@ -0,0 +1,94 @@
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using System.Runtime.Serialization;
+    using System.Text.Json.Serialization;
+
+    [Serializable]
+    [DataContract]
+    public sealed class SplitMix64
+        : AbstractRandom,
+            IEquatable<SplitMix64>,
+            IComparable,
+            IComparable<SplitMix64>
+    {
+        public static IRandom Instance => ThreadLocalRandom<SplitMix64>.Instance;
+
+        public override RandomState InternalState => new(_state, 0, _cachedGaussian);
+
+        internal ulong _state;
+
+        public SplitMix64()
+            : this(Guid.NewGuid()) { }
+
+        public SplitMix64(Guid guid)
+            : this(BitConverter.ToUInt64(guid.ToByteArray(), 0)) { }
+
+        public SplitMix64(ulong seed)
+        {
+            _state = seed;
+        }
+
+        [JsonConstructor]
+        public SplitMix64(RandomState internalState)
+        {
+            _state = internalState.State1;
+            _cachedGaussian = internalState.Gaussian;
+        }
+
+        public override uint NextUint()
+        {
+            unchecked
+            {
+                _state += 0x9E3779B97F4A7C15UL;
+
+                ulong z = _state;
+                z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9UL;
+                z = (z ^ (z >> 27)) * 0x94D049BB133111EBUL;
+                z ^= (z >> 31);
+
+                return (uint)z;
+            }
+        }
+
+        public override IRandom Copy()
+        {
+            return new SplitMix64(InternalState);
+        }
+
+        public bool Equals(SplitMix64 other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            return _state == other._state;
+        }
+
+        public int CompareTo(object obj)
+        {
+            return CompareTo(obj as SplitMix64);
+        }
+
+        public int CompareTo(SplitMix64 other)
+        {
+            if (other == null)
+            {
+                return -1;
+            }
+
+            return _state.CompareTo(other._state);
+        }
+
+        public override int GetHashCode()
+        {
+            return _state.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return $"{{\"State\": {_state}}}";
+        }
+    }
+}

package/Runtime/Core/Random/SplitMix64.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cea6a12d9c0d4373b21094cdb49b8cfb
+timeCreated: 1735605670

package/Runtime/Core/Random/XorShiroRandom.cs

@@ -0,0 +1,117 @@
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Text.Json.Serialization;
+    using Extension;
+    using Helper;
+
+    public sealed class XorShiroRandom
+        : AbstractRandom,
+            IEquatable<XorShiroRandom>,
+            IComparable,
+            IComparable<XorShiroRandom>
+    {
+        public override RandomState InternalState => new(_s0, _s1, _cachedGaussian);
+
+        internal ulong _s0;
+        internal ulong _s1;
+
+        public XorShiroRandom()
+            : this(Guid.NewGuid()) { }
+
+        public XorShiroRandom(Guid guid)
+        {
+            byte[] bytes = guid.ToByteArray();
+            _s0 = BitConverter.ToUInt64(bytes, 0);
+            _s1 = BitConverter.ToUInt64(bytes, 8);
+        }
+
+        public XorShiroRandom(ulong seed1, ulong seed2)
+        {
+            _s0 = seed1;
+            _s1 = seed2;
+        }
+
+        [JsonConstructor]
+        public XorShiroRandom(RandomState internalState)
+        {
+            _s0 = internalState.State1;
+            _s1 = internalState.State2;
+            _cachedGaussian = internalState.Gaussian;
+        }
+
+        public override uint NextUint()
+        {
+            unchecked
+            {
+                ulong s0 = _s0;
+                ulong s1 = _s1;
+                ulong result = s0 + s1;
+
+                s1 ^= s0;
+                _s0 = Rotl(s0, 24) ^ s1 ^ (s1 << 16);
+                _s1 = Rotl(s1, 37);
+
+                return (uint)result;
+            }
+        }
+
+        public override IRandom Copy()
+        {
+            return new XorShiroRandom(InternalState);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong Rotl(ulong x, int k)
+        {
+            return (x << k) | (x >> (64 - k));
+        }
+
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as XorShiroRandom);
+        }
+
+        public bool Equals(XorShiroRandom other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            return _s0 == other._s0 && _s1 == other._s1;
+        }
+
+        public override int GetHashCode()
+        {
+            return Objects.ValueTypeHashCode(_s0, _s1);
+        }
+
+        public override string ToString()
+        {
+            return this.ToJson();
+        }
+
+        public int CompareTo(object obj)
+        {
+            return CompareTo(obj as XorShiroRandom);
+        }
+
+        public int CompareTo(XorShiroRandom other)
+        {
+            if (other == null)
+            {
+                return -1;
+            }
+
+            int comparison = _s0.CompareTo(other._s0);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            return _s1.CompareTo(other._s1);
+        }
+    }
+}

package/Runtime/Core/Random/XorShiroRandom.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1252767904fc4f4bb2a8a876964f2dfc
+timeCreated: 1735610452