diff --git a/ci/big_quickcheck/src/lib.rs b/ci/big_quickcheck/src/lib.rs index e5768ed1..36d52877 100644 --- a/ci/big_quickcheck/src/lib.rs +++ b/ci/big_quickcheck/src/lib.rs @@ -357,18 +357,3 @@ fn quickcheck_modpow() { qc.quickcheck(test_modpow as fn(i128, u128, i128) -> TestResult); } - -#[test] -fn quickcheck_scalar_cmp() { - let gen = StdThreadGen::new(usize::max_value()); - let mut qc = QuickCheck::with_gen(gen); - - fn test_cmp(lhs: i64, rhs: i64) -> TestResult { - let correct = lhs.partial_cmp(&rhs); - let big_lhs = BigInt::from(lhs); - let res = big_lhs.partial_cmp(&rhs); - TestResult::from_bool(correct == res) - } - - qc.quickcheck(test_cmp as fn(i64, i64) -> TestResult); -} diff --git a/src/algorithms.rs b/src/algorithms.rs index 26c7aff3..a9b52144 100644 --- a/src/algorithms.rs +++ b/src/algorithms.rs @@ -811,16 +811,6 @@ fn biguint_shr2(n: Cow<'_, BigUint>, digits: usize, shift: u8) -> BigUint { biguint_from_vec(data) } -pub(crate) fn cmp_zero_padded_slice(mut a: &[BigDigit], mut b: &[BigDigit]) -> Ordering { - while let Some((&0, head)) = a.split_last() { - a = head; - } - while let Some((&0, head)) = b.split_last() { - b = head; - } - cmp_slice(a, b) -} - pub(crate) fn cmp_slice(a: &[BigDigit], b: &[BigDigit]) -> Ordering { debug_assert!(a.last() != Some(&0)); debug_assert!(b.last() != Some(&0)); @@ -854,29 +844,4 @@ mod algorithm_tests { assert_eq!(sub_sign_i(&a.data[..], &b.data[..]), &a_i - &b_i); assert_eq!(sub_sign_i(&b.data[..], &a.data[..]), &b_i - &a_i); } - - #[test] - fn test_cmp_zero_padded_slice() { - use super::cmp_zero_padded_slice; - use core::cmp::Ordering::*; - - assert_eq!(cmp_zero_padded_slice(&[1, 0], &[1]), Equal); - assert_eq!(cmp_zero_padded_slice(&[1], &[1, 0]), Equal); - - assert_eq!(cmp_zero_padded_slice(&[0], &[0]), Equal); - assert_eq!(cmp_zero_padded_slice(&[], &[0]), Equal); - assert_eq!(cmp_zero_padded_slice(&[0], &[]), Equal); - - assert_eq!(cmp_zero_padded_slice(&[1], &[0]), Greater); - assert_eq!(cmp_zero_padded_slice(&[1000], &[0]), Greater); - assert_eq!(cmp_zero_padded_slice(&[1000], &[0, 0, 0]), Greater); - assert_eq!(cmp_zero_padded_slice(&[1000, 0], &[0, 0, 0]), Greater); - assert_eq!(cmp_zero_padded_slice(&[0, 1000, 0], &[0, 1000]), Equal); - - assert_eq!(cmp_zero_padded_slice(&[0], &[1]), Less); - assert_eq!(cmp_zero_padded_slice(&[0], &[1000]), Less); - assert_eq!(cmp_zero_padded_slice(&[0, 0, 0], &[1000]), Less); - assert_eq!(cmp_zero_padded_slice(&[0, 0, 0], &[1000, 0]), Less); - assert_eq!(cmp_zero_padded_slice(&[0, 1000], &[0, 1000, 0]), Equal); - } } diff --git a/src/bigint.rs b/src/bigint.rs index f8fc172b..a78645e9 100644 --- a/src/bigint.rs +++ b/src/bigint.rs @@ -199,26 +199,6 @@ impl PartialOrd for BigInt { } } -fn sign(num: T) -> Sign -where - T: Ord + Zero, -{ - if num < T::zero() { - Sign::Minus - } else if num > T::zero() { - Sign::Plus - } else { - Sign::NoSign - } -} - -impl_partialord_partialeq_for_bigint!(i8, u8); -impl_partialord_partialeq_for_bigint!(i16, u16); -impl_partialord_partialeq_for_bigint!(i32, u32); -impl_partialord_partialeq_for_bigint!(i64, u64); -impl_partialord_partialeq_for_bigint!(i128, u128); -impl_partialord_partialeq_for_bigint!(isize, usize); - impl Ord for BigInt { #[inline] fn cmp(&self, other: &BigInt) -> Ordering { diff --git a/src/biguint.rs b/src/biguint.rs index c79a759c..bf348735 100644 --- a/src/biguint.rs +++ b/src/biguint.rs @@ -37,7 +37,7 @@ mod monty; use self::algorithms::{__add2, __sub2rev, add2, sub2, sub2rev}; use self::algorithms::{biguint_shl, biguint_shr}; -use self::algorithms::{cmp_slice, cmp_zero_padded_slice, fls, ilog2}; +use self::algorithms::{cmp_slice, fls, ilog2}; use self::algorithms::{div_rem, div_rem_digit, div_rem_ref, rem_digit}; use self::algorithms::{mac_with_carry, mul3, scalar_mul}; use self::monty::monty_modpow; @@ -118,54 +118,6 @@ impl Ord for BigUint { } } -impl_partialord_partialeq_for_biguint_below_digit!(u8); -impl_partialord_partialeq_for_biguint_below_digit!(u16); -impl_partialord_partialeq_for_biguint_below_digit!(u32); - -impl_scalar_partialeq!(impl PartialEq for BigUint); -impl_partialord_rev!(impl PartialOrd for BigUint); -impl PartialOrd for BigUint { - #[cfg(u64_digit)] - #[inline] - fn partial_cmp(&self, other: &u64) -> Option { - Some(cmp_zero_padded_slice(&self.data[..], &[*other])) - } - - #[cfg(not(u64_digit))] - #[inline] - fn partial_cmp(&self, other: &u64) -> Option { - let (hi, lo) = big_digit::from_doublebigdigit(*other); - Some(cmp_zero_padded_slice(&self.data[..], &[lo, hi])) - } -} - -impl_scalar_partialeq!(impl PartialEq for BigUint); -impl_partialord_rev!(impl PartialOrd for BigUint); -impl PartialOrd for BigUint { - #[cfg(u64_digit)] - #[inline] - fn partial_cmp(&self, other: &u128) -> Option { - let (hi, lo) = big_digit::from_doublebigdigit(*other); - Some(cmp_zero_padded_slice(&self.data[..], &[lo, hi])) - } - - #[cfg(not(u64_digit))] - #[inline] - fn partial_cmp(&self, other: &u128) -> Option { - let (a, b, c, d) = u32_from_u128(*other); - Some(cmp_zero_padded_slice(&self.data[..], &[d, c, b, a])) - } -} - -impl_scalar_partialeq!(impl PartialEq for BigUint); -impl_partialord_rev!(impl PartialOrd for BigUint); -impl PartialOrd for BigUint { - #[inline] - fn partial_cmp(&self, other: &usize) -> Option { - self.partial_cmp(&(*other as UsizePromotion)) - } -} - impl Default for BigUint { #[inline] fn default() -> BigUint { diff --git a/src/macros.rs b/src/macros.rs index f19e9c97..a03cb676 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -439,86 +439,3 @@ macro_rules! impl_product_iter_type { } }; } - -/// Implements PartialEq based on PartialOrd -macro_rules! impl_scalar_partialeq { - (impl PartialEq < $scalar:ty > for $res:ty) => { - impl PartialEq<$scalar> for $res { - #[inline] - fn eq(&self, other: &$scalar) -> bool { - match self.partial_cmp(other) { - Some(Equal) => true, - _ => false, - } - } - } - impl PartialEq<$res> for $scalar { - #[inline] - fn eq(&self, other: &$res) -> bool { - match self.partial_cmp(other) { - Some(Equal) => true, - _ => false, - } - } - } - }; -} - -macro_rules! impl_partialord_rev { - (impl PartialOrd < $scalar:ty > for $typ:ty) => { - impl PartialOrd<$typ> for $scalar { - #[inline] - fn partial_cmp(&self, other: &$typ) -> Option { - other.partial_cmp(self).map(Ordering::reverse) - } - } - }; -} - -macro_rules! impl_partialord_partialeq_for_biguint_below_digit { - ($typ_unsigned:ty) => { - impl_scalar_partialeq!(impl PartialEq<$typ_unsigned> for BigUint); - impl_partialord_rev!(impl PartialOrd<$typ_unsigned> for BigUint); - impl PartialOrd<$typ_unsigned> for BigUint { - #[inline] - fn partial_cmp(&self, other: &$typ_unsigned) -> Option { - Some(cmp_zero_padded_slice(&self.data[..], &[BigDigit::from(*other)])) - } - } - }; -} - -macro_rules! impl_partialord_partialeq_for_bigint { - ($typ_signed:ty, $typ_unsigned:ty) => { - impl_scalar_partialeq!(impl PartialEq<$typ_signed> for BigInt); - impl_partialord_rev!(impl PartialOrd<$typ_signed> for BigInt); - impl PartialOrd<$typ_signed> for BigInt { - #[inline] - fn partial_cmp(&self, other: &$typ_signed) -> Option { - let scmp = self.sign().cmp(&sign(*other)); - if scmp != Equal { - return Some(scmp); - } - - let abs: $typ_unsigned = other.unsigned_abs(); - match self.sign { - NoSign => Some(Equal), - Plus => self.data.partial_cmp(&abs), - Minus => abs.partial_cmp(&self.data), - } - } - } - - impl_scalar_partialeq!(impl PartialEq<$typ_unsigned> for BigInt); - impl_partialord_rev!(impl PartialOrd<$typ_unsigned> for BigInt); - impl PartialOrd<$typ_unsigned> for BigInt { - #[inline] - fn partial_cmp(&self, other: &$typ_unsigned) -> Option { - match self.sign { - Minus => Some(Less), - _ => self.data.partial_cmp(other), - } - } - } - }; -} diff --git a/tests/bigint.rs b/tests/bigint.rs index 9b3dd18e..72a43088 100644 --- a/tests/bigint.rs +++ b/tests/bigint.rs @@ -34,9 +34,7 @@ fn test_from_bytes_be() { check("AB", "16706"); check("Hello world!", "22405534230753963835153736737"); assert_eq!(BigInt::from_bytes_be(Plus, &[]), BigInt::zero()); - assert_eq!(BigInt::from_bytes_be(Plus, &[]), 0); assert_eq!(BigInt::from_bytes_be(Minus, &[]), BigInt::zero()); - assert_eq!(BigInt::from_bytes_be(Minus, &[]), 0); } #[test] @@ -1022,26 +1020,74 @@ fn test_lcm() { #[test] fn test_next_multiple_of() { - assert_eq!(BigInt::from(16).next_multiple_of(&BigInt::from(8)), 16); - assert_eq!(BigInt::from(23).next_multiple_of(&BigInt::from(8)), 24); - assert_eq!(BigInt::from(16).next_multiple_of(&BigInt::from(-8)), 16); - assert_eq!(BigInt::from(23).next_multiple_of(&BigInt::from(-8)), 16); - assert_eq!(BigInt::from(-16).next_multiple_of(&BigInt::from(8)), -16); - assert_eq!(BigInt::from(-23).next_multiple_of(&BigInt::from(8)), -16); - assert_eq!(BigInt::from(-16).next_multiple_of(&BigInt::from(-8)), -16); - assert_eq!(BigInt::from(-23).next_multiple_of(&BigInt::from(-8)), -24); + assert_eq!( + BigInt::from(16).next_multiple_of(&BigInt::from(8)), + BigInt::from(16) + ); + assert_eq!( + BigInt::from(23).next_multiple_of(&BigInt::from(8)), + BigInt::from(24) + ); + assert_eq!( + BigInt::from(16).next_multiple_of(&BigInt::from(-8)), + BigInt::from(16) + ); + assert_eq!( + BigInt::from(23).next_multiple_of(&BigInt::from(-8)), + BigInt::from(16) + ); + assert_eq!( + BigInt::from(-16).next_multiple_of(&BigInt::from(8)), + BigInt::from(-16) + ); + assert_eq!( + BigInt::from(-23).next_multiple_of(&BigInt::from(8)), + BigInt::from(-16) + ); + assert_eq!( + BigInt::from(-16).next_multiple_of(&BigInt::from(-8)), + BigInt::from(-16) + ); + assert_eq!( + BigInt::from(-23).next_multiple_of(&BigInt::from(-8)), + BigInt::from(-24) + ); } #[test] fn test_prev_multiple_of() { - assert_eq!(BigInt::from(16).prev_multiple_of(&BigInt::from(8)), 16); - assert_eq!(BigInt::from(23).prev_multiple_of(&BigInt::from(8)), 16); - assert_eq!(BigInt::from(16).prev_multiple_of(&BigInt::from(-8)), 16); - assert_eq!(BigInt::from(23).prev_multiple_of(&BigInt::from(-8)), 24); - assert_eq!(BigInt::from(-16).prev_multiple_of(&BigInt::from(8)), -16); - assert_eq!(BigInt::from(-23).prev_multiple_of(&BigInt::from(8)), -24); - assert_eq!(BigInt::from(-16).prev_multiple_of(&BigInt::from(-8)), -16); - assert_eq!(BigInt::from(-23).prev_multiple_of(&BigInt::from(-8)), -16); + assert_eq!( + BigInt::from(16).prev_multiple_of(&BigInt::from(8)), + BigInt::from(16) + ); + assert_eq!( + BigInt::from(23).prev_multiple_of(&BigInt::from(8)), + BigInt::from(16) + ); + assert_eq!( + BigInt::from(16).prev_multiple_of(&BigInt::from(-8)), + BigInt::from(16) + ); + assert_eq!( + BigInt::from(23).prev_multiple_of(&BigInt::from(-8)), + BigInt::from(24) + ); + assert_eq!( + BigInt::from(-16).prev_multiple_of(&BigInt::from(8)), + BigInt::from(-16) + ); + assert_eq!( + BigInt::from(-23).prev_multiple_of(&BigInt::from(8)), + BigInt::from(-24) + ); + assert_eq!( + BigInt::from(-16).prev_multiple_of(&BigInt::from(-8)), + BigInt::from(-16) + ); + assert_eq!( + BigInt::from(-23).prev_multiple_of(&BigInt::from(-8)), + BigInt::from(-16) + ); } #[test] diff --git a/tests/bigint_scalar.rs b/tests/bigint_scalar.rs index 5f0d111a..485f2c5b 100644 --- a/tests/bigint_scalar.rs +++ b/tests/bigint_scalar.rs @@ -1,8 +1,7 @@ use num_bigint::BigInt; use num_bigint::Sign::Plus; -use num_traits::{Bounded, Signed, ToPrimitive, Zero}; +use num_traits::{Signed, ToPrimitive, Zero}; -use std::cmp::Ordering; use std::ops::Neg; mod consts; @@ -94,7 +93,7 @@ fn test_scalar_div_rem() { if !r.is_zero() { assert_eq!(r.sign(), a.sign()); } - assert!(r.abs() <= b); + assert!(r.abs() <= BigInt::from(b)); assert!(*a == b * &q + &r); assert!(q == *ans_q); assert!(r == *ans_r); @@ -147,160 +146,3 @@ fn test_scalar_div_rem() { } } } - -#[test] -fn test_bigint_scalar_cmp() { - let m_five = BigInt::from(-5); - let m_one = BigInt::from(-1); - let zero = BigInt::from(0); - let one = BigInt::from(1); - let five = BigInt::from(5); - - fn cmp_asserts(big: &BigInt, scalar: i32) { - assert_eq!(big.partial_cmp(&(scalar as i8)), Some(Ordering::Equal)); - assert_eq!((scalar as i8).partial_cmp(big), Some(Ordering::Equal)); - assert_eq!( - big.partial_cmp(&(scalar as i8 - 1)), - Some(Ordering::Greater) - ); - assert_eq!((scalar as i8 + 1).partial_cmp(big), Some(Ordering::Greater)); - assert_eq!(big.partial_cmp(&(scalar as i8 + 1)), Some(Ordering::Less)); - assert_eq!((scalar as i8 - 1).partial_cmp(big), Some(Ordering::Less)); - - assert_eq!(big.partial_cmp(&(scalar as i16)), Some(Ordering::Equal)); - assert_eq!((scalar as i16).partial_cmp(big), Some(Ordering::Equal)); - assert_eq!( - big.partial_cmp(&(scalar as i16 - 1)), - Some(Ordering::Greater) - ); - assert_eq!( - (scalar as i16 + 1).partial_cmp(big), - Some(Ordering::Greater) - ); - assert_eq!(big.partial_cmp(&(scalar as i16 + 1)), Some(Ordering::Less)); - assert_eq!((scalar as i16 - 1).partial_cmp(big), Some(Ordering::Less)); - - assert_eq!(big.partial_cmp(&(scalar as i32)), Some(Ordering::Equal)); - assert_eq!((scalar as i32).partial_cmp(big), Some(Ordering::Equal)); - assert_eq!( - big.partial_cmp(&(scalar as i32 - 1)), - Some(Ordering::Greater) - ); - assert_eq!( - (scalar as i32 + 1).partial_cmp(big), - Some(Ordering::Greater) - ); - assert_eq!(big.partial_cmp(&(scalar as i32 + 1)), Some(Ordering::Less)); - assert_eq!((scalar as i32 - 1).partial_cmp(big), Some(Ordering::Less)); - - assert_eq!(big.partial_cmp(&(scalar as i64)), Some(Ordering::Equal)); - assert_eq!((scalar as i64).partial_cmp(big), Some(Ordering::Equal)); - assert_eq!( - big.partial_cmp(&(scalar as i64 - 1)), - Some(Ordering::Greater) - ); - assert_eq!( - (scalar as i64 + 1).partial_cmp(big), - Some(Ordering::Greater) - ); - assert_eq!(big.partial_cmp(&(scalar as i64 + 1)), Some(Ordering::Less)); - assert_eq!((scalar as i64 - 1).partial_cmp(big), Some(Ordering::Less)); - - assert_eq!(big.partial_cmp(&(scalar as i128)), Some(Ordering::Equal)); - assert_eq!((scalar as i128).partial_cmp(big), Some(Ordering::Equal)); - assert_eq!( - big.partial_cmp(&(scalar as i128 - 1)), - Some(Ordering::Greater) - ); - assert_eq!( - (scalar as i128 + 1).partial_cmp(big), - Some(Ordering::Greater) - ); - assert_eq!(big.partial_cmp(&(scalar as i128 + 1)), Some(Ordering::Less)); - assert_eq!((scalar as i128 - 1).partial_cmp(big), Some(Ordering::Less)); - - assert_eq!(big.partial_cmp(&(scalar as isize)), Some(Ordering::Equal)); - assert_eq!((scalar as isize).partial_cmp(big), Some(Ordering::Equal)); - assert_eq!( - big.partial_cmp(&(scalar as isize - 1)), - Some(Ordering::Greater) - ); - assert_eq!( - (scalar as isize + 1).partial_cmp(big), - Some(Ordering::Greater) - ); - assert_eq!( - big.partial_cmp(&(scalar as isize + 1)), - Some(Ordering::Less) - ); - assert_eq!((scalar as isize - 1).partial_cmp(big), Some(Ordering::Less)); - - assert_eq!((scalar as i8), *big); - assert_eq!(*big, (scalar as i16)); - assert_eq!((scalar as i16), *big); - assert_eq!(*big, (scalar as i32)); - assert_eq!((scalar as i32), *big); - assert_eq!(*big, (scalar as i64)); - assert_eq!((scalar as i64), *big); - assert_eq!(*big, (scalar as i128)); - assert_eq!((scalar as i128), *big); - assert_eq!(*big, (scalar as isize)); - assert_eq!((scalar as isize), *big); - - if scalar > 0 { - assert_eq!(*big, (scalar as u8)); - assert_eq!((scalar as u8), *big); - assert_eq!(*big, (scalar as u16)); - assert_eq!((scalar as u16), *big); - assert_eq!(*big, (scalar as u32)); - assert_eq!((scalar as u32), *big); - assert_eq!(*big, (scalar as u64)); - assert_eq!((scalar as u64), *big); - assert_eq!(*big, (scalar as u128)); - assert_eq!((scalar as u128), *big); - assert_eq!(*big, (scalar as usize)); - assert_eq!((scalar as usize), *big); - } - } - - cmp_asserts(&zero, 0i32); - cmp_asserts(&one, 1i32); - cmp_asserts(&five, 5i32); - cmp_asserts(&m_five, -5i32); - cmp_asserts(&m_one, -1i32); -} - -#[test] -fn test_bigint_scalar_cmp_limits() { - fn check() - where - T: Copy + Bounded, - BigInt: From + PartialOrd, - { - let min = T::min_value(); - let big_min = BigInt::from(min); - assert_eq!(big_min.partial_cmp(&min), Some(Ordering::Equal)); - assert_eq!((&big_min - 1u32).partial_cmp(&min), Some(Ordering::Less)); - assert_eq!((&big_min + 1u32).partial_cmp(&min), Some(Ordering::Greater)); - - let max = T::max_value(); - let big_max = BigInt::from(max); - assert_eq!(big_max.partial_cmp(&max), Some(Ordering::Equal)); - assert_eq!((&big_max - 1u32).partial_cmp(&max), Some(Ordering::Less)); - assert_eq!((&big_max + 1u32).partial_cmp(&max), Some(Ordering::Greater)); - } - - check::(); - check::(); - check::(); - check::(); - check::(); - check::(); - - check::(); - check::(); - check::(); - check::(); - check::(); - check::(); -} diff --git a/tests/biguint.rs b/tests/biguint.rs index 3e455e77..3f1a47d3 100644 --- a/tests/biguint.rs +++ b/tests/biguint.rs @@ -1055,11 +1055,11 @@ fn test_lcm() { fn test_next_multiple_of() { assert_eq!( BigUint::from(16u32).next_multiple_of(&BigUint::from(8u32)), - 16u32 + BigUint::from(16u32) ); assert_eq!( BigUint::from(23u32).next_multiple_of(&BigUint::from(8u32)), - 24u32 + BigUint::from(24u32) ); } @@ -1067,11 +1067,11 @@ fn test_next_multiple_of() { fn test_prev_multiple_of() { assert_eq!( BigUint::from(16u32).prev_multiple_of(&BigUint::from(8u32)), - 16u32 + BigUint::from(16u32) ); assert_eq!( BigUint::from(23u32).prev_multiple_of(&BigUint::from(8u32)), - 16u32 + BigUint::from(16u32) ); } diff --git a/tests/biguint_scalar.rs b/tests/biguint_scalar.rs index d280841a..b6eadd9e 100644 --- a/tests/biguint_scalar.rs +++ b/tests/biguint_scalar.rs @@ -66,8 +66,8 @@ fn test_scalar_mul() { #[test] fn test_scalar_rem_noncommutative() { - assert_eq!(5u8 % BigUint::from(7u8), 5u8); - assert_eq!(BigUint::from(5u8) % 7u8, 5u8); + assert_eq!(5u8 % BigUint::from(7u8), BigUint::from(5u8)); + assert_eq!(BigUint::from(5u8) % 7u8, BigUint::from(5u8)); } #[test] @@ -111,53 +111,3 @@ fn test_scalar_div_rem() { } } } - -#[test] -fn test_biguint_scalar_cmp() { - use std::cmp::Ordering::*; - - let zero = BigUint::from(0u32); - let one = BigUint::from(1u32); - let five = BigUint::from(5u32); - - fn scalar_cmp_asserts(num: &BigUint, scalar: i32) { - assert_eq!(num.partial_cmp(&(scalar as u8)), Some(Equal)); - assert_eq!((scalar as u8).partial_cmp(num), Some(Equal)); - assert_eq!((scalar as u8 + 1).partial_cmp(num), Some(Greater)); - assert_eq!(num.partial_cmp(&(scalar as u8 + 1)), Some(Less)); - - assert_eq!(num.partial_cmp(&(scalar as u16)), Some(Equal)); - assert_eq!((scalar as u16).partial_cmp(num), Some(Equal)); - assert_eq!((scalar as u16 + 1).partial_cmp(num), Some(Greater)); - assert_eq!(num.partial_cmp(&(scalar as u16 + 1)), Some(Less)); - - assert_eq!(num.partial_cmp(&(scalar as u32)), Some(Equal)); - assert_eq!((scalar as u32).partial_cmp(num), Some(Equal)); - assert_eq!((scalar as u32 + 1).partial_cmp(num), Some(Greater)); - assert_eq!(num.partial_cmp(&(scalar as u32 + 1)), Some(Less)); - - assert_eq!(num.partial_cmp(&(scalar as u64)), Some(Equal)); - assert_eq!((scalar as u64).partial_cmp(num), Some(Equal)); - assert_eq!((scalar as u64 + 1).partial_cmp(num), Some(Greater)); - assert_eq!(num.partial_cmp(&(scalar as u64 + 1)), Some(Less)); - - assert_eq!(num.partial_cmp(&(scalar as u128)), Some(Equal)); - assert_eq!((scalar as u128).partial_cmp(num), Some(Equal)); - assert_eq!((scalar as u128 + 1).partial_cmp(num), Some(Greater)); - assert_eq!(num.partial_cmp(&(scalar as u128 + 1)), Some(Less)); - - assert_eq!(num.partial_cmp(&(scalar as usize)), Some(Equal)); - assert_eq!((scalar as usize).partial_cmp(num), Some(Equal)); - assert_eq!((scalar as usize + 1).partial_cmp(num), Some(Greater)); - assert_eq!(num.partial_cmp(&(scalar as usize + 1)), Some(Less)); - } - - scalar_cmp_asserts(&zero, 0); - scalar_cmp_asserts(&one, 1); - scalar_cmp_asserts(&five, 5); - - let a = BigUint::from(10000000000u64); - assert_eq!(a.partial_cmp(&10000000000u64), Some(Equal)); - assert_eq!(a.partial_cmp(&1000000000u64), Some(Greater)); - assert_eq!(a.partial_cmp(&100000000000u64), Some(Less)); -}