Refactor Compare functions as Equal or NotEqual

Author: adamgraham

CHANGELOG.md

@@ -14,6 +14,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - New editor mesh debugger: Window > Analysis > Mesh Debugger
 - Behavior help URLs
 
+### Changed
+
+- Refactored the `Compare<T>` class
+  - Changed the `Compare.Test` function to two distinct functions: `Compare.Equal` and `Compare.NotEqual`
+  - The generics are now applied to the functions instead of the class, i.e., `Compare.Equal<int>` instead of `Compare<int>.Equal`
+
 ## [1.4.0] - 2022/05/20
 
 ### Added

Documentation~/articles/benchmarking.md

@@ -23,9 +23,9 @@ Benchmark.Run(1000, Foo, Bar, Baz);
 
 ## 🎏 Compare Equality
 
-Alternatively, sometimes it is useful to test if the results of two functions are equal. The **Debug Tools** package comes with another static class [Compare](/api/Zigurous.Debug/Compare-1) to handle these tests. The class uses generics to know the type of value you are looking to compare, and it returns the percentage of results that are equal.
+Sometimes it is useful to test if multiple functions return the same results. The **Debug Tools** package comes with another static class [Compare](/api/Zigurous.Debug/Compare-1) to handle these tests. The class uses generics to know the type of value you are looking to compare, and it returns the percentage of results that are equal (or not equal) for a given amount of iterations.
 
 ```csharp
-Compare<bool>.Test(Foo, Bar, 1000);
-Compare<float>.Test(Foo, Bar, 1000);
+Compare.Equal(Foo, Bar, 1000);
+Compare.NotEqual(Foo, Bar, 1000);
 ```

Runtime/Compare.cs

@@ -3,13 +3,12 @@
 namespace Zigurous.Debug
 {
     /// <summary>
-    /// Compares how many results are equal between two functions.
+    /// Compares the results of multiple functions for equality.
     /// </summary>
-    /// <typeparam name="T">The type of value to compare.</typeparam>
-    public static class Compare<T> where T : IEquatable<T>
+    public static class Compare
     {
         /// <summary>
-        /// Tests the equality of the results of two functions with a given
+        /// Compares how many results of the two functions are equal for a given
         /// amount of iterations.
         /// </summary>
         /// <param name="foo">The first function to execute.</param>
@@ -18,7 +17,8 @@ public static class Compare<T> where T : IEquatable<T>
         /// <param name="log">Logs the final comparison result.</param>
         /// <param name="logIndividual">Logs the result of each iteration of the functions.</param>
         /// <returns>The percentage of equal results.</returns>
-        public static float Test(Func<T> foo, Func<T> bar, int iterations, bool log = true, bool logIndividual = false)
+        public static float Equal<T>(Func<T> foo, Func<T> bar, int iterations, bool log = true, bool logIndividual = false)
+             where T : IEquatable<T>
         {
             #if UNITY_EDITOR || DEVELOPMENT_BUILD
             int amountEqual = 0;
@@ -51,6 +51,50 @@ public static float Test(Func<T> foo, Func<T> bar, int iterations, bool log = tr
             #endif
         }
 
+        /// <summary>
+        /// Compares how many results of the two functions are not equal for a
+        /// given amount of iterations.
+        /// </summary>
+        /// <param name="foo">The first function to execute.</param>
+        /// <param name="bar">The second function to execute.</param>
+        /// <param name="iterations">The amount of times each function is executed.</param>
+        /// <param name="log">Logs the final comparison result.</param>
+        /// <param name="logIndividual">Logs the result of each iteration of the functions.</param>
+        /// <returns>The percentage of equal results.</returns>
+        public static float NotEqual<T>(Func<T> foo, Func<T> bar, int iterations, bool log = true, bool logIndividual = false)
+             where T : IEquatable<T>
+        {
+            #if UNITY_EDITOR || DEVELOPMENT_BUILD
+            int amountNotEqual = 0;
+
+            for (int i = 0; i < iterations; i++)
+            {
+                T resultFoo = foo();
+                T resultBar = bar();
+
+                bool equal = resultFoo.Equals(resultBar);
+
+                if (!equal) {
+                    amountNotEqual++;
+                }
+
+                if (log && logIndividual) {
+                    UnityEngine.Debug.Log($"[Compare] {resultFoo.ToString()} vs {resultBar.ToString()} | {(equal ? "Equal" : "Not Equal")}");
+                }
+            }
+
+            float percentNotEqual = (float)amountNotEqual / (float)iterations;
+
+            if (log) {
+                UnityEngine.Debug.Log($"[Compare] {amountNotEqual.ToString()}/{iterations.ToString()} ({(percentNotEqual * 100f).ToString()}%) not equal results");
+            }
+
+            return percentNotEqual;
+            #else
+            return float.NaN;
+            #endif
+        }
+
     }
 
 }