Implement two-complement for BigInt.words and consider sign bit for BigInt.bitWidth.

Author: objecthub

Sources/NumberKit/BigInt.swift

@@ -722,13 +722,17 @@ extension BigInt: IntegerNumber,
   /// This is a signed type
   public static let isSigned: Bool = true
 
-  /// Returns the number of bits used to represent this `BigInt`.
+  /// Returns the number of bits used to represent this `BigInt`. This consists of the
+  /// words for representing the absolute value and one extra bit for representing the sign.
   public var bitWidth: Int {
-    return self.uwords.count * UInt32.bitWidth
+    return (self.uwords.count * UInt32.bitWidth) + 1
   }
 
   /// Returns the number of trailing zero bits in the representation of this `BigInt`.
   public var trailingZeroBitCount: Int {
+    guard !self.isZero else {
+      return self.bitWidth
+    }
     var i = 0
     while i < self.uwords.count && self.uwords[i] == 0 {
       i += 1
@@ -738,9 +742,8 @@ extension BigInt: IntegerNumber,
   }
 
   /// Returns the words in the binary representation of the magnitude of this number in the
-  /// format expected by Swift 4.
-  /// IMPORTANT: This might not return the expected result for negative numbers. Need to
-  /// figure out the exact spec first.
+  /// format expected by Swift 4, i.e. using the two-complement of the representation for
+  /// negative numbers.
   public var words: [UInt] {
     var res = [UInt]()
     res.reserveCapacity((self.uwords.count + 1) / 2)
@@ -752,6 +755,17 @@ extension BigInt: IntegerNumber,
       i += 1
       res.append(current | next)
     }
+    res.append(0)
+    if self.negative {
+      var addOne = true
+      for i in res.indices {
+        if addOne {
+          (res[i], addOne) = (~res[i]).addingReportingOverflow(1)
+        } else {
+          res[i] = ~res[i]
+        }
+      }
+    }
     return res
   }
 
@@ -839,7 +853,7 @@ extension BigInt: IntegerNumber,
   }
 
   public init(_ value: UInt) {
-    self.init(Int64(value))
+    self.init(UInt64(value))
   }
 
   public init(_ value: UInt8) {

Tests/NumberKitTests/BigIntTests.swift

@@ -146,6 +146,34 @@ class BigIntTests: XCTestCase {
     XCTAssertEqual(x6 >> 5, x6 / 32)
   }
 
+  func testWords() {
+    let x1: BigInt = "39998740587340080087986767562130873870358038157034635280980314708375001"
+    XCTAssertEqual(x1.words, [17444856893563336153,
+                              10071105391305811219,
+                              12534310513326413052,
+                              6372167008517,
+                              0])
+    let x2: BigInt = -x1
+    XCTAssertEqual(x2.words, [1001887180146215463,
+                              8375638682403740396,
+                              5912433560383138563,
+                              18446737701542543098,
+                              18446744073709551615])
+    let x3: BigInt = x1 >> 64
+    XCTAssertEqual(x3.words, [10071105391305811219,
+                              12534310513326413052,
+                              6372167008517,
+                              0])
+    let x4: BigInt = BigInt(UInt.max)
+    XCTAssertEqual(x4.words, [18446744073709551615, 0])
+    let x5: BigInt = -x4
+    XCTAssertEqual(x5.words, [1,18446744073709551615])
+    let x6: BigInt = -x5
+    XCTAssertEqual(x6.words, [18446744073709551615, 0])
+    let x7: BigInt = BigInt(UInt.max) + 1
+    XCTAssertEqual(x7.words, [0, 1, 0])
+  }
+  
   func testDescription() {
     let x1s = "1234"
     let x1n = BigInt(stringLiteral: x1s)