NumberUtilities + NumericExtensions = NumericUtilities, some SIMD

Author: antonfirsov

src/ImageSharp.Drawing/Processing/PatternBrush.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Buffers;
 using System.Numerics;
-using SixLabors.ImageSharp.Advanced;
+using SixLabors.ImageSharp.Drawing.Utilities;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -155,7 +155,7 @@ public override void Apply(Span<float> scanline, int x, int y)
 
                     for (int i = 0; i < scanline.Length; i++)
                     {
-                        amountSpan[i] = NumberUtilities.ClampFloat(scanline[i] * this.Options.BlendPercentage, 0, 1F);
+                        amountSpan[i] = NumericUtilities.ClampFloat(scanline[i] * this.Options.BlendPercentage, 0, 1F);
 
                         int patternX = (x + i) % this.pattern.Columns;
                         overlaySpan[i] = this.pattern[patternY, patternX];

src/ImageSharp.Drawing/Shapes/Rasterization/RasterizerExtensions.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using SixLabors.ImageSharp.Drawing.Utilities;
 
 namespace SixLabors.ImageSharp.Drawing.Shapes.Rasterization
 {
@@ -59,11 +60,8 @@ private static void ScanCurrentSubpixelLineInto(this ref PolygonScanner scanner,
                 int nextX = startX + 1;
                 endX = Math.Min(endX, scanline.Length); // reduce to end to the right edge
                 nextX = Math.Max(nextX, 0);
-                for (int x = nextX; x < endX; x++)
-                {
-                    scanline[x] += scanner.SubpixelDistance;
-                    scanlineDirty = true;
-                }
+
+                scanline.Slice(nextX, endX - nextX).AddToAllElements(scanner.SubpixelDistance);
             }
         }
     }

src/ImageSharp.Drawing/Utilities/NumberUtilities.cs

@@ -1,29 +1,63 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
-namespace SixLabors.ImageSharp.Drawing
+namespace SixLabors.ImageSharp.Drawing.Utilities
 {
-    internal static class NumericExtensions
+    internal static class NumericUtilities
     {
+        public static void AddToAllElements(this Span<float> span, float value)
+        {
+            ref float current = ref MemoryMarshal.GetReference(span);
+            ref float max = ref Unsafe.Add(ref current, span.Length);
+
+            if (Vector.IsHardwareAccelerated)
+            {
+                int n = span.Length / Vector<float>.Count;
+                ref Vector<float> currentVec = ref Unsafe.As<float, Vector<float>>(ref current);
+                ref Vector<float> maxVec = ref Unsafe.Add(ref currentVec, n);
+
+                Vector<float> vecVal = new Vector<float>(value);
+                while (Unsafe.IsAddressLessThan(ref currentVec, ref maxVec))
+                {
+                    currentVec += vecVal;
+                    currentVec = ref Unsafe.Add(ref currentVec, 1);
+                }
+
+                // current = ref Unsafe.Add(ref current, n * Vector<float>.Count);
+                current = ref Unsafe.As<Vector<float>, float>(ref currentVec);
+            }
+
+            while (Unsafe.IsAddressLessThan(ref current, ref max))
+            {
+                current += value;
+                current = ref Unsafe.Add(ref current, 1);
+            }
+        }
+
         // https://apisof.net/catalog/System.Numerics.BitOperations.Log2(UInt32)
         // BitOperations.Log2() has been introduced in .NET Core 3.0,
         // since we do target only 3.1+, we can detect it's presence by using SUPPORTS_RUNTIME_INTRINSICS
         // TODO: Ideally this should have a separate definition in Build.props, but that adaption should be done cross-repo. Using a workaround until then.
 #if SUPPORTS_RUNTIME_INTRINSICS
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Log2(uint value) => System.Numerics.BitOperations.Log2(value);
+
 #else
-        private static System.ReadOnlySpan<byte> Log2DeBruijn => new byte[32]
+
+#pragma warning disable SA1515, SA1414, SA1114, SA1201
+        private static ReadOnlySpan<byte> Log2DeBruijn => new byte[32]
         {
             00, 09, 01, 10, 13, 21, 02, 29,
             11, 14, 16, 18, 22, 25, 03, 30,
             08, 12, 20, 28, 15, 17, 24, 07,
             19, 27, 23, 06, 26, 05, 04, 31
         };
 
-#pragma warning disable SA1515, SA1414, SA1114
         // Adapted from:
         // https://github.com/dotnet/runtime/blob/5c65d891f203618245184fa54397ced0a8ca806c/src/libraries/System.Private.CoreLib/src/System/Numerics/BitOperations.cs#L205-L223
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -42,11 +76,27 @@ public static int Log2(uint value)
             // uint.MaxValue >> 27 is always in range [0 - 31] so we use Unsafe.AddByteOffset to avoid bounds check
             return Unsafe.AddByteOffset(
                 // Using deBruijn sequence, k=2, n=5 (2^5=32) : 0b_0000_0111_1100_0100_1010_1100_1101_1101u
-                ref System.Runtime.InteropServices.MemoryMarshal.GetReference(Log2DeBruijn),
+                ref MemoryMarshal.GetReference(Log2DeBruijn),
                 // uint|long -> IntPtr cast on 32-bit platforms does expensive overflow checks not needed here
-                (System.IntPtr)(int)((value * 0x07C4ACDDu) >> 27));
+                (IntPtr)(int)((value * 0x07C4ACDDu) >> 27));
         }
+
 #pragma warning restore
 #endif
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float ClampFloat(float value, float min, float max)
+        {
+            if (value >= max)
+            {
+                return max;
+            }
+
+            if (value <= min)
+            {
+                return min;
+            }
+
+            return value;
+        }
     }
 }

…g/Common/Extensions/NumericExtensions.cs …rp.Drawing/Utilities/NumericUtilities.cssrc/ImageSharp.Drawing/Common/Extensions/NumericExtensions.cs renamed to src/ImageSharp.Drawing/Utilities/NumericUtilities.cs src/ImageSharp.Drawing/Common/Extensions/NumericExtensions.cs renamed to src/ImageSharp.Drawing/Utilities/NumericUtilities.cs

@@ -49,7 +49,7 @@ private static void IntrospectiveSort(Span<float> keys, Span<TValue> values)
             {
                 if (keys.Length > 1)
                 {
-                    IntroSort(keys, values, 2 * (NumericExtensions.Log2((uint)keys.Length) + 1));
+                    IntroSort(keys, values, 2 * (NumericUtilities.Log2((uint)keys.Length) + 1));
                 }
             }
 

src/ImageSharp.Drawing/Utilities/SortUtility.KeyValueSort.cs

@@ -0,0 +1,32 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Linq;
+using SixLabors.ImageSharp.Drawing.Utilities;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Drawing.Tests.Drawing.Utils
+{
+    public class NumericUtilitiesTests
+    {
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(3)]
+        [InlineData(7)]
+        [InlineData(8)]
+        [InlineData(13)]
+        [InlineData(130)]
+        public void AddToAllElements(int length)
+        {
+            float[] values = Enumerable.Range(0, length).Select(v => (float)v).ToArray();
+
+            const float val = 13.4321f;
+            float[] expected = values.Select(x => x + val).ToArray();
+            values.AsSpan().AddToAllElements(val);
+            
+            Assert.Equal(expected, values);
+        } 
+    }
+}

tests/ImageSharp.Drawing.Tests/ImageInfoTests.cs

@@ -3,11 +3,10 @@
 
 using System;
 using System.Linq;
-
-using Xunit;
 using SixLabors.ImageSharp.Drawing.Utilities;
+using Xunit;
 
-namespace SixLabors.ImageSharp.Drawing.Tests.Drawing.Utils
+namespace SixLabors.ImageSharp.Drawing.Tests.Utilities
 {
     public class SortUtilityTests
     {