[BigInt] Disable custom _Significand and Karatsuba multiplication.

Author: xwu

Sources/BigIntModule/BigInt._Significand.swift

@@ -9,6 +9,27 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if true
+extension BigInt {
+  /// The significand of a `BigInt` value, a nonempty collection of the
+  /// significant digits of that value's magnitude stored in words of type
+  /// `UInt`.
+  ///
+  /// The first element of the collection is the lowest word.
+  @usableFromInline
+  internal typealias _Significand = [UInt]
+}
+
+extension BigInt._Significand {
+  /// Creates a new significand with the given words.
+  @inlinable
+  internal init(_ low: UInt, _ rest: [UInt] = []) {
+    self = [low]
+    reserveCapacity(rest.count + 1)
+    insert(contentsOf: rest, at: 1)
+  }
+}
+#else
 extension BigInt {
   /// The significand of a `BigInt` value, a nonempty collection of the
   /// significant digits of that value's magnitude stored in words of type
@@ -26,13 +47,6 @@ extension BigInt {
     /// highest.
     @usableFromInline
     internal var _rest: [UInt]
-    
-    /// Creates a new significand with a single low word equal to zero.
-    @inlinable
-    internal init() {
-      _low = 0
-      _rest = []
-    }
 
     /// Creates a new significand with the given words.
     @inlinable
@@ -417,6 +431,7 @@ extension BigInt._Significand {
 }
 
 extension BigInt._Significand: Hashable { }
+#endif
 
 /// Nota bene:
 /// While operations implemented on `BigInt` expect inputs that are normalized
@@ -595,7 +610,7 @@ extension BigInt._Significand {
 
   // @inlinable
   internal func multiplying(by other: Self) -> Self {
-    var result = Self()
+    var result = Self(0)
     result.reserveCapacity(count + other.count)
     for i in 0..<other.count {
       var temporary = self
@@ -609,25 +624,25 @@ extension BigInt._Significand {
   // words) of the lower half of each operand.
   // @inlinable
   internal func multiplying(by other: Self, karatsubaThreshold: Int) -> Self {
-    func add(_ lhs: Slice<Self>, _ rhs: Slice<Self>) -> Self {
+    func add(_ lhs: SubSequence, _ rhs: SubSequence) -> Self {
       // Recall that we have a precondition for `Self<C: Collection>(_: C)` that
       // the argument not be empty.
-      if lhs.isEmpty { return rhs.isEmpty ? Self() : Self(rhs) }
+      if lhs.isEmpty { return rhs.isEmpty ? Self(0) : Self(rhs) }
       if rhs.isEmpty { return Self(lhs) }
 
       var result = Self(lhs)
       result.add(Self(rhs))
       return result
     }
 
-    func multiply(_ lhs: Slice<Self>, _ rhs: Slice<Self>) -> Self {
+    func multiply(_ lhs: SubSequence, _ rhs: SubSequence) -> Self {
 
       // Based on Karatsuba's method. For details see:
       // <https://mathworld.wolfram.com/KaratsubaMultiplication.html>.
 
       let m = (Swift.max(lhs.count, rhs.count) + 1) / 2
       guard m >= karatsubaThreshold else {
-        if lhs.isEmpty || rhs.isEmpty { return Self() }
+        if lhs.isEmpty || rhs.isEmpty { return Self(0) }
         return Self(lhs).multiplying(by: Self(rhs))
       }
 
@@ -655,7 +670,7 @@ extension BigInt._Significand {
   @inlinable
   @discardableResult
   internal mutating func divide(by other: UInt) -> /* remainder: */ Self {
-    if other == 1 { return Self() }
+    if other == 1 { return Self(0) }
     var remainder = 0 as UInt
     for i in (0..<count).reversed() {
       (self[i], remainder) = other.dividingFullWidth((remainder, self[i]))
@@ -706,11 +721,11 @@ extension BigInt._Significand {
       other.removeLast(n &- (i &+ 1))
       n = i &+ 1
     }
-    guard n > 1 else { return divide(by: other._low) }
+    guard n > 1 else { return divide(by: other[0]) }
     let clz = other[n &- 1].leadingZeroBitCount
 
     var m = count - n
-    guard let j = lastIndex(where: { $0 != 0 }) else { return Self() }
+    guard let j = lastIndex(where: { $0 != 0 }) else { return Self(0) }
     if m > j &+ 1 {
       removeLast(m &- (j &+ 1))
       m = j &+ 1

Sources/BigIntModule/BigInt.swift

@@ -91,7 +91,7 @@ public struct BigInt {
   internal mutating func _normalize() {
     guard let i = _significand.firstIndex(where: { $0 != 0 }) else {
       _combination = 0
-      _significand = _Significand()
+      _significand = _Significand(0)
       return
     }
     assert(_combination != 0)
@@ -163,7 +163,7 @@ extension BigInt: AdditiveArithmetic {
   @inlinable
   public init() {
     _combination = 0
-    _significand = _Significand()
+    _significand = _Significand(0)
   }
 
   @inlinable
@@ -275,7 +275,7 @@ extension BigInt: SignedNumeric {
     let combination =
       lhs._signum * rhs._signum * (lhs._exponent + rhs._exponent + 1)
     let significand =
-      lhs._significand.multiplying(by: rhs._significand, karatsubaThreshold: 8)
+      lhs._significand.multiplying(by: rhs._significand /*, karatsubaThreshold: 8 */)
     var result = BigInt(_combination: combination, significand: significand)
     result._normalize()
     return result
@@ -451,7 +451,7 @@ extension BigInt: BinaryInteger {
       var result = lhs._significand.divide(by: rhs._significand)
       swap(&result, &lhs._significand)
     } else {
-      lhs._significand = _Significand()
+      lhs._significand = _Significand(0)
     }
     lhs._normalize()
   }
@@ -682,7 +682,7 @@ extension BigInt {
     let signum = Int(bitPattern: words.last!) < 0 ? -1 : 1
     guard let exponent = words.firstIndex(where: { $0 != 0 }) else {
       _combination = 0
-      _significand = _Significand()
+      _significand = _Significand(0)
       return
     }
     _combination = signum * (exponent + 1)