Spannified internals of BigInteger

src/libraries/System.Runtime.Numerics/src/System.Runtime.Numerics.csproj

@@ -7,12 +7,12 @@
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System\Numerics\BigIntegerCalculator.AddSub.cs" />
-    <Compile Include="System\Numerics\BigIntegerCalculator.BitsBuffer.cs" />
     <Compile Include="System\Numerics\BigIntegerCalculator.DivRem.cs" />
     <Compile Include="System\Numerics\BigIntegerCalculator.FastReducer.cs" />
     <Compile Include="System\Numerics\BigIntegerCalculator.GcdInv.cs" />
     <Compile Include="System\Numerics\BigIntegerCalculator.PowMod.cs" />
     <Compile Include="System\Numerics\BigIntegerCalculator.SquMul.cs" />
+    <Compile Include="System\Numerics\BigIntegerCalculator.Utils.cs" />
     <Compile Include="System\Numerics\BigInteger.cs" />
     <Compile Include="System\Numerics\BigNumber.cs" />
     <Compile Include="System\Numerics\NumericsHelpers.cs" />
@@ -30,5 +30,6 @@
     <Reference Include="System.Memory" />
     <Reference Include="System.Runtime" />
     <Reference Include="System.Runtime.Extensions" />
+    <Reference Include="System.Runtime.CompilerServices.Unsafe" />
   </ItemGroup>
 </Project>

src/libraries/System.Runtime.Numerics/src/System/Numerics/BigIntegerCalculator.AddSub.cs

@@ -2,275 +2,193 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
-using System.Security;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace System.Numerics
 {
     internal static partial class BigIntegerCalculator
     {
-        public static uint[] Add(uint[] left, uint right)
+        public static void Add(ReadOnlySpan<uint> left, uint right, Span<uint> bits)
         {
-            Debug.Assert(left != null);
             Debug.Assert(left.Length >= 1);
+            Debug.Assert(bits.Length == left.Length + 1);
 
             // Executes the addition for one big and one 32-bit integer.
             // Thus, we've similar code than below, but there is no loop for
             // processing the 32-bit integer, since it's a single element.
 
-            uint[] bits = new uint[left.Length + 1];
+            long carry = right;
 
-            long digit = (long)left[0] + right;
-            bits[0] = unchecked((uint)digit);
-            long carry = digit >> 32;
-
-            for (int i = 1; i < left.Length; i++)
+            for (int i = 0; i < left.Length; i++)
             {
-                digit = left[i] + carry;
+                long digit = left[i] + carry;
                 bits[i] = unchecked((uint)digit);
                 carry = digit >> 32;
             }
-            bits[left.Length] = (uint)carry;
 
-            return bits;
+            bits[left.Length] = (uint)carry;
         }
 
-        public static unsafe uint[] Add(uint[] left, uint[] right)
+        public static void Add(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, Span<uint> bits)
         {
-            Debug.Assert(left != null);
-            Debug.Assert(right != null);
+            Debug.Assert(left.Length >= 0);
+            Debug.Assert(right.Length >= 0);
             Debug.Assert(left.Length >= right.Length);
+            Debug.Assert(bits.Length == left.Length + 1);
 
-            // Switching to unsafe pointers helps sparing
-            // some nasty index calculations...
-
-            uint[] bits = new uint[left.Length + 1];
-
-            fixed (uint* l = left, r = right, b = &bits[0])
-            {
-                Add(l, left.Length,
-                    r, right.Length,
-                    b, bits.Length);
-            }
-
-            return bits;
-        }
+            int i = 0;
+            long carry = 0L;
 
-        private static unsafe void Add(uint* left, int leftLength,
-                                       uint* right, int rightLength,
-                                       uint* bits, int bitsLength)
-        {
-            Debug.Assert(leftLength >= 0);
-            Debug.Assert(rightLength >= 0);
-            Debug.Assert(leftLength >= rightLength);
-            Debug.Assert(bitsLength == leftLength + 1);
+            // Switching to managed references helps eliminating
+            // index bounds check...
+            ref uint leftPtr = ref MemoryMarshal.GetReference(left);
+            ref uint resultPtr = ref MemoryMarshal.GetReference(bits);
 
             // Executes the "grammar-school" algorithm for computing z = a + b.
             // While calculating z_i = a_i + b_i we take care of overflow:
             // Since a_i + b_i + c <= 2(2^32 - 1) + 1 = 2^33 - 1, our carry c
             // has always the value 1 or 0; hence, we're safe here.
 
-            int i = 0;
-            long carry = 0L;
-
-            for (; i < rightLength; i++)
+            for ( ; i < right.Length; i++)
             {
-                long digit = (left[i] + carry) + right[i];
-                bits[i] = unchecked((uint)digit);
+                long digit = (Unsafe.Add(ref leftPtr, i) + carry) + right[i];
+                Unsafe.Add(ref resultPtr, i) = unchecked((uint)digit);
                 carry = digit >> 32;
             }
-            for (; i < leftLength; i++)
+            for ( ; i < left.Length; i++)
             {
                 long digit = left[i] + carry;
-                bits[i] = unchecked((uint)digit);
+                Unsafe.Add(ref resultPtr, i) = unchecked((uint)digit);
                 carry = digit >> 32;
             }
-            bits[i] = (uint)carry;
+            Unsafe.Add(ref resultPtr, i) = (uint)carry;
         }
 
-        private static unsafe void AddSelf(uint* left, int leftLength,
-                                           uint* right, int rightLength)
+        private static void AddSelf(Span<uint> left, ReadOnlySpan<uint> right)
         {
-            Debug.Assert(leftLength >= 0);
-            Debug.Assert(rightLength >= 0);
-            Debug.Assert(leftLength >= rightLength);
+            Debug.Assert(left.Length >= 0);
+            Debug.Assert(right.Length >= 0);
+            Debug.Assert(left.Length >= right.Length);
+
+            int i = 0;
+            long carry = 0L;
+
+            // Switching to managed references helps eliminating
+            // index bounds check...
+            ref uint leftPtr = ref MemoryMarshal.GetReference(left);
+            ref uint rightPtr = ref MemoryMarshal.GetReference(right);
 
             // Executes the "grammar-school" algorithm for computing z = a + b.
             // Same as above, but we're writing the result directly to a and
             // stop execution, if we're out of b and c is already 0.
 
-            int i = 0;
-            long carry = 0L;
-
-            for (; i < rightLength; i++)
+            for ( ; i < right.Length; i++)
             {
-                long digit = (left[i] + carry) + right[i];
-                left[i] = unchecked((uint)digit);
+                long digit = (Unsafe.Add(ref leftPtr, i) + carry) + right[i];
+                Unsafe.Add(ref leftPtr, i) = unchecked((uint)digit);
                 carry = digit >> 32;
             }
-            for (; carry != 0 && i < leftLength; i++)
+            for ( ; carry != 0 && i < left.Length; i++)
             {
-                long digit = left[i] + carry;
-                left[i] = (uint)digit;
+                long digit = Unsafe.Add(ref leftPtr, i) + carry;
+                Unsafe.Add(ref leftPtr, i) = (uint)digit;
                 carry = digit >> 32;
             }
 
             Debug.Assert(carry == 0);
         }
 
-        public static uint[] Subtract(uint[] left, uint right)
+        public static void Subtract(ReadOnlySpan<uint> left, uint right, Span<uint> bits)
         {
-            Debug.Assert(left != null);
             Debug.Assert(left.Length >= 1);
             Debug.Assert(left[0] >= right || left.Length >= 2);
+            Debug.Assert(bits.Length == left.Length);
 
             // Executes the subtraction for one big and one 32-bit integer.
             // Thus, we've similar code than below, but there is no loop for
             // processing the 32-bit integer, since it's a single element.
 
-            uint[] bits = new uint[left.Length];
+            long carry = -right;
 
-            long digit = (long)left[0] - right;
-            bits[0] = unchecked((uint)digit);
-            long carry = digit >> 32;
-
-            for (int i = 1; i < left.Length; i++)
+            for (int i = 0; i < left.Length; i++)
             {
-                digit = left[i] + carry;
+                long digit = left[i] + carry;
                 bits[i] = unchecked((uint)digit);
                 carry = digit >> 32;
             }
-
-            return bits;
         }
 
-        public static unsafe uint[] Subtract(uint[] left, uint[] right)
+        public static void Subtract(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, Span<uint> bits)
         {
-            Debug.Assert(left != null);
-            Debug.Assert(right != null);
+            Debug.Assert(left.Length >= 0);
+            Debug.Assert(right.Length >= 0);
             Debug.Assert(left.Length >= right.Length);
             Debug.Assert(Compare(left, right) >= 0);
+            Debug.Assert(bits.Length == left.Length);
 
-            // Switching to unsafe pointers helps sparing
-            // some nasty index calculations...
-
-            uint[] bits = new uint[left.Length];
-
-            fixed (uint* l = left, r = right, b = bits)
-            {
-                Subtract(l, left.Length,
-                         r, right.Length,
-                         b, bits.Length);
-            }
-
-            return bits;
-        }
+            int i = 0;
+            long carry = 0L;
 
-        private static unsafe void Subtract(uint* left, int leftLength,
-                                            uint* right, int rightLength,
-                                            uint* bits, int bitsLength)
-        {
-            Debug.Assert(leftLength >= 0);
-            Debug.Assert(rightLength >= 0);
-            Debug.Assert(leftLength >= rightLength);
-            Debug.Assert(Compare(left, leftLength, right, rightLength) >= 0);
-            Debug.Assert(bitsLength == leftLength);
+            // Switching to managed references helps eliminating
+            // index bounds check...
+            ref uint leftPtr = ref MemoryMarshal.GetReference(left);
+            ref uint resultPtr = ref MemoryMarshal.GetReference(bits);
 
             // Executes the "grammar-school" algorithm for computing z = a - b.
             // While calculating z_i = a_i - b_i we take care of overflow:
             // Since a_i - b_i doesn't need any additional bit, our carry c
             // has always the value -1 or 0; hence, we're safe here.
 
-            int i = 0;
-            long carry = 0L;
-
-            for (; i < rightLength; i++)
+            for ( ; i < right.Length; i++)
             {
-                long digit = (left[i] + carry) - right[i];
-                bits[i] = unchecked((uint)digit);
+                long digit = (Unsafe.Add(ref leftPtr, i) + carry) - right[i];
+                Unsafe.Add(ref resultPtr, i) = unchecked((uint)digit);
                 carry = digit >> 32;
             }
-            for (; i < leftLength; i++)
+            for ( ; i < left.Length; i++)
             {
                 long digit = left[i] + carry;
-                bits[i] = (uint)digit;
+                Unsafe.Add(ref resultPtr, i) = (uint)digit;
                 carry = digit >> 32;
             }
 
             Debug.Assert(carry == 0);
         }
 
-        private static unsafe void SubtractSelf(uint* left, int leftLength,
-                                                uint* right, int rightLength)
+        private static void SubtractSelf(Span<uint> left, ReadOnlySpan<uint> right)
         {
-            Debug.Assert(leftLength >= 0);
-            Debug.Assert(rightLength >= 0);
-            Debug.Assert(leftLength >= rightLength);
-            Debug.Assert(Compare(left, leftLength, right, rightLength) >= 0);
+            Debug.Assert(left.Length >= 0);
+            Debug.Assert(right.Length >= 0);
+            Debug.Assert(left.Length >= right.Length);
+            Debug.Assert(Compare(left, right) >= 0);
+
+            int i = 0;
+            long carry = 0L;
+
+            // Switching to managed references helps eliminating
+            // index bounds check...
+            ref uint leftPtr = ref MemoryMarshal.GetReference(left);
+            ref uint rightPtr = ref MemoryMarshal.GetReference(right);
 
             // Executes the "grammar-school" algorithm for computing z = a - b.
             // Same as above, but we're writing the result directly to a and
             // stop execution, if we're out of b and c is already 0.
 
-            int i = 0;
-            long carry = 0L;
-
-            for (; i < rightLength; i++)
+            for (; i < right.Length; i++)
             {
-                long digit = (left[i] + carry) - right[i];
-                left[i] = unchecked((uint)digit);
+                long digit = (Unsafe.Add(ref leftPtr, i) + carry) - Unsafe.Add(ref rightPtr, i);
+                Unsafe.Add(ref leftPtr, i) = unchecked((uint)digit);
                 carry = digit >> 32;
             }
-            for (; carry != 0 && i < leftLength; i++)
+            for (; carry != 0 && i < left.Length; i++)
             {
-                long digit = left[i] + carry;
-                left[i] = (uint)digit;
+                long digit = Unsafe.Add(ref leftPtr, i) + carry;
+                Unsafe.Add(ref leftPtr, i) = (uint)digit;
                 carry = digit >> 32;
             }
 
             Debug.Assert(carry == 0);
         }
-
-        public static int Compare(uint[] left, uint[] right)
-        {
-            Debug.Assert(left != null);
-            Debug.Assert(right != null);
-
-            if (left.Length < right.Length)
-                return -1;
-            if (left.Length > right.Length)
-                return 1;
-
-            for (int i = left.Length - 1; i >= 0; i--)
-            {
-                if (left[i] < right[i])
-                    return -1;
-                if (left[i] > right[i])
-                    return 1;
-            }
-
-            return 0;
-        }
-
-        private static unsafe int Compare(uint* left, int leftLength,
-                                          uint* right, int rightLength)
-        {
-            Debug.Assert(leftLength >= 0);
-            Debug.Assert(rightLength >= 0);
-
-            if (leftLength < rightLength)
-                return -1;
-            if (leftLength > rightLength)
-                return 1;
-
-            for (int i = leftLength - 1; i >= 0; i--)
-            {
-                if (left[i] < right[i])
-                    return -1;
-                if (left[i] > right[i])
-                    return 1;
-            }
-
-            return 0;
-        }
     }
 }