Move FastClamp to Numerics

Author: JimBobSquarePants

src/ImageSharp/ColorSpaces/Cmyk.cs

@@ -59,7 +59,7 @@ public Cmyk(float c, float m, float y, float k)
         [MethodImpl(InliningOptions.ShortMethod)]
         public Cmyk(Vector4 vector)
         {
-            vector = Vector4Utilities.FastClamp(vector, Min, Max);
+            vector = Numerics.Clamp(vector, Min, Max);
             this.C = vector.X;
             this.M = vector.Y;
             this.Y = vector.Z;

src/ImageSharp/Common/Helpers/Numerics.cs

@@ -253,6 +253,19 @@ public static double Clamp(double value, double min, double max)
             return value;
         }
 
+        /// <summary>
+        /// Returns the value clamped to the inclusive range of min and max.
+        /// 5x Faster than <see cref="Vector4.Clamp(Vector4, Vector4, Vector4)"/>
+        /// on platforms &lt; NET 5.
+        /// </summary>
+        /// <param name="value">The value to clamp.</param>
+        /// <param name="min">The minimum inclusive value.</param>
+        /// <param name="max">The maximum inclusive value.</param>
+        /// <returns>The clamped <see cref="Vector4"/>.</returns>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static Vector4 Clamp(Vector4 value, Vector4 min, Vector4 max)
+            => Vector4.Min(Vector4.Max(value, min), max);
+
         /// <summary>
         /// Clamps the span values to the inclusive range of min and max.
         /// </summary>

src/ImageSharp/Common/Helpers/SimdUtils.FallbackIntrinsics128.cs

@@ -125,7 +125,7 @@ internal static void NormalizedFloatToByteSaturate(
                     Vector4 s = Unsafe.Add(ref sBase, i);
                     s *= maxBytes;
                     s += half;
-                    s = Vector4Utilities.FastClamp(s, Vector4.Zero, maxBytes);
+                    s = Numerics.Clamp(s, Vector4.Zero, maxBytes);
 
                     ref ByteVector4 d = ref Unsafe.Add(ref dBase, i);
                     d.X = (byte)s.X;

src/ImageSharp/Common/Helpers/SimdUtils.cs

@@ -51,7 +51,7 @@ public static bool HasAvx2
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static Vector4 PseudoRound(this Vector4 v)
         {
-            Vector4 sign = Vector4Utilities.FastClamp(v, new Vector4(-1), new Vector4(1));
+            Vector4 sign = Numerics.Clamp(v, new Vector4(-1), new Vector4(1));
 
             return v + (sign * 0.5f);
         }

src/ImageSharp/Common/Helpers/Vector4Utilities.cs

@@ -20,18 +20,6 @@ internal static class Vector4Utilities
         private const int BlendAlphaControl = 0b_10_00_10_00;
         private const int ShuffleAlphaControl = 0b_11_11_11_11;
 
-        /// <summary>
-        /// Restricts a vector between a minimum and a maximum value.
-        /// 5x Faster then <see cref="Vector4.Clamp(Vector4, Vector4, Vector4)"/>.
-        /// </summary>
-        /// <param name="x">The vector to restrict.</param>
-        /// <param name="min">The minimum value.</param>
-        /// <param name="max">The maximum value.</param>
-        /// <returns>The <see cref="Vector4"/>.</returns>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static Vector4 FastClamp(Vector4 x, Vector4 min, Vector4 max)
-            => Vector4.Min(Vector4.Max(x, min), max);
-
         /// <summary>
         /// Pre-multiplies the "x", "y", "z" components of a vector by its "w" component leaving the "w" component intact.
         /// </summary>

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.cs

@@ -19,22 +19,22 @@ public void NormalizeColorsInPlace(float maximum)
             var CMax4 = new Vector4(maximum);
             var COff4 = new Vector4(MathF.Ceiling(maximum / 2));
 
-            this.V0L = Vector4Utilities.FastClamp(this.V0L + COff4, CMin4, CMax4);
-            this.V0R = Vector4Utilities.FastClamp(this.V0R + COff4, CMin4, CMax4);
-            this.V1L = Vector4Utilities.FastClamp(this.V1L + COff4, CMin4, CMax4);
-            this.V1R = Vector4Utilities.FastClamp(this.V1R + COff4, CMin4, CMax4);
-            this.V2L = Vector4Utilities.FastClamp(this.V2L + COff4, CMin4, CMax4);
-            this.V2R = Vector4Utilities.FastClamp(this.V2R + COff4, CMin4, CMax4);
-            this.V3L = Vector4Utilities.FastClamp(this.V3L + COff4, CMin4, CMax4);
-            this.V3R = Vector4Utilities.FastClamp(this.V3R + COff4, CMin4, CMax4);
-            this.V4L = Vector4Utilities.FastClamp(this.V4L + COff4, CMin4, CMax4);
-            this.V4R = Vector4Utilities.FastClamp(this.V4R + COff4, CMin4, CMax4);
-            this.V5L = Vector4Utilities.FastClamp(this.V5L + COff4, CMin4, CMax4);
-            this.V5R = Vector4Utilities.FastClamp(this.V5R + COff4, CMin4, CMax4);
-            this.V6L = Vector4Utilities.FastClamp(this.V6L + COff4, CMin4, CMax4);
-            this.V6R = Vector4Utilities.FastClamp(this.V6R + COff4, CMin4, CMax4);
-            this.V7L = Vector4Utilities.FastClamp(this.V7L + COff4, CMin4, CMax4);
-            this.V7R = Vector4Utilities.FastClamp(this.V7R + COff4, CMin4, CMax4);
+            this.V0L = Numerics.Clamp(this.V0L + COff4, CMin4, CMax4);
+            this.V0R = Numerics.Clamp(this.V0R + COff4, CMin4, CMax4);
+            this.V1L = Numerics.Clamp(this.V1L + COff4, CMin4, CMax4);
+            this.V1R = Numerics.Clamp(this.V1R + COff4, CMin4, CMax4);
+            this.V2L = Numerics.Clamp(this.V2L + COff4, CMin4, CMax4);
+            this.V2R = Numerics.Clamp(this.V2R + COff4, CMin4, CMax4);
+            this.V3L = Numerics.Clamp(this.V3L + COff4, CMin4, CMax4);
+            this.V3R = Numerics.Clamp(this.V3R + COff4, CMin4, CMax4);
+            this.V4L = Numerics.Clamp(this.V4L + COff4, CMin4, CMax4);
+            this.V4R = Numerics.Clamp(this.V4R + COff4, CMin4, CMax4);
+            this.V5L = Numerics.Clamp(this.V5L + COff4, CMin4, CMax4);
+            this.V5R = Numerics.Clamp(this.V5R + COff4, CMin4, CMax4);
+            this.V6L = Numerics.Clamp(this.V6L + COff4, CMin4, CMax4);
+            this.V6R = Numerics.Clamp(this.V6R + COff4, CMin4, CMax4);
+            this.V7L = Numerics.Clamp(this.V7L + COff4, CMin4, CMax4);
+            this.V7R = Numerics.Clamp(this.V7R + COff4, CMin4, CMax4);
         }
 
         /// <summary>

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.tt

@@ -41,7 +41,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
                 for (int j = 0; j < 2; j++)
                 {
 					char side = j == 0 ? 'L' : 'R';
-					Write($"this.V{i}{side} = Vector4Utilities.FastClamp(this.V{i}{side} + COff4, CMin4, CMax4);\r\n");
+					Write($"this.V{i}{side} = Numerics.Clamp(this.V{i}{side} + COff4, CMin4, CMax4);\r\n");
                 }
             }
 			PopIndent();

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs

@@ -671,7 +671,7 @@ private static Vector<float> NormalizeAndRound(Vector<float> row, Vector<float>
         private static Vector4 DivideRound(Vector4 dividend, Vector4 divisor)
         {
             // sign(dividend) = max(min(dividend, 1), -1)
-            Vector4 sign = Vector4Utilities.FastClamp(dividend, NegativeOne, Vector4.One);
+            Vector4 sign = Numerics.Clamp(dividend, NegativeOne, Vector4.One);
 
             // AlmostRound(dividend/divisor) = dividend/divisor + 0.5*sign(dividend)
             return (dividend / divisor) + (sign * Offset);

src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs

@@ -373,7 +373,7 @@ private void Pack(ref Vector4 vector)
         {
             vector *= MaxBytes;
             vector += Half;
-            vector = Vector4Utilities.FastClamp(vector, Vector4.Zero, MaxBytes);
+            vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
 
             this.R = (byte)vector.X;
             this.G = (byte)vector.Y;

src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs

@@ -296,7 +296,7 @@ private void Pack(ref Vector4 vector)
         {
             vector *= MaxBytes;
             vector += Half;
-            vector = Vector4Utilities.FastClamp(vector, Vector4.Zero, MaxBytes);
+            vector = Numerics.Clamp(vector, Vector4.Zero, MaxBytes);
 
             this.R = (byte)vector.X;
             this.G = (byte)vector.Y;