Cleanup and bug fix for wide stochastic rounding path.

Author: stephentyrone

Sources/IntegerUtilities/DivideWithRounding.swift

@@ -117,24 +117,20 @@ extension BinaryInteger {
       if q._lowWord & 1 == 1 { return q }
 
     case .stochastically:
-      var qhi: UInt64
+      let bmag = other.magnitude
+      let rmag = r.magnitude
+      var bhi: UInt64
       var rhi: UInt64
       if other.magnitude <= UInt64.max {
-        qhi = UInt64(other.magnitude)
-        rhi = UInt64(r.magnitude)
+        bhi = UInt64(bmag)
+        rhi = UInt64(rmag)
       } else {
-        // TODO: this is untested currently.
-        let qmag = other.magnitude
-        let shift = qmag._msb - 1
-        qhi = UInt64(truncatingIfNeeded: qmag >> shift)
-        rhi = UInt64(truncatingIfNeeded: r.magnitude >> shift)
+        let shift = bmag._msb - 63
+        bhi = UInt64(truncatingIfNeeded: bmag >> shift)
+        rhi = UInt64(truncatingIfNeeded: rmag >> shift)
       }
-      let (sum, car) = rhi.addingReportingOverflow(.random(in: 0 ..< qhi))
-      if car || sum >= qhi {
-        if (other > 0) != (r > 0) { return q-1 }
-        return q+1
-      }
-      return q
+      let (sum, car) = rhi.addingReportingOverflow(.random(in: 0 ..< bhi))
+      if sum < bhi && !car { return q }
 
     case .requireExact:
       preconditionFailure("Division was not exact.")
@@ -304,24 +300,20 @@ extension SignedInteger {
       if q._lowWord & 1 == 1 { return (q, r) }
 
     case .stochastically:
-      var qhi: UInt64
+      let bmag = other.magnitude
+      let rmag = r.magnitude
+      var bhi: UInt64
       var rhi: UInt64
       if other.magnitude <= UInt64.max {
-        qhi = UInt64(other.magnitude)
-        rhi = UInt64(r.magnitude)
+        bhi = UInt64(bmag)
+        rhi = UInt64(rmag)
       } else {
-        // TODO: this is untested currently.
-        let qmag = other.magnitude
-        let shift = qmag._msb - 1
-        qhi = UInt64(truncatingIfNeeded: qmag >> shift)
-        rhi = UInt64(truncatingIfNeeded: r.magnitude >> shift)
+        let shift = bmag._msb - 63
+        bhi = UInt64(truncatingIfNeeded: bmag >> shift)
+        rhi = UInt64(truncatingIfNeeded: rmag >> shift)
       }
-      let (sum, car) = rhi.addingReportingOverflow(.random(in: 0 ..< qhi))
-      if car || sum >= qhi {
-        if (other > 0) != (r > 0) { return (q-1, r+other) }
-        return (q+1, r-other)
-      }
-      return (q, r)
+      let (sum, car) = rhi.addingReportingOverflow(.random(in: 0 ..< bhi))
+      if sum < bhi && !car { return (q, r) }
 
     case .requireExact:
       preconditionFailure("Division was not exact.")

Tests/IntegerUtilitiesTests/DivideTests.swift

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 import IntegerUtilities
+import _TestSupport
 import XCTest
 
 final class IntegerUtilitiesDivideTests: XCTestCase {
@@ -435,6 +436,27 @@ final class IntegerUtilitiesDivideTests: XCTestCase {
     testDivideStochastic(values)
     testDivideExact(values)
   }
+
+  func testDivideInt128() {
+    var values = [DoubleWidth<Int64>](repeating: 0, count: 64)
+    for i in 0 ..< values.count {
+      while values[i] == 0 {
+        values[i] = .random(in: .min ... .max)
+      }
+    }
+    testDivideDown(values)
+    testDivideUp(values)
+    testDivideTowardZero(values)
+    testDivideAwayFromZero(values)
+    testDivideToNearestOrDown(values)
+    testDivideToNearestOrUp(values)
+    testDivideToNearestOrZero(values)
+    testDivideToNearestOrAway(values)
+    testDivideToNearestOrEven(values)
+    testDivideToOdd(values)
+    testDivideStochastic(values)
+    testDivideExact(values)
+  }
 
   func divideUInt8(_ a: UInt8, _ b: UInt8, rounding rule: RoundingRule) {
     let expected = UInt8(Int16(a).divided(by: Int16(b), rounding: rule).quotient)
@@ -477,11 +499,12 @@ final class IntegerUtilitiesDivideTests: XCTestCase {
   // check that it is acceptably close to the exact expected value; simple
   // use of any deterministic rounding rule will not achieve this.
   func testStochasticDivide<T: FixedWidthInteger>(_ a: T, _ b: T) -> Bool {
+    let trunc = a/b
     let sum = (0..<1024).reduce(into: 0.0) { sum, _ in
-      let rounded = a.divided(by: b, rounding: .stochastically)
-      sum += Double(rounded)
+      let rounding = a.divided(by: b, rounding: .stochastically) - trunc
+      sum += Double(rounding)
     }
-    let expected = 1024 * Double(a) / Double(b)
+    let expected = 1024*Double(a%b)/Double(b)
     let difference = abs(sum - expected)
     // Waving my hands slightly instead of giving a precise explanation
     // here, the expectation is that difference should be about