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

package/Tests/Runtime/Helper/WallMathTests.cs

@@ -0,0 +1,221 @@
+namespace UnityHelpers.Tests.Tests.Runtime.Helper
+{
+    using Core.Extension;
+    using Core.Helper;
+    using Core.Random;
+    using NUnit.Framework;
+    using UnityEngine;
+
+    public sealed class WallMathTests
+    {
+        private const int TestIterations = 10_000;
+
+        [Test]
+        public void ApproximatelyRandom()
+        {
+            for (int i = 0; i < TestIterations; ++i)
+            {
+                float target = PRNG.Instance.NextFloat(-1_000, 1_000);
+                float delta = PRNG.Instance.NextFloat(0f, 10f);
+
+                float insideOffset = delta * PRNG.Instance.NextFloat();
+                if (PRNG.Instance.NextBool())
+                {
+                    insideOffset *= -1;
+                }
+
+                float inside = target + insideOffset;
+                Assert.IsTrue(
+                    target.Approximately(inside, delta),
+                    $"Target {target} is not close enough to {inside} with a delta of {delta}."
+                );
+
+                float outsideOffset = delta * PRNG.Instance.NextFloat(1.001f, 10f);
+                if (PRNG.Instance.NextBool())
+                {
+                    outsideOffset *= -1;
+                }
+
+                float outside = target + outsideOffset;
+                Assert.IsFalse(
+                    target.Approximately(outside, delta),
+                    $"Target {target} was unexpectedly close to {outside} with a delta of {delta}."
+                );
+            }
+        }
+
+        [Test]
+        public void ApproximatelyExpected()
+        {
+            Assert.IsTrue(0f.Approximately(0f, 0f));
+            Assert.IsTrue(0f.Approximately(0.5f, 1f));
+            Assert.IsFalse(0.001f.Approximately(0f, 0f));
+            Assert.IsFalse(100f.Approximately(5f, 2.4f));
+
+            Assert.IsTrue(0.001f.Approximately(0.0001f));
+        }
+
+        [Test]
+        public void ClampRectInsideRandom()
+        {
+            for (int i = 0; i < TestIterations; ++i)
+            {
+                Vector2 position = PRNG.Instance.NextVector2InRange(10f);
+
+                Vector2 size;
+                do
+                {
+                    size = PRNG.Instance.NextVector2InRange(10f);
+                } while (size.x < 0 || size.y < 0);
+
+                Rect rect = new(position, size);
+
+                Vector2 inside = new(
+                    PRNG.Instance.NextFloat(rect.min.x, rect.max.x),
+                    PRNG.Instance.NextFloat(rect.min.y, rect.max.y)
+                );
+                Assert.IsTrue(rect.Contains(inside), $"Rect {rect} does not contain {inside}.");
+                Vector2 clamped = rect.Clamp(inside);
+                Assert.AreEqual(inside, clamped);
+            }
+        }
+
+        [Test]
+        public void ClampRectInsideExpected()
+        {
+            Rect rect = new Rect(Vector2.one, Vector2.one);
+            Vector2 clamped = rect.Clamp(rect.center);
+            Assert.AreEqual(rect.center, clamped);
+
+            Vector2 inside =
+                rect.center
+                + new Vector2(PRNG.Instance.NextFloat(0.1f), PRNG.Instance.NextFloat(0.1f));
+            clamped = rect.Clamp(inside);
+            Assert.AreEqual(
+                inside,
+                clamped,
+                $"Expected inside point {inside} unexpectedly was clamped to {clamped} for rect {rect}."
+            );
+        }
+
+        [Test]
+        public void ClampRectOutsideRandom()
+        {
+            Rect rect = new(Vector2.one, Vector2.one);
+            for (int i = 0; i < TestIterations; ++i)
+            {
+                Vector2 outside;
+                do
+                {
+                    outside = PRNG.Instance.NextVector2InRange(10f, rect.center);
+                } while (rect.Contains(outside));
+
+                Vector2 originalOutside = outside;
+                Vector2 clamped = rect.Clamp(ref outside);
+                Debug.Log($"Clamped {originalOutside} to {clamped}.");
+                Assert.AreNotEqual(originalOutside, clamped);
+                Assert.AreEqual(clamped, outside);
+
+                // Shrink just a little to ensure within bounds, clamping will put it right on the edge
+                const float shrinkScaleToAccountForPrecision = 0.99f;
+                Vector2 delta = rect.center - clamped;
+                delta *= shrinkScaleToAccountForPrecision;
+                clamped = rect.center + delta;
+                Assert.IsTrue(
+                    rect.Contains(clamped),
+                    $"Expected rect {rect} to contain {clamped}, but it did not."
+                );
+            }
+        }
+
+        [Test]
+        public void ClampRectOutsideExpected()
+        {
+            Rect rect = new(Vector2.one, Vector2.one);
+            Vector2 outside = new(rect.center.x, 100f);
+            Vector2 clamped = rect.Clamp(ref outside);
+            Assert.AreEqual(clamped, outside);
+            Assert.AreEqual(new Vector2(rect.center.x, 2f), clamped);
+
+            // Shrink just a little to ensure within bounds, clamping will put it right on the edge
+            const float shrinkScaleToAccountForPrecision = 0.99f;
+            Vector2 delta = rect.center - clamped;
+            delta *= shrinkScaleToAccountForPrecision;
+            clamped = rect.center + delta;
+            Assert.IsTrue(
+                rect.Contains(clamped),
+                $"Expected rect to contain {clamped}, but it did not."
+            );
+        }
+
+        [Test]
+        public void ClampFloat()
+        {
+            float value = 1.25f;
+            float clamped = value.Clamp(0, 1);
+            Assert.AreEqual(1, clamped);
+            Assert.AreEqual(1.25f, value);
+
+            value = 0.5f;
+            clamped = value.Clamp(0, 1);
+            Assert.AreEqual(0.5f, clamped);
+            Assert.AreEqual(0.5f, value);
+        }
+
+        [Test]
+        public void WrappedIncrementWrapped()
+        {
+            int ten = 10;
+            int one = ten.WrappedIncrement(10);
+            Assert.AreEqual(1, one);
+            Assert.AreEqual(10, ten);
+
+            int toChangeToOne = 10;
+            int returned = WallMath.WrappedIncrement(ref toChangeToOne, 10);
+            Assert.AreEqual(1, returned);
+            Assert.AreEqual(1, toChangeToOne);
+        }
+
+        [Test]
+        public void WrappedIncrementUnwrapped()
+        {
+            int ten = 10;
+            int eleven = ten.WrappedIncrement(100);
+            Assert.AreEqual(11, eleven);
+            Assert.AreEqual(10, ten);
+
+            int toChangeToEleven = 10;
+            int returned = WallMath.WrappedIncrement(ref toChangeToEleven, 100);
+            Assert.AreEqual(11, returned);
+            Assert.AreEqual(11, toChangeToEleven);
+        }
+
+        [Test]
+        public void WrappedAddWrapped()
+        {
+            int ten = 10;
+            int two = ten.WrappedAdd(2, 10);
+            Assert.AreEqual(10, ten);
+            Assert.AreEqual(2, two);
+
+            int toChangeToTwo = 10;
+            int returned = WallMath.WrappedAdd(ref toChangeToTwo, 2, 10);
+            Assert.AreEqual(2, returned);
+            Assert.AreEqual(2, toChangeToTwo);
+        }
+
+        [Test]
+        public void WrappedAddUnwrapped()
+        {
+            int ten = 10;
+            int twelve = ten.WrappedAdd(2, 100);
+            Assert.AreEqual(10, ten);
+            Assert.AreEqual(12, twelve);
+
+            int toChangeToTwelve = 10;
+            int returned = WallMath.WrappedAdd(ref toChangeToTwelve, 2, 100);
+            Assert.AreEqual(12, returned);
+            Assert.AreEqual(12, toChangeToTwelve);
+        }
+    }
+}

package/Tests/Runtime/Helper/WallMathTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 11e0e2d4098d47159de89eff698b2510
+timeCreated: 1732563313

package/Tests/Runtime/Helper.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d1cf06665d214b7aa507e42eb1fdfbe4
+timeCreated: 1732492095

package/Tests/Runtime/Performance/RandomPerformanceTests.cs

@@ -12,8 +12,12 @@
         {
             TimeSpan timeout = TimeSpan.FromSeconds(1.125);
 
-            UnityEngine.Debug.Log($"| Random | Next | NextFloat | NextDouble |");
-            UnityEngine.Debug.Log($"| ------ | ---- | --------- | ---------- |");
+            UnityEngine.Debug.Log(
+                $"| Random | NextBool | Next | NextUInt | NextFloat | NextDouble | NextUint - Range | "
+            );
+            UnityEngine.Debug.Log(
+                $"| ------ | -------- | ---- | -------- | --------- | ---------- | ---------------- |"
+            );
 
             RunTest(new PcgRandom(), timeout);
             RunTest(new SystemRandom(), timeout);
@@ -26,12 +30,21 @@
         private static void RunTest<T>(T random, TimeSpan timeout)
             where T : IRandom
         {
+            int nextBool = RunNextBool(timeout, random);
             int nextInt = RunNext(timeout, random);
+            int nextUint = RunNextUint(timeout, random);
             int nextFloat = RunNextFloat(timeout, random);
             int nextDouble = RunNextDouble(timeout, random);
+            int nextUintRange = RunNextUintRange(timeout, random);
 
             UnityEngine.Debug.Log(
-                $"| {random.GetType().Name} | {(nextInt / timeout.TotalSeconds):N0} | {(nextFloat / timeout.TotalSeconds):N0} | {(nextDouble / timeout.TotalSeconds):N0} |"
+                $"| {random.GetType().Name} | "
+                    + $"{(nextBool / timeout.TotalSeconds):N0} | "
+                    + $"{(nextInt / timeout.TotalSeconds):N0} | "
+                    + $"{(nextUint / timeout.TotalSeconds):N0} | "
+                    + $"{(nextFloat / timeout.TotalSeconds):N0} | "
+                    + $"{(nextDouble / timeout.TotalSeconds):N0} |"
+                    + $"{(nextUintRange / timeout.TotalSeconds):N0} |"
             );
         }
 
@@ -50,6 +63,48 @@
             return count;
         }
 
+        private static int RunNextBool<T>(TimeSpan timeout, T random)
+            where T : IRandom
+        {
+            int count = 0;
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                _ = random.NextBool();
+                ++count;
+            } while (timer.Elapsed < timeout);
+
+            return count;
+        }
+
+        private static int RunNextUint<T>(TimeSpan timeout, T random)
+            where T : IRandom
+        {
+            int count = 0;
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                _ = random.NextUint();
+                ++count;
+            } while (timer.Elapsed < timeout);
+
+            return count;
+        }
+
+        private static int RunNextUintRange<T>(TimeSpan timeout, T random)
+            where T : IRandom
+        {
+            int count = 0;
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                _ = random.NextUint(1_000);
+                ++count;
+            } while (timer.Elapsed < timeout);
+
+            return count;
+        }
+
         private static int RunNextFloat<T>(TimeSpan timeout, T random)
             where T : IRandom
         {

package/Tests/Runtime/Performance/SpatialTreePerformanceTest.cs

@@ -1,17 +1,18 @@
 namespace UnityHelpers.Tests.Performance
 {
-    using NUnit.Framework;
-    using System.Collections.Generic;
-    using System.Diagnostics;
     using System;
     using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics;
     using System.Linq;
     using System.Threading.Tasks;
-    using UnityEngine;
     using Core.DataStructure;
+    using NUnit.Framework;
+    using UnityEngine;
     using UnityEngine.TestTools;
 
-    public abstract class SpatialTreePerformanceTest<TTree> where TTree : ISpatialTree<Vector2>
+    public abstract class SpatialTreePerformanceTest<TTree>
+        where TTree : ISpatialTree<Vector2>
     {
         protected abstract TTree CreateTree(IEnumerable<Vector2> points);
 
@@ -23,11 +24,15 @@
 
             Vector2[] points = new Vector2[1_000_000];
             float radius = 500;
-            ParallelLoopResult result = Parallel.For(0, 1_000_000, index =>
-            {
-                // ReSharper disable once PossibleLossOfFraction
-                points[index] = new Vector2(index % 1_000, index / 1_000);
-            });
+            ParallelLoopResult result = Parallel.For(
+                0,
+                1_000_000,
+                index =>
+                {
+                    // ReSharper disable once PossibleLossOfFraction
+                    points[index] = new Vector2(index % 1_000, index / 1_000);
+                }
+            );
 
             while (!result.IsCompleted)
             {
@@ -37,7 +42,9 @@
             Stopwatch timer = Stopwatch.StartNew();
             TTree tree = CreateTree(points);
             timer.Stop();
-            UnityEngine.Debug.Log($"| Construction (1 million points) | {(int)Math.Floor(1 / timer.Elapsed.TotalSeconds)} ({timer.Elapsed.TotalSeconds} total) |");
+            UnityEngine.Debug.Log(
+                $"| Construction (1 million points) | {(int)Math.Floor(1 / timer.Elapsed.TotalSeconds)} ({timer.Elapsed.TotalSeconds} seconds total) |"
+            );
             Vector2 center = tree.Boundary.center;
             int count = 0;
             TimeSpan timeout = TimeSpan.FromSeconds(1);
@@ -47,10 +54,11 @@
                 int elementsInRange = tree.GetElementsInRange(center, radius).Count();
                 Assert.AreEqual(785456, elementsInRange);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
+            } while (timer.Elapsed < timeout);
 
-            UnityEngine.Debug.Log($"| Elements In Range - Full | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - Full | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             radius /= 2f;
             count = 0;
@@ -60,9 +68,10 @@
                 int elementsInRange = tree.GetElementsInRange(center, radius).Count();
                 Assert.AreEqual(196364, elementsInRange);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log($"| Elements In Range - Half | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - Half | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             radius /= 2f;
             count = 0;
@@ -72,9 +81,10 @@
                 int elementsInRange = tree.GetElementsInRange(center, radius).Count();
                 Assert.AreEqual(49080, elementsInRange);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log($"| Elements In Range - Quarter | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - Quarter | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             radius = 1f;
             count = 0;
@@ -84,9 +94,10 @@
                 int elementsInRange = tree.GetElementsInRange(center, radius).Count();
                 Assert.AreEqual(4, elementsInRange);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log($"| Elements In Range - 1 Range | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - 1 Range | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             int nearestNeighborCount = 500;
             List<Vector2> nearestNeighbors = new();
@@ -97,9 +108,10 @@
                 tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
                 Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log($"| ANN - 500 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| ANN - 500 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             nearestNeighborCount = 100;
             count = 0;
@@ -109,9 +121,10 @@
                 tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
                 Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log($"| ANN - 100 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| ANN - 100 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             nearestNeighborCount = 10;
             count = 0;
@@ -121,9 +134,10 @@
                 tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
                 Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log($"| ANN - 10 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| ANN - 10 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             nearestNeighborCount = 1;
             count = 0;
@@ -133,8 +147,7 @@
                 tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
                 Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
+            } while (timer.Elapsed < timeout);
             UnityEngine.Debug.Log($"| ANN - 1 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
         }
     }