Merge #134

134: Release 0.2.6 r=cuviper a=cuviper



Co-authored-by: Hactar <6060305+HactarCE@users.noreply.github.com>
Co-authored-by: Josh Stone <cuviper@gmail.com>

Cargo.toml

@@ -8,7 +8,7 @@ categories = [ "algorithms", "data-structures", "science" ]
 license = "MIT/Apache-2.0"
 name = "num-bigint"
 repository = "https://github.com/rust-num/num-bigint"
-version = "0.2.5"
+version = "0.2.6"
 readme = "README.md"
 build = "build.rs"
 

RELEASES.md

@@ -1,3 +1,11 @@
+# Release 0.2.6 (2020-01-27)
+
+- [Fix the promotion of negative `isize` in `BigInt` assign-ops][133].
+
+**Contributors**: @cuviper, @HactarCE
+
+[133]: https://github.com/rust-num/num-bigint/pull/133
+
 # Release 0.2.5 (2020-01-09)
 
 - [Updated the `autocfg` build dependency to 1.0][126].

src/macros.rs

@@ -344,7 +344,7 @@ macro_rules! promote_signed_scalars {
 macro_rules! promote_signed_scalars_assign {
     (impl $imp:ident for $res:ty, $method:ident) => {
         promote_scalars_assign!(impl $imp<i32> for $res, $method, i8, i16);
-        promote_scalars_assign!(impl $imp<UsizePromotion> for $res, $method, isize);
+        promote_scalars_assign!(impl $imp<IsizePromotion> for $res, $method, isize);
     }
 }
 

tests/bigint_scalar.rs

@@ -18,6 +18,7 @@ fn test_scalar_add() {
     fn check(x: &BigInt, y: &BigInt, z: &BigInt) {
         let (x, y, z) = (x.clone(), y.clone(), z.clone());
         assert_signed_scalar_op!(x + y == z);
+        assert_signed_scalar_assign_op!(x += y == z);
     }
 
     for elm in SUM_TRIPLES.iter() {
@@ -43,6 +44,7 @@ fn test_scalar_sub() {
     fn check(x: &BigInt, y: &BigInt, z: &BigInt) {
         let (x, y, z) = (x.clone(), y.clone(), z.clone());
         assert_signed_scalar_op!(x - y == z);
+        assert_signed_scalar_assign_op!(x -= y == z);
     }
 
     for elm in SUM_TRIPLES.iter() {
@@ -68,6 +70,7 @@ fn test_scalar_mul() {
     fn check(x: &BigInt, y: &BigInt, z: &BigInt) {
         let (x, y, z) = (x.clone(), y.clone(), z.clone());
         assert_signed_scalar_op!(x * y == z);
+        assert_signed_scalar_assign_op!(x *= y == z);
     }
 
     for elm in MUL_TRIPLES.iter() {
@@ -98,15 +101,18 @@ fn test_scalar_div_rem() {
         assert!(q == *ans_q);
         assert!(r == *ans_r);
 
+        let b = BigInt::from(b);
         let (a, b, ans_q, ans_r) = (a.clone(), b.clone(), ans_q.clone(), ans_r.clone());
-        assert_op!(a / b == ans_q);
-        assert_op!(a % b == ans_r);
-
-        if b <= i32::max_value() as u32 {
-            let nb = -(b as i32);
-            assert_op!(a / nb == -ans_q.clone());
-            assert_op!(a % nb == ans_r);
-        }
+        assert_signed_scalar_op!(a / b == ans_q);
+        assert_signed_scalar_op!(a % b == ans_r);
+        assert_signed_scalar_assign_op!(a /= b == ans_q);
+        assert_signed_scalar_assign_op!(a %= b == ans_r);
+
+        let nb = -b;
+        assert_signed_scalar_op!(a / nb == -ans_q.clone());
+        assert_signed_scalar_op!(a % nb == ans_r);
+        assert_signed_scalar_assign_op!(a /= nb == -ans_q.clone());
+        assert_signed_scalar_assign_op!(a %= nb == ans_r);
     }
 
     fn check(a: &BigInt, b: u32, q: &BigInt, r: &BigInt) {

tests/biguint_scalar.rs

@@ -15,6 +15,7 @@ fn test_scalar_add() {
     fn check(x: &BigUint, y: &BigUint, z: &BigUint) {
         let (x, y, z) = (x.clone(), y.clone(), z.clone());
         assert_unsigned_scalar_op!(x + y == z);
+        assert_unsigned_scalar_assign_op!(x += y == z);
     }
 
     for elm in SUM_TRIPLES.iter() {
@@ -33,6 +34,7 @@ fn test_scalar_sub() {
     fn check(x: &BigUint, y: &BigUint, z: &BigUint) {
         let (x, y, z) = (x.clone(), y.clone(), z.clone());
         assert_unsigned_scalar_op!(x - y == z);
+        assert_unsigned_scalar_assign_op!(x -= y == z);
     }
 
     for elm in SUM_TRIPLES.iter() {
@@ -51,6 +53,7 @@ fn test_scalar_mul() {
     fn check(x: &BigUint, y: &BigUint, z: &BigUint) {
         let (x, y, z) = (x.clone(), y.clone(), z.clone());
         assert_unsigned_scalar_op!(x * y == z);
+        assert_unsigned_scalar_assign_op!(x *= y == z);
     }
 
     for elm in MUL_TRIPLES.iter() {
@@ -76,6 +79,8 @@ fn test_scalar_div_rem() {
         let (x, y, z, r) = (x.clone(), y.clone(), z.clone(), r.clone());
         assert_unsigned_scalar_op!(x / y == z);
         assert_unsigned_scalar_op!(x % y == r);
+        assert_unsigned_scalar_assign_op!(x /= y == z);
+        assert_unsigned_scalar_assign_op!(x %= y == r);
     }
 
     for elm in MUL_TRIPLES.iter() {
@@ -104,6 +109,8 @@ fn test_scalar_div_rem() {
             check(&a, &b, &c, &d);
             assert_unsigned_scalar_op!(a / b == c);
             assert_unsigned_scalar_op!(a % b == d);
+            assert_unsigned_scalar_assign_op!(a /= b == c);
+            assert_unsigned_scalar_assign_op!(a %= b == d);
         }
     }
 }

tests/macros/mod.rs

@@ -68,3 +68,49 @@ macro_rules! assert_signed_scalar_op {
                           $left $op $right == $expected);
     };
 }
+
+/// Assert that an op works for scalar right
+macro_rules! assert_scalar_assign_op {
+    (($($to:ident),*) $left:ident $op:tt $right:ident == $expected:expr) => {
+        $(
+            if let Some(right) = $right.$to() {
+                let mut left = $left.clone();
+                assert_eq!({ left $op right; left}, $expected);
+            }
+        )*
+    };
+}
+
+#[cfg(not(has_i128))]
+macro_rules! assert_unsigned_scalar_assign_op {
+    ($left:ident $op:tt $right:ident == $expected:expr) => {
+        assert_scalar_assign_op!((to_u8, to_u16, to_u32, to_u64, to_usize)
+                                 $left $op $right == $expected);
+    };
+}
+
+#[cfg(has_i128)]
+macro_rules! assert_unsigned_scalar_assign_op {
+    ($left:ident $op:tt $right:ident == $expected:expr) => {
+        assert_scalar_assign_op!((to_u8, to_u16, to_u32, to_u64, to_usize, to_u128)
+                                 $left $op $right == $expected);
+    };
+}
+
+#[cfg(not(has_i128))]
+macro_rules! assert_signed_scalar_assign_op {
+    ($left:ident $op:tt $right:ident == $expected:expr) => {
+        assert_scalar_assign_op!((to_u8, to_u16, to_u32, to_u64, to_usize,
+                                  to_i8, to_i16, to_i32, to_i64, to_isize)
+                                 $left $op $right == $expected);
+    };
+}
+
+#[cfg(has_i128)]
+macro_rules! assert_signed_scalar_assign_op {
+    ($left:ident $op:tt $right:ident == $expected:expr) => {
+        assert_scalar_assign_op!((to_u8, to_u16, to_u32, to_u64, to_usize, to_u128,
+                                  to_i8, to_i16, to_i32, to_i64, to_isize, to_i128)
+                                 $left $op $right == $expected);
+    };
+}