| extern crate num_bigint; |
| extern crate num_integer; |
| extern crate num_traits; |
| |
| use num_bigint::Sign::Plus; |
| use num_bigint::{BigInt, ToBigInt}; |
| use num_bigint::{BigUint, ToBigUint}; |
| use num_integer::Integer; |
| |
| use std::cmp::Ordering::{Equal, Greater, Less}; |
| use std::collections::hash_map::RandomState; |
| use std::hash::{BuildHasher, Hash, Hasher}; |
| use std::i64; |
| use std::iter::repeat; |
| use std::str::FromStr; |
| use std::{f32, f64}; |
| #[cfg(has_i128)] |
| use std::{i128, u128}; |
| use std::{u16, u32, u64, u8, usize}; |
| |
| use num_traits::{ |
| CheckedAdd, CheckedDiv, CheckedMul, CheckedSub, Float, FromPrimitive, Num, One, Pow, |
| ToPrimitive, Zero, |
| }; |
| |
| mod consts; |
| use consts::*; |
| |
| #[macro_use] |
| mod macros; |
| |
| #[test] |
| fn test_from_bytes_be() { |
| fn check(s: &str, result: &str) { |
| assert_eq!( |
| BigUint::from_bytes_be(s.as_bytes()), |
| BigUint::parse_bytes(result.as_bytes(), 10).unwrap() |
| ); |
| } |
| check("A", "65"); |
| check("AA", "16705"); |
| check("AB", "16706"); |
| check("Hello world!", "22405534230753963835153736737"); |
| assert_eq!(BigUint::from_bytes_be(&[]), Zero::zero()); |
| } |
| |
| #[test] |
| fn test_to_bytes_be() { |
| fn check(s: &str, result: &str) { |
| let b = BigUint::parse_bytes(result.as_bytes(), 10).unwrap(); |
| assert_eq!(b.to_bytes_be(), s.as_bytes()); |
| } |
| check("A", "65"); |
| check("AA", "16705"); |
| check("AB", "16706"); |
| check("Hello world!", "22405534230753963835153736737"); |
| let b: BigUint = Zero::zero(); |
| assert_eq!(b.to_bytes_be(), [0]); |
| |
| // Test with leading/trailing zero bytes and a full BigDigit of value 0 |
| let b = BigUint::from_str_radix("00010000000000000200", 16).unwrap(); |
| assert_eq!(b.to_bytes_be(), [1, 0, 0, 0, 0, 0, 0, 2, 0]); |
| } |
| |
| #[test] |
| fn test_from_bytes_le() { |
| fn check(s: &str, result: &str) { |
| assert_eq!( |
| BigUint::from_bytes_le(s.as_bytes()), |
| BigUint::parse_bytes(result.as_bytes(), 10).unwrap() |
| ); |
| } |
| check("A", "65"); |
| check("AA", "16705"); |
| check("BA", "16706"); |
| check("!dlrow olleH", "22405534230753963835153736737"); |
| assert_eq!(BigUint::from_bytes_le(&[]), Zero::zero()); |
| } |
| |
| #[test] |
| fn test_to_bytes_le() { |
| fn check(s: &str, result: &str) { |
| let b = BigUint::parse_bytes(result.as_bytes(), 10).unwrap(); |
| assert_eq!(b.to_bytes_le(), s.as_bytes()); |
| } |
| check("A", "65"); |
| check("AA", "16705"); |
| check("BA", "16706"); |
| check("!dlrow olleH", "22405534230753963835153736737"); |
| let b: BigUint = Zero::zero(); |
| assert_eq!(b.to_bytes_le(), [0]); |
| |
| // Test with leading/trailing zero bytes and a full BigDigit of value 0 |
| let b = BigUint::from_str_radix("00010000000000000200", 16).unwrap(); |
| assert_eq!(b.to_bytes_le(), [0, 2, 0, 0, 0, 0, 0, 0, 1]); |
| } |
| |
| #[test] |
| fn test_cmp() { |
| let data: [&[_]; 7] = [&[], &[1], &[2], &[!0], &[0, 1], &[2, 1], &[1, 1, 1]]; |
| let data: Vec<BigUint> = data.iter().map(|v| BigUint::from_slice(*v)).collect(); |
| for (i, ni) in data.iter().enumerate() { |
| for (j0, nj) in data[i..].iter().enumerate() { |
| let j = j0 + i; |
| if i == j { |
| assert_eq!(ni.cmp(nj), Equal); |
| assert_eq!(nj.cmp(ni), Equal); |
| assert_eq!(ni, nj); |
| assert!(!(ni != nj)); |
| assert!(ni <= nj); |
| assert!(ni >= nj); |
| assert!(!(ni < nj)); |
| assert!(!(ni > nj)); |
| } else { |
| assert_eq!(ni.cmp(nj), Less); |
| assert_eq!(nj.cmp(ni), Greater); |
| |
| assert!(!(ni == nj)); |
| assert!(ni != nj); |
| |
| assert!(ni <= nj); |
| assert!(!(ni >= nj)); |
| assert!(ni < nj); |
| assert!(!(ni > nj)); |
| |
| assert!(!(nj <= ni)); |
| assert!(nj >= ni); |
| assert!(!(nj < ni)); |
| assert!(nj > ni); |
| } |
| } |
| } |
| } |
| |
| fn hash<T: Hash>(x: &T) -> u64 { |
| let mut hasher = <RandomState as BuildHasher>::Hasher::new(); |
| x.hash(&mut hasher); |
| hasher.finish() |
| } |
| |
| #[test] |
| fn test_hash() { |
| use hash; |
| |
| let a = BigUint::new(vec![]); |
| let b = BigUint::new(vec![0]); |
| let c = BigUint::new(vec![1]); |
| let d = BigUint::new(vec![1, 0, 0, 0, 0, 0]); |
| let e = BigUint::new(vec![0, 0, 0, 0, 0, 1]); |
| assert!(hash(&a) == hash(&b)); |
| assert!(hash(&b) != hash(&c)); |
| assert!(hash(&c) == hash(&d)); |
| assert!(hash(&d) != hash(&e)); |
| } |
| |
| // LEFT, RIGHT, AND, OR, XOR |
| const BIT_TESTS: &'static [( |
| &'static [u32], |
| &'static [u32], |
| &'static [u32], |
| &'static [u32], |
| &'static [u32], |
| )] = &[ |
| (&[], &[], &[], &[], &[]), |
| (&[1, 0, 1], &[1, 1], &[1], &[1, 1, 1], &[0, 1, 1]), |
| (&[1, 0, 1], &[0, 1, 1], &[0, 0, 1], &[1, 1, 1], &[1, 1]), |
| ( |
| &[268, 482, 17], |
| &[964, 54], |
| &[260, 34], |
| &[972, 502, 17], |
| &[712, 468, 17], |
| ), |
| ]; |
| |
| #[test] |
| fn test_bitand() { |
| for elm in BIT_TESTS { |
| let (a_vec, b_vec, c_vec, _, _) = *elm; |
| let a = BigUint::from_slice(a_vec); |
| let b = BigUint::from_slice(b_vec); |
| let c = BigUint::from_slice(c_vec); |
| |
| assert_op!(a & b == c); |
| assert_op!(b & a == c); |
| assert_assign_op!(a &= b == c); |
| assert_assign_op!(b &= a == c); |
| } |
| } |
| |
| #[test] |
| fn test_bitor() { |
| for elm in BIT_TESTS { |
| let (a_vec, b_vec, _, c_vec, _) = *elm; |
| let a = BigUint::from_slice(a_vec); |
| let b = BigUint::from_slice(b_vec); |
| let c = BigUint::from_slice(c_vec); |
| |
| assert_op!(a | b == c); |
| assert_op!(b | a == c); |
| assert_assign_op!(a |= b == c); |
| assert_assign_op!(b |= a == c); |
| } |
| } |
| |
| #[test] |
| fn test_bitxor() { |
| for elm in BIT_TESTS { |
| let (a_vec, b_vec, _, _, c_vec) = *elm; |
| let a = BigUint::from_slice(a_vec); |
| let b = BigUint::from_slice(b_vec); |
| let c = BigUint::from_slice(c_vec); |
| |
| assert_op!(a ^ b == c); |
| assert_op!(b ^ a == c); |
| assert_op!(a ^ c == b); |
| assert_op!(c ^ a == b); |
| assert_op!(b ^ c == a); |
| assert_op!(c ^ b == a); |
| assert_assign_op!(a ^= b == c); |
| assert_assign_op!(b ^= a == c); |
| assert_assign_op!(a ^= c == b); |
| assert_assign_op!(c ^= a == b); |
| assert_assign_op!(b ^= c == a); |
| assert_assign_op!(c ^= b == a); |
| } |
| } |
| |
| #[test] |
| fn test_shl() { |
| fn check(s: &str, shift: usize, ans: &str) { |
| let opt_biguint = BigUint::from_str_radix(s, 16).ok(); |
| let mut bu_assign = opt_biguint.unwrap(); |
| let bu = (bu_assign.clone() << shift).to_str_radix(16); |
| assert_eq!(bu, ans); |
| bu_assign <<= shift; |
| assert_eq!(bu_assign.to_str_radix(16), ans); |
| } |
| |
| check("0", 3, "0"); |
| check("1", 3, "8"); |
| |
| check( |
| "1\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0001\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0001", |
| 3, |
| "8\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0008\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0008", |
| ); |
| check( |
| "1\ |
| 0000\ |
| 0001\ |
| 0000\ |
| 0001", |
| 2, |
| "4\ |
| 0000\ |
| 0004\ |
| 0000\ |
| 0004", |
| ); |
| check( |
| "1\ |
| 0001\ |
| 0001", |
| 1, |
| "2\ |
| 0002\ |
| 0002", |
| ); |
| |
| check( |
| "\ |
| 4000\ |
| 0000\ |
| 0000\ |
| 0000", |
| 3, |
| "2\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0000", |
| ); |
| check( |
| "4000\ |
| 0000", |
| 2, |
| "1\ |
| 0000\ |
| 0000", |
| ); |
| check( |
| "4000", |
| 2, |
| "1\ |
| 0000", |
| ); |
| |
| check( |
| "4000\ |
| 0000\ |
| 0000\ |
| 0000", |
| 67, |
| "2\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0000", |
| ); |
| check( |
| "4000\ |
| 0000", |
| 35, |
| "2\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0000", |
| ); |
| check( |
| "4000", |
| 19, |
| "2\ |
| 0000\ |
| 0000", |
| ); |
| |
| check( |
| "fedc\ |
| ba98\ |
| 7654\ |
| 3210\ |
| fedc\ |
| ba98\ |
| 7654\ |
| 3210", |
| 4, |
| "f\ |
| edcb\ |
| a987\ |
| 6543\ |
| 210f\ |
| edcb\ |
| a987\ |
| 6543\ |
| 2100", |
| ); |
| check( |
| "88887777666655554444333322221111", |
| 16, |
| "888877776666555544443333222211110000", |
| ); |
| } |
| |
| #[test] |
| fn test_shr() { |
| fn check(s: &str, shift: usize, ans: &str) { |
| let opt_biguint = BigUint::from_str_radix(s, 16).ok(); |
| let mut bu_assign = opt_biguint.unwrap(); |
| let bu = (bu_assign.clone() >> shift).to_str_radix(16); |
| assert_eq!(bu, ans); |
| bu_assign >>= shift; |
| assert_eq!(bu_assign.to_str_radix(16), ans); |
| } |
| |
| check("0", 3, "0"); |
| check("f", 3, "1"); |
| |
| check( |
| "1\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0001\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0001", |
| 3, |
| "2000\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 2000\ |
| 0000\ |
| 0000\ |
| 0000", |
| ); |
| check( |
| "1\ |
| 0000\ |
| 0001\ |
| 0000\ |
| 0001", |
| 2, |
| "4000\ |
| 0000\ |
| 4000\ |
| 0000", |
| ); |
| check( |
| "1\ |
| 0001\ |
| 0001", |
| 1, |
| "8000\ |
| 8000", |
| ); |
| |
| check( |
| "2\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0001\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0001", |
| 67, |
| "4000\ |
| 0000\ |
| 0000\ |
| 0000", |
| ); |
| check( |
| "2\ |
| 0000\ |
| 0001\ |
| 0000\ |
| 0001", |
| 35, |
| "4000\ |
| 0000", |
| ); |
| check( |
| "2\ |
| 0001\ |
| 0001", |
| 19, |
| "4000", |
| ); |
| |
| check( |
| "1\ |
| 0000\ |
| 0000\ |
| 0000\ |
| 0000", |
| 1, |
| "8000\ |
| 0000\ |
| 0000\ |
| 0000", |
| ); |
| check( |
| "1\ |
| 0000\ |
| 0000", |
| 1, |
| "8000\ |
| 0000", |
| ); |
| check( |
| "1\ |
| 0000", |
| 1, |
| "8000", |
| ); |
| check( |
| "f\ |
| edcb\ |
| a987\ |
| 6543\ |
| 210f\ |
| edcb\ |
| a987\ |
| 6543\ |
| 2100", |
| 4, |
| "fedc\ |
| ba98\ |
| 7654\ |
| 3210\ |
| fedc\ |
| ba98\ |
| 7654\ |
| 3210", |
| ); |
| |
| check( |
| "888877776666555544443333222211110000", |
| 16, |
| "88887777666655554444333322221111", |
| ); |
| } |
| |
| // `DoubleBigDigit` size dependent |
| #[test] |
| fn test_convert_i64() { |
| fn check(b1: BigUint, i: i64) { |
| let b2: BigUint = FromPrimitive::from_i64(i).unwrap(); |
| assert_eq!(b1, b2); |
| assert_eq!(b1.to_i64().unwrap(), i); |
| } |
| |
| check(Zero::zero(), 0); |
| check(One::one(), 1); |
| check(i64::MAX.to_biguint().unwrap(), i64::MAX); |
| |
| check(BigUint::new(vec![]), 0); |
| check(BigUint::new(vec![1]), 1); |
| check(BigUint::new(vec![N1]), (1 << 32) - 1); |
| check(BigUint::new(vec![0, 1]), 1 << 32); |
| check(BigUint::new(vec![N1, N1 >> 1]), i64::MAX); |
| |
| assert_eq!(i64::MIN.to_biguint(), None); |
| assert_eq!(BigUint::new(vec![N1, N1]).to_i64(), None); |
| assert_eq!(BigUint::new(vec![0, 0, 1]).to_i64(), None); |
| assert_eq!(BigUint::new(vec![N1, N1, N1]).to_i64(), None); |
| } |
| |
| #[test] |
| #[cfg(has_i128)] |
| fn test_convert_i128() { |
| fn check(b1: BigUint, i: i128) { |
| let b2: BigUint = FromPrimitive::from_i128(i).unwrap(); |
| assert_eq!(b1, b2); |
| assert_eq!(b1.to_i128().unwrap(), i); |
| } |
| |
| check(Zero::zero(), 0); |
| check(One::one(), 1); |
| check(i128::MAX.to_biguint().unwrap(), i128::MAX); |
| |
| check(BigUint::new(vec![]), 0); |
| check(BigUint::new(vec![1]), 1); |
| check(BigUint::new(vec![N1]), (1 << 32) - 1); |
| check(BigUint::new(vec![0, 1]), 1 << 32); |
| check(BigUint::new(vec![N1, N1, N1, N1 >> 1]), i128::MAX); |
| |
| assert_eq!(i128::MIN.to_biguint(), None); |
| assert_eq!(BigUint::new(vec![N1, N1, N1, N1]).to_i128(), None); |
| assert_eq!(BigUint::new(vec![0, 0, 0, 0, 1]).to_i128(), None); |
| assert_eq!(BigUint::new(vec![N1, N1, N1, N1, N1]).to_i128(), None); |
| } |
| |
| // `DoubleBigDigit` size dependent |
| #[test] |
| fn test_convert_u64() { |
| fn check(b1: BigUint, u: u64) { |
| let b2: BigUint = FromPrimitive::from_u64(u).unwrap(); |
| assert_eq!(b1, b2); |
| assert_eq!(b1.to_u64().unwrap(), u); |
| } |
| |
| check(Zero::zero(), 0); |
| check(One::one(), 1); |
| check(u64::MIN.to_biguint().unwrap(), u64::MIN); |
| check(u64::MAX.to_biguint().unwrap(), u64::MAX); |
| |
| check(BigUint::new(vec![]), 0); |
| check(BigUint::new(vec![1]), 1); |
| check(BigUint::new(vec![N1]), (1 << 32) - 1); |
| check(BigUint::new(vec![0, 1]), 1 << 32); |
| check(BigUint::new(vec![N1, N1]), u64::MAX); |
| |
| assert_eq!(BigUint::new(vec![0, 0, 1]).to_u64(), None); |
| assert_eq!(BigUint::new(vec![N1, N1, N1]).to_u64(), None); |
| } |
| |
| #[test] |
| #[cfg(has_i128)] |
| fn test_convert_u128() { |
| fn check(b1: BigUint, u: u128) { |
| let b2: BigUint = FromPrimitive::from_u128(u).unwrap(); |
| assert_eq!(b1, b2); |
| assert_eq!(b1.to_u128().unwrap(), u); |
| } |
| |
| check(Zero::zero(), 0); |
| check(One::one(), 1); |
| check(u128::MIN.to_biguint().unwrap(), u128::MIN); |
| check(u128::MAX.to_biguint().unwrap(), u128::MAX); |
| |
| check(BigUint::new(vec![]), 0); |
| check(BigUint::new(vec![1]), 1); |
| check(BigUint::new(vec![N1]), (1 << 32) - 1); |
| check(BigUint::new(vec![0, 1]), 1 << 32); |
| check(BigUint::new(vec![N1, N1, N1, N1]), u128::MAX); |
| |
| assert_eq!(BigUint::new(vec![0, 0, 0, 0, 1]).to_u128(), None); |
| assert_eq!(BigUint::new(vec![N1, N1, N1, N1, N1]).to_u128(), None); |
| } |
| |
| #[test] |
| fn test_convert_f32() { |
| fn check(b1: &BigUint, f: f32) { |
| let b2 = BigUint::from_f32(f).unwrap(); |
| assert_eq!(b1, &b2); |
| assert_eq!(b1.to_f32().unwrap(), f); |
| } |
| |
| check(&BigUint::zero(), 0.0); |
| check(&BigUint::one(), 1.0); |
| check(&BigUint::from(u16::MAX), 2.0.powi(16) - 1.0); |
| check(&BigUint::from(1u64 << 32), 2.0.powi(32)); |
| check(&BigUint::from_slice(&[0, 0, 1]), 2.0.powi(64)); |
| check( |
| &((BigUint::one() << 100) + (BigUint::one() << 123)), |
| 2.0.powi(100) + 2.0.powi(123), |
| ); |
| check(&(BigUint::one() << 127), 2.0.powi(127)); |
| check(&(BigUint::from((1u64 << 24) - 1) << (128 - 24)), f32::MAX); |
| |
| // keeping all 24 digits with the bits at different offsets to the BigDigits |
| let x: u32 = 0b00000000101111011111011011011101; |
| let mut f = x as f32; |
| let mut b = BigUint::from(x); |
| for _ in 0..64 { |
| check(&b, f); |
| f *= 2.0; |
| b = b << 1; |
| } |
| |
| // this number when rounded to f64 then f32 isn't the same as when rounded straight to f32 |
| let n: u64 = 0b0000000000111111111111111111111111011111111111111111111111111111; |
| assert!((n as f64) as f32 != n as f32); |
| assert_eq!(BigUint::from(n).to_f32(), Some(n as f32)); |
| |
| // test rounding up with the bits at different offsets to the BigDigits |
| let mut f = ((1u64 << 25) - 1) as f32; |
| let mut b = BigUint::from(1u64 << 25); |
| for _ in 0..64 { |
| assert_eq!(b.to_f32(), Some(f)); |
| f *= 2.0; |
| b = b << 1; |
| } |
| |
| // rounding |
| assert_eq!(BigUint::from_f32(-1.0), None); |
| assert_eq!(BigUint::from_f32(-0.99999), Some(BigUint::zero())); |
| assert_eq!(BigUint::from_f32(-0.5), Some(BigUint::zero())); |
| assert_eq!(BigUint::from_f32(-0.0), Some(BigUint::zero())); |
| assert_eq!( |
| BigUint::from_f32(f32::MIN_POSITIVE / 2.0), |
| Some(BigUint::zero()) |
| ); |
| assert_eq!(BigUint::from_f32(f32::MIN_POSITIVE), Some(BigUint::zero())); |
| assert_eq!(BigUint::from_f32(0.5), Some(BigUint::zero())); |
| assert_eq!(BigUint::from_f32(0.99999), Some(BigUint::zero())); |
| assert_eq!(BigUint::from_f32(f32::consts::E), Some(BigUint::from(2u32))); |
| assert_eq!( |
| BigUint::from_f32(f32::consts::PI), |
| Some(BigUint::from(3u32)) |
| ); |
| |
| // special float values |
| assert_eq!(BigUint::from_f32(f32::NAN), None); |
| assert_eq!(BigUint::from_f32(f32::INFINITY), None); |
| assert_eq!(BigUint::from_f32(f32::NEG_INFINITY), None); |
| assert_eq!(BigUint::from_f32(f32::MIN), None); |
| |
| // largest BigUint that will round to a finite f32 value |
| let big_num = (BigUint::one() << 128) - BigUint::one() - (BigUint::one() << (128 - 25)); |
| assert_eq!(big_num.to_f32(), Some(f32::MAX)); |
| assert_eq!((big_num + BigUint::one()).to_f32(), None); |
| |
| assert_eq!(((BigUint::one() << 128) - BigUint::one()).to_f32(), None); |
| assert_eq!((BigUint::one() << 128).to_f32(), None); |
| } |
| |
| #[test] |
| fn test_convert_f64() { |
| fn check(b1: &BigUint, f: f64) { |
| let b2 = BigUint::from_f64(f).unwrap(); |
| assert_eq!(b1, &b2); |
| assert_eq!(b1.to_f64().unwrap(), f); |
| } |
| |
| check(&BigUint::zero(), 0.0); |
| check(&BigUint::one(), 1.0); |
| check(&BigUint::from(u32::MAX), 2.0.powi(32) - 1.0); |
| check(&BigUint::from(1u64 << 32), 2.0.powi(32)); |
| check(&BigUint::from_slice(&[0, 0, 1]), 2.0.powi(64)); |
| check( |
| &((BigUint::one() << 100) + (BigUint::one() << 152)), |
| 2.0.powi(100) + 2.0.powi(152), |
| ); |
| check(&(BigUint::one() << 1023), 2.0.powi(1023)); |
| check(&(BigUint::from((1u64 << 53) - 1) << (1024 - 53)), f64::MAX); |
| |
| // keeping all 53 digits with the bits at different offsets to the BigDigits |
| let x: u64 = 0b0000000000011110111110110111111101110111101111011111011011011101; |
| let mut f = x as f64; |
| let mut b = BigUint::from(x); |
| for _ in 0..128 { |
| check(&b, f); |
| f *= 2.0; |
| b = b << 1; |
| } |
| |
| // test rounding up with the bits at different offsets to the BigDigits |
| let mut f = ((1u64 << 54) - 1) as f64; |
| let mut b = BigUint::from(1u64 << 54); |
| for _ in 0..128 { |
| assert_eq!(b.to_f64(), Some(f)); |
| f *= 2.0; |
| b = b << 1; |
| } |
| |
| // rounding |
| assert_eq!(BigUint::from_f64(-1.0), None); |
| assert_eq!(BigUint::from_f64(-0.99999), Some(BigUint::zero())); |
| assert_eq!(BigUint::from_f64(-0.5), Some(BigUint::zero())); |
| assert_eq!(BigUint::from_f64(-0.0), Some(BigUint::zero())); |
| assert_eq!( |
| BigUint::from_f64(f64::MIN_POSITIVE / 2.0), |
| Some(BigUint::zero()) |
| ); |
| assert_eq!(BigUint::from_f64(f64::MIN_POSITIVE), Some(BigUint::zero())); |
| assert_eq!(BigUint::from_f64(0.5), Some(BigUint::zero())); |
| assert_eq!(BigUint::from_f64(0.99999), Some(BigUint::zero())); |
| assert_eq!(BigUint::from_f64(f64::consts::E), Some(BigUint::from(2u32))); |
| assert_eq!( |
| BigUint::from_f64(f64::consts::PI), |
| Some(BigUint::from(3u32)) |
| ); |
| |
| // special float values |
| assert_eq!(BigUint::from_f64(f64::NAN), None); |
| assert_eq!(BigUint::from_f64(f64::INFINITY), None); |
| assert_eq!(BigUint::from_f64(f64::NEG_INFINITY), None); |
| assert_eq!(BigUint::from_f64(f64::MIN), None); |
| |
| // largest BigUint that will round to a finite f64 value |
| let big_num = (BigUint::one() << 1024) - BigUint::one() - (BigUint::one() << (1024 - 54)); |
| assert_eq!(big_num.to_f64(), Some(f64::MAX)); |
| assert_eq!((big_num + BigUint::one()).to_f64(), None); |
| |
| assert_eq!(((BigInt::one() << 1024) - BigInt::one()).to_f64(), None); |
| assert_eq!((BigUint::one() << 1024).to_f64(), None); |
| } |
| |
| #[test] |
| fn test_convert_to_bigint() { |
| fn check(n: BigUint, ans: BigInt) { |
| assert_eq!(n.to_bigint().unwrap(), ans); |
| assert_eq!(n.to_bigint().unwrap().to_biguint().unwrap(), n); |
| } |
| check(Zero::zero(), Zero::zero()); |
| check( |
| BigUint::new(vec![1, 2, 3]), |
| BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3])), |
| ); |
| } |
| |
| #[test] |
| fn test_convert_from_uint() { |
| macro_rules! check { |
| ($ty:ident, $max:expr) => { |
| assert_eq!(BigUint::from($ty::zero()), BigUint::zero()); |
| assert_eq!(BigUint::from($ty::one()), BigUint::one()); |
| assert_eq!(BigUint::from($ty::MAX - $ty::one()), $max - BigUint::one()); |
| assert_eq!(BigUint::from($ty::MAX), $max); |
| }; |
| } |
| |
| check!(u8, BigUint::from_slice(&[u8::MAX as u32])); |
| check!(u16, BigUint::from_slice(&[u16::MAX as u32])); |
| check!(u32, BigUint::from_slice(&[u32::MAX])); |
| check!(u64, BigUint::from_slice(&[u32::MAX, u32::MAX])); |
| #[cfg(has_i128)] |
| check!( |
| u128, |
| BigUint::from_slice(&[u32::MAX, u32::MAX, u32::MAX, u32::MAX]) |
| ); |
| check!(usize, BigUint::from(usize::MAX as u64)); |
| } |
| |
| #[test] |
| fn test_add() { |
| for elm in SUM_TRIPLES.iter() { |
| let (a_vec, b_vec, c_vec) = *elm; |
| let a = BigUint::from_slice(a_vec); |
| let b = BigUint::from_slice(b_vec); |
| let c = BigUint::from_slice(c_vec); |
| |
| assert_op!(a + b == c); |
| assert_op!(b + a == c); |
| assert_assign_op!(a += b == c); |
| assert_assign_op!(b += a == c); |
| } |
| } |
| |
| #[test] |
| fn test_sub() { |
| for elm in SUM_TRIPLES.iter() { |
| let (a_vec, b_vec, c_vec) = *elm; |
| let a = BigUint::from_slice(a_vec); |
| let b = BigUint::from_slice(b_vec); |
| let c = BigUint::from_slice(c_vec); |
| |
| assert_op!(c - a == b); |
| assert_op!(c - b == a); |
| assert_assign_op!(c -= a == b); |
| assert_assign_op!(c -= b == a); |
| } |
| } |
| |
| #[test] |
| #[should_panic] |
| fn test_sub_fail_on_underflow() { |
| let (a, b): (BigUint, BigUint) = (Zero::zero(), One::one()); |
| let _ = a - b; |
| } |
| |
| #[test] |
| fn test_mul() { |
| for elm in MUL_TRIPLES.iter() { |
| let (a_vec, b_vec, c_vec) = *elm; |
| let a = BigUint::from_slice(a_vec); |
| let b = BigUint::from_slice(b_vec); |
| let c = BigUint::from_slice(c_vec); |
| |
| assert_op!(a * b == c); |
| assert_op!(b * a == c); |
| assert_assign_op!(a *= b == c); |
| assert_assign_op!(b *= a == c); |
| } |
| |
| for elm in DIV_REM_QUADRUPLES.iter() { |
| let (a_vec, b_vec, c_vec, d_vec) = *elm; |
| let a = BigUint::from_slice(a_vec); |
| let b = BigUint::from_slice(b_vec); |
| let c = BigUint::from_slice(c_vec); |
| let d = BigUint::from_slice(d_vec); |
| |
| assert!(a == &b * &c + &d); |
| assert!(a == &c * &b + &d); |
| } |
| } |
| |
| #[test] |
| fn test_div_rem() { |
| for elm in MUL_TRIPLES.iter() { |
| let (a_vec, b_vec, c_vec) = *elm; |
| let a = BigUint::from_slice(a_vec); |
| let b = BigUint::from_slice(b_vec); |
| let c = BigUint::from_slice(c_vec); |
| |
| if !a.is_zero() { |
| assert_op!(c / a == b); |
| assert_op!(c % a == Zero::zero()); |
| assert_assign_op!(c /= a == b); |
| assert_assign_op!(c %= a == Zero::zero()); |
| assert_eq!(c.div_rem(&a), (b.clone(), Zero::zero())); |
| } |
| if !b.is_zero() { |
| assert_op!(c / b == a); |
| assert_op!(c % b == Zero::zero()); |
| assert_assign_op!(c /= b == a); |
| assert_assign_op!(c %= b == Zero::zero()); |
| assert_eq!(c.div_rem(&b), (a.clone(), Zero::zero())); |
| } |
| } |
| |
| for elm in DIV_REM_QUADRUPLES.iter() { |
| let (a_vec, b_vec, c_vec, d_vec) = *elm; |
| let a = BigUint::from_slice(a_vec); |
| let b = BigUint::from_slice(b_vec); |
| let c = BigUint::from_slice(c_vec); |
| let d = BigUint::from_slice(d_vec); |
| |
| if !b.is_zero() { |
| assert_op!(a / b == c); |
| assert_op!(a % b == d); |
| assert_assign_op!(a /= b == c); |
| assert_assign_op!(a %= b == d); |
| assert!(a.div_rem(&b) == (c, d)); |
| } |
| } |
| } |
| |
| #[test] |
| fn test_checked_add() { |
| for elm in SUM_TRIPLES.iter() { |
| let (a_vec, b_vec, c_vec) = *elm; |
| let a = BigUint::from_slice(a_vec); |
| let b = BigUint::from_slice(b_vec); |
| let c = BigUint::from_slice(c_vec); |
| |
| assert!(a.checked_add(&b).unwrap() == c); |
| assert!(b.checked_add(&a).unwrap() == c); |
| } |
| } |
| |
| #[test] |
| fn test_checked_sub() { |
| for elm in SUM_TRIPLES.iter() { |
| let (a_vec, b_vec, c_vec) = *elm; |
| let a = BigUint::from_slice(a_vec); |
| let b = BigUint::from_slice(b_vec); |
| let c = BigUint::from_slice(c_vec); |
| |
| assert!(c.checked_sub(&a).unwrap() == b); |
| assert!(c.checked_sub(&b).unwrap() == a); |
| |
| if a > c { |
| assert!(a.checked_sub(&c).is_none()); |
| } |
| if b > c { |
| assert!(b.checked_sub(&c).is_none()); |
| } |
| } |
| } |
| |
| #[test] |
| fn test_checked_mul() { |
| for elm in MUL_TRIPLES.iter() { |
| let (a_vec, b_vec, c_vec) = *elm; |
| let a = BigUint::from_slice(a_vec); |
| let b = BigUint::from_slice(b_vec); |
| let c = BigUint::from_slice(c_vec); |
| |
| assert!(a.checked_mul(&b).unwrap() == c); |
| assert!(b.checked_mul(&a).unwrap() == c); |
| } |
| |
| for elm in DIV_REM_QUADRUPLES.iter() { |
| let (a_vec, b_vec, c_vec, d_vec) = *elm; |
| let a = BigUint::from_slice(a_vec); |
| let b = BigUint::from_slice(b_vec); |
| let c = BigUint::from_slice(c_vec); |
| let d = BigUint::from_slice(d_vec); |
| |
| assert!(a == b.checked_mul(&c).unwrap() + &d); |
| assert!(a == c.checked_mul(&b).unwrap() + &d); |
| } |
| } |
| |
| #[test] |
| fn test_mul_overflow() { |
| /* Test for issue #187 - overflow due to mac3 incorrectly sizing temporary */ |
| let s = "531137992816767098689588206552468627329593117727031923199444138200403559860852242739162502232636710047537552105951370000796528760829212940754539968588340162273730474622005920097370111"; |
| let a: BigUint = s.parse().unwrap(); |
| let b = a.clone(); |
| let _ = a.checked_mul(&b); |
| } |
| |
| #[test] |
| fn test_checked_div() { |
| for elm in MUL_TRIPLES.iter() { |
| let (a_vec, b_vec, c_vec) = *elm; |
| let a = BigUint::from_slice(a_vec); |
| let b = BigUint::from_slice(b_vec); |
| let c = BigUint::from_slice(c_vec); |
| |
| if !a.is_zero() { |
| assert!(c.checked_div(&a).unwrap() == b); |
| } |
| if !b.is_zero() { |
| assert!(c.checked_div(&b).unwrap() == a); |
| } |
| |
| assert!(c.checked_div(&Zero::zero()).is_none()); |
| } |
| } |
| |
| #[test] |
| fn test_gcd() { |
| fn check(a: usize, b: usize, c: usize) { |
| let big_a: BigUint = FromPrimitive::from_usize(a).unwrap(); |
| let big_b: BigUint = FromPrimitive::from_usize(b).unwrap(); |
| let big_c: BigUint = FromPrimitive::from_usize(c).unwrap(); |
| |
| assert_eq!(big_a.gcd(&big_b), big_c); |
| } |
| |
| check(10, 2, 2); |
| check(10, 3, 1); |
| check(0, 3, 3); |
| check(3, 3, 3); |
| check(56, 42, 14); |
| } |
| |
| #[test] |
| fn test_lcm() { |
| fn check(a: usize, b: usize, c: usize) { |
| let big_a: BigUint = FromPrimitive::from_usize(a).unwrap(); |
| let big_b: BigUint = FromPrimitive::from_usize(b).unwrap(); |
| let big_c: BigUint = FromPrimitive::from_usize(c).unwrap(); |
| |
| assert_eq!(big_a.lcm(&big_b), big_c); |
| } |
| |
| check(1, 0, 0); |
| check(0, 1, 0); |
| check(1, 1, 1); |
| check(8, 9, 72); |
| check(11, 5, 55); |
| check(99, 17, 1683); |
| } |
| |
| #[test] |
| fn test_is_even() { |
| let one: BigUint = FromStr::from_str("1").unwrap(); |
| let two: BigUint = FromStr::from_str("2").unwrap(); |
| let thousand: BigUint = FromStr::from_str("1000").unwrap(); |
| let big: BigUint = FromStr::from_str("1000000000000000000000").unwrap(); |
| let bigger: BigUint = FromStr::from_str("1000000000000000000001").unwrap(); |
| assert!(one.is_odd()); |
| assert!(two.is_even()); |
| assert!(thousand.is_even()); |
| assert!(big.is_even()); |
| assert!(bigger.is_odd()); |
| assert!((&one << 64).is_even()); |
| assert!(((&one << 64) + one).is_odd()); |
| } |
| |
| fn to_str_pairs() -> Vec<(BigUint, Vec<(u32, String)>)> { |
| let bits = 32; |
| vec![ |
| ( |
| Zero::zero(), |
| vec![(2, "0".to_string()), (3, "0".to_string())], |
| ), |
| ( |
| BigUint::from_slice(&[0xff]), |
| vec![ |
| (2, "11111111".to_string()), |
| (3, "100110".to_string()), |
| (4, "3333".to_string()), |
| (5, "2010".to_string()), |
| (6, "1103".to_string()), |
| (7, "513".to_string()), |
| (8, "377".to_string()), |
| (9, "313".to_string()), |
| (10, "255".to_string()), |
| (11, "212".to_string()), |
| (12, "193".to_string()), |
| (13, "168".to_string()), |
| (14, "143".to_string()), |
| (15, "120".to_string()), |
| (16, "ff".to_string()), |
| ], |
| ), |
| ( |
| BigUint::from_slice(&[0xfff]), |
| vec![ |
| (2, "111111111111".to_string()), |
| (4, "333333".to_string()), |
| (16, "fff".to_string()), |
| ], |
| ), |
| ( |
| BigUint::from_slice(&[1, 2]), |
| vec![ |
| ( |
| 2, |
| format!("10{}1", repeat("0").take(bits - 1).collect::<String>()), |
| ), |
| ( |
| 4, |
| format!("2{}1", repeat("0").take(bits / 2 - 1).collect::<String>()), |
| ), |
| ( |
| 10, |
| match bits { |
| 64 => "36893488147419103233".to_string(), |
| 32 => "8589934593".to_string(), |
| 16 => "131073".to_string(), |
| _ => panic!(), |
| }, |
| ), |
| ( |
| 16, |
| format!("2{}1", repeat("0").take(bits / 4 - 1).collect::<String>()), |
| ), |
| ], |
| ), |
| ( |
| BigUint::from_slice(&[1, 2, 3]), |
| vec![ |
| ( |
| 2, |
| format!( |
| "11{}10{}1", |
| repeat("0").take(bits - 2).collect::<String>(), |
| repeat("0").take(bits - 1).collect::<String>() |
| ), |
| ), |
| ( |
| 4, |
| format!( |
| "3{}2{}1", |
| repeat("0").take(bits / 2 - 1).collect::<String>(), |
| repeat("0").take(bits / 2 - 1).collect::<String>() |
| ), |
| ), |
| ( |
| 8, |
| match bits { |
| 64 => "14000000000000000000004000000000000000000001".to_string(), |
| 32 => "6000000000100000000001".to_string(), |
| 16 => "140000400001".to_string(), |
| _ => panic!(), |
| }, |
| ), |
| ( |
| 10, |
| match bits { |
| 64 => "1020847100762815390427017310442723737601".to_string(), |
| 32 => "55340232229718589441".to_string(), |
| 16 => "12885032961".to_string(), |
| _ => panic!(), |
| }, |
| ), |
| ( |
| 16, |
| format!( |
| "3{}2{}1", |
| repeat("0").take(bits / 4 - 1).collect::<String>(), |
| repeat("0").take(bits / 4 - 1).collect::<String>() |
| ), |
| ), |
| ], |
| ), |
| ] |
| } |
| |
| #[test] |
| fn test_to_str_radix() { |
| let r = to_str_pairs(); |
| for num_pair in r.iter() { |
| let &(ref n, ref rs) = num_pair; |
| for str_pair in rs.iter() { |
| let &(ref radix, ref str) = str_pair; |
| assert_eq!(n.to_str_radix(*radix), *str); |
| } |
| } |
| } |
| |
| #[test] |
| fn test_from_and_to_radix() { |
| const GROUND_TRUTH: &'static [(&'static [u8], u32, &'static [u8])] = &[ |
| (b"0", 42, &[0]), |
| ( |
| b"ffffeeffbb", |
| 2, |
| &[ |
| 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| ], |
| ), |
| ( |
| b"ffffeeffbb", |
| 3, |
| &[ |
| 2, 2, 1, 1, 2, 1, 1, 2, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 1, 0, 0, 2, 2, 0, 1, |
| ], |
| ), |
| ( |
| b"ffffeeffbb", |
| 4, |
| &[3, 2, 3, 2, 3, 3, 3, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3], |
| ), |
| ( |
| b"ffffeeffbb", |
| 5, |
| &[0, 4, 3, 3, 1, 4, 2, 4, 1, 4, 4, 2, 3, 0, 0, 1, 2, 1], |
| ), |
| ( |
| b"ffffeeffbb", |
| 6, |
| &[5, 5, 4, 5, 5, 0, 0, 1, 2, 5, 3, 0, 1, 0, 2, 2], |
| ), |
| ( |
| b"ffffeeffbb", |
| 7, |
| &[4, 2, 3, 6, 0, 1, 6, 1, 6, 2, 0, 3, 2, 4, 1], |
| ), |
| ( |
| b"ffffeeffbb", |
| 8, |
| &[3, 7, 6, 7, 7, 5, 3, 7, 7, 7, 7, 7, 7, 1], |
| ), |
| (b"ffffeeffbb", 9, &[8, 4, 5, 7, 0, 0, 3, 2, 0, 3, 0, 8, 3]), |
| (b"ffffeeffbb", 10, &[5, 9, 5, 3, 1, 5, 0, 1, 5, 9, 9, 0, 1]), |
| (b"ffffeeffbb", 11, &[10, 7, 6, 5, 2, 0, 3, 3, 3, 4, 9, 3]), |
| (b"ffffeeffbb", 12, &[11, 8, 5, 10, 1, 10, 3, 1, 1, 9, 5, 1]), |
| (b"ffffeeffbb", 13, &[0, 5, 7, 4, 6, 5, 6, 11, 8, 12, 7]), |
| (b"ffffeeffbb", 14, &[11, 4, 4, 11, 8, 4, 6, 0, 3, 11, 3]), |
| (b"ffffeeffbb", 15, &[5, 11, 13, 2, 1, 10, 2, 0, 9, 13, 1]), |
| (b"ffffeeffbb", 16, &[11, 11, 15, 15, 14, 14, 15, 15, 15, 15]), |
| (b"ffffeeffbb", 17, &[0, 2, 14, 12, 2, 14, 8, 10, 4, 9]), |
| (b"ffffeeffbb", 18, &[17, 15, 5, 13, 10, 16, 16, 13, 9, 5]), |
| (b"ffffeeffbb", 19, &[14, 13, 2, 8, 9, 0, 1, 14, 7, 3]), |
| (b"ffffeeffbb", 20, &[15, 19, 3, 14, 0, 17, 19, 18, 2, 2]), |
| (b"ffffeeffbb", 21, &[11, 5, 4, 13, 5, 18, 9, 1, 8, 1]), |
| (b"ffffeeffbb", 22, &[21, 3, 7, 21, 15, 12, 17, 0, 20]), |
| (b"ffffeeffbb", 23, &[21, 21, 6, 9, 10, 7, 21, 0, 14]), |
| (b"ffffeeffbb", 24, &[11, 10, 19, 14, 22, 11, 17, 23, 9]), |
| (b"ffffeeffbb", 25, &[20, 18, 21, 22, 21, 14, 3, 5, 7]), |
| (b"ffffeeffbb", 26, &[13, 15, 24, 11, 17, 6, 23, 6, 5]), |
| (b"ffffeeffbb", 27, &[17, 16, 7, 0, 21, 0, 3, 24, 3]), |
| (b"ffffeeffbb", 28, &[11, 16, 11, 15, 14, 18, 13, 25, 2]), |
| (b"ffffeeffbb", 29, &[6, 8, 7, 19, 14, 13, 21, 5, 2]), |
| (b"ffffeeffbb", 30, &[5, 13, 18, 11, 10, 7, 8, 20, 1]), |
| (b"ffffeeffbb", 31, &[22, 26, 15, 19, 8, 27, 29, 8, 1]), |
| (b"ffffeeffbb", 32, &[27, 29, 31, 29, 30, 31, 31, 31]), |
| (b"ffffeeffbb", 33, &[32, 20, 27, 12, 1, 12, 26, 25]), |
| (b"ffffeeffbb", 34, &[17, 9, 16, 33, 13, 25, 31, 20]), |
| (b"ffffeeffbb", 35, &[25, 32, 2, 25, 11, 4, 3, 17]), |
| (b"ffffeeffbb", 36, &[35, 34, 5, 6, 32, 3, 1, 14]), |
| (b"ffffeeffbb", 37, &[16, 21, 18, 4, 33, 19, 21, 11]), |
| (b"ffffeeffbb", 38, &[33, 25, 19, 29, 20, 6, 23, 9]), |
| (b"ffffeeffbb", 39, &[26, 27, 29, 23, 16, 18, 0, 8]), |
| (b"ffffeeffbb", 40, &[35, 39, 30, 11, 16, 17, 28, 6]), |
| (b"ffffeeffbb", 41, &[36, 30, 9, 18, 12, 19, 26, 5]), |
| (b"ffffeeffbb", 42, &[11, 34, 37, 27, 1, 13, 32, 4]), |
| (b"ffffeeffbb", 43, &[3, 24, 11, 2, 10, 40, 1, 4]), |
| (b"ffffeeffbb", 44, &[43, 12, 40, 32, 3, 23, 19, 3]), |
| (b"ffffeeffbb", 45, &[35, 38, 44, 18, 22, 18, 42, 2]), |
| (b"ffffeeffbb", 46, &[21, 45, 18, 41, 17, 2, 24, 2]), |
| (b"ffffeeffbb", 47, &[37, 37, 11, 12, 6, 0, 8, 2]), |
| (b"ffffeeffbb", 48, &[11, 41, 40, 43, 5, 43, 41, 1]), |
| (b"ffffeeffbb", 49, &[18, 45, 7, 13, 20, 21, 30, 1]), |
| (b"ffffeeffbb", 50, &[45, 21, 5, 34, 21, 18, 20, 1]), |
| (b"ffffeeffbb", 51, &[17, 6, 26, 22, 38, 24, 11, 1]), |
| (b"ffffeeffbb", 52, &[39, 33, 38, 30, 46, 31, 3, 1]), |
| (b"ffffeeffbb", 53, &[31, 7, 44, 23, 9, 32, 49]), |
| (b"ffffeeffbb", 54, &[17, 35, 8, 37, 31, 18, 44]), |
| (b"ffffeeffbb", 55, &[10, 52, 9, 48, 36, 39, 39]), |
| (b"ffffeeffbb", 56, &[11, 50, 51, 22, 25, 36, 35]), |
| (b"ffffeeffbb", 57, &[14, 55, 12, 43, 20, 3, 32]), |
| (b"ffffeeffbb", 58, &[35, 18, 45, 56, 9, 51, 28]), |
| (b"ffffeeffbb", 59, &[51, 28, 20, 26, 55, 3, 26]), |
| (b"ffffeeffbb", 60, &[35, 6, 27, 46, 58, 33, 23]), |
| (b"ffffeeffbb", 61, &[58, 7, 6, 54, 49, 20, 21]), |
| (b"ffffeeffbb", 62, &[53, 59, 3, 14, 10, 22, 19]), |
| (b"ffffeeffbb", 63, &[53, 50, 23, 4, 56, 36, 17]), |
| (b"ffffeeffbb", 64, &[59, 62, 47, 59, 63, 63, 15]), |
| (b"ffffeeffbb", 65, &[0, 53, 39, 4, 40, 37, 14]), |
| (b"ffffeeffbb", 66, &[65, 59, 39, 1, 64, 19, 13]), |
| (b"ffffeeffbb", 67, &[35, 14, 19, 16, 25, 10, 12]), |
| (b"ffffeeffbb", 68, &[51, 38, 63, 50, 15, 8, 11]), |
| (b"ffffeeffbb", 69, &[44, 45, 18, 58, 68, 12, 10]), |
| (b"ffffeeffbb", 70, &[25, 51, 0, 60, 13, 24, 9]), |
| (b"ffffeeffbb", 71, &[54, 30, 9, 65, 28, 41, 8]), |
| (b"ffffeeffbb", 72, &[35, 35, 55, 54, 17, 64, 7]), |
| (b"ffffeeffbb", 73, &[34, 4, 48, 40, 27, 19, 7]), |
| (b"ffffeeffbb", 74, &[53, 47, 4, 56, 36, 51, 6]), |
| (b"ffffeeffbb", 75, &[20, 56, 10, 72, 24, 13, 6]), |
| (b"ffffeeffbb", 76, &[71, 31, 52, 60, 48, 53, 5]), |
| (b"ffffeeffbb", 77, &[32, 73, 14, 63, 15, 21, 5]), |
| (b"ffffeeffbb", 78, &[65, 13, 17, 32, 64, 68, 4]), |
| (b"ffffeeffbb", 79, &[37, 56, 2, 56, 25, 41, 4]), |
| (b"ffffeeffbb", 80, &[75, 59, 37, 41, 43, 15, 4]), |
| (b"ffffeeffbb", 81, &[44, 68, 0, 21, 27, 72, 3]), |
| (b"ffffeeffbb", 82, &[77, 35, 2, 74, 46, 50, 3]), |
| (b"ffffeeffbb", 83, &[52, 51, 19, 76, 10, 30, 3]), |
| (b"ffffeeffbb", 84, &[11, 80, 19, 19, 76, 10, 3]), |
| (b"ffffeeffbb", 85, &[0, 82, 20, 14, 68, 77, 2]), |
| (b"ffffeeffbb", 86, &[3, 12, 78, 37, 62, 61, 2]), |
| (b"ffffeeffbb", 87, &[35, 12, 20, 8, 52, 46, 2]), |
| (b"ffffeeffbb", 88, &[43, 6, 54, 42, 30, 32, 2]), |
| (b"ffffeeffbb", 89, &[49, 52, 85, 21, 80, 18, 2]), |
| (b"ffffeeffbb", 90, &[35, 64, 78, 24, 18, 6, 2]), |
| (b"ffffeeffbb", 91, &[39, 17, 83, 63, 17, 85, 1]), |
| (b"ffffeeffbb", 92, &[67, 22, 85, 79, 75, 74, 1]), |
| (b"ffffeeffbb", 93, &[53, 60, 39, 29, 4, 65, 1]), |
| (b"ffffeeffbb", 94, &[37, 89, 2, 72, 76, 55, 1]), |
| (b"ffffeeffbb", 95, &[90, 74, 89, 9, 9, 47, 1]), |
| (b"ffffeeffbb", 96, &[59, 20, 46, 35, 81, 38, 1]), |
| (b"ffffeeffbb", 97, &[94, 87, 60, 71, 3, 31, 1]), |
| (b"ffffeeffbb", 98, &[67, 22, 63, 50, 62, 23, 1]), |
| (b"ffffeeffbb", 99, &[98, 6, 69, 12, 61, 16, 1]), |
| (b"ffffeeffbb", 100, &[95, 35, 51, 10, 95, 9, 1]), |
| (b"ffffeeffbb", 101, &[87, 27, 7, 8, 62, 3, 1]), |
| (b"ffffeeffbb", 102, &[17, 3, 32, 79, 59, 99]), |
| (b"ffffeeffbb", 103, &[30, 22, 90, 0, 87, 94]), |
| (b"ffffeeffbb", 104, &[91, 68, 87, 68, 38, 90]), |
| (b"ffffeeffbb", 105, &[95, 80, 54, 73, 15, 86]), |
| (b"ffffeeffbb", 106, &[31, 30, 24, 16, 17, 82]), |
| (b"ffffeeffbb", 107, &[51, 50, 10, 12, 42, 78]), |
| (b"ffffeeffbb", 108, &[71, 71, 96, 78, 89, 74]), |
| (b"ffffeeffbb", 109, &[33, 18, 93, 22, 50, 71]), |
| (b"ffffeeffbb", 110, &[65, 53, 57, 88, 29, 68]), |
| (b"ffffeeffbb", 111, &[53, 93, 67, 90, 27, 65]), |
| (b"ffffeeffbb", 112, &[11, 109, 96, 65, 43, 62]), |
| (b"ffffeeffbb", 113, &[27, 23, 106, 56, 76, 59]), |
| (b"ffffeeffbb", 114, &[71, 84, 31, 112, 11, 57]), |
| (b"ffffeeffbb", 115, &[90, 22, 1, 56, 76, 54]), |
| (b"ffffeeffbb", 116, &[35, 38, 98, 57, 40, 52]), |
| (b"ffffeeffbb", 117, &[26, 113, 115, 62, 17, 50]), |
| (b"ffffeeffbb", 118, &[51, 14, 5, 18, 7, 48]), |
| (b"ffffeeffbb", 119, &[102, 31, 110, 108, 8, 46]), |
| (b"ffffeeffbb", 120, &[35, 93, 96, 50, 22, 44]), |
| (b"ffffeeffbb", 121, &[87, 61, 2, 36, 47, 42]), |
| (b"ffffeeffbb", 122, &[119, 64, 1, 22, 83, 40]), |
| (b"ffffeeffbb", 123, &[77, 119, 32, 90, 6, 39]), |
| (b"ffffeeffbb", 124, &[115, 122, 31, 79, 62, 37]), |
| (b"ffffeeffbb", 125, &[95, 108, 47, 74, 3, 36]), |
| (b"ffffeeffbb", 126, &[53, 25, 116, 39, 78, 34]), |
| (b"ffffeeffbb", 127, &[22, 23, 125, 67, 35, 33]), |
| (b"ffffeeffbb", 128, &[59, 127, 59, 127, 127, 31]), |
| (b"ffffeeffbb", 129, &[89, 36, 1, 59, 100, 30]), |
| (b"ffffeeffbb", 130, &[65, 91, 123, 89, 79, 29]), |
| (b"ffffeeffbb", 131, &[58, 72, 39, 63, 65, 28]), |
| (b"ffffeeffbb", 132, &[131, 62, 92, 82, 57, 27]), |
| (b"ffffeeffbb", 133, &[109, 31, 51, 123, 55, 26]), |
| (b"ffffeeffbb", 134, &[35, 74, 21, 27, 60, 25]), |
| (b"ffffeeffbb", 135, &[125, 132, 49, 37, 70, 24]), |
| (b"ffffeeffbb", 136, &[51, 121, 117, 133, 85, 23]), |
| (b"ffffeeffbb", 137, &[113, 60, 135, 22, 107, 22]), |
| (b"ffffeeffbb", 138, &[113, 91, 73, 93, 133, 21]), |
| (b"ffffeeffbb", 139, &[114, 75, 102, 51, 26, 21]), |
| (b"ffffeeffbb", 140, &[95, 25, 35, 16, 62, 20]), |
| (b"ffffeeffbb", 141, &[131, 137, 16, 110, 102, 19]), |
| (b"ffffeeffbb", 142, &[125, 121, 108, 34, 6, 19]), |
| (b"ffffeeffbb", 143, &[65, 78, 138, 55, 55, 18]), |
| (b"ffffeeffbb", 144, &[107, 125, 121, 15, 109, 17]), |
| (b"ffffeeffbb", 145, &[35, 13, 122, 42, 22, 17]), |
| (b"ffffeeffbb", 146, &[107, 38, 103, 123, 83, 16]), |
| (b"ffffeeffbb", 147, &[116, 96, 71, 98, 2, 16]), |
| (b"ffffeeffbb", 148, &[127, 23, 75, 99, 71, 15]), |
| (b"ffffeeffbb", 149, &[136, 110, 53, 114, 144, 14]), |
| (b"ffffeeffbb", 150, &[95, 140, 133, 130, 71, 14]), |
| (b"ffffeeffbb", 151, &[15, 50, 29, 137, 0, 14]), |
| (b"ffffeeffbb", 152, &[147, 15, 89, 121, 83, 13]), |
| (b"ffffeeffbb", 153, &[17, 87, 93, 72, 17, 13]), |
| (b"ffffeeffbb", 154, &[109, 113, 3, 133, 106, 12]), |
| (b"ffffeeffbb", 155, &[115, 141, 120, 139, 44, 12]), |
| (b"ffffeeffbb", 156, &[143, 45, 4, 82, 140, 11]), |
| (b"ffffeeffbb", 157, &[149, 92, 15, 106, 82, 11]), |
| (b"ffffeeffbb", 158, &[37, 107, 79, 46, 26, 11]), |
| (b"ffffeeffbb", 159, &[137, 37, 146, 51, 130, 10]), |
| (b"ffffeeffbb", 160, &[155, 69, 29, 115, 77, 10]), |
| (b"ffffeeffbb", 161, &[67, 98, 46, 68, 26, 10]), |
| (b"ffffeeffbb", 162, &[125, 155, 60, 63, 138, 9]), |
| (b"ffffeeffbb", 163, &[96, 43, 118, 93, 90, 9]), |
| (b"ffffeeffbb", 164, &[159, 99, 123, 152, 43, 9]), |
| (b"ffffeeffbb", 165, &[65, 17, 1, 69, 163, 8]), |
| (b"ffffeeffbb", 166, &[135, 108, 25, 165, 119, 8]), |
| (b"ffffeeffbb", 167, &[165, 116, 164, 103, 77, 8]), |
| (b"ffffeeffbb", 168, &[11, 166, 67, 44, 36, 8]), |
| (b"ffffeeffbb", 169, &[65, 59, 71, 149, 164, 7]), |
| (b"ffffeeffbb", 170, &[85, 83, 26, 76, 126, 7]), |
| (b"ffffeeffbb", 171, &[71, 132, 140, 157, 88, 7]), |
| (b"ffffeeffbb", 172, &[3, 6, 127, 47, 52, 7]), |
| (b"ffffeeffbb", 173, &[122, 66, 53, 83, 16, 7]), |
| (b"ffffeeffbb", 174, &[35, 6, 5, 88, 155, 6]), |
| (b"ffffeeffbb", 175, &[95, 20, 84, 56, 122, 6]), |
| (b"ffffeeffbb", 176, &[43, 91, 57, 159, 89, 6]), |
| (b"ffffeeffbb", 177, &[110, 127, 54, 40, 58, 6]), |
| (b"ffffeeffbb", 178, &[49, 115, 43, 47, 27, 6]), |
| (b"ffffeeffbb", 179, &[130, 91, 4, 178, 175, 5]), |
| (b"ffffeeffbb", 180, &[35, 122, 109, 70, 147, 5]), |
| (b"ffffeeffbb", 181, &[94, 94, 4, 79, 119, 5]), |
| (b"ffffeeffbb", 182, &[39, 54, 66, 19, 92, 5]), |
| (b"ffffeeffbb", 183, &[119, 2, 143, 69, 65, 5]), |
| (b"ffffeeffbb", 184, &[67, 57, 90, 44, 39, 5]), |
| (b"ffffeeffbb", 185, &[90, 63, 141, 123, 13, 5]), |
| (b"ffffeeffbb", 186, &[53, 123, 172, 119, 174, 4]), |
| (b"ffffeeffbb", 187, &[153, 21, 68, 28, 151, 4]), |
| (b"ffffeeffbb", 188, &[131, 138, 94, 32, 128, 4]), |
| (b"ffffeeffbb", 189, &[179, 121, 156, 130, 105, 4]), |
| (b"ffffeeffbb", 190, &[185, 179, 164, 131, 83, 4]), |
| (b"ffffeeffbb", 191, &[118, 123, 37, 31, 62, 4]), |
| (b"ffffeeffbb", 192, &[59, 106, 83, 16, 41, 4]), |
| (b"ffffeeffbb", 193, &[57, 37, 47, 86, 20, 4]), |
| (b"ffffeeffbb", 194, &[191, 140, 63, 45, 0, 4]), |
| (b"ffffeeffbb", 195, &[65, 169, 83, 84, 175, 3]), |
| (b"ffffeeffbb", 196, &[67, 158, 64, 6, 157, 3]), |
| (b"ffffeeffbb", 197, &[121, 26, 167, 3, 139, 3]), |
| (b"ffffeeffbb", 198, &[197, 151, 165, 75, 121, 3]), |
| (b"ffffeeffbb", 199, &[55, 175, 36, 22, 104, 3]), |
| (b"ffffeeffbb", 200, &[195, 167, 162, 38, 87, 3]), |
| (b"ffffeeffbb", 201, &[35, 27, 136, 124, 70, 3]), |
| (b"ffffeeffbb", 202, &[87, 64, 153, 76, 54, 3]), |
| (b"ffffeeffbb", 203, &[151, 191, 14, 94, 38, 3]), |
| (b"ffffeeffbb", 204, &[119, 103, 135, 175, 22, 3]), |
| (b"ffffeeffbb", 205, &[200, 79, 123, 115, 7, 3]), |
| (b"ffffeeffbb", 206, &[133, 165, 202, 115, 198, 2]), |
| (b"ffffeeffbb", 207, &[44, 153, 193, 175, 184, 2]), |
| (b"ffffeeffbb", 208, &[91, 190, 125, 86, 171, 2]), |
| (b"ffffeeffbb", 209, &[109, 151, 34, 53, 158, 2]), |
| (b"ffffeeffbb", 210, &[95, 40, 171, 74, 145, 2]), |
| (b"ffffeeffbb", 211, &[84, 195, 162, 150, 132, 2]), |
| (b"ffffeeffbb", 212, &[31, 15, 59, 68, 120, 2]), |
| (b"ffffeeffbb", 213, &[125, 57, 127, 36, 108, 2]), |
| (b"ffffeeffbb", 214, &[51, 132, 2, 55, 96, 2]), |
| (b"ffffeeffbb", 215, &[175, 133, 177, 122, 84, 2]), |
| (b"ffffeeffbb", 216, &[179, 35, 78, 23, 73, 2]), |
| (b"ffffeeffbb", 217, &[53, 101, 208, 186, 61, 2]), |
| (b"ffffeeffbb", 218, &[33, 9, 214, 179, 50, 2]), |
| (b"ffffeeffbb", 219, &[107, 147, 175, 217, 39, 2]), |
| (b"ffffeeffbb", 220, &[175, 81, 179, 79, 29, 2]), |
| (b"ffffeeffbb", 221, &[0, 76, 95, 204, 18, 2]), |
| (b"ffffeeffbb", 222, &[53, 213, 16, 150, 8, 2]), |
| (b"ffffeeffbb", 223, &[158, 161, 42, 136, 221, 1]), |
| (b"ffffeeffbb", 224, &[123, 54, 52, 162, 212, 1]), |
| (b"ffffeeffbb", 225, &[170, 43, 151, 2, 204, 1]), |
| (b"ffffeeffbb", 226, &[27, 68, 224, 105, 195, 1]), |
| (b"ffffeeffbb", 227, &[45, 69, 157, 20, 187, 1]), |
| (b"ffffeeffbb", 228, &[71, 213, 64, 199, 178, 1]), |
| (b"ffffeeffbb", 229, &[129, 203, 66, 186, 170, 1]), |
| (b"ffffeeffbb", 230, &[205, 183, 57, 208, 162, 1]), |
| (b"ffffeeffbb", 231, &[32, 50, 164, 33, 155, 1]), |
| (b"ffffeeffbb", 232, &[35, 135, 53, 123, 147, 1]), |
| (b"ffffeeffbb", 233, &[209, 47, 89, 13, 140, 1]), |
| (b"ffffeeffbb", 234, &[143, 56, 175, 168, 132, 1]), |
| (b"ffffeeffbb", 235, &[225, 157, 216, 121, 125, 1]), |
| (b"ffffeeffbb", 236, &[51, 66, 119, 105, 118, 1]), |
| (b"ffffeeffbb", 237, &[116, 150, 26, 119, 111, 1]), |
| (b"ffffeeffbb", 238, &[221, 15, 87, 162, 104, 1]), |
| (b"ffffeeffbb", 239, &[234, 155, 214, 234, 97, 1]), |
| (b"ffffeeffbb", 240, &[155, 46, 84, 96, 91, 1]), |
| (b"ffffeeffbb", 241, &[187, 48, 90, 225, 84, 1]), |
| (b"ffffeeffbb", 242, &[87, 212, 151, 140, 78, 1]), |
| (b"ffffeeffbb", 243, &[206, 22, 189, 81, 72, 1]), |
| (b"ffffeeffbb", 244, &[119, 93, 122, 48, 66, 1]), |
| (b"ffffeeffbb", 245, &[165, 224, 117, 40, 60, 1]), |
| (b"ffffeeffbb", 246, &[77, 121, 100, 57, 54, 1]), |
| (b"ffffeeffbb", 247, &[52, 128, 242, 98, 48, 1]), |
| (b"ffffeeffbb", 248, &[115, 247, 224, 164, 42, 1]), |
| (b"ffffeeffbb", 249, &[218, 127, 223, 5, 37, 1]), |
| (b"ffffeeffbb", 250, &[95, 54, 168, 118, 31, 1]), |
| (b"ffffeeffbb", 251, &[121, 204, 240, 3, 26, 1]), |
| (b"ffffeeffbb", 252, &[179, 138, 123, 162, 20, 1]), |
| (b"ffffeeffbb", 253, &[21, 50, 1, 91, 15, 1]), |
| (b"ffffeeffbb", 254, &[149, 11, 63, 40, 10, 1]), |
| (b"ffffeeffbb", 255, &[170, 225, 247, 9, 5, 1]), |
| (b"ffffeeffbb", 256, &[187, 255, 238, 255, 255]), |
| ]; |
| |
| for &(bigint, radix, inbaseradix_le) in GROUND_TRUTH.iter() { |
| let bigint = BigUint::parse_bytes(bigint, 16).unwrap(); |
| // to_radix_le |
| assert_eq!(bigint.to_radix_le(radix), inbaseradix_le); |
| // to_radix_be |
| let mut inbase_be = bigint.to_radix_be(radix); |
| inbase_be.reverse(); // now le |
| assert_eq!(inbase_be, inbaseradix_le); |
| // from_radix_le |
| assert_eq!( |
| BigUint::from_radix_le(inbaseradix_le, radix).unwrap(), |
| bigint |
| ); |
| // from_radix_be |
| let mut inbaseradix_be = Vec::from(inbaseradix_le); |
| inbaseradix_be.reverse(); |
| assert_eq!( |
| BigUint::from_radix_be(&inbaseradix_be, radix).unwrap(), |
| bigint |
| ); |
| } |
| |
| assert!(BigUint::from_radix_le(&[10, 100, 10], 50).is_none()); |
| } |
| |
| #[test] |
| fn test_from_str_radix() { |
| let r = to_str_pairs(); |
| for num_pair in r.iter() { |
| let &(ref n, ref rs) = num_pair; |
| for str_pair in rs.iter() { |
| let &(ref radix, ref str) = str_pair; |
| assert_eq!(n, &BigUint::from_str_radix(str, *radix).unwrap()); |
| } |
| } |
| |
| let zed = BigUint::from_str_radix("Z", 10).ok(); |
| assert_eq!(zed, None); |
| let blank = BigUint::from_str_radix("_", 2).ok(); |
| assert_eq!(blank, None); |
| let blank_one = BigUint::from_str_radix("_1", 2).ok(); |
| assert_eq!(blank_one, None); |
| let plus_one = BigUint::from_str_radix("+1", 10).ok(); |
| assert_eq!(plus_one, Some(BigUint::from_slice(&[1]))); |
| let plus_plus_one = BigUint::from_str_radix("++1", 10).ok(); |
| assert_eq!(plus_plus_one, None); |
| let minus_one = BigUint::from_str_radix("-1", 10).ok(); |
| assert_eq!(minus_one, None); |
| let zero_plus_two = BigUint::from_str_radix("0+2", 10).ok(); |
| assert_eq!(zero_plus_two, None); |
| let three = BigUint::from_str_radix("1_1", 2).ok(); |
| assert_eq!(three, Some(BigUint::from_slice(&[3]))); |
| let ff = BigUint::from_str_radix("1111_1111", 2).ok(); |
| assert_eq!(ff, Some(BigUint::from_slice(&[0xff]))); |
| } |
| |
| #[test] |
| fn test_all_str_radix() { |
| #[allow(deprecated, unused_imports)] |
| use std::ascii::AsciiExt; |
| |
| let n = BigUint::new((0..10).collect()); |
| for radix in 2..37 { |
| let s = n.to_str_radix(radix); |
| let x = BigUint::from_str_radix(&s, radix); |
| assert_eq!(x.unwrap(), n); |
| |
| let s = s.to_ascii_uppercase(); |
| let x = BigUint::from_str_radix(&s, radix); |
| assert_eq!(x.unwrap(), n); |
| } |
| } |
| |
| #[test] |
| fn test_lower_hex() { |
| let a = BigUint::parse_bytes(b"A", 16).unwrap(); |
| let hello = BigUint::parse_bytes("22405534230753963835153736737".as_bytes(), 10).unwrap(); |
| |
| assert_eq!(format!("{:x}", a), "a"); |
| assert_eq!(format!("{:x}", hello), "48656c6c6f20776f726c6421"); |
| assert_eq!(format!("{:♥>+#8x}", a), "♥♥♥♥+0xa"); |
| } |
| |
| #[test] |
| fn test_upper_hex() { |
| let a = BigUint::parse_bytes(b"A", 16).unwrap(); |
| let hello = BigUint::parse_bytes("22405534230753963835153736737".as_bytes(), 10).unwrap(); |
| |
| assert_eq!(format!("{:X}", a), "A"); |
| assert_eq!(format!("{:X}", hello), "48656C6C6F20776F726C6421"); |
| assert_eq!(format!("{:♥>+#8X}", a), "♥♥♥♥+0xA"); |
| } |
| |
| #[test] |
| fn test_binary() { |
| let a = BigUint::parse_bytes(b"A", 16).unwrap(); |
| let hello = BigUint::parse_bytes("224055342307539".as_bytes(), 10).unwrap(); |
| |
| assert_eq!(format!("{:b}", a), "1010"); |
| assert_eq!( |
| format!("{:b}", hello), |
| "110010111100011011110011000101101001100011010011" |
| ); |
| assert_eq!(format!("{:♥>+#8b}", a), "♥+0b1010"); |
| } |
| |
| #[test] |
| fn test_octal() { |
| let a = BigUint::parse_bytes(b"A", 16).unwrap(); |
| let hello = BigUint::parse_bytes("22405534230753963835153736737".as_bytes(), 10).unwrap(); |
| |
| assert_eq!(format!("{:o}", a), "12"); |
| assert_eq!(format!("{:o}", hello), "22062554330674403566756233062041"); |
| assert_eq!(format!("{:♥>+#8o}", a), "♥♥♥+0o12"); |
| } |
| |
| #[test] |
| fn test_display() { |
| let a = BigUint::parse_bytes(b"A", 16).unwrap(); |
| let hello = BigUint::parse_bytes("22405534230753963835153736737".as_bytes(), 10).unwrap(); |
| |
| assert_eq!(format!("{}", a), "10"); |
| assert_eq!(format!("{}", hello), "22405534230753963835153736737"); |
| assert_eq!(format!("{:♥>+#8}", a), "♥♥♥♥♥+10"); |
| } |
| |
| #[test] |
| fn test_factor() { |
| fn factor(n: usize) -> BigUint { |
| let mut f: BigUint = One::one(); |
| for i in 2..n + 1 { |
| // FIXME(#5992): assignment operator overloads |
| // f *= FromPrimitive::from_usize(i); |
| let bu: BigUint = FromPrimitive::from_usize(i).unwrap(); |
| f = f * bu; |
| } |
| return f; |
| } |
| |
| fn check(n: usize, s: &str) { |
| let n = factor(n); |
| let ans = match BigUint::from_str_radix(s, 10) { |
| Ok(x) => x, |
| Err(_) => panic!(), |
| }; |
| assert_eq!(n, ans); |
| } |
| |
| check(3, "6"); |
| check(10, "3628800"); |
| check(20, "2432902008176640000"); |
| check(30, "265252859812191058636308480000000"); |
| } |
| |
| #[test] |
| fn test_bits() { |
| assert_eq!(BigUint::new(vec![0, 0, 0, 0]).bits(), 0); |
| let n: BigUint = FromPrimitive::from_usize(0).unwrap(); |
| assert_eq!(n.bits(), 0); |
| let n: BigUint = FromPrimitive::from_usize(1).unwrap(); |
| assert_eq!(n.bits(), 1); |
| let n: BigUint = FromPrimitive::from_usize(3).unwrap(); |
| assert_eq!(n.bits(), 2); |
| let n: BigUint = BigUint::from_str_radix("4000000000", 16).unwrap(); |
| assert_eq!(n.bits(), 39); |
| let one: BigUint = One::one(); |
| assert_eq!((one << 426).bits(), 427); |
| } |
| |
| #[test] |
| fn test_iter_sum() { |
| let result: BigUint = FromPrimitive::from_isize(1234567).unwrap(); |
| let data: Vec<BigUint> = vec![ |
| FromPrimitive::from_u32(1000000).unwrap(), |
| FromPrimitive::from_u32(200000).unwrap(), |
| FromPrimitive::from_u32(30000).unwrap(), |
| FromPrimitive::from_u32(4000).unwrap(), |
| FromPrimitive::from_u32(500).unwrap(), |
| FromPrimitive::from_u32(60).unwrap(), |
| FromPrimitive::from_u32(7).unwrap(), |
| ]; |
| |
| assert_eq!(result, data.iter().sum()); |
| assert_eq!(result, data.into_iter().sum()); |
| } |
| |
| #[test] |
| fn test_iter_product() { |
| let data: Vec<BigUint> = vec![ |
| FromPrimitive::from_u32(1001).unwrap(), |
| FromPrimitive::from_u32(1002).unwrap(), |
| FromPrimitive::from_u32(1003).unwrap(), |
| FromPrimitive::from_u32(1004).unwrap(), |
| FromPrimitive::from_u32(1005).unwrap(), |
| ]; |
| let result = data.get(0).unwrap() |
| * data.get(1).unwrap() |
| * data.get(2).unwrap() |
| * data.get(3).unwrap() |
| * data.get(4).unwrap(); |
| |
| assert_eq!(result, data.iter().product()); |
| assert_eq!(result, data.into_iter().product()); |
| } |
| |
| #[test] |
| fn test_iter_sum_generic() { |
| let result: BigUint = FromPrimitive::from_isize(1234567).unwrap(); |
| let data = vec![1000000_u32, 200000, 30000, 4000, 500, 60, 7]; |
| |
| assert_eq!(result, data.iter().sum()); |
| assert_eq!(result, data.into_iter().sum()); |
| } |
| |
| #[test] |
| fn test_iter_product_generic() { |
| let data = vec![1001_u32, 1002, 1003, 1004, 1005]; |
| let result = data[0].to_biguint().unwrap() |
| * data[1].to_biguint().unwrap() |
| * data[2].to_biguint().unwrap() |
| * data[3].to_biguint().unwrap() |
| * data[4].to_biguint().unwrap(); |
| |
| assert_eq!(result, data.iter().product()); |
| assert_eq!(result, data.into_iter().product()); |
| } |
| |
| #[test] |
| fn test_pow() { |
| let one = BigUint::from(1u32); |
| let two = BigUint::from(2u32); |
| let four = BigUint::from(4u32); |
| let eight = BigUint::from(8u32); |
| let tentwentyfour = BigUint::from(1024u32); |
| let twentyfourtyeight = BigUint::from(2048u32); |
| macro_rules! check { |
| ($t:ty) => { |
| assert_eq!(two.pow(0 as $t), one); |
| assert_eq!(two.pow(1 as $t), two); |
| assert_eq!(two.pow(2 as $t), four); |
| assert_eq!(two.pow(3 as $t), eight); |
| assert_eq!(two.pow(10 as $t), tentwentyfour); |
| assert_eq!(two.pow(11 as $t), twentyfourtyeight); |
| assert_eq!(two.pow(&(11 as $t)), twentyfourtyeight); |
| }; |
| } |
| check!(u8); |
| check!(u16); |
| check!(u32); |
| check!(u64); |
| check!(usize); |
| #[cfg(has_i128)] |
| check!(u128); |
| } |
