[BigInt tests] 💀 Binary *, / and %

Tests/BigIntTests/BinaryMulTests.swift

@@ -0,0 +1,372 @@
+//===--- BinaryMulTests.swift ---------------------------------*- swift -*-===//
+//
+// This source file is part of the Swift Numerics open source project
+//
+// Copyright (c) 2023 Apple Inc. and the Swift Numerics project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
+
+// BinaryMulTests
+import XCTest
+@testable import BigIntModule
+
+// swiftlint:disable line_length
+// swiftlint:disable number_separator
+// swiftformat:disable numberFormatting
+
+private typealias Word = BigIntPrototype.Word
+
+private let intZero = Int.zero
+private let intMax = Int.max
+private let intMaxAsWord = Word(intMax.magnitude)
+
+/// `2^n = value`
+private typealias Pow2 = (value: Int, n: Int)
+
+private let powersOf2: [Pow2] = [
+  (value: 2, n: 1),
+  (value: 4, n: 2),
+  (value: 16, n: 4)
+]
+
+class BinaryMulTests: XCTestCase {
+
+  // MARK: - Int
+
+  func test_int_zero() {
+    let zero = BigInt()
+    let expected = BigInt()
+
+    for int in generateInts(approximateCount: 100) {
+      let big = BigInt(int)
+      XCTAssertEqual(zero * big, expected, "\(big)")
+      XCTAssertEqual(big * zero, expected, "\(big)")
+    }
+  }
+
+  func test_int_plus1() {
+    let one = BigInt(1)
+
+    for int in generateInts(approximateCount: 100) {
+      let big = BigInt(int)
+      let expected = BigInt(int)
+      XCTAssertEqual(one * big, expected, "\(big)")
+      XCTAssertEqual(big * one, expected, "\(big)")
+    }
+  }
+
+  func test_int_minus1() {
+    let minusOne = BigInt(-1)
+
+    for int in generateInts(approximateCount: 100) {
+      // '-Smi.min' overflows
+      if int == .min {
+        continue
+      }
+
+      let big = BigInt(int)
+      let expected = BigInt(-int)
+      XCTAssertEqual(minusOne * big, expected, "\(big)")
+      XCTAssertEqual(big * minusOne, expected, "\(big)")
+    }
+  }
+
+  func test_int_singleWord() {
+    let intWidth = Int.bitWidth
+    let ints = generateInts(approximateCount: 15)
+
+    for (a, b) in CartesianProduct(ints) {
+      let aPlus = a == .min ? nil : abs(a)
+      let bPlus = b == .min ? nil : abs(b)
+      let aMinus = a < 0 ? a : -a
+      let bMinus = b < 0 ? b : -b
+
+      let cases = [
+        (aPlus, bPlus), // a * b
+        (aPlus, bMinus), // a * (-b)
+        (aMinus, bPlus), // -a * b
+        (aMinus, bMinus) // -a * (-b)
+      ]
+
+      for (aInt, bInt) in cases {
+        guard let aInt = aInt, let bInt = bInt else { continue }
+
+        let aBig = BigInt(aInt)
+        let bBig = BigInt(bInt)
+
+        let (high, low) = aInt.multipliedFullWidth(by: bInt)
+        let expected = (BigInt(high) << intWidth) | BigInt(low)
+
+        XCTAssertEqual(aBig * bBig, expected, "\(aInt) * \(bInt)")
+        XCTAssertEqual(bBig * aBig, expected, "\(aInt) * \(bInt)")
+      }
+    }
+  }
+
+  func test_int_multipleWords() {
+    let bigWords: [Word] = [3689348814741910327, 2459565876494606880]
+    let int = BigInt(370955168)
+    let intNegative = -int
+
+    // Both positive
+    var big = BigInt(.positive, magnitude: bigWords)
+    var expected = BigInt(.positive, magnitude: [11068046445635360608, 1229782937530123449, 49460689])
+    XCTAssertEqual(big * int, expected)
+    XCTAssertEqual(int * big, expected)
+
+    // Self negative, other positive
+    big = BigInt(.negative, magnitude: bigWords)
+    expected = BigInt(.negative, magnitude: [11068046445635360608, 1229782937530123449, 49460689])
+    XCTAssertEqual(big * int, expected)
+    XCTAssertEqual(int * big, expected)
+
+    // Self positive, other negative
+    big = BigInt(.positive, magnitude: bigWords)
+    expected = BigInt(.negative, magnitude: [11068046445635360608, 1229782937530123449, 49460689])
+    XCTAssertEqual(big * intNegative, expected)
+    XCTAssertEqual(intNegative * big, expected)
+
+    // Both negative
+    big = BigInt(.negative, magnitude: bigWords)
+    expected = BigInt(.positive, magnitude: [11068046445635360608, 1229782937530123449, 49460689])
+    XCTAssertEqual(big * intNegative, expected)
+    XCTAssertEqual(intNegative * big, expected)
+  }
+
+  /// Multiply by a power of `2^n` (2, 4, 8) is the same as shift left by `n`
+  func test_int_powerOf2() {
+    for p in generateBigInts(approximateCount: 100) {
+      if p.isZero {
+        continue
+      }
+
+      for power in powersOf2 {
+        guard let p = self.cleanBitsSoItCanBeMultipliedWithoutOverflow(
+          value: p,
+          power: power
+        ) else { continue }
+
+        let big = p.create()
+        let powerBig = BigInt(power.value)
+
+        let expectedMagnitude = p.magnitude.map { $0 << power.n }
+        let expected = BigInt(p.sign, magnitude: expectedMagnitude)
+        XCTAssertEqual(big * powerBig, expected, "\(p) * \(power.value) (shift: \(power.n)")
+        XCTAssertEqual(powerBig * big, expected, "\(p) * \(power.value) (shift: \(power.n)")
+      }
+    }
+  }
+
+  private func cleanBitsSoItCanBeMultipliedWithoutOverflow(
+    value: BigIntPrototype,
+    power: Pow2
+  ) -> BigIntPrototype? {
+    // 1111 >> 1 = 0111
+    let mask = Word.max >> power.n
+    // Apply mask to every word
+    let magnitude = value.magnitude.map { $0 & mask }
+
+    // Zero may behave differently than other numbers
+    let allWordsZero = magnitude.allSatisfy { $0 == 0 }
+    if allWordsZero {
+      return nil
+    }
+
+    return BigIntPrototype(value.sign, magnitude: magnitude)
+  }
+
+  // MARK: - Big
+
+  func test_big_zero() {
+    let zero = BigInt()
+    let expected = BigInt()
+
+    for p in generateBigInts(approximateCount: 100) {
+      let big = p.create()
+      XCTAssertEqual(zero * big, expected, "\(big)")
+      XCTAssertEqual(big * zero, expected, "\(big)")
+    }
+  }
+
+  func test_big_plus1() {
+    let one = BigInt(1)
+
+    for p in generateBigInts(approximateCount: 100) {
+      let big = p.create()
+      let expected = p.create()
+      XCTAssertEqual(one * big, expected, "\(big)")
+      XCTAssertEqual(big * one, expected, "\(big)")
+    }
+  }
+
+  func test_big_minus1() {
+    let minusOne = BigInt(-1)
+
+    for p in generateBigInts(approximateCount: 100) {
+      let big = p.create()
+      let expected = p.isZero ? BigInt() : p.withOppositeSign.create()
+      XCTAssertEqual(minusOne * big, expected, "\(big)")
+      XCTAssertEqual(big * minusOne, expected, "\(big)")
+    }
+  }
+
+  /// Mul by `n^2` should shift left by `n`
+  func test_big_powerOf2() {
+    for p in generateBigInts(approximateCount: 100) {
+      if p.isZero {
+        continue
+      }
+
+      for power in powersOf2 {
+        guard let p = self.cleanBitsSoItCanBeMultipliedWithoutOverflow(value: p, power: power) else {
+          continue
+        }
+
+        let big = p.create()
+        let powerBig = BigInt(power.value)
+
+        let expectedMagnitude = p.magnitude.map { $0 << power.n }
+        let expected = BigInt(p.sign, magnitude: expectedMagnitude)
+        XCTAssertEqual(big * powerBig, expected, "\(p) * \(power.value) (shift: \(power.n)")
+        XCTAssertEqual(powerBig * big, expected, "\(p) * \(power.value) (shift: \(power.n)")
+      }
+    }
+  }
+
+  func test_big_singleWord_vs_multipleWords() {
+    let multiWords: [Word] = [3689348814741910327, 2459565876494606880]
+    let singleWords: [Word] = [1844674407370955168]
+    let expectedWords: [Word] = [
+      18077809192235360608, 16110156491039675065, 245956587649460688
+    ]
+
+    // Both positive
+    var multi = BigInt(.positive, magnitude: multiWords)
+    var single = BigInt(.positive, magnitude: singleWords)
+    var expected = BigInt(.positive, magnitude: expectedWords)
+    XCTAssertEqual(multi * single, expected)
+    XCTAssertEqual(single * multi, expected)
+
+    // Self negative, other positive
+    multi = BigInt(.negative, magnitude: multiWords)
+    single = BigInt(.positive, magnitude: singleWords)
+    expected = BigInt(.negative, magnitude: expectedWords)
+    XCTAssertEqual(multi * single, expected)
+    XCTAssertEqual(single * multi, expected)
+
+    // Self positive, other negative
+    multi = BigInt(.positive, magnitude: multiWords)
+    single = BigInt(.negative, magnitude: singleWords)
+    expected = BigInt(.negative, magnitude: expectedWords)
+    XCTAssertEqual(multi * single, expected)
+    XCTAssertEqual(single * multi, expected)
+
+    // Both negative
+    multi = BigInt(.negative, magnitude: multiWords)
+    single = BigInt(.negative, magnitude: singleWords)
+    expected = BigInt(.positive, magnitude: expectedWords)
+    XCTAssertEqual(multi * single, expected)
+    XCTAssertEqual(single * multi, expected)
+  }
+
+  func test_big_bothMultipleWords() {
+    let lhsWords: [Word] = [1844674407370955168, 4304240283865562048]
+    let rhsWords: [Word] = [3689348814741910327, 2459565876494606880]
+    let expectedWords: [Word] = [
+      18077809192235360608, 6640827866535438585, 11600952384132895787, 573898704515408272
+    ]
+
+    // Both positive
+    var lhs = BigInt(.positive, magnitude: lhsWords)
+    var rhs = BigInt(.positive, magnitude: rhsWords)
+    var expected = BigInt(.positive, magnitude: expectedWords)
+    XCTAssertEqual(lhs * rhs, expected)
+    XCTAssertEqual(rhs * lhs, expected)
+
+    // Self negative, other positive
+    lhs = BigInt(.negative, magnitude: lhsWords)
+    rhs = BigInt(.positive, magnitude: rhsWords)
+    expected = BigInt(.negative, magnitude: expectedWords)
+    XCTAssertEqual(lhs * rhs, expected)
+    XCTAssertEqual(rhs * lhs, expected)
+
+    // Self positive, other negative
+    lhs = BigInt(.positive, magnitude: lhsWords)
+    rhs = BigInt(.negative, magnitude: rhsWords)
+    expected = BigInt(.negative, magnitude: expectedWords)
+    XCTAssertEqual(lhs * rhs, expected)
+    XCTAssertEqual(rhs * lhs, expected)
+
+    // Both negative
+    lhs = BigInt(.negative, magnitude: lhsWords)
+    rhs = BigInt(.negative, magnitude: rhsWords)
+    expected = BigInt(.positive, magnitude: expectedWords)
+    XCTAssertEqual(lhs * rhs, expected)
+    XCTAssertEqual(rhs * lhs, expected)
+  }
+
+  // MARK: - Carry overflow
+
+  /// This proves that naive school algorithm will never overflow on 'carry'
+  /// (in sign + magnitude representation).
+  ///
+  /// Basically, it will `Word.max * Word.max` to get max possible carry,
+  /// then it will add it to another `Word.max * Word.max` and so on...
+  func test_big_carryOverflow() {
+    typealias Word = BigIntPrototype.Word
+
+    // Case 1
+    // lowIndex 0
+    //   high, low = 18446744073709551615 * 18446744073709551615 = 18446744073709551614 1
+    //   carry, result[i] = current[i] + low + current carry = 0 1 0 = 0 1
+    //   next carry = carry + high = 0 + 18446744073709551614 = 18446744073709551614
+    //
+    // lowIndex 1
+    //   high, low = 18446744073709551615 * 18446744073709551615 = 18446744073709551614 1
+    //   carry, result[i] = current[i] + low + current carry = 0 1 18446744073709551614 = 0 18446744073709551615
+    //   next carry = carry + high = 0 + 18446744073709551614 = 18446744073709551614
+    //   ^^^^^^^^^^ no overflow here!
+    do {
+      let lhs = BigInt(.positive, magnitude: [.max, .max, .max])
+      let rhs = BigInt(.positive, magnitude: [.max, .max])
+      XCTAssertNotNil(lhs * rhs)
+    }
+
+    // Case 2
+    // lowIndex 0
+    //   high, low = 18446744073709551615 * 18446744073709551614 = 18446744073709551613 2
+    //   carry, result[i] = current[i] + low + current carry = 0 2 0 = 0 2
+    //   next carry = carry + high = 0 + 18446744073709551613 = 18446744073709551613
+    //
+    // lowIndex 1
+    //   high, low = 18446744073709551615 * 18446744073709551615 = 18446744073709551614 1
+    //   carry, result[i] = current[i] + low + current carry = 0 1 18446744073709551613 = 0 18446744073709551614
+    //   next carry = carry + high = 0 + 18446744073709551614 = 18446744073709551614
+    //   ^^^^^^^^^^ no overflow here!
+    do {
+      let lhs = BigInt(.positive, magnitude: [.max, .max, .max])
+      let rhs = BigInt(.positive, magnitude: [.max - Word(1), .max])
+      XCTAssertNotNil(lhs * rhs)
+    }
+
+    // Case 3
+    // lowIndex 0
+    //   high, low = 18446744073709551615 * 18446744073709551615 = 18446744073709551614 1
+    //   carry, result[i] = current[i] + low + current carry = 0 1 0 = 0 1
+    //   next carry = carry + high = 0 + 18446744073709551614 = 18446744073709551614
+    //
+    // lowIndex 1
+    //   high, low = 18446744073709551615 * 18446744073709551614 = 18446744073709551613 2
+    //   carry, result[i] = current[i] + low + current carry = 0 2 18446744073709551614 = 1 0
+    //   next carry = carry + high = 1 + 18446744073709551613 = 18446744073709551614
+    //   ^^^^^^^^^^ no overflow here!
+    do {
+      let lhs = BigInt(.positive, magnitude: [.max, .max, .max])
+      let rhs = BigInt(.positive, magnitude: [.max, .max, Word(1)])
+      XCTAssertNotNil(lhs * rhs)
+    }
+  }
+}