fix(bigint): keep narrow quotients on Knuth division

Author: Yu-zh

bigint/bigint_wide_wbtest.mbt

@@ -183,6 +183,21 @@ test "BigInt::bit_length" {
   inspect((1N << 63).bit_length(), content="64")
 }
 
+///|
+test "recursive division dispatch accounts for quotient width" {
+  @debug.debug_inspect(
+    [
+      use_recursive_division(64, 64),
+      use_recursive_division(65, 64),
+      use_recursive_division(66, 64),
+      use_recursive_division(128, 63),
+      use_recursive_division(129, 128),
+      use_recursive_division(130, 128),
+    ],
+    content="[false, false, true, false, false, true]",
+  )
+}
+
 ///|
 test "decimal sizing avoids Int overflow" {
   let cases : Array[Int64] = [

bigint/division_bench_test.mbt

@@ -51,6 +51,17 @@ fn make_unbalanced_division(
   (quotient * divisor + divisor - 1N, divisor)
 }
 
+///|
+/// Builds the large-divisor, single-limb-quotient shape used by pidigits.
+fn make_narrow_division(
+  quotient : Int,
+  divisor_limbs : Int,
+) -> (@bigint.BigInt, @bigint.BigInt) {
+  let divisor = division_bench_dense(divisor_limbs * 8, 0x8796a5b4c3d2e1f0UL)
+  let quotient = @bigint.BigInt::from_int(quotient)
+  (quotient * divisor + divisor - 1N, divisor)
+}
+
 ///|
 test "bench BigInt balanced division n=4000 digits" (it : @bench.T) {
   let (dividend, divisor) = make_balanced_division(4000)
@@ -74,3 +85,9 @@ test "bench BigInt unbalanced division q=65536 d=64 limbs" (it : @bench.T) {
   let (dividend, divisor) = make_unbalanced_division(65536, 64)
   it.bench(fn() { it.keep(dividend / divisor) })
 }
+
+///|
+test "bench BigInt narrow division q=9 d=64 limbs" (it : @bench.T) {
+  let (dividend, divisor) = make_narrow_division(9, 64)
+  it.bench(fn() { it.keep(dividend / divisor) })
+}

bigint/division_wide.mbt

@@ -24,15 +24,24 @@
 /// Divisors below this size are faster with ordinary Knuth D.
 const DIV_RECURSIVE_THRESHOLD = 64
 
+///|
+/// Recursive division only pays off when both the divisor and quotient are
+/// wide. With at most two quotient-limb passes, Knuth D is linear in the large
+/// divisor and avoids recursive splitting, multiplication, and allocation.
+/// Requires `dividend_len >= divisor_len`.
+fn use_recursive_division(dividend_len : Int, divisor_len : Int) -> Bool {
+  divisor_len >= DIV_RECURSIVE_THRESHOLD && dividend_len - divisor_len > 1
+}
+
 ///|
 /// Magnitude-only division. Both operands must be positive and `self > other`.
 fn BigInt::div_mod_mag(self : BigInt, other : BigInt) -> (BigInt, BigInt) {
   if other.len == 1 {
     self.div_mod_single_limb(other.limbs.unsafe_get(0))
-  } else if other.len < DIV_RECURSIVE_THRESHOLD {
-    self.knuth_div(other)
-  } else {
+  } else if use_recursive_division(self.len, other.len) {
     self.div_mod_recursive(other)
+  } else {
+    self.knuth_div(other)
   }
 }
 
@@ -60,10 +69,10 @@ fn div_mod_normalized(u : BigInt, v : BigInt) -> (BigInt, BigInt) {
   if v.len == 1 {
     return u.div_mod_single_limb(v.limbs.unsafe_get(0))
   }
-  if v.len < DIV_RECURSIVE_THRESHOLD {
-    return u.knuth_div(v)
+  if use_recursive_division(u.len, v.len) {
+    return div_mod_recursive_steps(u, v)
   }
-  div_mod_recursive_steps(u, v)
+  u.knuth_div(v)
 }
 
 ///|

bigint/quickcheck_deep_test.mbt

@@ -245,6 +245,29 @@ test "recursive division with highly unbalanced operands" {
   }
 }
 
+///|
+test "large divisors with narrow quotients" {
+  // On native/wasm these sizes straddle and exceed the 64-limb recursive
+  // divisor threshold. Their single-limb quotients must stay on Knuth D.
+  let divisor_sizes : Array[Int] = [126, 128, 130, 256]
+  let quotients : Array[@bigint.BigInt] = [
+    2N,
+    9N,
+    (1N << 63) - 1N,
+    (1N << 64) - 1N,
+  ]
+  for size in divisor_sizes {
+    let divisor = mag_of_limbs(seed_u64(size) + 0x51a11UL, size)
+    for quotient in quotients {
+      for remainder in ([0N, 1N, divisor >> 1, divisor - 1N] : Array[_]) {
+        let dividend = quotient * divisor + remainder
+        assert_eq(dividend / divisor, quotient)
+        assert_eq(dividend % divisor, remainder)
+      }
+    }
+  }
+}
+
 ///|
 test "division with adversarial divisor top limbs" {
   // Knuth 4.3.1 quotient-digit estimation is most fragile when the