DivideBurnikelZieglerThreshold

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

@@ -14,7 +14,7 @@ internal static
 #else
         internal const
 #endif
-        int DivideThreshold = 32;
+        int DivideBurnikelZieglerThreshold = 32;
 
         public static void Divide(ReadOnlySpan<uint> left, uint right, Span<uint> quotient, out uint remainder)
         {
@@ -75,7 +75,7 @@ public static void Divide(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, Spa
             DummyForDebug(quotient);
             DummyForDebug(remainder);
 
-            if (right.Length <= DivideThreshold || left.Length - right.Length <= DivideThreshold)
+            if (right.Length < DivideBurnikelZieglerThreshold || left.Length - right.Length < DivideBurnikelZieglerThreshold)
             {
                 left.CopyTo(remainder);
                 DivideGrammarSchool(remainder, right, quotient);
@@ -92,7 +92,7 @@ public static void Divide(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right, Spa
             Debug.Assert(quotient.Length == left.Length - right.Length + 1);
             DummyForDebug(quotient);
 
-            if (right.Length <= DivideThreshold || left.Length - right.Length <= DivideThreshold)
+            if (right.Length < DivideBurnikelZieglerThreshold || left.Length - right.Length < DivideBurnikelZieglerThreshold)
             {
                 // Same as above, but only returning the quotient.
 
@@ -123,7 +123,7 @@ public static void Remainder(ReadOnlySpan<uint> left, ReadOnlySpan<uint> right,
             Debug.Assert(remainder.Length == left.Length);
             DummyForDebug(remainder);
 
-            if (right.Length <= DivideThreshold || left.Length - right.Length <= DivideThreshold)
+            if (right.Length < DivideBurnikelZieglerThreshold || left.Length - right.Length < DivideBurnikelZieglerThreshold)
             {
                 // Same as above, but only returning the remainder.
 
@@ -158,7 +158,7 @@ private static void DivRem(Span<uint> left, ReadOnlySpan<uint> right, Span<uint>
                 || quotient.Length == 0);
             DummyForDebug(quotient);
 
-            if (right.Length <= DivideThreshold || left.Length - right.Length <= DivideThreshold)
+            if (right.Length < DivideBurnikelZieglerThreshold || left.Length - right.Length < DivideBurnikelZieglerThreshold)
                 DivideGrammarSchool(left, right, quotient);
             else
             {
@@ -358,8 +358,8 @@ private static void DivideBurnikelZiegler(ReadOnlySpan<uint> left, ReadOnlySpan<
             // Fast recursive division: Algorithm 3
             int n;
             {
-                // m = min{1<<k|(1<<k) * DivideThreshold > right.Length}
-                int m = (int)BitOperations.RoundUpToPowerOf2((uint)right.Length / (uint)DivideThreshold + 1);
+                // m = min{1<<k|(1<<k) * DivideBurnikelZieglerThreshold > right.Length}
+                int m = (int)BitOperations.RoundUpToPowerOf2((uint)right.Length / (uint)DivideBurnikelZieglerThreshold + 1);
 
                 int j = (right.Length + m - 1) / m; // Ceil(right.Length/m)
                 n = j * m;
@@ -508,6 +508,7 @@ private static void BurnikelZieglerFallback(ReadOnlySpan<uint> left, ReadOnlySpa
             Debug.Assert(quotient.Length == right.Length);
             Debug.Assert(remainder.Length >= right.Length + 1);
             Debug.Assert(right[^1] > 0);
+            Debug.Assert(right.Length < DivideBurnikelZieglerThreshold);
 
             left = left.Slice(0, ActualLength(left));
 
@@ -580,7 +581,7 @@ private static void BurnikelZieglerD2n1n(ReadOnlySpan<uint> left, ReadOnlySpan<u
             Debug.Assert(remainder.Length >= right.Length + 1);
             Debug.Assert(right[^1] > 0);
 
-            if ((right.Length & 1) != 0 || right.Length <= DivideThreshold)
+            if ((right.Length & 1) != 0 || right.Length < DivideBurnikelZieglerThreshold)
             {
                 BurnikelZieglerFallback(left, right, quotient, remainder);
                 return;

src/libraries/System.Runtime.Numerics/tests/BigInteger/divide.cs

@@ -205,11 +205,11 @@ public static void RunOverflow()
         [Fact]
         public void D3n2nBound()
         {
-            var right = (BigInteger.One << (BigIntegerCalculator.DivideThreshold * 4 * 32 - 1))
-                + (BigInteger.One << (BigIntegerCalculator.DivideThreshold * 2 * 32)) - 1;
+            var right = (BigInteger.One << (BigIntegerCalculator.DivideBurnikelZieglerThreshold * 4 * 32 - 1))
+                + (BigInteger.One << (BigIntegerCalculator.DivideBurnikelZieglerThreshold * 2 * 32)) - 1;
             var rem = right - 1;
 
-            var qi = BigIntegerCalculator.DivideThreshold * 8 * 32 * 4 - 1;
+            var qi = BigIntegerCalculator.DivideBurnikelZieglerThreshold * 8 * 32 * 4 - 1;
             var q = (BigInteger.One << qi) - 1;
             var left = q * right + rem;
 

src/libraries/System.Runtime.Numerics/tests/BigInteger/divrem.cs

@@ -134,7 +134,7 @@ public static void Boundary()
         public static void RunDivRemMedium()
         {
             Test();
-            BigIntTools.Utils.RunWithFakeThreshold(BigIntegerCalculator.DivideThreshold, 5, Test);
+            BigIntTools.Utils.RunWithFakeThreshold(BigIntegerCalculator.DivideBurnikelZieglerThreshold, 5, Test);
 
             void Test()
             {
@@ -190,11 +190,11 @@ public static void RunDivRemLarge()
         [Fact]
         public void D3n2nBound()
         {
-            var right = (BigInteger.One << (BigIntegerCalculator.DivideThreshold * 4 * 32 - 1))
-                + (BigInteger.One << (BigIntegerCalculator.DivideThreshold * 2 * 32)) - 1;
+            var right = (BigInteger.One << (BigIntegerCalculator.DivideBurnikelZieglerThreshold * 4 * 32 - 1))
+                + (BigInteger.One << (BigIntegerCalculator.DivideBurnikelZieglerThreshold * 2 * 32)) - 1;
             var rem = right - 1;
 
-            var qi = BigIntegerCalculator.DivideThreshold * 8 * 32 * 4 - 1;
+            var qi = BigIntegerCalculator.DivideBurnikelZieglerThreshold * 8 * 32 * 4 - 1;
             var q = (BigInteger.One << qi) - 1;
             var left = q * right + rem;
 

src/libraries/System.Runtime.Numerics/tests/BigInteger/op_divide.cs

@@ -152,11 +152,11 @@ public static void RunOverflow()
         [Fact]
         public void D3n2nBound()
         {
-            var right = (BigInteger.One << (BigIntegerCalculator.DivideThreshold * 4 * 32 - 1))
-                + (BigInteger.One << (BigIntegerCalculator.DivideThreshold * 2 * 32)) - 1;
+            var right = (BigInteger.One << (BigIntegerCalculator.DivideBurnikelZieglerThreshold * 4 * 32 - 1))
+                + (BigInteger.One << (BigIntegerCalculator.DivideBurnikelZieglerThreshold * 2 * 32)) - 1;
             var rem = right - 1;
 
-            var qi = BigIntegerCalculator.DivideThreshold * 8 * 32 * 4 - 1;
+            var qi = BigIntegerCalculator.DivideBurnikelZieglerThreshold * 8 * 32 * 4 - 1;
             var q = (BigInteger.One << qi) - 1;
             var left = q * right + rem;
 

src/libraries/System.Runtime.Numerics/tests/BigInteger/op_modulus.cs

@@ -180,11 +180,11 @@ public static void RunRemainderAxiom0ModX()
         [Fact]
         public void D3n2nBound()
         {
-            var right = (BigInteger.One << (BigIntegerCalculator.DivideThreshold * 4 * 32 - 1))
-                + (BigInteger.One << (BigIntegerCalculator.DivideThreshold * 2 * 32)) - 1;
+            var right = (BigInteger.One << (BigIntegerCalculator.DivideBurnikelZieglerThreshold * 4 * 32 - 1))
+                + (BigInteger.One << (BigIntegerCalculator.DivideBurnikelZieglerThreshold * 2 * 32)) - 1;
             var rem = right - 1;
 
-            var qi = BigIntegerCalculator.DivideThreshold * 8 * 32 * 4 - 1;
+            var qi = BigIntegerCalculator.DivideBurnikelZieglerThreshold * 8 * 32 * 4 - 1;
             var q = (BigInteger.One << qi) - 1;
             var left = q * right + rem;