Introduce Numerics and migrate ImageMaths methods

Author: JimBobSquarePants

src/ImageSharp/ColorSpaces/Companding/LCompanding.cs

@@ -24,7 +24,7 @@ public static class LCompanding
         /// <returns>The <see cref="float"/> representing the linear channel value.</returns>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static float Expand(float channel)
-            => channel <= 0.08F ? (100F * channel) / CieConstants.Kappa : ImageMaths.Pow3((channel + 0.16F) / 1.16F);
+            => channel <= 0.08F ? (100F * channel) / CieConstants.Kappa : Numerics.Pow3((channel + 0.16F) / 1.16F);
 
         /// <summary>
         /// Compresses an uncompanded channel (linear) to its nonlinear equivalent.

src/ImageSharp/ColorSpaces/Conversion/Implementation/Converters/CieLabToCieXyzConverter.cs

@@ -25,11 +25,11 @@ public CieXyz Convert(in CieLab input)
             float fx = (a / 500F) + fy;
             float fz = fy - (b / 200F);
 
-            float fx3 = ImageMaths.Pow3(fx);
-            float fz3 = ImageMaths.Pow3(fz);
+            float fx3 = Numerics.Pow3(fx);
+            float fz3 = Numerics.Pow3(fz);
 
             float xr = fx3 > CieConstants.Epsilon ? fx3 : ((116F * fx) - 16F) / CieConstants.Kappa;
-            float yr = l > CieConstants.Kappa * CieConstants.Epsilon ? ImageMaths.Pow3((l + 16F) / 116F) : l / CieConstants.Kappa;
+            float yr = l > CieConstants.Kappa * CieConstants.Epsilon ? Numerics.Pow3((l + 16F) / 116F) : l / CieConstants.Kappa;
             float zr = fz3 > CieConstants.Epsilon ? fz3 : ((116F * fz) - 16F) / CieConstants.Kappa;
 
             var wxyz = new Vector3(input.WhitePoint.X, input.WhitePoint.Y, input.WhitePoint.Z);

src/ImageSharp/ColorSpaces/Conversion/Implementation/Converters/CieLuvToCieXyzConverter.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using System.Runtime.CompilerServices;
@@ -24,7 +24,7 @@ public CieXyz Convert(in CieLuv input)
             float v0 = ComputeV0(input.WhitePoint);
 
             float y = l > CieConstants.Kappa * CieConstants.Epsilon
-                        ? ImageMaths.Pow3((l + 16) / 116)
+                        ? Numerics.Pow3((l + 16) / 116)
                         : l / CieConstants.Kappa;
 
             float a = ((52 * l / (u + (13 * l * u0))) - 1) / 3;
@@ -71,4 +71,4 @@ private static float ComputeU0(in CieXyz input)
         private static float ComputeV0(in CieXyz input)
             => (9 * input.Y) / (input.X + (15 * input.Y) + (3 * input.Z));
     }
-}
+}

src/ImageSharp/ColorSpaces/Conversion/Implementation/Converters/HunterLabToCieXyzConverter.cs

@@ -26,7 +26,7 @@ public CieXyz Convert(in HunterLab input)
             float ka = ComputeKa(input.WhitePoint);
             float kb = ComputeKb(input.WhitePoint);
 
-            float pow = ImageMaths.Pow2(l / 100F);
+            float pow = Numerics.Pow2(l / 100F);
             float sqrtPow = MathF.Sqrt(pow);
             float y = pow * yn;
 

src/ImageSharp/Common/Helpers/ImageMaths.cs

@@ -4,13 +4,12 @@
 using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
-
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp
 {
     /// <summary>
-    /// Provides common mathematical methods.
+    /// Provides common mathematical methods used for image processing.
     /// </summary>
     internal static class ImageMaths
     {
@@ -108,85 +107,6 @@ public static byte DownScaleFrom16BitTo8Bit(ushort component)
         [MethodImpl(InliningOptions.ShortMethod)]
         public static ushort UpscaleFrom8BitTo16Bit(byte component) => (ushort)(component * 257);
 
-        /// <summary>
-        /// Determine the Greatest CommonDivisor (GCD) of two numbers.
-        /// </summary>
-        public static int GreatestCommonDivisor(int a, int b)
-        {
-            while (b != 0)
-            {
-                int temp = b;
-                b = a % b;
-                a = temp;
-            }
-
-            return a;
-        }
-
-        /// <summary>
-        /// Determine the Least Common Multiple (LCM) of two numbers.
-        /// </summary>
-        public static int LeastCommonMultiple(int a, int b)
-        {
-            // https://en.wikipedia.org/wiki/Least_common_multiple#Reduction_by_the_greatest_common_divisor
-            return (a / GreatestCommonDivisor(a, b)) * b;
-        }
-
-        /// <summary>
-        /// Calculates <paramref name="x"/> % 2
-        /// </summary>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static int Modulo2(int x) => x & 1;
-
-        /// <summary>
-        /// Calculates <paramref name="x"/> % 4
-        /// </summary>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static int Modulo4(int x) => x & 3;
-
-        /// <summary>
-        /// Calculates <paramref name="x"/> % 8
-        /// </summary>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static int Modulo8(int x) => x & 7;
-
-        /// <summary>
-        /// Fast (x mod m) calculator, with the restriction that
-        /// <paramref name="m"/> should be power of 2.
-        /// </summary>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static int ModuloP2(int x, int m) => x & (m - 1);
-
-        /// <summary>
-        /// Returns the absolute value of a 32-bit signed integer. Uses bit shifting to speed up the operation.
-        /// </summary>
-        /// <param name="x">
-        /// A number that is greater than <see cref="int.MinValue"/>, but less than or equal to <see cref="int.MaxValue"/>
-        /// </param>
-        /// <returns>The <see cref="int"/></returns>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static int FastAbs(int x)
-        {
-            int y = x >> 31;
-            return (x ^ y) - y;
-        }
-
-        /// <summary>
-        /// Returns a specified number raised to the power of 2
-        /// </summary>
-        /// <param name="x">A single-precision floating-point number</param>
-        /// <returns>The number <paramref name="x" /> raised to the power of 2.</returns>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static float Pow2(float x) => x * x;
-
-        /// <summary>
-        /// Returns a specified number raised to the power of 3
-        /// </summary>
-        /// <param name="x">A single-precision floating-point number</param>
-        /// <returns>The number <paramref name="x" /> raised to the power of 3.</returns>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static float Pow3(float x) => x * x * x;
-
         /// <summary>
         /// Returns how many bits are required to store the specified number of colors.
         /// Performs a Log2() on the value.
@@ -206,48 +126,6 @@ public static int FastAbs(int x)
         [MethodImpl(InliningOptions.ShortMethod)]
         public static int GetColorCountForBitDepth(int bitDepth) => 1 << bitDepth;
 
-        /// <summary>
-        /// Implementation of 1D Gaussian G(x) function
-        /// </summary>
-        /// <param name="x">The x provided to G(x).</param>
-        /// <param name="sigma">The spread of the blur.</param>
-        /// <returns>The Gaussian G(x)</returns>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static float Gaussian(float x, float sigma)
-        {
-            const float Numerator = 1.0f;
-            float denominator = MathF.Sqrt(2 * MathF.PI) * sigma;
-
-            float exponentNumerator = -x * x;
-            float exponentDenominator = 2 * Pow2(sigma);
-
-            float left = Numerator / denominator;
-            float right = MathF.Exp(exponentNumerator / exponentDenominator);
-
-            return left * right;
-        }
-
-        /// <summary>
-        /// Returns the result of a normalized sine cardinal function for the given value.
-        /// SinC(x) = sin(pi*x)/(pi*x).
-        /// </summary>
-        /// <param name="f">A single-precision floating-point number to calculate the result for.</param>
-        /// <returns>
-        /// The sine cardinal of <paramref name="f" />.
-        /// </returns>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static float SinC(float f)
-        {
-            if (MathF.Abs(f) > Constants.Epsilon)
-            {
-                f *= MathF.PI;
-                float result = MathF.Sin(f) / f;
-                return MathF.Abs(result) < Constants.Epsilon ? 0F : result;
-            }
-
-            return 1F;
-        }
-
         /// <summary>
         /// Gets the bounding <see cref="Rectangle"/> from the given points.
         /// </summary>