Implement bit testing and bit setting.

objecthub · objecthub · commit f5993eb65695 · 2018-01-23T22:55:38.000-08:00
diff --git a/Sources/NumberKit/BigInt.swift b/Sources/NumberKit/BigInt.swift
@@ -623,44 +623,39 @@ public struct BigInt: Hashable,
     return self.negate.minus(BigInt.one)
   }
   
-  /// Computes the two complement for the given words.
-  private static func twoComplement(_ words: inout ContiguousArray<UInt32>) {
-    var carry = true
-    for i in words.indices {
-      if carry {
-        (words[i], carry) = (~words[i]).addingReportingOverflow(1)
-      } else {
-        words[i] = ~words[i]
-      }
-    }
+  /// Returns true if the most significant bit is set in the number represented by `words`.
+  private static func isMostSignificantBitSet(_ words: ContiguousArray<UInt32>) -> Bool {
+    return (words.last! & (1 << (UInt32.bitWidth - 1))) != 0
   }
   
-  /// Creates a `BigInt` number from a number representation in two-complement form.
+  /// Creates a `BigInt` number from a number represented by `words` in two-complement form.
   private static func fromTwoComplement(_ words: inout ContiguousArray<UInt32>) -> BigInt {
-    if BigInt.positiveTwoComplement(words) {
-      return BigInt(words: words, negative: false)
-    } else {
-      BigInt.twoComplement(&words)
+    if BigInt.isMostSignificantBitSet(words) {
+      var carry = true
+      for i in words.indices {
+        if carry {
+          (words[i], carry) = (~words[i]).addingReportingOverflow(1)
+        } else {
+          words[i] = ~words[i]
+        }
+      }
       return BigInt(words: words, negative: true)
+    } else {
+      return BigInt(words: words, negative: false)
     }
   }
   
-  /// Determines if this is a positive number assuming a two-complement format of the
-  /// words representing a number.
-  private static func positiveTwoComplement(_ words: ContiguousArray<UInt32>) -> Bool {
-    return (words.last! & (1 << (UInt32.bitWidth - 1))) == 0
-  }
-  
-  /// Computes the maximum size needed for applying bit operations to two numbers in
-  /// two-complement representation.
+  /// Computes the minimum number of words needed for applying bit operations to two
+  /// numbers in two-complement representation. `left` and `right` are representing the
+  /// magnitude of those two numbers.
   private static func twoComplementSize(_ left: ContiguousArray<UInt32>,
                                         _ right: ContiguousArray<UInt32>) -> Int {
-    return Swift.max(left.count + (BigInt.positiveTwoComplement(left) ? 0 : 1),
-                     right.count + (BigInt.positiveTwoComplement(right) ? 0 : 1))
+    return Swift.max(left.count + (BigInt.isMostSignificantBitSet(left) ? 1 : 0),
+                     right.count + (BigInt.isMostSignificantBitSet(right) ? 1 : 0))
   }
   
-  /// Computes the bitwise `and` between this value and `rhs`.
-  /// The resulting number is negative if both operands are negative.
+  /// Computes the bitwise `and` between this value and `rhs` assuming a
+  /// representation of the numbers in two-complement form.
   public func and(_ rhs: BigInt) -> BigInt {
     var (leftcarry, rightcarry) = (true, true)
     let size = BigInt.twoComplementSize(self.uwords, rhs.uwords)
@@ -688,8 +683,8 @@ public struct BigInt: Hashable,
     return BigInt.fromTwoComplement(&res)
   }
   
-  /// Computes the bitwise `or` (inclusive or) between this value and `rhs`.
-  /// The resulting number is negative if one of the two operands is negative.
+  /// Computes the bitwise `or` (inclusive or) between this value and `rhs` assuming a
+  /// representation of the numbers in two-complement form.
   public func or(_ rhs: BigInt) -> BigInt {
     var (leftcarry, rightcarry) = (true, true)
     let size = BigInt.twoComplementSize(self.uwords, rhs.uwords)
@@ -717,8 +712,8 @@ public struct BigInt: Hashable,
     return BigInt.fromTwoComplement(&res)
   }
   
-  /// Computes the bitwise `xor` (exclusive or) between this value and `rhs`.
-  /// The resulting number is negative if one of the two operands is negative.
+  /// Computes the bitwise `xor` (exclusive or) between this value and `rhs` assuming a
+  /// representation of the numbers in two-complement form.
   public func xor(_ rhs: BigInt) -> BigInt {
     var (leftcarry, rightcarry) = (true, true)
     let size = BigInt.twoComplementSize(self.uwords, rhs.uwords)
@@ -747,8 +742,7 @@ public struct BigInt: Hashable,
   }
   
   /// Shifts the bits in this `BigInt` to the left if `n` is positive, or to the right
-  /// if `n` is negative. Bits are shifted as if this `BigInt` is an unsigned number.
-  /// The sign gets preserved.
+  /// if `n` is negative. This is an arithmetic shift operation.
   public func shift(_ n: Int) -> BigInt {
     if n < 0 {
       return self.shiftRight(-n)
@@ -791,15 +785,21 @@ public struct BigInt: Hashable,
       carry = word << (UInt32.bitWidth - sbits)
       i -= 1
     }
-    return BigInt(words: ContiguousArray<UInt32>(res.reversed()), negative: self.negative)
+    let x = BigInt(words: ContiguousArray<UInt32>(res.reversed()), negative: self.negative)
+    if self.negative && carry > 0 {
+      return x.minus(BigInt.one)
+    } else {
+      return x
+    }
   }
   
   /// Number of bits used to represent the (unsigned) `BigInt` number.
   public var bitSize: Int {
     return self.uwords.count * UInt32.bitWidth
   }
   
-  /// Number of bits set in this `BigInt` number. For negative numbers, `bigCount` returns
+  /// Number of bits set in this `BigInt` number. For negative numbers, `n.bigCount` returns
+  /// `~n.not.bigCount`.
   public var bitCount: Int {
     if self.negative {
       return ~self.not.bitCount
@@ -812,31 +812,97 @@ public struct BigInt: Hashable,
     }
   }
   
-  /// Returns the number of trailing zero bits ignoring the sign.
-  public var trailingZeroBits: Int {
+  /// Returns the first bit that is set in the two-complement form of this number. For zero,
+  /// `firstBitSet` will be -1.
+  public var firstBitSet: Int {
     guard !self.isZero else {
-      return 0
+      return -1
     }
     var i = 0
-    while i < self.uwords.count && self.uwords[i] == 0 {
+    var carry = true
+    while i < self.uwords.count {
+      var word = self.uwords[i]
+      if self.negative {
+        if carry {
+          (word, carry) = (~word).addingReportingOverflow(1)
+        } else {
+          word = ~word
+        }
+      }
+      if word != 0 {
+        return i * UInt32.bitWidth + word.trailingZeroBitCount
+      }
       i += 1
     }
-    return i < self.uwords.count ? i * UInt32.bitWidth + self.uwords[i].trailingZeroBitCount
-                                 : i * UInt32.bitWidth
+    return i * UInt32.bitWidth
   }
   
-  /// Returns the number of leading zero bits ignoring the sign.
-  public var leadingZeroBits: Int {
+  /// Returns true if bit `n` is set
+  public func isBitSet(_ n: Int) -> Bool {
     guard !self.isZero else {
-      return self.bitSize
+      return false
     }
-    var res = 0
-    var i = self.uwords.count - 1
-    while i >= 0 && self.uwords[i] == 0 {
-      i -= 1
-      res += UInt32.bitWidth
+    let nword = n / UInt32.bitWidth
+    let nbit = n % UInt32.bitWidth
+    guard nword < self.uwords.count else {
+      return self.negative
+    }
+    guard self.negative else {
+      return (self.uwords[nword] & (1 << nbit)) != 0
+    }
+    var i = 0
+    var carry = true
+    var word: UInt32 = 0
+    while i <= nword {
+      word = self.uwords[i]
+      if self.negative {
+        if carry {
+          (word, carry) = (~word).addingReportingOverflow(1)
+        } else {
+          word = ~word
+        }
+      }
+      i += 1
+    }
+    return (word & (1 << nbit)) != 0
+  }
+  
+  /// Sets `bit` to the given value and returns the result as a new `BigInt` value.
+  /// `true` corresponds to 1, `false` corresponds to 0.
+  public func set(bit n: Int, to value: Bool) -> BigInt {
+    var words = self.uwords
+    let nword = n / UInt32.bitWidth
+    let nbit = n % UInt32.bitWidth
+    var i = words.count
+    while i <= nword {
+      words.append(0)
+      i += 1
+    }
+    guard self.negative else {
+      if value {
+        words[nword] |= 1 << nbit
+      } else {
+        words[nword] &= ~(1 << nbit)
+      }
+      return BigInt(words: words, negative: false)
+    }
+    if BigInt.isMostSignificantBitSet(words) {
+      words.append(0)
+    }
+    var carry = true
+    for i in words.indices {
+      if carry {
+        (words[i], carry) = (~words[i]).addingReportingOverflow(1)
+      } else {
+        words[i] = ~words[i]
+      }
+    }
+    if value {
+      words[nword] |= 1 << nbit
+    } else {
+      words[nword] &= ~(1 << nbit)
     }
-    return i >= 0 ? res + self.uwords[i].leadingZeroBitCount : res
+    return BigInt.fromTwoComplement(&words)
   }
 }
 
@@ -856,11 +922,10 @@ extension BigInt: IntegerNumber,
   /// Returns the number of bits used to represent this `BigInt` assuming a binary representation
   /// using the two-complement for negative numbers.
   public var bitWidth: Int {
-    return self.words.count * UInt32.bitWidth
+    return self.words.count * UInt.bitWidth
   }
   
-  /// Returns the number of trailing zero bits assuming a binary representation using the
-  /// two-complement for negative numbers.
+  /// Returns the number of trailing zero bits assuming a representation in two-complement form.
   public var trailingZeroBitCount: Int {
     let words = self.words
     var res = 0
@@ -872,8 +937,7 @@ extension BigInt: IntegerNumber,
     return i < words.count ? res + words[i].trailingZeroBitCount : res
   }
   
-  /// Returns the number of leading zero bits assuming a binary representation using the
-  /// two-complement for negative numbers.
+  /// Returns the number of leading zero bits assuming a representation in two-complement form.
   public var leadingZeroBitCount: Int {
     let words = self.words
     var res = 0
diff --git a/Tests/NumberKitTests/BigIntTests.swift b/Tests/NumberKitTests/BigIntTests.swift
@@ -194,6 +194,31 @@ class BigIntTests: XCTestCase {
     XCTAssertEqual(x5 >> 1, x5 / 2)
     let x6: BigInt = "98724897408742085724085724524524524524524522454525245999098037580357603865"
     XCTAssertEqual(x6 >> 5, x6 / 32)
+    let x7: BigInt = "-234245400000000001111"
+    let r7: BigInt = "-1830042187500000009"
+    XCTAssertEqual(x7 >> 7, r7)
+    let x8: BigInt = "-987248974087420857240857245245245245245245224545252459990980375803576038650"
+    let r8: BigInt = "-28732726760424582090952237056488091045910411763041410012839489378"
+    XCTAssertEqual(x8 >> 35, r8)
+    let x9: BigInt = "-1"
+    XCTAssertEqual(x9 >> 1, x9)
+    let x10: BigInt = "-2"
+    XCTAssertEqual(x10 >> 1, x9)
+    let x11: BigInt = "-3"
+    XCTAssertEqual(x11 >> 1, x10)
+    let x12: BigInt = "-4"
+    XCTAssertEqual(x12 >> 1, x10)
+    let x13: BigInt = "-100000000000000000000000000000000"
+    let r13: BigInt = "-79"
+    XCTAssertEqual(x13 >> 100, r13)
+    let r14: BigInt = "-126765060022822940149670320537600000000000000000000000000000000"
+    XCTAssertEqual(x13 << 100, r14)
+    let x15: BigInt = "-9872489740874208572408572"
+    let r15: BigInt = "-1356864658148807688588085270081961984"
+    XCTAssertEqual(x15 << 37, r15)
+    let x16: BigInt = "-111308731087301939383033999999"
+    let r16: BigInt = "-131410155234356299897170703642124868710991004696576"
+    XCTAssertEqual(x16 << 70, r16)
   }
   
   func testBitCount() {
@@ -222,12 +247,69 @@ class BigIntTests: XCTestCase {
   func testZeroBits() {
     let x0: BigInt = "170"
     XCTAssertEqual(x0.bitSize, 32)
-    XCTAssertEqual(x0.trailingZeroBits, 1)
-    XCTAssertEqual(x0.leadingZeroBits, 24)
+    XCTAssertEqual(x0.trailingZeroBitCount, 1)
+    XCTAssertEqual(x0.firstBitSet, 1)
     let x1: BigInt = "4285720457200"
     XCTAssertEqual(x1.bitSize, 64)
-    XCTAssertEqual(x1.trailingZeroBits, 4)
-    XCTAssertEqual(x1.leadingZeroBits, 22)
+    XCTAssertEqual(x1.trailingZeroBitCount, 4)
+    XCTAssertEqual(x1.firstBitSet, 4)
+    let x2: BigInt = "-4"
+    XCTAssertEqual(x2.trailingZeroBitCount, 2)
+    XCTAssertEqual(x2.firstBitSet, 2)
+    let x3: BigInt = "81623247908021670355559786741760"
+    XCTAssertEqual(x3.trailingZeroBitCount, 74)
+    XCTAssertEqual(x3.firstBitSet, 74)
+    let x4: BigInt = "-157334116307980970279619537141760"
+    XCTAssertEqual(x4.trailingZeroBitCount, 74)
+    XCTAssertEqual(x4.firstBitSet, 74)
+    XCTAssertEqual(BigInt.zero.trailingZeroBitCount, BigInt.zero.bitWidth)
+    XCTAssertEqual(BigInt.zero.firstBitSet, -1)
+  }
+  
+  func testBitTest() {
+    let x0: BigInt = "2863311530"
+    for i in 0..<32 {
+      XCTAssertEqual(x0.isBitSet(i), i.isOdd)
+    }
+    XCTAssertEqual(x0.isBitSet(32), false)
+    XCTAssertEqual(x0.isBitSet(33), false)
+    XCTAssertEqual(x0.isBitSet(34), false)
+    XCTAssertEqual(x0.isBitSet(35), false)
+    let x1: BigInt = "64942224592110934030034938344746347339829000900128380"
+    let bits1: Set<Int> =
+      [2, 3, 4, 5, 6, 9, 10, 11, 13, 16, 17, 20, 22, 23, 24, 26, 27, 31, 33, 34, 35, 37,
+       38, 39, 41, 43, 44, 47, 48, 49, 50, 52, 54, 55, 59, 65, 68, 71, 72, 75, 77, 78,
+       79, 80, 82, 83, 84, 85, 87, 90, 91, 92, 94, 95, 100, 102, 103, 110, 111, 112,
+       113, 114, 123, 124, 127, 129, 130, 135, 136, 137, 138, 141, 142, 143, 145,
+       148, 149, 150, 151, 152, 154, 158, 160, 161, 164, 167, 168, 170, 171, 173, 175]
+    for i in 0..<300 {
+      XCTAssertEqual(x1.isBitSet(i), bits1.contains(i))
+    }
+    let x2: BigInt = "-1234567894257563210000294749382000039387453720000987383000032"
+    let zeros1: Set<Int> =
+      [0, 1, 2, 3, 4, 6, 7, 8, 9, 11, 13, 14, 15, 19, 20, 21, 23, 24, 27, 28, 32, 34, 35,
+       36, 37, 38, 40, 41, 42, 43, 44, 48, 49, 53, 58, 65, 66, 68, 71, 73, 75, 77, 79,
+       80, 81, 82, 85, 86, 88, 90, 92, 95, 96, 98, 99, 101, 102, 105, 106, 107, 108,
+       110, 111, 118, 121, 122, 123, 125, 130, 132, 135, 136, 139, 141, 144, 145,
+       146, 147, 150, 151, 154, 162, 163, 164, 165, 166, 167, 168, 169, 171, 172,
+       173, 177, 180, 183, 184, 186, 187, 189, 191, 194, 198, 199]
+    for i in 0..<400 {
+      XCTAssertEqual(x2.isBitSet(i), !zeros1.contains(i))
+    }
+  }
+  
+  func testBitSet() {
+    var x1 = BigInt.zero
+    for i in [2, 3, 4, 5, 6, 9, 10, 11, 13, 16, 17, 20, 22, 23, 24, 26, 27, 31, 33, 34, 35, 37,
+              38, 39, 41, 43, 44, 47, 48, 49, 50, 52, 54, 55, 59, 65, 68, 71, 72, 75, 77, 78,
+              79, 80, 82, 83, 84, 85, 87, 90, 91, 92, 94, 95, 100, 102, 103, 110, 111, 112,
+              113, 114, 123, 124, 127, 129, 130, 135, 136, 137, 138, 141, 142, 143, 145,
+              148, 149, 150, 151, 152, 154, 158, 160, 161, 164, 167, 168, 170, 171, 173, 175] {
+      x1 = x1.set(bit: i, to: true)
+    }
+    let y1: BigInt = "64942224592110934030034938344746347339829000900128380"
+    XCTAssertEqual(x1, y1)
+    XCTAssertEqual(x1.bitSize, y1.bitSize)
   }
   
   func testWords() {
