Merge pull request #273 from xwu/toil-and-trouble

[_TestSupport] Fix DoubleWidth think-o that trips an assert

Author: stephentyrone

Sources/_TestSupport/DoubleWidth.swift

@@ -363,8 +363,10 @@ extension DoubleWidth : FixedWidthInteger {
 
     let low =
       DoubleWidth<Low>(mid1.partial, a.partial)
+    let (sum_, overflow_) =
+      mid1.carry.addingReportingOverflow(mid2.partial)
     let high =
-      DoubleWidth(High(mid2.carry + d.carry), mid1.carry + mid2.partial)
+      DoubleWidth(High(mid2.carry + d.carry + (overflow_ ? 1 : 0)), sum_)
 
     if isNegative {
       let (lowComplement, overflow) = (~low).addingReportingOverflow(1)
@@ -631,10 +633,14 @@ extension DoubleWidth : UnsignedInteger where Base : UnsignedInteger {
   ) -> (quotient: Low, remainder: Magnitude) {
     // The following invariants are guaranteed to hold by dividingFullWidth or
     // quotientAndRemainder before this method is invoked:
-    assert(lhs.high != (0 as Low))
     assert(rhs.leadingZeroBitCount == 0)
     assert(Magnitude(lhs.high, lhs.mid) < rhs)
 
+    guard lhs.high != (0 as Low) else {
+      let lhs_ = Magnitude(lhs.mid, lhs.low)
+      return lhs_ < rhs ? (0, lhs_) : (1, lhs_ &- rhs)
+    }
+
     // Estimate the quotient.
     var quotient = lhs.high == rhs.high
       ? Low.max
@@ -735,8 +741,10 @@ extension DoubleWidth : UnsignedInteger where Base : UnsignedInteger {
 
     // Left shift both rhs and lhs, then divide and right shift the remainder.
     let shift = rhs.leadingZeroBitCount
+    // Note the use of `>>` instead of `&>>` below,
+    // as `high` should be zero if `shift` is zero.
+    let high = (lhs >> (Magnitude.bitWidth &- shift)).low
     let rhs = rhs &<< shift
-    let high = (lhs &>> (Magnitude.bitWidth &- shift)).low
     let lhs = lhs &<< shift
     let (quotient, remainder) =
       Magnitude._divide((high, lhs.high, lhs.low), by: rhs)

Tests/IntegerUtilitiesTests/DoubleWidthTests.swift

@@ -129,6 +129,34 @@ final class DoubleWidthTests: XCTestCase {
 
     XCTAssertEqual(x % 3, 1)
     XCTAssertEqual(x % y, x)
+
+    do {
+      let lhs = _UInt16((high: 0b0011_0000, low: 0))
+      let rhs = _UInt16((high: 0b0010_0000, low: 0))
+      XCTAssertEqual(lhs % rhs, 4096)
+    }
+    do {
+      let lhs = _UInt128((high: 0xa0c7d7165cf01386, low: 0xbf3f66a93056143f))
+      let rhs = _UInt128((high: 0x9ac3a19b1e7d6b83, low: 0x513929792d588736))
+      XCTAssertEqual(String(lhs % rhs), "7997221894243298914179865336050715913")
+    }
+    do {
+      let lhs = _UInt128((high: 0xea8a9116b7af33b7, low: 0x3d9d6779ddd22ca3))
+      let rhs = _UInt128((high: 0xc3673efc7f1f37cc, low: 0x312f661057d0ba94))
+      XCTAssertEqual(String(lhs % rhs), "52023287460685389410162512181093036559")
+    }
+    do {
+      let lhs = _UInt256("2369676578372158364766242369061213561181961479062237766620")!
+      let rhs = _UInt256("102797312405202436815976773795958969482")!
+      XCTAssertEqual(String(lhs / rhs), "23051931251193218442")
+    }
+    do {
+      let lhs = _UInt256("96467201117289166187766181030232879447148862859323917044548749804018359008044")!
+      let rhs = _UInt256("4646260627574879223760172113656436161581617773435991717024")!
+      XCTAssertEqual(String(lhs / rhs), "20762331011904583253")
+    }
+    
+    XCTAssertTrue((0xff01 as _UInt16).multipliedFullWidth(by: 0x101) == (high: 256, low: 1))
   }
 
   func testArithmetic_Signed() {