Codegen improvements to Guard.IsCloseTo

Author: Sergio0694

Microsoft.Toolkit/Diagnostics/Guard.Comparable.Numeric.cs

@@ -23,18 +23,18 @@ public static partial class Guard
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static void IsCloseTo(int value, int target, uint delta, string name)
         {
-            // Cast to long before calculating the difference to avoid overflows
-            // when the values are at the two extremes of the supported range.
-            // Then cast to double to calculate the absolute value: this allows
-            // the JIT compiler to use AVX instructions on X64 CPUs instead of
-            // conditional jumps, which results in more efficient assembly code.
-            // The IEEE 754 specs guarantees that a 32 bit integer value can
-            // be stored within a double precision floating point value with
-            // no loss of precision, so the result will always be correct here.
-            // The difference is then cast to uint as that's the maximum possible
-            // value it can have, and comparing two 32 bit integer values
-            // results in shorter and slightly faster code than using doubles.
-            if ((uint)Math.Abs((double)((long)value - target)) <= delta)
+            uint difference;
+
+            if (value >= target)
+            {
+                difference = (uint)(value - target);
+            }
+            else
+            {
+                difference = (uint)(target - value);
+            }
+
+            if (difference <= delta)
             {
                 return;
             }
@@ -53,7 +53,18 @@ public static void IsCloseTo(int value, int target, uint delta, string name)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static void IsNotCloseTo(int value, int target, uint delta, string name)
         {
-            if ((uint)Math.Abs((double)((long)value - target)) > delta)
+            uint difference;
+
+            if (value >= target)
+            {
+                difference = (uint)(value - target);
+            }
+            else
+            {
+                difference = (uint)(target - value);
+            }
+
+            if (difference > delta)
             {
                 return;
             }
@@ -69,12 +80,21 @@ public static void IsNotCloseTo(int value, int target, uint delta, string name)
         /// <param name="delta">The maximum distance to allow between <paramref name="value"/> and <paramref name="target"/>.</param>
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if (<paramref name="value"/> - <paramref name="target"/>) > <paramref name="delta"/>.</exception>
-        [MethodImpl(MethodImplOptions.NoInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static void IsCloseTo(long value, long target, ulong delta, string name)
         {
-            // This method and the one below are not inlined because
-            // using the decimal type results in quite a bit of code.
-            if ((ulong)Math.Abs((decimal)value - target) <= delta)
+            ulong difference;
+
+            if (value >= target)
+            {
+                difference = (ulong)(value - target);
+            }
+            else
+            {
+                difference = (ulong)(target - value);
+            }
+
+            if (difference <= delta)
             {
                 return;
             }
@@ -90,10 +110,21 @@ public static void IsCloseTo(long value, long target, ulong delta, string name)
         /// <param name="delta">The maximum distance to allow between <paramref name="value"/> and <paramref name="target"/>.</param>
         /// <param name="name">The name of the input parameter being tested.</param>
         /// <exception cref="ArgumentException">Thrown if (<paramref name="value"/> - <paramref name="target"/>) &lt;= <paramref name="delta"/>.</exception>
-        [MethodImpl(MethodImplOptions.NoInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static void IsNotCloseTo(long value, long target, ulong delta, string name)
         {
-            if ((ulong)Math.Abs((decimal)value - target) > delta)
+            ulong difference;
+
+            if (value >= target)
+            {
+                difference = (ulong)(value - target);
+            }
+            else
+            {
+                difference = (ulong)(target - value);
+            }
+
+            if (difference > delta)
             {
                 return;
             }