More tests and comments

Author: janmarthedal

src/bigint.rs

@@ -3259,9 +3259,9 @@ impl BigInt {
     /// uses the two's complement for negative numbers
     pub fn bit(&self, bit: u64) -> bool {
         // Let the binary representation of a number be
-        //   x 1 0 ... 0
+        //   ... 0  x 1 0 ... 0
         // Then the two's complement is
-        //  !x 1 0 ... 0
+        //   ... 1 !x 1 0 ... 0
         // where !x is obtained from x by flipping each bit
         let b = self.data.bit(bit);
         if self.is_negative() && bit > self.data.trailing_zeros().unwrap() {
@@ -3275,6 +3275,7 @@ impl BigInt {
         match self.sign {
             Sign::Plus => self.data.set_bit(bit, value),
             Sign::NoSign => {
+                // clearing a bit for zero is a no-op
                 if value {
                     self.data.set_bit(bit, true);
                     self.sign = Sign::Plus;
@@ -3283,25 +3284,28 @@ impl BigInt {
             Sign::Minus => {
                 let bits_per_digit = u64::from(big_digit::BITS);
                 if bit < bits_per_digit * self.len() as u64 {
-                    let digit_index = (bit / bits_per_digit) as usize;
+                    // This implementation corresponds to what the function `bitand_neg_pos` does when
+                    // value=false and what `bitor_neg_pos` does when value=true, except there is no
+                    // need to explicitly iterate over the digits of the right-hand side
+                    let bit_index = (bit / bits_per_digit) as usize;
                     let bit_mask = (1 as BigDigit) << (bit % bits_per_digit);
                     let mut carry_in = 1;
                     let mut carry_out = 1;
-                    for (i, d) in self.digits_mut().iter_mut().enumerate() {
-                        let twos_in = negate_carry(*d, &mut carry_in);
-                        let twos_out = if i != digit_index {
-                            // leave as-is
+                    for (index, digit) in self.digits_mut().iter_mut().enumerate() {
+                        let twos_in = negate_carry(*digit, &mut carry_in);
+                        let twos_out = if index != bit_index {
                             twos_in
                         } else if value {
-                            // set bit
                             twos_in | bit_mask
                         } else {
-                            // clear bit
                             twos_in & !bit_mask
                         };
-                        *d = negate_carry(twos_out, &mut carry_out);
+                        *digit = negate_carry(twos_out, &mut carry_out);
                     }
                 } else {
+                    // The bit to set/clear is outside the represented digits, and thus more significant
+                    // than the most significant bit of the current number. This corresponds to setting
+                    // the bit to the negated value (no-op for value=true)
                     if !value {
                         self.data.set_bit(bit, true);
                     }

tests/bigint.rs

@@ -1316,10 +1316,37 @@ fn test_bit() {
     assert!(BigInt::from(12u8).bit(2));
     assert!(BigInt::from(12u8).bit(3));
     assert!(!BigInt::from(12u8).bit(4));
+    assert!(!BigInt::from(12u8).bit(200));
     // -12 = (...110100)_2
     assert!(!BigInt::from(-12i8).bit(0));
     assert!(!BigInt::from(-12i8).bit(1));
     assert!(BigInt::from(-12i8).bit(2));
     assert!(!BigInt::from(-12i8).bit(3));
     assert!(BigInt::from(-12i8).bit(4));
+    assert!(BigInt::from(-12i8).bit(200));
+}
+
+#[test]
+fn test_set_bit() {
+    let mut x = BigInt::zero();
+    x.set_bit(200, true);
+    assert_eq!(x, BigInt::one() << 200);
+    x.set_bit(10, true);
+    x.set_bit(200, false);
+    assert_eq!(x, BigInt::one() << 10);
+    x.set_bit(10, false);
+    x.set_bit(5, false);
+    assert_eq!(x, BigInt::zero());
+
+    x = BigInt::from(-12i8);
+    x.set_bit(200, true);
+    assert_eq!(x, BigInt::from(-12i8));
+    x.set_bit(200, false);
+    assert_eq!(x, BigInt::from_biguint(Minus, BigUint::from(12u8) | (BigUint::one() << 200)));
+    x.set_bit(6, false);
+    assert_eq!(x, BigInt::from_biguint(Minus, BigUint::from(76u8) | (BigUint::one() << 200)));
+    x.set_bit(6, true);
+    assert_eq!(x, BigInt::from_biguint(Minus, BigUint::from(12u8) | (BigUint::one() << 200)));
+    x.set_bit(200, true);
+    assert_eq!(x, BigInt::from(-12i8));
 }

tests/biguint.rs

@@ -1828,4 +1828,7 @@ fn test_set_bit() {
     x.set_bit(128, false);
     x.set_bit(130, false);
     assert_eq!(x, (BigUint::from(2u8) << 128) | BigUint::from(2u8));
+    x.set_bit(129, false);
+    x.set_bit(1, false);
+    assert_eq!(x, BigUint::zero());
 }