From 279522316c1392fb8d5d306f1934fb8415972531 Mon Sep 17 00:00:00 2001 From: Kent Overstreet Date: Mon, 18 Jul 2016 15:56:03 -0800 Subject: [PATCH] bigint: Break out into multiple files --- bigint/src/algorithms.rs | 586 ++++ bigint/src/bigint.rs | 1107 ++++++++ bigint/src/biguint.rs | 1199 ++++++++ bigint/src/lib.rs | 5189 +---------------------------------- bigint/src/macros.rs | 133 + bigint/src/tests/bigint.rs | 954 +++++++ bigint/src/tests/biguint.rs | 1236 +++++++++ 7 files changed, 5230 insertions(+), 5174 deletions(-) create mode 100644 bigint/src/algorithms.rs create mode 100644 bigint/src/bigint.rs create mode 100644 bigint/src/biguint.rs create mode 100644 bigint/src/macros.rs create mode 100644 bigint/src/tests/bigint.rs create mode 100644 bigint/src/tests/biguint.rs diff --git a/bigint/src/algorithms.rs b/bigint/src/algorithms.rs new file mode 100644 index 0000000..050e0b8 --- /dev/null +++ b/bigint/src/algorithms.rs @@ -0,0 +1,586 @@ +use std::borrow::Cow; +use std::cmp; +use std::cmp::Ordering::{self, Less, Greater, Equal}; +use std::iter::repeat; +use std::mem; +use traits; +use traits::{Zero, One}; + +use biguint::BigUint; + +use bigint::Sign; +use bigint::Sign::{Minus, NoSign, Plus}; + +#[allow(non_snake_case)] +pub mod big_digit { + /// A `BigDigit` is a `BigUint`'s composing element. + pub type BigDigit = u32; + + /// A `DoubleBigDigit` is the internal type used to do the computations. Its + /// size is the double of the size of `BigDigit`. + pub type DoubleBigDigit = u64; + + pub const ZERO_BIG_DIGIT: BigDigit = 0; + + // `DoubleBigDigit` size dependent + pub const BITS: usize = 32; + + pub const BASE: DoubleBigDigit = 1 << BITS; + const LO_MASK: DoubleBigDigit = (-1i32 as DoubleBigDigit) >> BITS; + + #[inline] + fn get_hi(n: DoubleBigDigit) -> BigDigit { + (n >> BITS) as BigDigit + } + #[inline] + fn get_lo(n: DoubleBigDigit) -> BigDigit { + (n & LO_MASK) as BigDigit + } + + /// Split one `DoubleBigDigit` into two `BigDigit`s. + #[inline] + pub fn from_doublebigdigit(n: DoubleBigDigit) -> (BigDigit, BigDigit) { + (get_hi(n), get_lo(n)) + } + + /// Join two `BigDigit`s into one `DoubleBigDigit` + #[inline] + pub fn to_doublebigdigit(hi: BigDigit, lo: BigDigit) -> DoubleBigDigit { + (lo as DoubleBigDigit) | ((hi as DoubleBigDigit) << BITS) + } +} + +use big_digit::{BigDigit, DoubleBigDigit}; + +// Generic functions for add/subtract/multiply with carry/borrow: + +// Add with carry: +#[inline] +fn adc(a: BigDigit, b: BigDigit, carry: &mut BigDigit) -> BigDigit { + let (hi, lo) = big_digit::from_doublebigdigit((a as DoubleBigDigit) + (b as DoubleBigDigit) + + (*carry as DoubleBigDigit)); + + *carry = hi; + lo +} + +// Subtract with borrow: +#[inline] +fn sbb(a: BigDigit, b: BigDigit, borrow: &mut BigDigit) -> BigDigit { + let (hi, lo) = big_digit::from_doublebigdigit(big_digit::BASE + (a as DoubleBigDigit) - + (b as DoubleBigDigit) - + (*borrow as DoubleBigDigit)); + // hi * (base) + lo == 1*(base) + ai - bi - borrow + // => ai - bi - borrow < 0 <=> hi == 0 + *borrow = (hi == 0) as BigDigit; + lo +} + +#[inline] +pub fn mac_with_carry(a: BigDigit, b: BigDigit, c: BigDigit, carry: &mut BigDigit) -> BigDigit { + let (hi, lo) = big_digit::from_doublebigdigit((a as DoubleBigDigit) + + (b as DoubleBigDigit) * (c as DoubleBigDigit) + + (*carry as DoubleBigDigit)); + *carry = hi; + lo +} + +/// Divide a two digit numerator by a one digit divisor, returns quotient and remainder: +/// +/// Note: the caller must ensure that both the quotient and remainder will fit into a single digit. +/// This is _not_ true for an arbitrary numerator/denominator. +/// +/// (This function also matches what the x86 divide instruction does). +#[inline] +fn div_wide(hi: BigDigit, lo: BigDigit, divisor: BigDigit) -> (BigDigit, BigDigit) { + debug_assert!(hi < divisor); + + let lhs = big_digit::to_doublebigdigit(hi, lo); + let rhs = divisor as DoubleBigDigit; + ((lhs / rhs) as BigDigit, (lhs % rhs) as BigDigit) +} + +pub fn div_rem_digit(mut a: BigUint, b: BigDigit) -> (BigUint, BigDigit) { + let mut rem = 0; + + for d in a.data.iter_mut().rev() { + let (q, r) = div_wide(rem, *d, b); + *d = q; + rem = r; + } + + (a.normalize(), rem) +} + +// Only for the Add impl: +#[must_use] +#[inline] +pub fn __add2(a: &mut [BigDigit], b: &[BigDigit]) -> BigDigit { + debug_assert!(a.len() >= b.len()); + + let mut carry = 0; + let (a_lo, a_hi) = a.split_at_mut(b.len()); + + for (a, b) in a_lo.iter_mut().zip(b) { + *a = adc(*a, *b, &mut carry); + } + + if carry != 0 { + for a in a_hi { + *a = adc(*a, 0, &mut carry); + if carry == 0 { break } + } + } + + carry +} + +/// /Two argument addition of raw slices: +/// a += b +/// +/// The caller _must_ ensure that a is big enough to store the result - typically this means +/// resizing a to max(a.len(), b.len()) + 1, to fit a possible carry. +pub fn add2(a: &mut [BigDigit], b: &[BigDigit]) { + let carry = __add2(a, b); + + debug_assert!(carry == 0); +} + +pub fn sub2(a: &mut [BigDigit], b: &[BigDigit]) { + let mut borrow = 0; + + let len = cmp::min(a.len(), b.len()); + let (a_lo, a_hi) = a.split_at_mut(len); + let (b_lo, b_hi) = b.split_at(len); + + for (a, b) in a_lo.iter_mut().zip(b_lo) { + *a = sbb(*a, *b, &mut borrow); + } + + if borrow != 0 { + for a in a_hi { + *a = sbb(*a, 0, &mut borrow); + if borrow == 0 { break } + } + } + + // note: we're _required_ to fail on underflow + assert!(borrow == 0 && b_hi.iter().all(|x| *x == 0), + "Cannot subtract b from a because b is larger than a."); +} + +pub fn sub2rev(a: &[BigDigit], b: &mut [BigDigit]) { + debug_assert!(b.len() >= a.len()); + + let mut borrow = 0; + + let len = cmp::min(a.len(), b.len()); + let (a_lo, a_hi) = a.split_at(len); + let (b_lo, b_hi) = b.split_at_mut(len); + + for (a, b) in a_lo.iter().zip(b_lo) { + *b = sbb(*a, *b, &mut borrow); + } + + assert!(a_hi.is_empty()); + + // note: we're _required_ to fail on underflow + assert!(borrow == 0 && b_hi.iter().all(|x| *x == 0), + "Cannot subtract b from a because b is larger than a."); +} + +pub fn sub_sign(a: &[BigDigit], b: &[BigDigit]) -> (Sign, BigUint) { + // Normalize: + let a = &a[..a.iter().rposition(|&x| x != 0).map_or(0, |i| i + 1)]; + let b = &b[..b.iter().rposition(|&x| x != 0).map_or(0, |i| i + 1)]; + + match cmp_slice(a, b) { + Greater => { + let mut a = a.to_vec(); + sub2(&mut a, b); + (Plus, BigUint::new(a)) + } + Less => { + let mut b = b.to_vec(); + sub2(&mut b, a); + (Minus, BigUint::new(b)) + } + _ => (NoSign, Zero::zero()), + } +} + +/// Three argument multiply accumulate: +/// acc += b * c +fn mac_digit(acc: &mut [BigDigit], b: &[BigDigit], c: BigDigit) { + if c == 0 { + return; + } + + let mut b_iter = b.iter(); + let mut carry = 0; + + for ai in acc.iter_mut() { + if let Some(bi) = b_iter.next() { + *ai = mac_with_carry(*ai, *bi, c, &mut carry); + } else if carry != 0 { + *ai = mac_with_carry(*ai, 0, c, &mut carry); + } else { + break; + } + } + + assert!(carry == 0); +} + +/// Three argument multiply accumulate: +/// acc += b * c +fn mac3(acc: &mut [BigDigit], b: &[BigDigit], c: &[BigDigit]) { + let (x, y) = if b.len() < c.len() { + (b, c) + } else { + (c, b) + }; + + // Karatsuba multiplication is slower than long multiplication for small x and y: + // + if x.len() <= 4 { + for (i, xi) in x.iter().enumerate() { + mac_digit(&mut acc[i..], y, *xi); + } + } else { + /* + * Karatsuba multiplication: + * + * The idea is that we break x and y up into two smaller numbers that each have about half + * as many digits, like so (note that multiplying by b is just a shift): + * + * x = x0 + x1 * b + * y = y0 + y1 * b + * + * With some algebra, we can compute x * y with three smaller products, where the inputs to + * each of the smaller products have only about half as many digits as x and y: + * + * x * y = (x0 + x1 * b) * (y0 + y1 * b) + * + * x * y = x0 * y0 + * + x0 * y1 * b + * + x1 * y0 * b + * + x1 * y1 * b^2 + * + * Let p0 = x0 * y0 and p2 = x1 * y1: + * + * x * y = p0 + * + (x0 * y1 + x1 * p0) * b + * + p2 * b^2 + * + * The real trick is that middle term: + * + * x0 * y1 + x1 * y0 + * + * = x0 * y1 + x1 * y0 - p0 + p0 - p2 + p2 + * + * = x0 * y1 + x1 * y0 - x0 * y0 - x1 * y1 + p0 + p2 + * + * Now we complete the square: + * + * = -(x0 * y0 - x0 * y1 - x1 * y0 + x1 * y1) + p0 + p2 + * + * = -((x1 - x0) * (y1 - y0)) + p0 + p2 + * + * Let p1 = (x1 - x0) * (y1 - y0), and substitute back into our original formula: + * + * x * y = p0 + * + (p0 + p2 - p1) * b + * + p2 * b^2 + * + * Where the three intermediate products are: + * + * p0 = x0 * y0 + * p1 = (x1 - x0) * (y1 - y0) + * p2 = x1 * y1 + * + * In doing the computation, we take great care to avoid unnecessary temporary variables + * (since creating a BigUint requires a heap allocation): thus, we rearrange the formula a + * bit so we can use the same temporary variable for all the intermediate products: + * + * x * y = p2 * b^2 + p2 * b + * + p0 * b + p0 + * - p1 * b + * + * The other trick we use is instead of doing explicit shifts, we slice acc at the + * appropriate offset when doing the add. + */ + + /* + * When x is smaller than y, it's significantly faster to pick b such that x is split in + * half, not y: + */ + let b = x.len() / 2; + let (x0, x1) = x.split_at(b); + let (y0, y1) = y.split_at(b); + + /* + * We reuse the same BigUint for all the intermediate multiplies and have to size p + * appropriately here: x1.len() >= x0.len and y1.len() >= y0.len(): + */ + let len = x1.len() + y1.len() + 1; + let mut p = BigUint { data: vec![0; len] }; + + // p2 = x1 * y1 + mac3(&mut p.data[..], x1, y1); + + // Not required, but the adds go faster if we drop any unneeded 0s from the end: + p = p.normalize(); + + add2(&mut acc[b..], &p.data[..]); + add2(&mut acc[b * 2..], &p.data[..]); + + // Zero out p before the next multiply: + p.data.truncate(0); + p.data.extend(repeat(0).take(len)); + + // p0 = x0 * y0 + mac3(&mut p.data[..], x0, y0); + p = p.normalize(); + + add2(&mut acc[..], &p.data[..]); + add2(&mut acc[b..], &p.data[..]); + + // p1 = (x1 - x0) * (y1 - y0) + // We do this one last, since it may be negative and acc can't ever be negative: + let (j0_sign, j0) = sub_sign(x1, x0); + let (j1_sign, j1) = sub_sign(y1, y0); + + match j0_sign * j1_sign { + Plus => { + p.data.truncate(0); + p.data.extend(repeat(0).take(len)); + + mac3(&mut p.data[..], &j0.data[..], &j1.data[..]); + p = p.normalize(); + + sub2(&mut acc[b..], &p.data[..]); + }, + Minus => { + mac3(&mut acc[b..], &j0.data[..], &j1.data[..]); + }, + NoSign => (), + } + } +} + +pub fn mul3(x: &[BigDigit], y: &[BigDigit]) -> BigUint { + let len = x.len() + y.len() + 1; + let mut prod = BigUint { data: vec![0; len] }; + + mac3(&mut prod.data[..], x, y); + prod.normalize() +} + +pub fn div_rem(u: &BigUint, d: &BigUint) -> (BigUint, BigUint) { + if d.is_zero() { + panic!() + } + if u.is_zero() { + return (Zero::zero(), Zero::zero()); + } + if *d == One::one() { + return (u.clone(), Zero::zero()); + } + + // Required or the q_len calculation below can underflow: + match u.cmp(d) { + Less => return (Zero::zero(), u.clone()), + Equal => return (One::one(), Zero::zero()), + Greater => {} // Do nothing + } + + // This algorithm is from Knuth, TAOCP vol 2 section 4.3, algorithm D: + // + // First, normalize the arguments so the highest bit in the highest digit of the divisor is + // set: the main loop uses the highest digit of the divisor for generating guesses, so we + // want it to be the largest number we can efficiently divide by. + // + let shift = d.data.last().unwrap().leading_zeros() as usize; + let mut a = u << shift; + let b = d << shift; + + // The algorithm works by incrementally calculating "guesses", q0, for part of the + // remainder. Once we have any number q0 such that q0 * b <= a, we can set + // + // q += q0 + // a -= q0 * b + // + // and then iterate until a < b. Then, (q, a) will be our desired quotient and remainder. + // + // q0, our guess, is calculated by dividing the last few digits of a by the last digit of b + // - this should give us a guess that is "close" to the actual quotient, but is possibly + // greater than the actual quotient. If q0 * b > a, we simply use iterated subtraction + // until we have a guess such that q0 & b <= a. + // + + let bn = *b.data.last().unwrap(); + let q_len = a.data.len() - b.data.len() + 1; + let mut q = BigUint { data: vec![0; q_len] }; + + // We reuse the same temporary to avoid hitting the allocator in our inner loop - this is + // sized to hold a0 (in the common case; if a particular digit of the quotient is zero a0 + // can be bigger). + // + let mut tmp = BigUint { data: Vec::with_capacity(2) }; + + for j in (0..q_len).rev() { + /* + * When calculating our next guess q0, we don't need to consider the digits below j + * + b.data.len() - 1: we're guessing digit j of the quotient (i.e. q0 << j) from + * digit bn of the divisor (i.e. bn << (b.data.len() - 1) - so the product of those + * two numbers will be zero in all digits up to (j + b.data.len() - 1). + */ + let offset = j + b.data.len() - 1; + if offset >= a.data.len() { + continue; + } + + /* just avoiding a heap allocation: */ + let mut a0 = tmp; + a0.data.truncate(0); + a0.data.extend(a.data[offset..].iter().cloned()); + + /* + * q0 << j * big_digit::BITS is our actual quotient estimate - we do the shifts + * implicitly at the end, when adding and subtracting to a and q. Not only do we + * save the cost of the shifts, the rest of the arithmetic gets to work with + * smaller numbers. + */ + let (mut q0, _) = div_rem_digit(a0, bn); + let mut prod = &b * &q0; + + while cmp_slice(&prod.data[..], &a.data[j..]) == Greater { + let one: BigUint = One::one(); + q0 = q0 - one; + prod = prod - &b; + } + + add2(&mut q.data[j..], &q0.data[..]); + sub2(&mut a.data[j..], &prod.data[..]); + a = a.normalize(); + + tmp = q0; + } + + debug_assert!(a < b); + + (q.normalize(), a >> shift) +} + +/// Find last set bit +/// fls(0) == 0, fls(u32::MAX) == 32 +pub fn fls(v: T) -> usize { + mem::size_of::() * 8 - v.leading_zeros() as usize +} + +pub fn ilog2(v: T) -> usize { + fls(v) - 1 +} + +#[inline] +pub fn biguint_shl(n: Cow, bits: usize) -> BigUint { + let n_unit = bits / big_digit::BITS; + let mut data = match n_unit { + 0 => n.into_owned().data, + _ => { + let len = n_unit + n.data.len() + 1; + let mut data = Vec::with_capacity(len); + data.extend(repeat(0).take(n_unit)); + data.extend(n.data.iter().cloned()); + data + } + }; + + let n_bits = bits % big_digit::BITS; + if n_bits > 0 { + let mut carry = 0; + for elem in data[n_unit..].iter_mut() { + let new_carry = *elem >> (big_digit::BITS - n_bits); + *elem = (*elem << n_bits) | carry; + carry = new_carry; + } + if carry != 0 { + data.push(carry); + } + } + + BigUint::new(data) +} + +#[inline] +pub fn biguint_shr(n: Cow, bits: usize) -> BigUint { + let n_unit = bits / big_digit::BITS; + if n_unit >= n.data.len() { + return Zero::zero(); + } + let mut data = match n_unit { + 0 => n.into_owned().data, + _ => n.data[n_unit..].to_vec(), + }; + + let n_bits = bits % big_digit::BITS; + if n_bits > 0 { + let mut borrow = 0; + for elem in data.iter_mut().rev() { + let new_borrow = *elem << (big_digit::BITS - n_bits); + *elem = (*elem >> n_bits) | borrow; + borrow = new_borrow; + } + } + + BigUint::new(data) +} + +pub fn cmp_slice(a: &[BigDigit], b: &[BigDigit]) -> Ordering { + debug_assert!(a.last() != Some(&0)); + debug_assert!(b.last() != Some(&0)); + + let (a_len, b_len) = (a.len(), b.len()); + if a_len < b_len { + return Less; + } + if a_len > b_len { + return Greater; + } + + for (&ai, &bi) in a.iter().rev().zip(b.iter().rev()) { + if ai < bi { + return Less; + } + if ai > bi { + return Greater; + } + } + return Equal; +} + +#[cfg(test)] +mod algorithm_tests { + use {BigDigit, BigUint, BigInt}; + use Sign::Plus; + use traits::Num; + + #[test] + fn test_sub_sign() { + use super::sub_sign; + + fn sub_sign_i(a: &[BigDigit], b: &[BigDigit]) -> BigInt { + let (sign, val) = sub_sign(a, b); + BigInt::from_biguint(sign, val) + } + + let a = BigUint::from_str_radix("265252859812191058636308480000000", 10).unwrap(); + let b = BigUint::from_str_radix("26525285981219105863630848000000", 10).unwrap(); + let a_i = BigInt::from_biguint(Plus, a.clone()); + let b_i = BigInt::from_biguint(Plus, b.clone()); + + 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); + } +} diff --git a/bigint/src/bigint.rs b/bigint/src/bigint.rs new file mode 100644 index 0000000..6cf7486 --- /dev/null +++ b/bigint/src/bigint.rs @@ -0,0 +1,1107 @@ +use std::default::Default; +use std::ops::{Add, Div, Mul, Neg, Rem, Shl, Shr, Sub}; +use std::str::{self, FromStr}; +use std::fmt; +use std::cmp::Ordering::{self, Less, Greater, Equal}; +use std::{f32, f64}; +use std::{u8, i64, u64}; +use std::ascii::AsciiExt; + +#[cfg(feature = "serde")] +use serde; + +// Some of the tests of non-RNG-based functionality are randomized using the +// RNG-based functionality, so the RNG-based functionality needs to be enabled +// for tests. +#[cfg(any(feature = "rand", test))] +use rand::Rng; + +use integer::Integer; +use traits::{ToPrimitive, FromPrimitive, Num, CheckedAdd, CheckedSub, CheckedMul, + CheckedDiv, Signed, Zero, One}; + +use self::Sign::{Minus, NoSign, Plus}; + +use super::ParseBigIntError; +use super::big_digit; +use super::big_digit::BigDigit; +use biguint; +use biguint::to_str_radix_reversed; +use biguint::BigUint; + +#[cfg(test)] +#[path = "tests/bigint.rs"] +mod bigint_tests; + +/// A Sign is a `BigInt`'s composing element. +#[derive(PartialEq, PartialOrd, Eq, Ord, Copy, Clone, Debug, Hash)] +#[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))] +pub enum Sign { + Minus, + NoSign, + Plus, +} + +impl Neg for Sign { + type Output = Sign; + + /// Negate Sign value. + #[inline] + fn neg(self) -> Sign { + match self { + Minus => Plus, + NoSign => NoSign, + Plus => Minus, + } + } +} + +impl Mul for Sign { + type Output = Sign; + + #[inline] + fn mul(self, other: Sign) -> Sign { + match (self, other) { + (NoSign, _) | (_, NoSign) => NoSign, + (Plus, Plus) | (Minus, Minus) => Plus, + (Plus, Minus) | (Minus, Plus) => Minus, + } + } +} + +#[cfg(feature = "serde")] +impl serde::Serialize for Sign { + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: serde::Serializer + { + match *self { + Sign::Minus => (-1i8).serialize(serializer), + Sign::NoSign => 0i8.serialize(serializer), + Sign::Plus => 1i8.serialize(serializer), + } + } +} + +#[cfg(feature = "serde")] +impl serde::Deserialize for Sign { + fn deserialize(deserializer: &mut D) -> Result + where D: serde::Deserializer + { + use serde::de::Error; + + let sign: i8 = try!(serde::Deserialize::deserialize(deserializer)); + match sign { + -1 => Ok(Sign::Minus), + 0 => Ok(Sign::NoSign), + 1 => Ok(Sign::Plus), + _ => Err(D::Error::invalid_value("sign must be -1, 0, or 1")), + } + } +} + +/// A big signed integer type. +#[derive(Clone, Debug, Hash)] +#[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))] +pub struct BigInt { + sign: Sign, + data: BigUint, +} + +impl PartialEq for BigInt { + #[inline] + fn eq(&self, other: &BigInt) -> bool { + self.cmp(other) == Equal + } +} + +impl Eq for BigInt {} + +impl PartialOrd for BigInt { + #[inline] + fn partial_cmp(&self, other: &BigInt) -> Option { + Some(self.cmp(other)) + } +} + +impl Ord for BigInt { + #[inline] + fn cmp(&self, other: &BigInt) -> Ordering { + let scmp = self.sign.cmp(&other.sign); + if scmp != Equal { + return scmp; + } + + match self.sign { + NoSign => Equal, + Plus => self.data.cmp(&other.data), + Minus => other.data.cmp(&self.data), + } + } +} + +impl Default for BigInt { + #[inline] + fn default() -> BigInt { + Zero::zero() + } +} + +impl fmt::Display for BigInt { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.pad_integral(!self.is_negative(), "", &self.data.to_str_radix(10)) + } +} + +impl fmt::Binary for BigInt { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.pad_integral(!self.is_negative(), "0b", &self.data.to_str_radix(2)) + } +} + +impl fmt::Octal for BigInt { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.pad_integral(!self.is_negative(), "0o", &self.data.to_str_radix(8)) + } +} + +impl fmt::LowerHex for BigInt { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.pad_integral(!self.is_negative(), "0x", &self.data.to_str_radix(16)) + } +} + +impl fmt::UpperHex for BigInt { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.pad_integral(!self.is_negative(), + "0x", + &self.data.to_str_radix(16).to_ascii_uppercase()) + } +} + +impl FromStr for BigInt { + type Err = ParseBigIntError; + + #[inline] + fn from_str(s: &str) -> Result { + BigInt::from_str_radix(s, 10) + } +} + +impl Num for BigInt { + type FromStrRadixErr = ParseBigIntError; + + /// Creates and initializes a BigInt. + #[inline] + fn from_str_radix(mut s: &str, radix: u32) -> Result { + let sign = if s.starts_with('-') { + let tail = &s[1..]; + if !tail.starts_with('+') { + s = tail + } + Minus + } else { + Plus + }; + let bu = try!(BigUint::from_str_radix(s, radix)); + Ok(BigInt::from_biguint(sign, bu)) + } +} + +impl Shl for BigInt { + type Output = BigInt; + + #[inline] + fn shl(self, rhs: usize) -> BigInt { + (&self) << rhs + } +} + +impl<'a> Shl for &'a BigInt { + type Output = BigInt; + + #[inline] + fn shl(self, rhs: usize) -> BigInt { + BigInt::from_biguint(self.sign, &self.data << rhs) + } +} + +impl Shr for BigInt { + type Output = BigInt; + + #[inline] + fn shr(self, rhs: usize) -> BigInt { + BigInt::from_biguint(self.sign, self.data >> rhs) + } +} + +impl<'a> Shr for &'a BigInt { + type Output = BigInt; + + #[inline] + fn shr(self, rhs: usize) -> BigInt { + BigInt::from_biguint(self.sign, &self.data >> rhs) + } +} + +impl Zero for BigInt { + #[inline] + fn zero() -> BigInt { + BigInt::from_biguint(NoSign, Zero::zero()) + } + + #[inline] + fn is_zero(&self) -> bool { + self.sign == NoSign + } +} + +impl One for BigInt { + #[inline] + fn one() -> BigInt { + BigInt::from_biguint(Plus, One::one()) + } +} + +impl Signed for BigInt { + #[inline] + fn abs(&self) -> BigInt { + match self.sign { + Plus | NoSign => self.clone(), + Minus => BigInt::from_biguint(Plus, self.data.clone()), + } + } + + #[inline] + fn abs_sub(&self, other: &BigInt) -> BigInt { + if *self <= *other { + Zero::zero() + } else { + self - other + } + } + + #[inline] + fn signum(&self) -> BigInt { + match self.sign { + Plus => BigInt::from_biguint(Plus, One::one()), + Minus => BigInt::from_biguint(Minus, One::one()), + NoSign => Zero::zero(), + } + } + + #[inline] + fn is_positive(&self) -> bool { + self.sign == Plus + } + + #[inline] + fn is_negative(&self) -> bool { + self.sign == Minus + } +} + +// We want to forward to BigUint::add, but it's not clear how that will go until +// we compare both sign and magnitude. So we duplicate this body for every +// val/ref combination, deferring that decision to BigUint's own forwarding. +macro_rules! bigint_add { + ($a:expr, $a_owned:expr, $a_data:expr, $b:expr, $b_owned:expr, $b_data:expr) => { + match ($a.sign, $b.sign) { + (_, NoSign) => $a_owned, + (NoSign, _) => $b_owned, + // same sign => keep the sign with the sum of magnitudes + (Plus, Plus) | (Minus, Minus) => + BigInt::from_biguint($a.sign, $a_data + $b_data), + // opposite signs => keep the sign of the larger with the difference of magnitudes + (Plus, Minus) | (Minus, Plus) => + match $a.data.cmp(&$b.data) { + Less => BigInt::from_biguint($b.sign, $b_data - $a_data), + Greater => BigInt::from_biguint($a.sign, $a_data - $b_data), + Equal => Zero::zero(), + }, + } + }; +} + +impl<'a, 'b> Add<&'b BigInt> for &'a BigInt { + type Output = BigInt; + + #[inline] + fn add(self, other: &BigInt) -> BigInt { + bigint_add!(self, + self.clone(), + &self.data, + other, + other.clone(), + &other.data) + } +} + +impl<'a> Add for &'a BigInt { + type Output = BigInt; + + #[inline] + fn add(self, other: BigInt) -> BigInt { + bigint_add!(self, self.clone(), &self.data, other, other, other.data) + } +} + +impl<'a> Add<&'a BigInt> for BigInt { + type Output = BigInt; + + #[inline] + fn add(self, other: &BigInt) -> BigInt { + bigint_add!(self, self, self.data, other, other.clone(), &other.data) + } +} + +impl Add for BigInt { + type Output = BigInt; + + #[inline] + fn add(self, other: BigInt) -> BigInt { + bigint_add!(self, self, self.data, other, other, other.data) + } +} + +// We want to forward to BigUint::sub, but it's not clear how that will go until +// we compare both sign and magnitude. So we duplicate this body for every +// val/ref combination, deferring that decision to BigUint's own forwarding. +macro_rules! bigint_sub { + ($a:expr, $a_owned:expr, $a_data:expr, $b:expr, $b_owned:expr, $b_data:expr) => { + match ($a.sign, $b.sign) { + (_, NoSign) => $a_owned, + (NoSign, _) => -$b_owned, + // opposite signs => keep the sign of the left with the sum of magnitudes + (Plus, Minus) | (Minus, Plus) => + BigInt::from_biguint($a.sign, $a_data + $b_data), + // same sign => keep or toggle the sign of the left with the difference of magnitudes + (Plus, Plus) | (Minus, Minus) => + match $a.data.cmp(&$b.data) { + Less => BigInt::from_biguint(-$a.sign, $b_data - $a_data), + Greater => BigInt::from_biguint($a.sign, $a_data - $b_data), + Equal => Zero::zero(), + }, + } + }; +} + +impl<'a, 'b> Sub<&'b BigInt> for &'a BigInt { + type Output = BigInt; + + #[inline] + fn sub(self, other: &BigInt) -> BigInt { + bigint_sub!(self, + self.clone(), + &self.data, + other, + other.clone(), + &other.data) + } +} + +impl<'a> Sub for &'a BigInt { + type Output = BigInt; + + #[inline] + fn sub(self, other: BigInt) -> BigInt { + bigint_sub!(self, self.clone(), &self.data, other, other, other.data) + } +} + +impl<'a> Sub<&'a BigInt> for BigInt { + type Output = BigInt; + + #[inline] + fn sub(self, other: &BigInt) -> BigInt { + bigint_sub!(self, self, self.data, other, other.clone(), &other.data) + } +} + +impl Sub for BigInt { + type Output = BigInt; + + #[inline] + fn sub(self, other: BigInt) -> BigInt { + bigint_sub!(self, self, self.data, other, other, other.data) + } +} + +forward_all_binop_to_ref_ref!(impl Mul for BigInt, mul); + +impl<'a, 'b> Mul<&'b BigInt> for &'a BigInt { + type Output = BigInt; + + #[inline] + fn mul(self, other: &BigInt) -> BigInt { + BigInt::from_biguint(self.sign * other.sign, &self.data * &other.data) + } +} + +forward_all_binop_to_ref_ref!(impl Div for BigInt, div); + +impl<'a, 'b> Div<&'b BigInt> for &'a BigInt { + type Output = BigInt; + + #[inline] + fn div(self, other: &BigInt) -> BigInt { + let (q, _) = self.div_rem(other); + q + } +} + +forward_all_binop_to_ref_ref!(impl Rem for BigInt, rem); + +impl<'a, 'b> Rem<&'b BigInt> for &'a BigInt { + type Output = BigInt; + + #[inline] + fn rem(self, other: &BigInt) -> BigInt { + let (_, r) = self.div_rem(other); + r + } +} + +impl Neg for BigInt { + type Output = BigInt; + + #[inline] + fn neg(mut self) -> BigInt { + self.sign = -self.sign; + self + } +} + +impl<'a> Neg for &'a BigInt { + type Output = BigInt; + + #[inline] + fn neg(self) -> BigInt { + -self.clone() + } +} + +impl CheckedAdd for BigInt { + #[inline] + fn checked_add(&self, v: &BigInt) -> Option { + return Some(self.add(v)); + } +} + +impl CheckedSub for BigInt { + #[inline] + fn checked_sub(&self, v: &BigInt) -> Option { + return Some(self.sub(v)); + } +} + +impl CheckedMul for BigInt { + #[inline] + fn checked_mul(&self, v: &BigInt) -> Option { + return Some(self.mul(v)); + } +} + +impl CheckedDiv for BigInt { + #[inline] + fn checked_div(&self, v: &BigInt) -> Option { + if v.is_zero() { + return None; + } + return Some(self.div(v)); + } +} + +impl Integer for BigInt { + #[inline] + fn div_rem(&self, other: &BigInt) -> (BigInt, BigInt) { + // r.sign == self.sign + let (d_ui, r_ui) = self.data.div_mod_floor(&other.data); + let d = BigInt::from_biguint(self.sign, d_ui); + let r = BigInt::from_biguint(self.sign, r_ui); + if other.is_negative() { + (-d, r) + } else { + (d, r) + } + } + + #[inline] + fn div_floor(&self, other: &BigInt) -> BigInt { + let (d, _) = self.div_mod_floor(other); + d + } + + #[inline] + fn mod_floor(&self, other: &BigInt) -> BigInt { + let (_, m) = self.div_mod_floor(other); + m + } + + fn div_mod_floor(&self, other: &BigInt) -> (BigInt, BigInt) { + // m.sign == other.sign + let (d_ui, m_ui) = self.data.div_rem(&other.data); + let d = BigInt::from_biguint(Plus, d_ui); + let m = BigInt::from_biguint(Plus, m_ui); + let one: BigInt = One::one(); + match (self.sign, other.sign) { + (_, NoSign) => panic!(), + (Plus, Plus) | (NoSign, Plus) => (d, m), + (Plus, Minus) | (NoSign, Minus) => { + if m.is_zero() { + (-d, Zero::zero()) + } else { + (-d - one, m + other) + } + } + (Minus, Plus) => { + if m.is_zero() { + (-d, Zero::zero()) + } else { + (-d - one, other - m) + } + } + (Minus, Minus) => (d, -m), + } + } + + /// Calculates the Greatest Common Divisor (GCD) of the number and `other`. + /// + /// The result is always positive. + #[inline] + fn gcd(&self, other: &BigInt) -> BigInt { + BigInt::from_biguint(Plus, self.data.gcd(&other.data)) + } + + /// Calculates the Lowest Common Multiple (LCM) of the number and `other`. + #[inline] + fn lcm(&self, other: &BigInt) -> BigInt { + BigInt::from_biguint(Plus, self.data.lcm(&other.data)) + } + + /// Deprecated, use `is_multiple_of` instead. + #[inline] + fn divides(&self, other: &BigInt) -> bool { + return self.is_multiple_of(other); + } + + /// Returns `true` if the number is a multiple of `other`. + #[inline] + fn is_multiple_of(&self, other: &BigInt) -> bool { + self.data.is_multiple_of(&other.data) + } + + /// Returns `true` if the number is divisible by `2`. + #[inline] + fn is_even(&self) -> bool { + self.data.is_even() + } + + /// Returns `true` if the number is not divisible by `2`. + #[inline] + fn is_odd(&self) -> bool { + self.data.is_odd() + } +} + +impl ToPrimitive for BigInt { + #[inline] + fn to_i64(&self) -> Option { + match self.sign { + Plus => self.data.to_i64(), + NoSign => Some(0), + Minus => { + self.data.to_u64().and_then(|n| { + let m: u64 = 1 << 63; + if n < m { + Some(-(n as i64)) + } else if n == m { + Some(i64::MIN) + } else { + None + } + }) + } + } + } + + #[inline] + fn to_u64(&self) -> Option { + match self.sign { + Plus => self.data.to_u64(), + NoSign => Some(0), + Minus => None, + } + } + + #[inline] + fn to_f32(&self) -> Option { + self.data.to_f32().map(|n| { + if self.sign == Minus { + -n + } else { + n + } + }) + } + + #[inline] + fn to_f64(&self) -> Option { + self.data.to_f64().map(|n| { + if self.sign == Minus { + -n + } else { + n + } + }) + } +} + +impl FromPrimitive for BigInt { + #[inline] + fn from_i64(n: i64) -> Option { + Some(BigInt::from(n)) + } + + #[inline] + fn from_u64(n: u64) -> Option { + Some(BigInt::from(n)) + } + + #[inline] + fn from_f64(n: f64) -> Option { + if n >= 0.0 { + BigUint::from_f64(n).map(|x| BigInt::from_biguint(Plus, x)) + } else { + BigUint::from_f64(-n).map(|x| BigInt::from_biguint(Minus, x)) + } + } +} + +impl From for BigInt { + #[inline] + fn from(n: i64) -> Self { + if n >= 0 { + BigInt::from(n as u64) + } else { + let u = u64::MAX - (n as u64) + 1; + BigInt { + sign: Minus, + data: BigUint::from(u), + } + } + } +} + +macro_rules! impl_bigint_from_int { + ($T:ty) => { + impl From<$T> for BigInt { + #[inline] + fn from(n: $T) -> Self { + BigInt::from(n as i64) + } + } + } +} + +impl_bigint_from_int!(i8); +impl_bigint_from_int!(i16); +impl_bigint_from_int!(i32); +impl_bigint_from_int!(isize); + +impl From for BigInt { + #[inline] + fn from(n: u64) -> Self { + if n > 0 { + BigInt { + sign: Plus, + data: BigUint::from(n), + } + } else { + BigInt::zero() + } + } +} + +macro_rules! impl_bigint_from_uint { + ($T:ty) => { + impl From<$T> for BigInt { + #[inline] + fn from(n: $T) -> Self { + BigInt::from(n as u64) + } + } + } +} + +impl_bigint_from_uint!(u8); +impl_bigint_from_uint!(u16); +impl_bigint_from_uint!(u32); +impl_bigint_from_uint!(usize); + +impl From for BigInt { + #[inline] + fn from(n: BigUint) -> Self { + if n.is_zero() { + BigInt::zero() + } else { + BigInt { + sign: Plus, + data: n, + } + } + } +} + +#[cfg(feature = "serde")] +impl serde::Serialize for BigInt { + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: serde::Serializer + { + (self.sign, &self.data).serialize(serializer) + } +} + +#[cfg(feature = "serde")] +impl serde::Deserialize for BigInt { + fn deserialize(deserializer: &mut D) -> Result + where D: serde::Deserializer + { + let (sign, data) = try!(serde::Deserialize::deserialize(deserializer)); + Ok(BigInt { + sign: sign, + data: data, + }) + } +} + +/// A generic trait for converting a value to a `BigInt`. +pub trait ToBigInt { + /// Converts the value of `self` to a `BigInt`. + fn to_bigint(&self) -> Option; +} + +impl ToBigInt for BigInt { + #[inline] + fn to_bigint(&self) -> Option { + Some(self.clone()) + } +} + +impl ToBigInt for BigUint { + #[inline] + fn to_bigint(&self) -> Option { + if self.is_zero() { + Some(Zero::zero()) + } else { + Some(BigInt { + sign: Plus, + data: self.clone(), + }) + } + } +} + +impl biguint::ToBigUint for BigInt { + #[inline] + fn to_biguint(&self) -> Option { + match self.sign() { + Plus => Some(self.data.clone()), + NoSign => Some(Zero::zero()), + Minus => None, + } + } +} + +macro_rules! impl_to_bigint { + ($T:ty, $from_ty:path) => { + impl ToBigInt for $T { + #[inline] + fn to_bigint(&self) -> Option { + $from_ty(*self) + } + } + } +} + +impl_to_bigint!(isize, FromPrimitive::from_isize); +impl_to_bigint!(i8, FromPrimitive::from_i8); +impl_to_bigint!(i16, FromPrimitive::from_i16); +impl_to_bigint!(i32, FromPrimitive::from_i32); +impl_to_bigint!(i64, FromPrimitive::from_i64); +impl_to_bigint!(usize, FromPrimitive::from_usize); +impl_to_bigint!(u8, FromPrimitive::from_u8); +impl_to_bigint!(u16, FromPrimitive::from_u16); +impl_to_bigint!(u32, FromPrimitive::from_u32); +impl_to_bigint!(u64, FromPrimitive::from_u64); +impl_to_bigint!(f32, FromPrimitive::from_f32); +impl_to_bigint!(f64, FromPrimitive::from_f64); + +pub trait RandBigInt { + /// Generate a random `BigUint` of the given bit size. + fn gen_biguint(&mut self, bit_size: usize) -> BigUint; + + /// Generate a random BigInt of the given bit size. + fn gen_bigint(&mut self, bit_size: usize) -> BigInt; + + /// Generate a random `BigUint` less than the given bound. Fails + /// when the bound is zero. + fn gen_biguint_below(&mut self, bound: &BigUint) -> BigUint; + + /// Generate a random `BigUint` within the given range. The lower + /// bound is inclusive; the upper bound is exclusive. Fails when + /// the upper bound is not greater than the lower bound. + fn gen_biguint_range(&mut self, lbound: &BigUint, ubound: &BigUint) -> BigUint; + + /// Generate a random `BigInt` within the given range. The lower + /// bound is inclusive; the upper bound is exclusive. Fails when + /// the upper bound is not greater than the lower bound. + fn gen_bigint_range(&mut self, lbound: &BigInt, ubound: &BigInt) -> BigInt; +} + +#[cfg(any(feature = "rand", test))] +impl RandBigInt for R { + fn gen_biguint(&mut self, bit_size: usize) -> BigUint { + let (digits, rem) = bit_size.div_rem(&big_digit::BITS); + let mut data = Vec::with_capacity(digits + 1); + for _ in 0..digits { + data.push(self.gen()); + } + if rem > 0 { + let final_digit: BigDigit = self.gen(); + data.push(final_digit >> (big_digit::BITS - rem)); + } + BigUint::new(data) + } + + fn gen_bigint(&mut self, bit_size: usize) -> BigInt { + // Generate a random BigUint... + let biguint = self.gen_biguint(bit_size); + // ...and then randomly assign it a Sign... + let sign = if biguint.is_zero() { + // ...except that if the BigUint is zero, we need to try + // again with probability 0.5. This is because otherwise, + // the probability of generating a zero BigInt would be + // double that of any other number. + if self.gen() { + return self.gen_bigint(bit_size); + } else { + NoSign + } + } else if self.gen() { + Plus + } else { + Minus + }; + BigInt::from_biguint(sign, biguint) + } + + fn gen_biguint_below(&mut self, bound: &BigUint) -> BigUint { + assert!(!bound.is_zero()); + let bits = bound.bits(); + loop { + let n = self.gen_biguint(bits); + if n < *bound { + return n; + } + } + } + + fn gen_biguint_range(&mut self, lbound: &BigUint, ubound: &BigUint) -> BigUint { + assert!(*lbound < *ubound); + return lbound + self.gen_biguint_below(&(ubound - lbound)); + } + + fn gen_bigint_range(&mut self, lbound: &BigInt, ubound: &BigInt) -> BigInt { + assert!(*lbound < *ubound); + let delta = (ubound - lbound).to_biguint().unwrap(); + return lbound + self.gen_biguint_below(&delta).to_bigint().unwrap(); + } +} + +impl BigInt { + /// Creates and initializes a BigInt. + /// + /// The digits are in little-endian base 2^32. + #[inline] + pub fn new(sign: Sign, digits: Vec) -> BigInt { + BigInt::from_biguint(sign, BigUint::new(digits)) + } + + /// Creates and initializes a `BigInt`. + /// + /// The digits are in little-endian base 2^32. + #[inline] + pub fn from_biguint(sign: Sign, data: BigUint) -> BigInt { + if sign == NoSign || data.is_zero() { + return BigInt { + sign: NoSign, + data: Zero::zero(), + }; + } + BigInt { + sign: sign, + data: data, + } + } + + /// Creates and initializes a `BigInt`. + #[inline] + pub fn from_slice(sign: Sign, slice: &[BigDigit]) -> BigInt { + BigInt::from_biguint(sign, BigUint::from_slice(slice)) + } + + /// Creates and initializes a `BigInt`. + /// + /// The bytes are in big-endian byte order. + /// + /// # Examples + /// + /// ``` + /// use num_bigint::{BigInt, Sign}; + /// + /// assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"A"), + /// BigInt::parse_bytes(b"65", 10).unwrap()); + /// assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"AA"), + /// BigInt::parse_bytes(b"16705", 10).unwrap()); + /// assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"AB"), + /// BigInt::parse_bytes(b"16706", 10).unwrap()); + /// assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"Hello world!"), + /// BigInt::parse_bytes(b"22405534230753963835153736737", 10).unwrap()); + /// ``` + #[inline] + pub fn from_bytes_be(sign: Sign, bytes: &[u8]) -> BigInt { + BigInt::from_biguint(sign, BigUint::from_bytes_be(bytes)) + } + + /// Creates and initializes a `BigInt`. + /// + /// The bytes are in little-endian byte order. + #[inline] + pub fn from_bytes_le(sign: Sign, bytes: &[u8]) -> BigInt { + BigInt::from_biguint(sign, BigUint::from_bytes_le(bytes)) + } + + /// Returns the sign and the byte representation of the `BigInt` in little-endian byte order. + /// + /// # Examples + /// + /// ``` + /// use num_bigint::{ToBigInt, Sign}; + /// + /// let i = -1125.to_bigint().unwrap(); + /// assert_eq!(i.to_bytes_le(), (Sign::Minus, vec![101, 4])); + /// ``` + #[inline] + pub fn to_bytes_le(&self) -> (Sign, Vec) { + (self.sign, self.data.to_bytes_le()) + } + + /// Returns the sign and the byte representation of the `BigInt` in big-endian byte order. + /// + /// # Examples + /// + /// ``` + /// use num_bigint::{ToBigInt, Sign}; + /// + /// let i = -1125.to_bigint().unwrap(); + /// assert_eq!(i.to_bytes_be(), (Sign::Minus, vec![4, 101])); + /// ``` + #[inline] + pub fn to_bytes_be(&self) -> (Sign, Vec) { + (self.sign, self.data.to_bytes_be()) + } + + /// Returns the integer formatted as a string in the given radix. + /// `radix` must be in the range `[2, 36]`. + /// + /// # Examples + /// + /// ``` + /// use num_bigint::BigInt; + /// + /// let i = BigInt::parse_bytes(b"ff", 16).unwrap(); + /// assert_eq!(i.to_str_radix(16), "ff"); + /// ``` + #[inline] + pub fn to_str_radix(&self, radix: u32) -> String { + let mut v = to_str_radix_reversed(&self.data, radix); + + if self.is_negative() { + v.push(b'-'); + } + + v.reverse(); + unsafe { String::from_utf8_unchecked(v) } + } + + /// Returns the sign of the `BigInt` as a `Sign`. + /// + /// # Examples + /// + /// ``` + /// use num_bigint::{ToBigInt, Sign}; + /// + /// assert_eq!(ToBigInt::to_bigint(&1234).unwrap().sign(), Sign::Plus); + /// assert_eq!(ToBigInt::to_bigint(&-4321).unwrap().sign(), Sign::Minus); + /// assert_eq!(ToBigInt::to_bigint(&0).unwrap().sign(), Sign::NoSign); + /// ``` + #[inline] + pub fn sign(&self) -> Sign { + self.sign + } + + /// Creates and initializes a `BigInt`. + /// + /// # Examples + /// + /// ``` + /// use num_bigint::{BigInt, ToBigInt}; + /// + /// assert_eq!(BigInt::parse_bytes(b"1234", 10), ToBigInt::to_bigint(&1234)); + /// assert_eq!(BigInt::parse_bytes(b"ABCD", 16), ToBigInt::to_bigint(&0xABCD)); + /// assert_eq!(BigInt::parse_bytes(b"G", 16), None); + /// ``` + #[inline] + pub fn parse_bytes(buf: &[u8], radix: u32) -> Option { + str::from_utf8(buf).ok().and_then(|s| BigInt::from_str_radix(s, radix).ok()) + } + + /// Determines the fewest bits necessary to express the `BigInt`, + /// not including the sign. + pub fn bits(&self) -> usize { + self.data.bits() + } + + /// Converts this `BigInt` into a `BigUint`, if it's not negative. + #[inline] + pub fn to_biguint(&self) -> Option { + match self.sign { + Plus => Some(self.data.clone()), + NoSign => Some(Zero::zero()), + Minus => None, + } + } + + #[inline] + pub fn checked_add(&self, v: &BigInt) -> Option { + return Some(self.add(v)); + } + + #[inline] + pub fn checked_sub(&self, v: &BigInt) -> Option { + return Some(self.sub(v)); + } + + #[inline] + pub fn checked_mul(&self, v: &BigInt) -> Option { + return Some(self.mul(v)); + } + + #[inline] + pub fn checked_div(&self, v: &BigInt) -> Option { + if v.is_zero() { + return None; + } + return Some(self.div(v)); + } +} diff --git a/bigint/src/biguint.rs b/bigint/src/biguint.rs new file mode 100644 index 0000000..b9dfa19 --- /dev/null +++ b/bigint/src/biguint.rs @@ -0,0 +1,1199 @@ +use std::borrow::Cow; +use std::default::Default; +use std::iter::repeat; +use std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Neg, Rem, Shl, Shr, Sub}; +use std::str::{self, FromStr}; +use std::fmt; +use std::cmp; +use std::cmp::Ordering::{self, Less, Greater, Equal}; +use std::{f32, f64}; +use std::{u8, i64, u64}; +use std::ascii::AsciiExt; + +#[cfg(feature = "serde")] +use serde; + +use integer::Integer; +use traits::{ToPrimitive, FromPrimitive, Float, Num, Unsigned, CheckedAdd, CheckedSub, CheckedMul, + CheckedDiv, Zero, One}; + +#[path = "algorithms.rs"] +mod algorithms; +pub use self::algorithms::big_digit; +pub use self::big_digit::{BigDigit, DoubleBigDigit, ZERO_BIG_DIGIT}; + +use self::algorithms::{mac_with_carry, mul3, div_rem, div_rem_digit}; +use self::algorithms::{__add2, add2, sub2, sub2rev}; +use self::algorithms::{biguint_shl, biguint_shr}; +use self::algorithms::{cmp_slice, fls, ilog2}; + +use ParseBigIntError; + +#[cfg(test)] +#[path = "tests/biguint.rs"] +mod biguint_tests; + +/// A big unsigned integer type. +/// +/// A `BigUint`-typed value `BigUint { data: vec!(a, b, c) }` represents a number +/// `(a + b * big_digit::BASE + c * big_digit::BASE^2)`. +#[derive(Clone, Debug, Hash)] +#[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))] +pub struct BigUint { + data: Vec, +} + +impl PartialEq for BigUint { + #[inline] + fn eq(&self, other: &BigUint) -> bool { + match self.cmp(other) { + Equal => true, + _ => false, + } + } +} +impl Eq for BigUint {} + +impl PartialOrd for BigUint { + #[inline] + fn partial_cmp(&self, other: &BigUint) -> Option { + Some(self.cmp(other)) + } +} + +impl Ord for BigUint { + #[inline] + fn cmp(&self, other: &BigUint) -> Ordering { + cmp_slice(&self.data[..], &other.data[..]) + } +} + +impl Default for BigUint { + #[inline] + fn default() -> BigUint { + Zero::zero() + } +} + +impl fmt::Display for BigUint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.pad_integral(true, "", &self.to_str_radix(10)) + } +} + +impl fmt::LowerHex for BigUint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.pad_integral(true, "0x", &self.to_str_radix(16)) + } +} + +impl fmt::UpperHex for BigUint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.pad_integral(true, "0x", &self.to_str_radix(16).to_ascii_uppercase()) + } +} + +impl fmt::Binary for BigUint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.pad_integral(true, "0b", &self.to_str_radix(2)) + } +} + +impl fmt::Octal for BigUint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.pad_integral(true, "0o", &self.to_str_radix(8)) + } +} + +impl FromStr for BigUint { + type Err = ParseBigIntError; + + #[inline] + fn from_str(s: &str) -> Result { + BigUint::from_str_radix(s, 10) + } +} + +// Convert from a power of two radix (bits == ilog2(radix)) where bits evenly divides +// BigDigit::BITS +fn from_bitwise_digits_le(v: &[u8], bits: usize) -> BigUint { + debug_assert!(!v.is_empty() && bits <= 8 && big_digit::BITS % bits == 0); + debug_assert!(v.iter().all(|&c| (c as BigDigit) < (1 << bits))); + + let digits_per_big_digit = big_digit::BITS / bits; + + let data = v.chunks(digits_per_big_digit) + .map(|chunk| { + chunk.iter().rev().fold(0, |acc, &c| (acc << bits) | c as BigDigit) + }) + .collect(); + + BigUint::new(data) +} + +// Convert from a power of two radix (bits == ilog2(radix)) where bits doesn't evenly divide +// BigDigit::BITS +fn from_inexact_bitwise_digits_le(v: &[u8], bits: usize) -> BigUint { + debug_assert!(!v.is_empty() && bits <= 8 && big_digit::BITS % bits != 0); + debug_assert!(v.iter().all(|&c| (c as BigDigit) < (1 << bits))); + + let big_digits = (v.len() * bits + big_digit::BITS - 1) / big_digit::BITS; + let mut data = Vec::with_capacity(big_digits); + + let mut d = 0; + let mut dbits = 0; // number of bits we currently have in d + + // walk v accumululating bits in d; whenever we accumulate big_digit::BITS in d, spit out a + // big_digit: + for &c in v { + d |= (c as BigDigit) << dbits; + dbits += bits; + + if dbits >= big_digit::BITS { + data.push(d); + dbits -= big_digit::BITS; + // if dbits was > big_digit::BITS, we dropped some of the bits in c (they couldn't fit + // in d) - grab the bits we lost here: + d = (c as BigDigit) >> (bits - dbits); + } + } + + if dbits > 0 { + debug_assert!(dbits < big_digit::BITS); + data.push(d as BigDigit); + } + + BigUint::new(data) +} + +// Read little-endian radix digits +fn from_radix_digits_be(v: &[u8], radix: u32) -> BigUint { + debug_assert!(!v.is_empty() && !radix.is_power_of_two()); + debug_assert!(v.iter().all(|&c| (c as u32) < radix)); + + // Estimate how big the result will be, so we can pre-allocate it. + let bits = (radix as f64).log2() * v.len() as f64; + let big_digits = (bits / big_digit::BITS as f64).ceil(); + let mut data = Vec::with_capacity(big_digits as usize); + + let (base, power) = get_radix_base(radix); + let radix = radix as BigDigit; + + let r = v.len() % power; + let i = if r == 0 { + power + } else { + r + }; + let (head, tail) = v.split_at(i); + + let first = head.iter().fold(0, |acc, &d| acc * radix + d as BigDigit); + data.push(first); + + debug_assert!(tail.len() % power == 0); + for chunk in tail.chunks(power) { + if data.last() != Some(&0) { + data.push(0); + } + + let mut carry = 0; + for d in data.iter_mut() { + *d = mac_with_carry(0, *d, base, &mut carry); + } + debug_assert!(carry == 0); + + let n = chunk.iter().fold(0, |acc, &d| acc * radix + d as BigDigit); + add2(&mut data, &[n]); + } + + BigUint::new(data) +} + +impl Num for BigUint { + type FromStrRadixErr = ParseBigIntError; + + /// Creates and initializes a `BigUint`. + fn from_str_radix(s: &str, radix: u32) -> Result { + assert!(2 <= radix && radix <= 36, "The radix must be within 2...36"); + let mut s = s; + if s.starts_with('+') { + let tail = &s[1..]; + if !tail.starts_with('+') { + s = tail + } + } + + if s.is_empty() { + // create ParseIntError::Empty + let e = u64::from_str_radix(s, radix).unwrap_err(); + return Err(e.into()); + } + + // First normalize all characters to plain digit values + let mut v = Vec::with_capacity(s.len()); + for b in s.bytes() { + let d = match b { + b'0'...b'9' => b - b'0', + b'a'...b'z' => b - b'a' + 10, + b'A'...b'Z' => b - b'A' + 10, + _ => u8::MAX, + }; + if d < radix as u8 { + v.push(d); + } else { + // create ParseIntError::InvalidDigit + let e = u64::from_str_radix(&s[v.len()..], radix).unwrap_err(); + return Err(e.into()); + } + } + + let res = if radix.is_power_of_two() { + // Powers of two can use bitwise masks and shifting instead of multiplication + let bits = ilog2(radix); + v.reverse(); + if big_digit::BITS % bits == 0 { + from_bitwise_digits_le(&v, bits) + } else { + from_inexact_bitwise_digits_le(&v, bits) + } + } else { + from_radix_digits_be(&v, radix) + }; + Ok(res) + } +} + +forward_all_binop_to_val_ref_commutative!(impl BitAnd for BigUint, bitand); + +impl<'a> BitAnd<&'a BigUint> for BigUint { + type Output = BigUint; + + #[inline] + fn bitand(self, other: &BigUint) -> BigUint { + let mut data = self.data; + for (ai, &bi) in data.iter_mut().zip(other.data.iter()) { + *ai &= bi; + } + data.truncate(other.data.len()); + BigUint::new(data) + } +} + +forward_all_binop_to_val_ref_commutative!(impl BitOr for BigUint, bitor); + +impl<'a> BitOr<&'a BigUint> for BigUint { + type Output = BigUint; + + fn bitor(self, other: &BigUint) -> BigUint { + let mut data = self.data; + for (ai, &bi) in data.iter_mut().zip(other.data.iter()) { + *ai |= bi; + } + if other.data.len() > data.len() { + let extra = &other.data[data.len()..]; + data.extend(extra.iter().cloned()); + } + BigUint::new(data) + } +} + +forward_all_binop_to_val_ref_commutative!(impl BitXor for BigUint, bitxor); + +impl<'a> BitXor<&'a BigUint> for BigUint { + type Output = BigUint; + + fn bitxor(self, other: &BigUint) -> BigUint { + let mut data = self.data; + for (ai, &bi) in data.iter_mut().zip(other.data.iter()) { + *ai ^= bi; + } + if other.data.len() > data.len() { + let extra = &other.data[data.len()..]; + data.extend(extra.iter().cloned()); + } + BigUint::new(data) + } +} + +impl Shl for BigUint { + type Output = BigUint; + + #[inline] + fn shl(self, rhs: usize) -> BigUint { + biguint_shl(Cow::Owned(self), rhs) + } +} + +impl<'a> Shl for &'a BigUint { + type Output = BigUint; + + #[inline] + fn shl(self, rhs: usize) -> BigUint { + biguint_shl(Cow::Borrowed(self), rhs) + } +} + +impl Shr for BigUint { + type Output = BigUint; + + #[inline] + fn shr(self, rhs: usize) -> BigUint { + biguint_shr(Cow::Owned(self), rhs) + } +} + +impl<'a> Shr for &'a BigUint { + type Output = BigUint; + + #[inline] + fn shr(self, rhs: usize) -> BigUint { + biguint_shr(Cow::Borrowed(self), rhs) + } +} + +impl Zero for BigUint { + #[inline] + fn zero() -> BigUint { + BigUint::new(Vec::new()) + } + + #[inline] + fn is_zero(&self) -> bool { + self.data.is_empty() + } +} + +impl One for BigUint { + #[inline] + fn one() -> BigUint { + BigUint::new(vec![1]) + } +} + +impl Unsigned for BigUint {} + +forward_all_binop_to_val_ref_commutative!(impl Add for BigUint, add); + +impl<'a> Add<&'a BigUint> for BigUint { + type Output = BigUint; + + fn add(mut self, other: &BigUint) -> BigUint { + if self.data.len() < other.data.len() { + let extra = other.data.len() - self.data.len(); + self.data.extend(repeat(0).take(extra)); + } + + let carry = __add2(&mut self.data[..], &other.data[..]); + if carry != 0 { + self.data.push(carry); + } + + self + } +} + +forward_val_val_binop!(impl Sub for BigUint, sub); +forward_ref_ref_binop!(impl Sub for BigUint, sub); + +impl<'a> Sub<&'a BigUint> for BigUint { + type Output = BigUint; + + fn sub(mut self, other: &BigUint) -> BigUint { + sub2(&mut self.data[..], &other.data[..]); + self.normalize() + } +} + +impl<'a> Sub for &'a BigUint { + type Output = BigUint; + + fn sub(self, mut other: BigUint) -> BigUint { + if other.data.len() < self.data.len() { + let extra = self.data.len() - other.data.len(); + other.data.extend(repeat(0).take(extra)); + } + + sub2rev(&self.data[..], &mut other.data[..]); + other.normalize() + } +} + +forward_all_binop_to_ref_ref!(impl Mul for BigUint, mul); + +impl<'a, 'b> Mul<&'b BigUint> for &'a BigUint { + type Output = BigUint; + + #[inline] + fn mul(self, other: &BigUint) -> BigUint { + mul3(&self.data[..], &other.data[..]) + } +} + +forward_all_binop_to_ref_ref!(impl Div for BigUint, div); + +impl<'a, 'b> Div<&'b BigUint> for &'a BigUint { + type Output = BigUint; + + #[inline] + fn div(self, other: &BigUint) -> BigUint { + let (q, _) = self.div_rem(other); + return q; + } +} + +forward_all_binop_to_ref_ref!(impl Rem for BigUint, rem); + +impl<'a, 'b> Rem<&'b BigUint> for &'a BigUint { + type Output = BigUint; + + #[inline] + fn rem(self, other: &BigUint) -> BigUint { + let (_, r) = self.div_rem(other); + return r; + } +} + +impl Neg for BigUint { + type Output = BigUint; + + #[inline] + fn neg(self) -> BigUint { + panic!() + } +} + +impl<'a> Neg for &'a BigUint { + type Output = BigUint; + + #[inline] + fn neg(self) -> BigUint { + panic!() + } +} + +impl CheckedAdd for BigUint { + #[inline] + fn checked_add(&self, v: &BigUint) -> Option { + return Some(self.add(v)); + } +} + +impl CheckedSub for BigUint { + #[inline] + fn checked_sub(&self, v: &BigUint) -> Option { + match self.cmp(v) { + Less => None, + Equal => Some(Zero::zero()), + Greater => Some(self.sub(v)), + } + } +} + +impl CheckedMul for BigUint { + #[inline] + fn checked_mul(&self, v: &BigUint) -> Option { + return Some(self.mul(v)); + } +} + +impl CheckedDiv for BigUint { + #[inline] + fn checked_div(&self, v: &BigUint) -> Option { + if v.is_zero() { + return None; + } + return Some(self.div(v)); + } +} + +impl Integer for BigUint { + #[inline] + fn div_rem(&self, other: &BigUint) -> (BigUint, BigUint) { + div_rem(self, other) + } + + #[inline] + fn div_floor(&self, other: &BigUint) -> BigUint { + let (d, _) = div_rem(self, other); + d + } + + #[inline] + fn mod_floor(&self, other: &BigUint) -> BigUint { + let (_, m) = div_rem(self, other); + m + } + + #[inline] + fn div_mod_floor(&self, other: &BigUint) -> (BigUint, BigUint) { + div_rem(self, other) + } + + /// Calculates the Greatest Common Divisor (GCD) of the number and `other`. + /// + /// The result is always positive. + #[inline] + fn gcd(&self, other: &BigUint) -> BigUint { + // Use Euclid's algorithm + let mut m = (*self).clone(); + let mut n = (*other).clone(); + while !m.is_zero() { + let temp = m; + m = n % &temp; + n = temp; + } + return n; + } + + /// Calculates the Lowest Common Multiple (LCM) of the number and `other`. + #[inline] + fn lcm(&self, other: &BigUint) -> BigUint { + ((self * other) / self.gcd(other)) + } + + /// Deprecated, use `is_multiple_of` instead. + #[inline] + fn divides(&self, other: &BigUint) -> bool { + self.is_multiple_of(other) + } + + /// Returns `true` if the number is a multiple of `other`. + #[inline] + fn is_multiple_of(&self, other: &BigUint) -> bool { + (self % other).is_zero() + } + + /// Returns `true` if the number is divisible by `2`. + #[inline] + fn is_even(&self) -> bool { + // Considering only the last digit. + match self.data.first() { + Some(x) => x.is_even(), + None => true, + } + } + + /// Returns `true` if the number is not divisible by `2`. + #[inline] + fn is_odd(&self) -> bool { + !self.is_even() + } +} + +fn high_bits_to_u64(v: &BigUint) -> u64 { + match v.data.len() { + 0 => 0, + 1 => v.data[0] as u64, + _ => { + let mut bits = v.bits(); + let mut ret = 0u64; + let mut ret_bits = 0; + + for d in v.data.iter().rev() { + let digit_bits = (bits - 1) % big_digit::BITS + 1; + let bits_want = cmp::min(64 - ret_bits, digit_bits); + + if bits_want != 64 { + ret <<= bits_want; + } + ret |= *d as u64 >> (digit_bits - bits_want); + ret_bits += bits_want; + bits -= bits_want; + + if ret_bits == 64 { + break; + } + } + + ret + } + } +} + +impl ToPrimitive for BigUint { + #[inline] + fn to_i64(&self) -> Option { + self.to_u64().and_then(|n| { + // If top bit of u64 is set, it's too large to convert to i64. + if n >> 63 == 0 { + Some(n as i64) + } else { + None + } + }) + } + + #[inline] + fn to_u64(&self) -> Option { + let mut ret: u64 = 0; + let mut bits = 0; + + for i in self.data.iter() { + if bits >= 64 { + return None; + } + + ret += (*i as u64) << bits; + bits += big_digit::BITS; + } + + Some(ret) + } + + #[inline] + fn to_f32(&self) -> Option { + let mantissa = high_bits_to_u64(self); + let exponent = self.bits() - fls(mantissa); + + if exponent > f32::MAX_EXP as usize { + None + } else { + let ret = (mantissa as f32) * 2.0f32.powi(exponent as i32); + if ret.is_infinite() { + None + } else { + Some(ret) + } + } + } + + #[inline] + fn to_f64(&self) -> Option { + let mantissa = high_bits_to_u64(self); + let exponent = self.bits() - fls(mantissa); + + if exponent > f64::MAX_EXP as usize { + None + } else { + let ret = (mantissa as f64) * 2.0f64.powi(exponent as i32); + if ret.is_infinite() { + None + } else { + Some(ret) + } + } + } +} + +impl FromPrimitive for BigUint { + #[inline] + fn from_i64(n: i64) -> Option { + if n >= 0 { + Some(BigUint::from(n as u64)) + } else { + None + } + } + + #[inline] + fn from_u64(n: u64) -> Option { + Some(BigUint::from(n)) + } + + #[inline] + fn from_f64(mut n: f64) -> Option { + // handle NAN, INFINITY, NEG_INFINITY + if !n.is_finite() { + return None; + } + + // match the rounding of casting from float to int + n = n.trunc(); + + // handle 0.x, -0.x + if n.is_zero() { + return Some(BigUint::zero()); + } + + let (mantissa, exponent, sign) = Float::integer_decode(n); + + if sign == -1 { + return None; + } + + let mut ret = BigUint::from(mantissa); + if exponent > 0 { + ret = ret << exponent as usize; + } else if exponent < 0 { + ret = ret >> (-exponent) as usize; + } + Some(ret) + } +} + +impl From for BigUint { + #[inline] + fn from(mut n: u64) -> Self { + let mut ret: BigUint = Zero::zero(); + + while n != 0 { + ret.data.push(n as BigDigit); + // don't overflow if BITS is 64: + n = (n >> 1) >> (big_digit::BITS - 1); + } + + ret + } +} + +macro_rules! impl_biguint_from_uint { + ($T:ty) => { + impl From<$T> for BigUint { + #[inline] + fn from(n: $T) -> Self { + BigUint::from(n as u64) + } + } + } +} + +impl_biguint_from_uint!(u8); +impl_biguint_from_uint!(u16); +impl_biguint_from_uint!(u32); +impl_biguint_from_uint!(usize); + +/// A generic trait for converting a value to a `BigUint`. +pub trait ToBigUint { + /// Converts the value of `self` to a `BigUint`. + fn to_biguint(&self) -> Option; +} + +impl ToBigUint for BigUint { + #[inline] + fn to_biguint(&self) -> Option { + Some(self.clone()) + } +} + +macro_rules! impl_to_biguint { + ($T:ty, $from_ty:path) => { + impl ToBigUint for $T { + #[inline] + fn to_biguint(&self) -> Option { + $from_ty(*self) + } + } + } +} + +impl_to_biguint!(isize, FromPrimitive::from_isize); +impl_to_biguint!(i8, FromPrimitive::from_i8); +impl_to_biguint!(i16, FromPrimitive::from_i16); +impl_to_biguint!(i32, FromPrimitive::from_i32); +impl_to_biguint!(i64, FromPrimitive::from_i64); +impl_to_biguint!(usize, FromPrimitive::from_usize); +impl_to_biguint!(u8, FromPrimitive::from_u8); +impl_to_biguint!(u16, FromPrimitive::from_u16); +impl_to_biguint!(u32, FromPrimitive::from_u32); +impl_to_biguint!(u64, FromPrimitive::from_u64); +impl_to_biguint!(f32, FromPrimitive::from_f32); +impl_to_biguint!(f64, FromPrimitive::from_f64); + +// Extract bitwise digits that evenly divide BigDigit +fn to_bitwise_digits_le(u: &BigUint, bits: usize) -> Vec { + debug_assert!(!u.is_zero() && bits <= 8 && big_digit::BITS % bits == 0); + + let last_i = u.data.len() - 1; + let mask: BigDigit = (1 << bits) - 1; + let digits_per_big_digit = big_digit::BITS / bits; + let digits = (u.bits() + bits - 1) / bits; + let mut res = Vec::with_capacity(digits); + + for mut r in u.data[..last_i].iter().cloned() { + for _ in 0..digits_per_big_digit { + res.push((r & mask) as u8); + r >>= bits; + } + } + + let mut r = u.data[last_i]; + while r != 0 { + res.push((r & mask) as u8); + r >>= bits; + } + + res +} + +// Extract bitwise digits that don't evenly divide BigDigit +fn to_inexact_bitwise_digits_le(u: &BigUint, bits: usize) -> Vec { + debug_assert!(!u.is_zero() && bits <= 8 && big_digit::BITS % bits != 0); + + let mask: BigDigit = (1 << bits) - 1; + let digits = (u.bits() + bits - 1) / bits; + let mut res = Vec::with_capacity(digits); + + let mut r = 0; + let mut rbits = 0; + + for c in &u.data { + r |= *c << rbits; + rbits += big_digit::BITS; + + while rbits >= bits { + res.push((r & mask) as u8); + r >>= bits; + + // r had more bits than it could fit - grab the bits we lost + if rbits > big_digit::BITS { + r = *c >> (big_digit::BITS - (rbits - bits)); + } + + rbits -= bits; + } + } + + if rbits != 0 { + res.push(r as u8); + } + + while let Some(&0) = res.last() { + res.pop(); + } + + res +} + +// Extract little-endian radix digits +#[inline(always)] // forced inline to get const-prop for radix=10 +fn to_radix_digits_le(u: &BigUint, radix: u32) -> Vec { + debug_assert!(!u.is_zero() && !radix.is_power_of_two()); + + // Estimate how big the result will be, so we can pre-allocate it. + let radix_digits = ((u.bits() as f64) / (radix as f64).log2()).ceil(); + let mut res = Vec::with_capacity(radix_digits as usize); + let mut digits = u.clone(); + + let (base, power) = get_radix_base(radix); + let radix = radix as BigDigit; + + while digits.data.len() > 1 { + let (q, mut r) = div_rem_digit(digits, base); + for _ in 0..power { + res.push((r % radix) as u8); + r /= radix; + } + digits = q; + } + + let mut r = digits.data[0]; + while r != 0 { + res.push((r % radix) as u8); + r /= radix; + } + + res +} + +pub fn to_str_radix_reversed(u: &BigUint, radix: u32) -> Vec { + assert!(2 <= radix && radix <= 36, "The radix must be within 2...36"); + + if u.is_zero() { + return vec![b'0']; + } + + let mut res = if radix.is_power_of_two() { + // Powers of two can use bitwise masks and shifting instead of division + let bits = ilog2(radix); + if big_digit::BITS % bits == 0 { + to_bitwise_digits_le(u, bits) + } else { + to_inexact_bitwise_digits_le(u, bits) + } + } else if radix == 10 { + // 10 is so common that it's worth separating out for const-propagation. + // Optimizers can often turn constant division into a faster multiplication. + to_radix_digits_le(u, 10) + } else { + to_radix_digits_le(u, radix) + }; + + // Now convert everything to ASCII digits. + for r in &mut res { + debug_assert!((*r as u32) < radix); + if *r < 10 { + *r += b'0'; + } else { + *r += b'a' - 10; + } + } + res +} + +impl BigUint { + /// Creates and initializes a `BigUint`. + /// + /// The digits are in little-endian base 2^32. + #[inline] + pub fn new(digits: Vec) -> BigUint { + BigUint { data: digits }.normalize() + } + + /// Creates and initializes a `BigUint`. + /// + /// The digits are in little-endian base 2^32. + #[inline] + pub fn from_slice(slice: &[BigDigit]) -> BigUint { + BigUint::new(slice.to_vec()) + } + + /// Creates and initializes a `BigUint`. + /// + /// The bytes are in big-endian byte order. + /// + /// # Examples + /// + /// ``` + /// use num_bigint::BigUint; + /// + /// assert_eq!(BigUint::from_bytes_be(b"A"), + /// BigUint::parse_bytes(b"65", 10).unwrap()); + /// assert_eq!(BigUint::from_bytes_be(b"AA"), + /// BigUint::parse_bytes(b"16705", 10).unwrap()); + /// assert_eq!(BigUint::from_bytes_be(b"AB"), + /// BigUint::parse_bytes(b"16706", 10).unwrap()); + /// assert_eq!(BigUint::from_bytes_be(b"Hello world!"), + /// BigUint::parse_bytes(b"22405534230753963835153736737", 10).unwrap()); + /// ``` + #[inline] + pub fn from_bytes_be(bytes: &[u8]) -> BigUint { + if bytes.is_empty() { + Zero::zero() + } else { + let mut v = bytes.to_vec(); + v.reverse(); + BigUint::from_bytes_le(&*v) + } + } + + /// Creates and initializes a `BigUint`. + /// + /// The bytes are in little-endian byte order. + #[inline] + pub fn from_bytes_le(bytes: &[u8]) -> BigUint { + if bytes.is_empty() { + Zero::zero() + } else { + from_bitwise_digits_le(bytes, 8) + } + } + + /// Returns the byte representation of the `BigUint` in little-endian byte order. + /// + /// # Examples + /// + /// ``` + /// use num_bigint::BigUint; + /// + /// let i = BigUint::parse_bytes(b"1125", 10).unwrap(); + /// assert_eq!(i.to_bytes_le(), vec![101, 4]); + /// ``` + #[inline] + pub fn to_bytes_le(&self) -> Vec { + if self.is_zero() { + vec![0] + } else { + to_bitwise_digits_le(self, 8) + } + } + + /// Returns the byte representation of the `BigUint` in big-endian byte order. + /// + /// # Examples + /// + /// ``` + /// use num_bigint::BigUint; + /// + /// let i = BigUint::parse_bytes(b"1125", 10).unwrap(); + /// assert_eq!(i.to_bytes_be(), vec![4, 101]); + /// ``` + #[inline] + pub fn to_bytes_be(&self) -> Vec { + let mut v = self.to_bytes_le(); + v.reverse(); + v + } + + /// Returns the integer formatted as a string in the given radix. + /// `radix` must be in the range `[2, 36]`. + /// + /// # Examples + /// + /// ``` + /// use num_bigint::BigUint; + /// + /// let i = BigUint::parse_bytes(b"ff", 16).unwrap(); + /// assert_eq!(i.to_str_radix(16), "ff"); + /// ``` + #[inline] + pub fn to_str_radix(&self, radix: u32) -> String { + let mut v = to_str_radix_reversed(self, radix); + v.reverse(); + unsafe { String::from_utf8_unchecked(v) } + } + + /// Creates and initializes a `BigUint`. + /// + /// # Examples + /// + /// ``` + /// use num_bigint::{BigUint, ToBigUint}; + /// + /// assert_eq!(BigUint::parse_bytes(b"1234", 10), ToBigUint::to_biguint(&1234)); + /// assert_eq!(BigUint::parse_bytes(b"ABCD", 16), ToBigUint::to_biguint(&0xABCD)); + /// assert_eq!(BigUint::parse_bytes(b"G", 16), None); + /// ``` + #[inline] + pub fn parse_bytes(buf: &[u8], radix: u32) -> Option { + str::from_utf8(buf).ok().and_then(|s| BigUint::from_str_radix(s, radix).ok()) + } + + /// Determines the fewest bits necessary to express the `BigUint`. + pub fn bits(&self) -> usize { + if self.is_zero() { + return 0; + } + let zeros = self.data.last().unwrap().leading_zeros(); + return self.data.len() * big_digit::BITS - zeros as usize; + } + + /// Strips off trailing zero bigdigits - comparisons require the last element in the vector to + /// be nonzero. + #[inline] + fn normalize(mut self) -> BigUint { + while let Some(&0) = self.data.last() { + self.data.pop(); + } + self + } +} + +#[cfg(feature = "serde")] +impl serde::Serialize for BigUint { + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: serde::Serializer + { + self.data.serialize(serializer) + } +} + +#[cfg(feature = "serde")] +impl serde::Deserialize for BigUint { + fn deserialize(deserializer: &mut D) -> Result + where D: serde::Deserializer + { + let data = try!(Vec::deserialize(deserializer)); + Ok(BigUint { data: data }) + } +} + +/// Returns the greatest power of the radix <= big_digit::BASE +#[inline] +fn get_radix_base(radix: u32) -> (BigDigit, usize) { + debug_assert!(2 <= radix && radix <= 36, "The radix must be within 2...36"); + debug_assert!(!radix.is_power_of_two()); + + // To generate this table: + // for radix in 2u64..37 { + // let mut power = big_digit::BITS / fls(radix as u64); + // let mut base = radix.pow(power as u32); + // + // while let Some(b) = base.checked_mul(radix) { + // if b > big_digit::MAX { + // break; + // } + // base = b; + // power += 1; + // } + // + // println!("({:10}, {:2}), // {:2}", base, power, radix); + // } + + match big_digit::BITS { + 32 => { + const BASES: [(u32, usize); 37] = [(0, 0), (0, 0), + (0, 0), // 2 + (3486784401, 20),// 3 + (0, 0), // 4 + (1220703125, 13),// 5 + (2176782336, 12),// 6 + (1977326743, 11),// 7 + (0, 0), // 8 + (3486784401, 10),// 9 + (1000000000, 9), // 10 + (2357947691, 9), // 11 + (429981696, 8), // 12 + (815730721, 8), // 13 + (1475789056, 8), // 14 + (2562890625, 8), // 15 + (0, 0), // 16 + (410338673, 7), // 17 + (612220032, 7), // 18 + (893871739, 7), // 19 + (1280000000, 7), // 20 + (1801088541, 7), // 21 + (2494357888, 7), // 22 + (3404825447, 7), // 23 + (191102976, 6), // 24 + (244140625, 6), // 25 + (308915776, 6), // 26 + (387420489, 6), // 27 + (481890304, 6), // 28 + (594823321, 6), // 29 + (729000000, 6), // 30 + (887503681, 6), // 31 + (0, 0), // 32 + (1291467969, 6), // 33 + (1544804416, 6), // 34 + (1838265625, 6), // 35 + (2176782336, 6) // 36 + ]; + + let (base, power) = BASES[radix as usize]; + (base as BigDigit, power) + } + 64 => { + const BASES: [(u64, usize); 37] = [(0, 0), (0, 0), + (9223372036854775808, 63), // 2 + (12157665459056928801, 40), // 3 + (4611686018427387904, 31), // 4 + (7450580596923828125, 27), // 5 + (4738381338321616896, 24), // 6 + (3909821048582988049, 22), // 7 + (9223372036854775808, 21), // 8 + (12157665459056928801, 20), // 9 + (10000000000000000000, 19), // 10 + (5559917313492231481, 18), // 11 + (2218611106740436992, 17), // 12 + (8650415919381337933, 17), // 13 + (2177953337809371136, 16), // 14 + (6568408355712890625, 16), // 15 + (1152921504606846976, 15), // 16 + (2862423051509815793, 15), // 17 + (6746640616477458432, 15), // 18 + (15181127029874798299, 15), // 19 + (1638400000000000000, 14), // 20 + (3243919932521508681, 14), // 21 + (6221821273427820544, 14), // 22 + (11592836324538749809, 14), // 23 + (876488338465357824, 13), // 24 + (1490116119384765625, 13), // 25 + (2481152873203736576, 13), // 26 + (4052555153018976267, 13), // 27 + (6502111422497947648, 13), // 28 + (10260628712958602189, 13), // 29 + (15943230000000000000, 13), // 30 + (787662783788549761, 12), // 31 + (1152921504606846976, 12), // 32 + (1667889514952984961, 12), // 33 + (2386420683693101056, 12), // 34 + (3379220508056640625, 12), // 35 + (4738381338321616896, 12), // 36 + ]; + + let (base, power) = BASES[radix as usize]; + (base as BigDigit, power) + } + _ => panic!("Invalid bigdigit size") + } +} diff --git a/bigint/src/lib.rs b/bigint/src/lib.rs index a32bd7d..ed0f442 100644 --- a/bigint/src/lib.rs +++ b/bigint/src/lib.rs @@ -80,2983 +80,9 @@ extern crate serde; extern crate num_integer as integer; extern crate num_traits as traits; -use std::borrow::Cow; -use std::default::Default; use std::error::Error; -use std::iter::repeat; use std::num::ParseIntError; -use std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Neg, Rem, Shl, Shr, Sub}; -use std::str::{self, FromStr}; use std::fmt; -#[cfg(test)] -use std::hash; -use std::cmp; -use std::cmp::Ordering::{self, Less, Greater, Equal}; -use std::{f32, f64}; -use std::{u8, i64, u64}; -use std::ascii::AsciiExt; - -#[cfg(feature = "serde")] -use serde; - -// Some of the tests of non-RNG-based functionality are randomized using the -// RNG-based functionality, so the RNG-based functionality needs to be enabled -// for tests. -#[cfg(any(feature = "rand", test))] -use rand::Rng; - -use integer::Integer; -use traits::{ToPrimitive, FromPrimitive, Float, Num, Unsigned, CheckedAdd, CheckedSub, CheckedMul, - CheckedDiv, Signed, Zero, One}; - -use self::Sign::{Minus, NoSign, Plus}; - -/// A `BigDigit` is a `BigUint`'s composing element. -pub type BigDigit = u32; - -/// A `DoubleBigDigit` is the internal type used to do the computations. Its -/// size is the double of the size of `BigDigit`. -pub type DoubleBigDigit = u64; - -pub const ZERO_BIG_DIGIT: BigDigit = 0; - -#[allow(non_snake_case)] -pub mod big_digit { - use super::BigDigit; - use super::DoubleBigDigit; - - // `DoubleBigDigit` size dependent - pub const BITS: usize = 32; - - pub const BASE: DoubleBigDigit = 1 << BITS; - const LO_MASK: DoubleBigDigit = (-1i32 as DoubleBigDigit) >> BITS; - - #[inline] - fn get_hi(n: DoubleBigDigit) -> BigDigit { - (n >> BITS) as BigDigit - } - #[inline] - fn get_lo(n: DoubleBigDigit) -> BigDigit { - (n & LO_MASK) as BigDigit - } - - /// Split one `DoubleBigDigit` into two `BigDigit`s. - #[inline] - pub fn from_doublebigdigit(n: DoubleBigDigit) -> (BigDigit, BigDigit) { - (get_hi(n), get_lo(n)) - } - - /// Join two `BigDigit`s into one `DoubleBigDigit` - #[inline] - pub fn to_doublebigdigit(hi: BigDigit, lo: BigDigit) -> DoubleBigDigit { - (lo as DoubleBigDigit) | ((hi as DoubleBigDigit) << BITS) - } -} - -// Generic functions for add/subtract/multiply with carry/borrow: -// - -// Add with carry: -#[inline] -fn adc(a: BigDigit, b: BigDigit, carry: &mut BigDigit) -> BigDigit { - let (hi, lo) = big_digit::from_doublebigdigit((a as DoubleBigDigit) + (b as DoubleBigDigit) + - (*carry as DoubleBigDigit)); - - *carry = hi; - lo -} - -// Subtract with borrow: -#[inline] -fn sbb(a: BigDigit, b: BigDigit, borrow: &mut BigDigit) -> BigDigit { - let (hi, lo) = big_digit::from_doublebigdigit(big_digit::BASE + (a as DoubleBigDigit) - - (b as DoubleBigDigit) - - (*borrow as DoubleBigDigit)); - // hi * (base) + lo == 1*(base) + ai - bi - borrow - // => ai - bi - borrow < 0 <=> hi == 0 - *borrow = (hi == 0) as BigDigit; - lo -} - -#[inline] -fn mac_with_carry(a: BigDigit, b: BigDigit, c: BigDigit, carry: &mut BigDigit) -> BigDigit { - let (hi, lo) = big_digit::from_doublebigdigit((a as DoubleBigDigit) + - (b as DoubleBigDigit) * (c as DoubleBigDigit) + - (*carry as DoubleBigDigit)); - *carry = hi; - lo -} - -/// Divide a two digit numerator by a one digit divisor, returns quotient and remainder: -/// -/// Note: the caller must ensure that both the quotient and remainder will fit into a single digit. -/// This is _not_ true for an arbitrary numerator/denominator. -/// -/// (This function also matches what the x86 divide instruction does). -#[inline] -fn div_wide(hi: BigDigit, lo: BigDigit, divisor: BigDigit) -> (BigDigit, BigDigit) { - debug_assert!(hi < divisor); - - let lhs = big_digit::to_doublebigdigit(hi, lo); - let rhs = divisor as DoubleBigDigit; - ((lhs / rhs) as BigDigit, (lhs % rhs) as BigDigit) -} - -/// A big unsigned integer type. -/// -/// A `BigUint`-typed value `BigUint { data: vec!(a, b, c) }` represents a number -/// `(a + b * big_digit::BASE + c * big_digit::BASE^2)`. -#[derive(Clone, Debug, Hash)] -#[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))] -pub struct BigUint { - data: Vec, -} - -impl PartialEq for BigUint { - #[inline] - fn eq(&self, other: &BigUint) -> bool { - match self.cmp(other) { - Equal => true, - _ => false, - } - } -} -impl Eq for BigUint {} - -impl PartialOrd for BigUint { - #[inline] - fn partial_cmp(&self, other: &BigUint) -> Option { - Some(self.cmp(other)) - } -} - -fn cmp_slice(a: &[BigDigit], b: &[BigDigit]) -> Ordering { - debug_assert!(a.last() != Some(&0)); - debug_assert!(b.last() != Some(&0)); - - let (a_len, b_len) = (a.len(), b.len()); - if a_len < b_len { - return Less; - } - if a_len > b_len { - return Greater; - } - - for (&ai, &bi) in a.iter().rev().zip(b.iter().rev()) { - if ai < bi { - return Less; - } - if ai > bi { - return Greater; - } - } - return Equal; -} - -impl Ord for BigUint { - #[inline] - fn cmp(&self, other: &BigUint) -> Ordering { - cmp_slice(&self.data[..], &other.data[..]) - } -} - -impl Default for BigUint { - #[inline] - fn default() -> BigUint { - Zero::zero() - } -} - -impl fmt::Display for BigUint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.pad_integral(true, "", &self.to_str_radix(10)) - } -} - -impl fmt::LowerHex for BigUint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.pad_integral(true, "0x", &self.to_str_radix(16)) - } -} - -impl fmt::UpperHex for BigUint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.pad_integral(true, "0x", &self.to_str_radix(16).to_ascii_uppercase()) - } -} - -impl fmt::Binary for BigUint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.pad_integral(true, "0b", &self.to_str_radix(2)) - } -} - -impl fmt::Octal for BigUint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.pad_integral(true, "0o", &self.to_str_radix(8)) - } -} - -impl FromStr for BigUint { - type Err = ParseBigIntError; - - #[inline] - fn from_str(s: &str) -> Result { - BigUint::from_str_radix(s, 10) - } -} - -// Convert from a power of two radix (bits == ilog2(radix)) where bits evenly divides -// BigDigit::BITS -fn from_bitwise_digits_le(v: &[u8], bits: usize) -> BigUint { - debug_assert!(!v.is_empty() && bits <= 8 && big_digit::BITS % bits == 0); - debug_assert!(v.iter().all(|&c| (c as BigDigit) < (1 << bits))); - - let digits_per_big_digit = big_digit::BITS / bits; - - let data = v.chunks(digits_per_big_digit) - .map(|chunk| { - chunk.iter().rev().fold(0, |acc, &c| (acc << bits) | c as BigDigit) - }) - .collect(); - - BigUint::new(data) -} - -// Convert from a power of two radix (bits == ilog2(radix)) where bits doesn't evenly divide -// BigDigit::BITS -fn from_inexact_bitwise_digits_le(v: &[u8], bits: usize) -> BigUint { - debug_assert!(!v.is_empty() && bits <= 8 && big_digit::BITS % bits != 0); - debug_assert!(v.iter().all(|&c| (c as BigDigit) < (1 << bits))); - - let big_digits = (v.len() * bits + big_digit::BITS - 1) / big_digit::BITS; - let mut data = Vec::with_capacity(big_digits); - - let mut d = 0; - let mut dbits = 0; // number of bits we currently have in d - - // walk v accumululating bits in d; whenever we accumulate big_digit::BITS in d, spit out a - // big_digit: - for &c in v { - d |= (c as BigDigit) << dbits; - dbits += bits; - - if dbits >= big_digit::BITS { - data.push(d); - dbits -= big_digit::BITS; - // if dbits was > big_digit::BITS, we dropped some of the bits in c (they couldn't fit - // in d) - grab the bits we lost here: - d = (c as BigDigit) >> (bits - dbits); - } - } - - if dbits > 0 { - debug_assert!(dbits < big_digit::BITS); - data.push(d as BigDigit); - } - - BigUint::new(data) -} - -// Read little-endian radix digits -fn from_radix_digits_be(v: &[u8], radix: u32) -> BigUint { - debug_assert!(!v.is_empty() && !radix.is_power_of_two()); - debug_assert!(v.iter().all(|&c| (c as u32) < radix)); - - // Estimate how big the result will be, so we can pre-allocate it. - let bits = (radix as f64).log2() * v.len() as f64; - let big_digits = (bits / big_digit::BITS as f64).ceil(); - let mut data = Vec::with_capacity(big_digits as usize); - - let (base, power) = get_radix_base(radix); - let radix = radix as BigDigit; - - let r = v.len() % power; - let i = if r == 0 { - power - } else { - r - }; - let (head, tail) = v.split_at(i); - - let first = head.iter().fold(0, |acc, &d| acc * radix + d as BigDigit); - data.push(first); - - debug_assert!(tail.len() % power == 0); - for chunk in tail.chunks(power) { - if data.last() != Some(&0) { - data.push(0); - } - - let mut carry = 0; - for d in data.iter_mut() { - *d = mac_with_carry(0, *d, base, &mut carry); - } - debug_assert!(carry == 0); - - let n = chunk.iter().fold(0, |acc, &d| acc * radix + d as BigDigit); - add2(&mut data, &[n]); - } - - BigUint::new(data) -} - -impl Num for BigUint { - type FromStrRadixErr = ParseBigIntError; - - /// Creates and initializes a `BigUint`. - fn from_str_radix(s: &str, radix: u32) -> Result { - assert!(2 <= radix && radix <= 36, "The radix must be within 2...36"); - let mut s = s; - if s.starts_with('+') { - let tail = &s[1..]; - if !tail.starts_with('+') { - s = tail - } - } - - if s.is_empty() { - // create ParseIntError::Empty - let e = u64::from_str_radix(s, radix).unwrap_err(); - return Err(e.into()); - } - - // First normalize all characters to plain digit values - let mut v = Vec::with_capacity(s.len()); - for b in s.bytes() { - let d = match b { - b'0'...b'9' => b - b'0', - b'a'...b'z' => b - b'a' + 10, - b'A'...b'Z' => b - b'A' + 10, - _ => u8::MAX, - }; - if d < radix as u8 { - v.push(d); - } else { - // create ParseIntError::InvalidDigit - let e = u64::from_str_radix(&s[v.len()..], radix).unwrap_err(); - return Err(e.into()); - } - } - - let res = if radix.is_power_of_two() { - // Powers of two can use bitwise masks and shifting instead of multiplication - let bits = ilog2(radix); - v.reverse(); - if big_digit::BITS % bits == 0 { - from_bitwise_digits_le(&v, bits) - } else { - from_inexact_bitwise_digits_le(&v, bits) - } - } else { - from_radix_digits_be(&v, radix) - }; - Ok(res) - } -} - -macro_rules! forward_val_val_binop { - (impl $imp:ident for $res:ty, $method:ident) => { - impl $imp<$res> for $res { - type Output = $res; - - #[inline] - fn $method(self, other: $res) -> $res { - // forward to val-ref - $imp::$method(self, &other) - } - } - } -} - -macro_rules! forward_val_val_binop_commutative { - (impl $imp:ident for $res:ty, $method:ident) => { - impl $imp<$res> for $res { - type Output = $res; - - #[inline] - fn $method(self, other: $res) -> $res { - // forward to val-ref, with the larger capacity as val - if self.data.capacity() >= other.data.capacity() { - $imp::$method(self, &other) - } else { - $imp::$method(other, &self) - } - } - } - } -} - -macro_rules! forward_ref_val_binop { - (impl $imp:ident for $res:ty, $method:ident) => { - impl<'a> $imp<$res> for &'a $res { - type Output = $res; - - #[inline] - fn $method(self, other: $res) -> $res { - // forward to ref-ref - $imp::$method(self, &other) - } - } - } -} - -macro_rules! forward_ref_val_binop_commutative { - (impl $imp:ident for $res:ty, $method:ident) => { - impl<'a> $imp<$res> for &'a $res { - type Output = $res; - - #[inline] - fn $method(self, other: $res) -> $res { - // reverse, forward to val-ref - $imp::$method(other, self) - } - } - } -} - -macro_rules! forward_val_ref_binop { - (impl $imp:ident for $res:ty, $method:ident) => { - impl<'a> $imp<&'a $res> for $res { - type Output = $res; - - #[inline] - fn $method(self, other: &$res) -> $res { - // forward to ref-ref - $imp::$method(&self, other) - } - } - } -} - -macro_rules! forward_ref_ref_binop { - (impl $imp:ident for $res:ty, $method:ident) => { - impl<'a, 'b> $imp<&'b $res> for &'a $res { - type Output = $res; - - #[inline] - fn $method(self, other: &$res) -> $res { - // forward to val-ref - $imp::$method(self.clone(), other) - } - } - } -} - -macro_rules! forward_ref_ref_binop_commutative { - (impl $imp:ident for $res:ty, $method:ident) => { - impl<'a, 'b> $imp<&'b $res> for &'a $res { - type Output = $res; - - #[inline] - fn $method(self, other: &$res) -> $res { - // forward to val-ref, choosing the larger to clone - if self.data.len() >= other.data.len() { - $imp::$method(self.clone(), other) - } else { - $imp::$method(other.clone(), self) - } - } - } - } -} - -// Forward everything to ref-ref, when reusing storage is not helpful -macro_rules! forward_all_binop_to_ref_ref { - (impl $imp:ident for $res:ty, $method:ident) => { - forward_val_val_binop!(impl $imp for $res, $method); - forward_val_ref_binop!(impl $imp for $res, $method); - forward_ref_val_binop!(impl $imp for $res, $method); - }; -} - -// Forward everything to val-ref, so LHS storage can be reused -macro_rules! forward_all_binop_to_val_ref { - (impl $imp:ident for $res:ty, $method:ident) => { - forward_val_val_binop!(impl $imp for $res, $method); - forward_ref_val_binop!(impl $imp for $res, $method); - forward_ref_ref_binop!(impl $imp for $res, $method); - }; -} - -// Forward everything to val-ref, commutatively, so either LHS or RHS storage can be reused -macro_rules! forward_all_binop_to_val_ref_commutative { - (impl $imp:ident for $res:ty, $method:ident) => { - forward_val_val_binop_commutative!(impl $imp for $res, $method); - forward_ref_val_binop_commutative!(impl $imp for $res, $method); - forward_ref_ref_binop_commutative!(impl $imp for $res, $method); - }; -} - -forward_all_binop_to_val_ref_commutative!(impl BitAnd for BigUint, bitand); - -impl<'a> BitAnd<&'a BigUint> for BigUint { - type Output = BigUint; - - #[inline] - fn bitand(self, other: &BigUint) -> BigUint { - let mut data = self.data; - for (ai, &bi) in data.iter_mut().zip(other.data.iter()) { - *ai &= bi; - } - data.truncate(other.data.len()); - BigUint::new(data) - } -} - -forward_all_binop_to_val_ref_commutative!(impl BitOr for BigUint, bitor); - -impl<'a> BitOr<&'a BigUint> for BigUint { - type Output = BigUint; - - fn bitor(self, other: &BigUint) -> BigUint { - let mut data = self.data; - for (ai, &bi) in data.iter_mut().zip(other.data.iter()) { - *ai |= bi; - } - if other.data.len() > data.len() { - let extra = &other.data[data.len()..]; - data.extend(extra.iter().cloned()); - } - BigUint::new(data) - } -} - -forward_all_binop_to_val_ref_commutative!(impl BitXor for BigUint, bitxor); - -impl<'a> BitXor<&'a BigUint> for BigUint { - type Output = BigUint; - - fn bitxor(self, other: &BigUint) -> BigUint { - let mut data = self.data; - for (ai, &bi) in data.iter_mut().zip(other.data.iter()) { - *ai ^= bi; - } - if other.data.len() > data.len() { - let extra = &other.data[data.len()..]; - data.extend(extra.iter().cloned()); - } - BigUint::new(data) - } -} - -#[inline] -fn biguint_shl(n: Cow, bits: usize) -> BigUint { - let n_unit = bits / big_digit::BITS; - let mut data = match n_unit { - 0 => n.into_owned().data, - _ => { - let len = n_unit + n.data.len() + 1; - let mut data = Vec::with_capacity(len); - data.extend(repeat(0).take(n_unit)); - data.extend(n.data.iter().cloned()); - data - } - }; - - let n_bits = bits % big_digit::BITS; - if n_bits > 0 { - let mut carry = 0; - for elem in data[n_unit..].iter_mut() { - let new_carry = *elem >> (big_digit::BITS - n_bits); - *elem = (*elem << n_bits) | carry; - carry = new_carry; - } - if carry != 0 { - data.push(carry); - } - } - - BigUint::new(data) -} - -impl Shl for BigUint { - type Output = BigUint; - - #[inline] - fn shl(self, rhs: usize) -> BigUint { - biguint_shl(Cow::Owned(self), rhs) - } -} - -impl<'a> Shl for &'a BigUint { - type Output = BigUint; - - #[inline] - fn shl(self, rhs: usize) -> BigUint { - biguint_shl(Cow::Borrowed(self), rhs) - } -} - -#[inline] -fn biguint_shr(n: Cow, bits: usize) -> BigUint { - let n_unit = bits / big_digit::BITS; - if n_unit >= n.data.len() { - return Zero::zero(); - } - let mut data = match n_unit { - 0 => n.into_owned().data, - _ => n.data[n_unit..].to_vec(), - }; - - let n_bits = bits % big_digit::BITS; - if n_bits > 0 { - let mut borrow = 0; - for elem in data.iter_mut().rev() { - let new_borrow = *elem << (big_digit::BITS - n_bits); - *elem = (*elem >> n_bits) | borrow; - borrow = new_borrow; - } - } - - BigUint::new(data) -} - -impl Shr for BigUint { - type Output = BigUint; - - #[inline] - fn shr(self, rhs: usize) -> BigUint { - biguint_shr(Cow::Owned(self), rhs) - } -} - -impl<'a> Shr for &'a BigUint { - type Output = BigUint; - - #[inline] - fn shr(self, rhs: usize) -> BigUint { - biguint_shr(Cow::Borrowed(self), rhs) - } -} - -impl Zero for BigUint { - #[inline] - fn zero() -> BigUint { - BigUint::new(Vec::new()) - } - - #[inline] - fn is_zero(&self) -> bool { - self.data.is_empty() - } -} - -impl One for BigUint { - #[inline] - fn one() -> BigUint { - BigUint::new(vec![1]) - } -} - -impl Unsigned for BigUint {} - -forward_all_binop_to_val_ref_commutative!(impl Add for BigUint, add); - -// Only for the Add impl: -#[must_use] -#[inline] -fn __add2(a: &mut [BigDigit], b: &[BigDigit]) -> BigDigit { - debug_assert!(a.len() >= b.len()); - - let mut carry = 0; - let (a_lo, a_hi) = a.split_at_mut(b.len()); - - for (a, b) in a_lo.iter_mut().zip(b) { - *a = adc(*a, *b, &mut carry); - } - - if carry != 0 { - for a in a_hi { - *a = adc(*a, 0, &mut carry); - if carry == 0 { break } - } - } - - carry -} - -/// /Two argument addition of raw slices: -/// a += b -/// -/// The caller _must_ ensure that a is big enough to store the result - typically this means -/// resizing a to max(a.len(), b.len()) + 1, to fit a possible carry. -fn add2(a: &mut [BigDigit], b: &[BigDigit]) { - let carry = __add2(a, b); - - debug_assert!(carry == 0); -} - -// We'd really prefer to avoid using add2/sub2 directly as much as possible - since they make the -// caller entirely responsible for ensuring a's vector is big enough, and that the result is -// normalized, they're rather error prone and verbose: -// -// We could implement the Add and Sub traits for BigUint + BigDigit slices, like below - this works -// great, except that then it becomes the module's public interface, which we probably don't want: -// -// I'm keeping the code commented out, because I think this is worth revisiting: -// -// impl<'a> Add<&'a [BigDigit]> for BigUint { -// type Output = BigUint; -// -// fn add(mut self, other: &[BigDigit]) -> BigUint { -// if self.data.len() < other.len() { -// let extra = other.len() - self.data.len(); -// self.data.extend(repeat(0).take(extra)); -// } -// -// let carry = __add2(&mut self.data[..], other); -// if carry != 0 { -// self.data.push(carry); -// } -// -// self -// } -// } -// - -impl<'a> Add<&'a BigUint> for BigUint { - type Output = BigUint; - - fn add(mut self, other: &BigUint) -> BigUint { - if self.data.len() < other.data.len() { - let extra = other.data.len() - self.data.len(); - self.data.extend(repeat(0).take(extra)); - } - - let carry = __add2(&mut self.data[..], &other.data[..]); - if carry != 0 { - self.data.push(carry); - } - - self - } -} - -forward_val_val_binop!(impl Sub for BigUint, sub); -forward_ref_ref_binop!(impl Sub for BigUint, sub); - -fn sub2(a: &mut [BigDigit], b: &[BigDigit]) { - let mut borrow = 0; - - let len = cmp::min(a.len(), b.len()); - let (a_lo, a_hi) = a.split_at_mut(len); - let (b_lo, b_hi) = b.split_at(len); - - for (a, b) in a_lo.iter_mut().zip(b_lo) { - *a = sbb(*a, *b, &mut borrow); - } - - if borrow != 0 { - for a in a_hi { - *a = sbb(*a, 0, &mut borrow); - if borrow == 0 { break } - } - } - - // note: we're _required_ to fail on underflow - assert!(borrow == 0 && b_hi.iter().all(|x| *x == 0), - "Cannot subtract b from a because b is larger than a."); -} - -impl<'a> Sub<&'a BigUint> for BigUint { - type Output = BigUint; - - fn sub(mut self, other: &BigUint) -> BigUint { - sub2(&mut self.data[..], &other.data[..]); - self.normalize() - } -} - -fn sub2rev(a: &[BigDigit], b: &mut [BigDigit]) { - debug_assert!(b.len() >= a.len()); - - let mut borrow = 0; - - let len = cmp::min(a.len(), b.len()); - let (a_lo, a_hi) = a.split_at(len); - let (b_lo, b_hi) = b.split_at_mut(len); - - for (a, b) in a_lo.iter().zip(b_lo) { - *b = sbb(*a, *b, &mut borrow); - } - - assert!(a_hi.is_empty()); - - // note: we're _required_ to fail on underflow - assert!(borrow == 0 && b_hi.iter().all(|x| *x == 0), - "Cannot subtract b from a because b is larger than a."); -} - -impl<'a> Sub for &'a BigUint { - type Output = BigUint; - - fn sub(self, mut other: BigUint) -> BigUint { - if other.data.len() < self.data.len() { - let extra = self.data.len() - other.data.len(); - other.data.extend(repeat(0).take(extra)); - } - - sub2rev(&self.data[..], &mut other.data[..]); - other.normalize() - } -} - -fn sub_sign(a: &[BigDigit], b: &[BigDigit]) -> BigInt { - // Normalize: - let a = &a[..a.iter().rposition(|&x| x != 0).map_or(0, |i| i + 1)]; - let b = &b[..b.iter().rposition(|&x| x != 0).map_or(0, |i| i + 1)]; - - match cmp_slice(a, b) { - Greater => { - let mut a = a.to_vec(); - sub2(&mut a, b); - BigInt::new(Plus, a) - } - Less => { - let mut b = b.to_vec(); - sub2(&mut b, a); - BigInt::new(Minus, b) - } - _ => Zero::zero(), - } -} - -forward_all_binop_to_ref_ref!(impl Mul for BigUint, mul); - -/// Three argument multiply accumulate: -/// acc += b * c -fn mac_digit(acc: &mut [BigDigit], b: &[BigDigit], c: BigDigit) { - if c == 0 { - return; - } - - let mut b_iter = b.iter(); - let mut carry = 0; - - for ai in acc.iter_mut() { - if let Some(bi) = b_iter.next() { - *ai = mac_with_carry(*ai, *bi, c, &mut carry); - } else if carry != 0 { - *ai = mac_with_carry(*ai, 0, c, &mut carry); - } else { - break; - } - } - - assert!(carry == 0); -} - -/// Three argument multiply accumulate: -/// acc += b * c -fn mac3(acc: &mut [BigDigit], b: &[BigDigit], c: &[BigDigit]) { - let (x, y) = if b.len() < c.len() { - (b, c) - } else { - (c, b) - }; - - // Karatsuba multiplication is slower than long multiplication for small x and y: - // - if x.len() <= 4 { - for (i, xi) in x.iter().enumerate() { - mac_digit(&mut acc[i..], y, *xi); - } - } else { - /* - * Karatsuba multiplication: - * - * The idea is that we break x and y up into two smaller numbers that each have about half - * as many digits, like so (note that multiplying by b is just a shift): - * - * x = x0 + x1 * b - * y = y0 + y1 * b - * - * With some algebra, we can compute x * y with three smaller products, where the inputs to - * each of the smaller products have only about half as many digits as x and y: - * - * x * y = (x0 + x1 * b) * (y0 + y1 * b) - * - * x * y = x0 * y0 - * + x0 * y1 * b - * + x1 * y0 * b - * + x1 * y1 * b^2 - * - * Let p0 = x0 * y0 and p2 = x1 * y1: - * - * x * y = p0 - * + (x0 * y1 + x1 * p0) * b - * + p2 * b^2 - * - * The real trick is that middle term: - * - * x0 * y1 + x1 * y0 - * - * = x0 * y1 + x1 * y0 - p0 + p0 - p2 + p2 - * - * = x0 * y1 + x1 * y0 - x0 * y0 - x1 * y1 + p0 + p2 - * - * Now we complete the square: - * - * = -(x0 * y0 - x0 * y1 - x1 * y0 + x1 * y1) + p0 + p2 - * - * = -((x1 - x0) * (y1 - y0)) + p0 + p2 - * - * Let p1 = (x1 - x0) * (y1 - y0), and substitute back into our original formula: - * - * x * y = p0 - * + (p0 + p2 - p1) * b - * + p2 * b^2 - * - * Where the three intermediate products are: - * - * p0 = x0 * y0 - * p1 = (x1 - x0) * (y1 - y0) - * p2 = x1 * y1 - * - * In doing the computation, we take great care to avoid unnecessary temporary variables - * (since creating a BigUint requires a heap allocation): thus, we rearrange the formula a - * bit so we can use the same temporary variable for all the intermediate products: - * - * x * y = p2 * b^2 + p2 * b - * + p0 * b + p0 - * - p1 * b - * - * The other trick we use is instead of doing explicit shifts, we slice acc at the - * appropriate offset when doing the add. - */ - - /* - * When x is smaller than y, it's significantly faster to pick b such that x is split in - * half, not y: - */ - let b = x.len() / 2; - let (x0, x1) = x.split_at(b); - let (y0, y1) = y.split_at(b); - - /* - * We reuse the same BigUint for all the intermediate multiplies and have to size p - * appropriately here: x1.len() >= x0.len and y1.len() >= y0.len(): - */ - let len = x1.len() + y1.len() + 1; - let mut p = BigUint { data: vec![0; len] }; - - // p2 = x1 * y1 - mac3(&mut p.data[..], x1, y1); - - // Not required, but the adds go faster if we drop any unneeded 0s from the end: - p = p.normalize(); - - add2(&mut acc[b..], &p.data[..]); - add2(&mut acc[b * 2..], &p.data[..]); - - // Zero out p before the next multiply: - p.data.truncate(0); - p.data.extend(repeat(0).take(len)); - - // p0 = x0 * y0 - mac3(&mut p.data[..], x0, y0); - p = p.normalize(); - - add2(&mut acc[..], &p.data[..]); - add2(&mut acc[b..], &p.data[..]); - - // p1 = (x1 - x0) * (y1 - y0) - // We do this one last, since it may be negative and acc can't ever be negative: - let j0 = sub_sign(x1, x0); - let j1 = sub_sign(y1, y0); - - match j0.sign * j1.sign { - Plus => { - p.data.truncate(0); - p.data.extend(repeat(0).take(len)); - - mac3(&mut p.data[..], &j0.data.data[..], &j1.data.data[..]); - p = p.normalize(); - - sub2(&mut acc[b..], &p.data[..]); - }, - Minus => { - mac3(&mut acc[b..], &j0.data.data[..], &j1.data.data[..]); - }, - NoSign => (), - } - } -} - -fn mul3(x: &[BigDigit], y: &[BigDigit]) -> BigUint { - let len = x.len() + y.len() + 1; - let mut prod = BigUint { data: vec![0; len] }; - - mac3(&mut prod.data[..], x, y); - prod.normalize() -} - -impl<'a, 'b> Mul<&'b BigUint> for &'a BigUint { - type Output = BigUint; - - #[inline] - fn mul(self, other: &BigUint) -> BigUint { - mul3(&self.data[..], &other.data[..]) - } -} - -fn div_rem_digit(mut a: BigUint, b: BigDigit) -> (BigUint, BigDigit) { - let mut rem = 0; - - for d in a.data.iter_mut().rev() { - let (q, r) = div_wide(rem, *d, b); - *d = q; - rem = r; - } - - (a.normalize(), rem) -} - -forward_all_binop_to_ref_ref!(impl Div for BigUint, div); - -impl<'a, 'b> Div<&'b BigUint> for &'a BigUint { - type Output = BigUint; - - #[inline] - fn div(self, other: &BigUint) -> BigUint { - let (q, _) = self.div_rem(other); - return q; - } -} - -forward_all_binop_to_ref_ref!(impl Rem for BigUint, rem); - -impl<'a, 'b> Rem<&'b BigUint> for &'a BigUint { - type Output = BigUint; - - #[inline] - fn rem(self, other: &BigUint) -> BigUint { - let (_, r) = self.div_rem(other); - return r; - } -} - -impl Neg for BigUint { - type Output = BigUint; - - #[inline] - fn neg(self) -> BigUint { - panic!() - } -} - -impl<'a> Neg for &'a BigUint { - type Output = BigUint; - - #[inline] - fn neg(self) -> BigUint { - panic!() - } -} - -impl CheckedAdd for BigUint { - #[inline] - fn checked_add(&self, v: &BigUint) -> Option { - return Some(self.add(v)); - } -} - -impl CheckedSub for BigUint { - #[inline] - fn checked_sub(&self, v: &BigUint) -> Option { - match self.cmp(v) { - Less => None, - Equal => Some(Zero::zero()), - Greater => Some(self.sub(v)), - } - } -} - -impl CheckedMul for BigUint { - #[inline] - fn checked_mul(&self, v: &BigUint) -> Option { - return Some(self.mul(v)); - } -} - -impl CheckedDiv for BigUint { - #[inline] - fn checked_div(&self, v: &BigUint) -> Option { - if v.is_zero() { - return None; - } - return Some(self.div(v)); - } -} - -impl Integer for BigUint { - #[inline] - fn div_rem(&self, other: &BigUint) -> (BigUint, BigUint) { - self.div_mod_floor(other) - } - - #[inline] - fn div_floor(&self, other: &BigUint) -> BigUint { - let (d, _) = self.div_mod_floor(other); - return d; - } - - #[inline] - fn mod_floor(&self, other: &BigUint) -> BigUint { - let (_, m) = self.div_mod_floor(other); - return m; - } - - fn div_mod_floor(&self, other: &BigUint) -> (BigUint, BigUint) { - if other.is_zero() { - panic!() - } - if self.is_zero() { - return (Zero::zero(), Zero::zero()); - } - if *other == One::one() { - return (self.clone(), Zero::zero()); - } - - // Required or the q_len calculation below can underflow: - match self.cmp(other) { - Less => return (Zero::zero(), self.clone()), - Equal => return (One::one(), Zero::zero()), - Greater => {} // Do nothing - } - - // This algorithm is from Knuth, TAOCP vol 2 section 4.3, algorithm D: - // - // First, normalize the arguments so the highest bit in the highest digit of the divisor is - // set: the main loop uses the highest digit of the divisor for generating guesses, so we - // want it to be the largest number we can efficiently divide by. - // - let shift = other.data.last().unwrap().leading_zeros() as usize; - let mut a = self << shift; - let b = other << shift; - - // The algorithm works by incrementally calculating "guesses", q0, for part of the - // remainder. Once we have any number q0 such that q0 * b <= a, we can set - // - // q += q0 - // a -= q0 * b - // - // and then iterate until a < b. Then, (q, a) will be our desired quotient and remainder. - // - // q0, our guess, is calculated by dividing the last few digits of a by the last digit of b - // - this should give us a guess that is "close" to the actual quotient, but is possibly - // greater than the actual quotient. If q0 * b > a, we simply use iterated subtraction - // until we have a guess such that q0 & b <= a. - // - - let bn = *b.data.last().unwrap(); - let q_len = a.data.len() - b.data.len() + 1; - let mut q = BigUint { data: vec![0; q_len] }; - - // We reuse the same temporary to avoid hitting the allocator in our inner loop - this is - // sized to hold a0 (in the common case; if a particular digit of the quotient is zero a0 - // can be bigger). - // - let mut tmp = BigUint { data: Vec::with_capacity(2) }; - - for j in (0..q_len).rev() { - /* - * When calculating our next guess q0, we don't need to consider the digits below j - * + b.data.len() - 1: we're guessing digit j of the quotient (i.e. q0 << j) from - * digit bn of the divisor (i.e. bn << (b.data.len() - 1) - so the product of those - * two numbers will be zero in all digits up to (j + b.data.len() - 1). - */ - let offset = j + b.data.len() - 1; - if offset >= a.data.len() { - continue; - } - - /* just avoiding a heap allocation: */ - let mut a0 = tmp; - a0.data.truncate(0); - a0.data.extend(a.data[offset..].iter().cloned()); - - /* - * q0 << j * big_digit::BITS is our actual quotient estimate - we do the shifts - * implicitly at the end, when adding and subtracting to a and q. Not only do we - * save the cost of the shifts, the rest of the arithmetic gets to work with - * smaller numbers. - */ - let (mut q0, _) = div_rem_digit(a0, bn); - let mut prod = &b * &q0; - - while cmp_slice(&prod.data[..], &a.data[j..]) == Greater { - let one: BigUint = One::one(); - q0 = q0 - one; - prod = prod - &b; - } - - add2(&mut q.data[j..], &q0.data[..]); - sub2(&mut a.data[j..], &prod.data[..]); - a = a.normalize(); - - tmp = q0; - } - - debug_assert!(a < b); - - (q.normalize(), a >> shift) - } - - /// Calculates the Greatest Common Divisor (GCD) of the number and `other`. - /// - /// The result is always positive. - #[inline] - fn gcd(&self, other: &BigUint) -> BigUint { - // Use Euclid's algorithm - let mut m = (*self).clone(); - let mut n = (*other).clone(); - while !m.is_zero() { - let temp = m; - m = n % &temp; - n = temp; - } - return n; - } - - /// Calculates the Lowest Common Multiple (LCM) of the number and `other`. - #[inline] - fn lcm(&self, other: &BigUint) -> BigUint { - ((self * other) / self.gcd(other)) - } - - /// Deprecated, use `is_multiple_of` instead. - #[inline] - fn divides(&self, other: &BigUint) -> bool { - self.is_multiple_of(other) - } - - /// Returns `true` if the number is a multiple of `other`. - #[inline] - fn is_multiple_of(&self, other: &BigUint) -> bool { - (self % other).is_zero() - } - - /// Returns `true` if the number is divisible by `2`. - #[inline] - fn is_even(&self) -> bool { - // Considering only the last digit. - match self.data.first() { - Some(x) => x.is_even(), - None => true, - } - } - - /// Returns `true` if the number is not divisible by `2`. - #[inline] - fn is_odd(&self) -> bool { - !self.is_even() - } -} - -fn high_bits_to_u64(v: &BigUint) -> u64 { - match v.data.len() { - 0 => 0, - 1 => v.data[0] as u64, - _ => { - let mut bits = v.bits(); - let mut ret = 0u64; - let mut ret_bits = 0; - - for d in v.data.iter().rev() { - let digit_bits = (bits - 1) % big_digit::BITS + 1; - let bits_want = cmp::min(64 - ret_bits, digit_bits); - - if bits_want != 64 { - ret <<= bits_want; - } - ret |= *d as u64 >> (digit_bits - bits_want); - ret_bits += bits_want; - bits -= bits_want; - - if ret_bits == 64 { - break; - } - } - - ret - } - } -} - -/// Find last set bit -/// fls(0) == 0, fls(u32::MAX) == 32 -fn fls(v: T) -> usize { - std::mem::size_of::() * 8 - v.leading_zeros() as usize -} - -fn ilog2(v: T) -> usize { - fls(v) - 1 -} - -impl ToPrimitive for BigUint { - #[inline] - fn to_i64(&self) -> Option { - self.to_u64().and_then(|n| { - // If top bit of u64 is set, it's too large to convert to i64. - if n >> 63 == 0 { - Some(n as i64) - } else { - None - } - }) - } - - #[inline] - fn to_u64(&self) -> Option { - let mut ret: u64 = 0; - let mut bits = 0; - - for i in self.data.iter() { - if bits >= 64 { - return None; - } - - ret += (*i as u64) << bits; - bits += big_digit::BITS; - } - - Some(ret) - } - - #[inline] - fn to_f32(&self) -> Option { - let mantissa = high_bits_to_u64(self); - let exponent = self.bits() - fls(mantissa); - - if exponent > f32::MAX_EXP as usize { - None - } else { - let ret = (mantissa as f32) * 2.0f32.powi(exponent as i32); - if ret.is_infinite() { - None - } else { - Some(ret) - } - } - } - - #[inline] - fn to_f64(&self) -> Option { - let mantissa = high_bits_to_u64(self); - let exponent = self.bits() - fls(mantissa); - - if exponent > f64::MAX_EXP as usize { - None - } else { - let ret = (mantissa as f64) * 2.0f64.powi(exponent as i32); - if ret.is_infinite() { - None - } else { - Some(ret) - } - } - } -} - -impl FromPrimitive for BigUint { - #[inline] - fn from_i64(n: i64) -> Option { - if n >= 0 { - Some(BigUint::from(n as u64)) - } else { - None - } - } - - #[inline] - fn from_u64(n: u64) -> Option { - Some(BigUint::from(n)) - } - - #[inline] - fn from_f64(mut n: f64) -> Option { - // handle NAN, INFINITY, NEG_INFINITY - if !n.is_finite() { - return None; - } - - // match the rounding of casting from float to int - n = n.trunc(); - - // handle 0.x, -0.x - if n.is_zero() { - return Some(BigUint::zero()); - } - - let (mantissa, exponent, sign) = Float::integer_decode(n); - - if sign == -1 { - return None; - } - - let mut ret = BigUint::from(mantissa); - if exponent > 0 { - ret = ret << exponent as usize; - } else if exponent < 0 { - ret = ret >> (-exponent) as usize; - } - Some(ret) - } -} - -impl From for BigUint { - #[inline] - fn from(mut n: u64) -> Self { - let mut ret: BigUint = Zero::zero(); - - while n != 0 { - ret.data.push(n as BigDigit); - // don't overflow if BITS is 64: - n = (n >> 1) >> (big_digit::BITS - 1); - } - - ret - } -} - -macro_rules! impl_biguint_from_uint { - ($T:ty) => { - impl From<$T> for BigUint { - #[inline] - fn from(n: $T) -> Self { - BigUint::from(n as u64) - } - } - } -} - -impl_biguint_from_uint!(u8); -impl_biguint_from_uint!(u16); -impl_biguint_from_uint!(u32); -impl_biguint_from_uint!(usize); - -/// A generic trait for converting a value to a `BigUint`. -pub trait ToBigUint { - /// Converts the value of `self` to a `BigUint`. - fn to_biguint(&self) -> Option; -} - -impl ToBigUint for BigInt { - #[inline] - fn to_biguint(&self) -> Option { - if self.sign == Plus { - Some(self.data.clone()) - } else if self.sign == NoSign { - Some(Zero::zero()) - } else { - None - } - } -} - -impl ToBigUint for BigUint { - #[inline] - fn to_biguint(&self) -> Option { - Some(self.clone()) - } -} - -macro_rules! impl_to_biguint { - ($T:ty, $from_ty:path) => { - impl ToBigUint for $T { - #[inline] - fn to_biguint(&self) -> Option { - $from_ty(*self) - } - } - } -} - -impl_to_biguint!(isize, FromPrimitive::from_isize); -impl_to_biguint!(i8, FromPrimitive::from_i8); -impl_to_biguint!(i16, FromPrimitive::from_i16); -impl_to_biguint!(i32, FromPrimitive::from_i32); -impl_to_biguint!(i64, FromPrimitive::from_i64); -impl_to_biguint!(usize, FromPrimitive::from_usize); -impl_to_biguint!(u8, FromPrimitive::from_u8); -impl_to_biguint!(u16, FromPrimitive::from_u16); -impl_to_biguint!(u32, FromPrimitive::from_u32); -impl_to_biguint!(u64, FromPrimitive::from_u64); -impl_to_biguint!(f32, FromPrimitive::from_f32); -impl_to_biguint!(f64, FromPrimitive::from_f64); - -// Extract bitwise digits that evenly divide BigDigit -fn to_bitwise_digits_le(u: &BigUint, bits: usize) -> Vec { - debug_assert!(!u.is_zero() && bits <= 8 && big_digit::BITS % bits == 0); - - let last_i = u.data.len() - 1; - let mask: BigDigit = (1 << bits) - 1; - let digits_per_big_digit = big_digit::BITS / bits; - let digits = (u.bits() + bits - 1) / bits; - let mut res = Vec::with_capacity(digits); - - for mut r in u.data[..last_i].iter().cloned() { - for _ in 0..digits_per_big_digit { - res.push((r & mask) as u8); - r >>= bits; - } - } - - let mut r = u.data[last_i]; - while r != 0 { - res.push((r & mask) as u8); - r >>= bits; - } - - res -} - -// Extract bitwise digits that don't evenly divide BigDigit -fn to_inexact_bitwise_digits_le(u: &BigUint, bits: usize) -> Vec { - debug_assert!(!u.is_zero() && bits <= 8 && big_digit::BITS % bits != 0); - - let mask: BigDigit = (1 << bits) - 1; - let digits = (u.bits() + bits - 1) / bits; - let mut res = Vec::with_capacity(digits); - - let mut r = 0; - let mut rbits = 0; - - for c in &u.data { - r |= *c << rbits; - rbits += big_digit::BITS; - - while rbits >= bits { - res.push((r & mask) as u8); - r >>= bits; - - // r had more bits than it could fit - grab the bits we lost - if rbits > big_digit::BITS { - r = *c >> (big_digit::BITS - (rbits - bits)); - } - - rbits -= bits; - } - } - - if rbits != 0 { - res.push(r as u8); - } - - while let Some(&0) = res.last() { - res.pop(); - } - - res -} - -// Extract little-endian radix digits -#[inline(always)] // forced inline to get const-prop for radix=10 -fn to_radix_digits_le(u: &BigUint, radix: u32) -> Vec { - debug_assert!(!u.is_zero() && !radix.is_power_of_two()); - - // Estimate how big the result will be, so we can pre-allocate it. - let radix_digits = ((u.bits() as f64) / (radix as f64).log2()).ceil(); - let mut res = Vec::with_capacity(radix_digits as usize); - let mut digits = u.clone(); - - let (base, power) = get_radix_base(radix); - let radix = radix as BigDigit; - - while digits.data.len() > 1 { - let (q, mut r) = div_rem_digit(digits, base); - for _ in 0..power { - res.push((r % radix) as u8); - r /= radix; - } - digits = q; - } - - let mut r = digits.data[0]; - while r != 0 { - res.push((r % radix) as u8); - r /= radix; - } - - res -} - -fn to_str_radix_reversed(u: &BigUint, radix: u32) -> Vec { - assert!(2 <= radix && radix <= 36, "The radix must be within 2...36"); - - if u.is_zero() { - return vec![b'0']; - } - - let mut res = if radix.is_power_of_two() { - // Powers of two can use bitwise masks and shifting instead of division - let bits = ilog2(radix); - if big_digit::BITS % bits == 0 { - to_bitwise_digits_le(u, bits) - } else { - to_inexact_bitwise_digits_le(u, bits) - } - } else if radix == 10 { - // 10 is so common that it's worth separating out for const-propagation. - // Optimizers can often turn constant division into a faster multiplication. - to_radix_digits_le(u, 10) - } else { - to_radix_digits_le(u, radix) - }; - - // Now convert everything to ASCII digits. - for r in &mut res { - debug_assert!((*r as u32) < radix); - if *r < 10 { - *r += b'0'; - } else { - *r += b'a' - 10; - } - } - res -} - -impl BigUint { - /// Creates and initializes a `BigUint`. - /// - /// The digits are in little-endian base 2^32. - #[inline] - pub fn new(digits: Vec) -> BigUint { - BigUint { data: digits }.normalize() - } - - /// Creates and initializes a `BigUint`. - /// - /// The digits are in little-endian base 2^32. - #[inline] - pub fn from_slice(slice: &[BigDigit]) -> BigUint { - BigUint::new(slice.to_vec()) - } - - /// Creates and initializes a `BigUint`. - /// - /// The bytes are in big-endian byte order. - /// - /// # Examples - /// - /// ``` - /// use num_bigint::BigUint; - /// - /// assert_eq!(BigUint::from_bytes_be(b"A"), - /// BigUint::parse_bytes(b"65", 10).unwrap()); - /// assert_eq!(BigUint::from_bytes_be(b"AA"), - /// BigUint::parse_bytes(b"16705", 10).unwrap()); - /// assert_eq!(BigUint::from_bytes_be(b"AB"), - /// BigUint::parse_bytes(b"16706", 10).unwrap()); - /// assert_eq!(BigUint::from_bytes_be(b"Hello world!"), - /// BigUint::parse_bytes(b"22405534230753963835153736737", 10).unwrap()); - /// ``` - #[inline] - pub fn from_bytes_be(bytes: &[u8]) -> BigUint { - if bytes.is_empty() { - Zero::zero() - } else { - let mut v = bytes.to_vec(); - v.reverse(); - BigUint::from_bytes_le(&*v) - } - } - - /// Creates and initializes a `BigUint`. - /// - /// The bytes are in little-endian byte order. - #[inline] - pub fn from_bytes_le(bytes: &[u8]) -> BigUint { - if bytes.is_empty() { - Zero::zero() - } else { - from_bitwise_digits_le(bytes, 8) - } - } - - /// Returns the byte representation of the `BigUint` in little-endian byte order. - /// - /// # Examples - /// - /// ``` - /// use num_bigint::BigUint; - /// - /// let i = BigUint::parse_bytes(b"1125", 10).unwrap(); - /// assert_eq!(i.to_bytes_le(), vec![101, 4]); - /// ``` - #[inline] - pub fn to_bytes_le(&self) -> Vec { - if self.is_zero() { - vec![0] - } else { - to_bitwise_digits_le(self, 8) - } - } - - /// Returns the byte representation of the `BigUint` in big-endian byte order. - /// - /// # Examples - /// - /// ``` - /// use num_bigint::BigUint; - /// - /// let i = BigUint::parse_bytes(b"1125", 10).unwrap(); - /// assert_eq!(i.to_bytes_be(), vec![4, 101]); - /// ``` - #[inline] - pub fn to_bytes_be(&self) -> Vec { - let mut v = self.to_bytes_le(); - v.reverse(); - v - } - - /// Returns the integer formatted as a string in the given radix. - /// `radix` must be in the range `[2, 36]`. - /// - /// # Examples - /// - /// ``` - /// use num_bigint::BigUint; - /// - /// let i = BigUint::parse_bytes(b"ff", 16).unwrap(); - /// assert_eq!(i.to_str_radix(16), "ff"); - /// ``` - #[inline] - pub fn to_str_radix(&self, radix: u32) -> String { - let mut v = to_str_radix_reversed(self, radix); - v.reverse(); - unsafe { String::from_utf8_unchecked(v) } - } - - /// Creates and initializes a `BigUint`. - /// - /// # Examples - /// - /// ``` - /// use num_bigint::{BigUint, ToBigUint}; - /// - /// assert_eq!(BigUint::parse_bytes(b"1234", 10), ToBigUint::to_biguint(&1234)); - /// assert_eq!(BigUint::parse_bytes(b"ABCD", 16), ToBigUint::to_biguint(&0xABCD)); - /// assert_eq!(BigUint::parse_bytes(b"G", 16), None); - /// ``` - #[inline] - pub fn parse_bytes(buf: &[u8], radix: u32) -> Option { - str::from_utf8(buf).ok().and_then(|s| BigUint::from_str_radix(s, radix).ok()) - } - - /// Determines the fewest bits necessary to express the `BigUint`. - pub fn bits(&self) -> usize { - if self.is_zero() { - return 0; - } - let zeros = self.data.last().unwrap().leading_zeros(); - return self.data.len() * big_digit::BITS - zeros as usize; - } - - /// Strips off trailing zero bigdigits - comparisons require the last element in the vector to - /// be nonzero. - #[inline] - fn normalize(mut self) -> BigUint { - while let Some(&0) = self.data.last() { - self.data.pop(); - } - self - } -} - -#[cfg(feature = "serde")] -impl serde::Serialize for BigUint { - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: serde::Serializer - { - self.data.serialize(serializer) - } -} - -#[cfg(feature = "serde")] -impl serde::Deserialize for BigUint { - fn deserialize(deserializer: &mut D) -> Result - where D: serde::Deserializer - { - let data = try!(Vec::deserialize(deserializer)); - Ok(BigUint { data: data }) - } -} - -/// Returns the greatest power of the radix <= big_digit::BASE -#[inline] -fn get_radix_base(radix: u32) -> (BigDigit, usize) { - debug_assert!(2 <= radix && radix <= 36, "The radix must be within 2...36"); - debug_assert!(!radix.is_power_of_two()); - - // To generate this table: - // for radix in 2u64..37 { - // let mut power = big_digit::BITS / fls(radix as u64); - // let mut base = radix.pow(power as u32); - // - // while let Some(b) = base.checked_mul(radix) { - // if b > big_digit::MAX { - // break; - // } - // base = b; - // power += 1; - // } - // - // println!("({:10}, {:2}), // {:2}", base, power, radix); - // } - - match big_digit::BITS { - 32 => { - const BASES: [(u32, usize); 37] = [(0, 0), (0, 0), - (0, 0), // 2 - (3486784401, 20),// 3 - (0, 0), // 4 - (1220703125, 13),// 5 - (2176782336, 12),// 6 - (1977326743, 11),// 7 - (0, 0), // 8 - (3486784401, 10),// 9 - (1000000000, 9), // 10 - (2357947691, 9), // 11 - (429981696, 8), // 12 - (815730721, 8), // 13 - (1475789056, 8), // 14 - (2562890625, 8), // 15 - (0, 0), // 16 - (410338673, 7), // 17 - (612220032, 7), // 18 - (893871739, 7), // 19 - (1280000000, 7), // 20 - (1801088541, 7), // 21 - (2494357888, 7), // 22 - (3404825447, 7), // 23 - (191102976, 6), // 24 - (244140625, 6), // 25 - (308915776, 6), // 26 - (387420489, 6), // 27 - (481890304, 6), // 28 - (594823321, 6), // 29 - (729000000, 6), // 30 - (887503681, 6), // 31 - (0, 0), // 32 - (1291467969, 6), // 33 - (1544804416, 6), // 34 - (1838265625, 6), // 35 - (2176782336, 6) // 36 - ]; - - let (base, power) = BASES[radix as usize]; - (base as BigDigit, power) - } - 64 => { - const BASES: [(u64, usize); 37] = [(0, 0), (0, 0), - (9223372036854775808, 63), // 2 - (12157665459056928801, 40), // 3 - (4611686018427387904, 31), // 4 - (7450580596923828125, 27), // 5 - (4738381338321616896, 24), // 6 - (3909821048582988049, 22), // 7 - (9223372036854775808, 21), // 8 - (12157665459056928801, 20), // 9 - (10000000000000000000, 19), // 10 - (5559917313492231481, 18), // 11 - (2218611106740436992, 17), // 12 - (8650415919381337933, 17), // 13 - (2177953337809371136, 16), // 14 - (6568408355712890625, 16), // 15 - (1152921504606846976, 15), // 16 - (2862423051509815793, 15), // 17 - (6746640616477458432, 15), // 18 - (15181127029874798299, 15), // 19 - (1638400000000000000, 14), // 20 - (3243919932521508681, 14), // 21 - (6221821273427820544, 14), // 22 - (11592836324538749809, 14), // 23 - (876488338465357824, 13), // 24 - (1490116119384765625, 13), // 25 - (2481152873203736576, 13), // 26 - (4052555153018976267, 13), // 27 - (6502111422497947648, 13), // 28 - (10260628712958602189, 13), // 29 - (15943230000000000000, 13), // 30 - (787662783788549761, 12), // 31 - (1152921504606846976, 12), // 32 - (1667889514952984961, 12), // 33 - (2386420683693101056, 12), // 34 - (3379220508056640625, 12), // 35 - (4738381338321616896, 12), // 36 - ]; - - let (base, power) = BASES[radix as usize]; - (base as BigDigit, power) - } - _ => panic!("Invalid bigdigit size") - } -} - -/// A Sign is a `BigInt`'s composing element. -#[derive(PartialEq, PartialOrd, Eq, Ord, Copy, Clone, Debug, Hash)] -#[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))] -pub enum Sign { - Minus, - NoSign, - Plus, -} - -impl Neg for Sign { - type Output = Sign; - - /// Negate Sign value. - #[inline] - fn neg(self) -> Sign { - match self { - Minus => Plus, - NoSign => NoSign, - Plus => Minus, - } - } -} - -impl Mul for Sign { - type Output = Sign; - - #[inline] - fn mul(self, other: Sign) -> Sign { - match (self, other) { - (NoSign, _) | (_, NoSign) => NoSign, - (Plus, Plus) | (Minus, Minus) => Plus, - (Plus, Minus) | (Minus, Plus) => Minus, - } - } -} - -#[cfg(feature = "serde")] -impl serde::Serialize for Sign { - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: serde::Serializer - { - match *self { - Sign::Minus => (-1i8).serialize(serializer), - Sign::NoSign => 0i8.serialize(serializer), - Sign::Plus => 1i8.serialize(serializer), - } - } -} - -#[cfg(feature = "serde")] -impl serde::Deserialize for Sign { - fn deserialize(deserializer: &mut D) -> Result - where D: serde::Deserializer - { - use serde::de::Error; - - let sign: i8 = try!(serde::Deserialize::deserialize(deserializer)); - match sign { - -1 => Ok(Sign::Minus), - 0 => Ok(Sign::NoSign), - 1 => Ok(Sign::Plus), - _ => Err(D::Error::invalid_value("sign must be -1, 0, or 1")), - } - } -} - -/// A big signed integer type. -#[derive(Clone, Debug, Hash)] -#[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))] -pub struct BigInt { - sign: Sign, - data: BigUint, -} - -impl PartialEq for BigInt { - #[inline] - fn eq(&self, other: &BigInt) -> bool { - self.cmp(other) == Equal - } -} - -impl Eq for BigInt {} - -impl PartialOrd for BigInt { - #[inline] - fn partial_cmp(&self, other: &BigInt) -> Option { - Some(self.cmp(other)) - } -} - -impl Ord for BigInt { - #[inline] - fn cmp(&self, other: &BigInt) -> Ordering { - let scmp = self.sign.cmp(&other.sign); - if scmp != Equal { - return scmp; - } - - match self.sign { - NoSign => Equal, - Plus => self.data.cmp(&other.data), - Minus => other.data.cmp(&self.data), - } - } -} - -impl Default for BigInt { - #[inline] - fn default() -> BigInt { - Zero::zero() - } -} - -impl fmt::Display for BigInt { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.pad_integral(!self.is_negative(), "", &self.data.to_str_radix(10)) - } -} - -impl fmt::Binary for BigInt { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.pad_integral(!self.is_negative(), "0b", &self.data.to_str_radix(2)) - } -} - -impl fmt::Octal for BigInt { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.pad_integral(!self.is_negative(), "0o", &self.data.to_str_radix(8)) - } -} - -impl fmt::LowerHex for BigInt { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.pad_integral(!self.is_negative(), "0x", &self.data.to_str_radix(16)) - } -} - -impl fmt::UpperHex for BigInt { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.pad_integral(!self.is_negative(), - "0x", - &self.data.to_str_radix(16).to_ascii_uppercase()) - } -} - -impl FromStr for BigInt { - type Err = ParseBigIntError; - - #[inline] - fn from_str(s: &str) -> Result { - BigInt::from_str_radix(s, 10) - } -} - -impl Num for BigInt { - type FromStrRadixErr = ParseBigIntError; - - /// Creates and initializes a BigInt. - #[inline] - fn from_str_radix(mut s: &str, radix: u32) -> Result { - let sign = if s.starts_with('-') { - let tail = &s[1..]; - if !tail.starts_with('+') { - s = tail - } - Minus - } else { - Plus - }; - let bu = try!(BigUint::from_str_radix(s, radix)); - Ok(BigInt::from_biguint(sign, bu)) - } -} - -impl Shl for BigInt { - type Output = BigInt; - - #[inline] - fn shl(self, rhs: usize) -> BigInt { - (&self) << rhs - } -} - -impl<'a> Shl for &'a BigInt { - type Output = BigInt; - - #[inline] - fn shl(self, rhs: usize) -> BigInt { - BigInt::from_biguint(self.sign, &self.data << rhs) - } -} - -impl Shr for BigInt { - type Output = BigInt; - - #[inline] - fn shr(self, rhs: usize) -> BigInt { - BigInt::from_biguint(self.sign, self.data >> rhs) - } -} - -impl<'a> Shr for &'a BigInt { - type Output = BigInt; - - #[inline] - fn shr(self, rhs: usize) -> BigInt { - BigInt::from_biguint(self.sign, &self.data >> rhs) - } -} - -impl Zero for BigInt { - #[inline] - fn zero() -> BigInt { - BigInt::from_biguint(NoSign, Zero::zero()) - } - - #[inline] - fn is_zero(&self) -> bool { - self.sign == NoSign - } -} - -impl One for BigInt { - #[inline] - fn one() -> BigInt { - BigInt::from_biguint(Plus, One::one()) - } -} - -impl Signed for BigInt { - #[inline] - fn abs(&self) -> BigInt { - match self.sign { - Plus | NoSign => self.clone(), - Minus => BigInt::from_biguint(Plus, self.data.clone()), - } - } - - #[inline] - fn abs_sub(&self, other: &BigInt) -> BigInt { - if *self <= *other { - Zero::zero() - } else { - self - other - } - } - - #[inline] - fn signum(&self) -> BigInt { - match self.sign { - Plus => BigInt::from_biguint(Plus, One::one()), - Minus => BigInt::from_biguint(Minus, One::one()), - NoSign => Zero::zero(), - } - } - - #[inline] - fn is_positive(&self) -> bool { - self.sign == Plus - } - - #[inline] - fn is_negative(&self) -> bool { - self.sign == Minus - } -} - -// We want to forward to BigUint::add, but it's not clear how that will go until -// we compare both sign and magnitude. So we duplicate this body for every -// val/ref combination, deferring that decision to BigUint's own forwarding. -macro_rules! bigint_add { - ($a:expr, $a_owned:expr, $a_data:expr, $b:expr, $b_owned:expr, $b_data:expr) => { - match ($a.sign, $b.sign) { - (_, NoSign) => $a_owned, - (NoSign, _) => $b_owned, - // same sign => keep the sign with the sum of magnitudes - (Plus, Plus) | (Minus, Minus) => - BigInt::from_biguint($a.sign, $a_data + $b_data), - // opposite signs => keep the sign of the larger with the difference of magnitudes - (Plus, Minus) | (Minus, Plus) => - match $a.data.cmp(&$b.data) { - Less => BigInt::from_biguint($b.sign, $b_data - $a_data), - Greater => BigInt::from_biguint($a.sign, $a_data - $b_data), - Equal => Zero::zero(), - }, - } - }; -} - -impl<'a, 'b> Add<&'b BigInt> for &'a BigInt { - type Output = BigInt; - - #[inline] - fn add(self, other: &BigInt) -> BigInt { - bigint_add!(self, - self.clone(), - &self.data, - other, - other.clone(), - &other.data) - } -} - -impl<'a> Add for &'a BigInt { - type Output = BigInt; - - #[inline] - fn add(self, other: BigInt) -> BigInt { - bigint_add!(self, self.clone(), &self.data, other, other, other.data) - } -} - -impl<'a> Add<&'a BigInt> for BigInt { - type Output = BigInt; - - #[inline] - fn add(self, other: &BigInt) -> BigInt { - bigint_add!(self, self, self.data, other, other.clone(), &other.data) - } -} - -impl Add for BigInt { - type Output = BigInt; - - #[inline] - fn add(self, other: BigInt) -> BigInt { - bigint_add!(self, self, self.data, other, other, other.data) - } -} - -// We want to forward to BigUint::sub, but it's not clear how that will go until -// we compare both sign and magnitude. So we duplicate this body for every -// val/ref combination, deferring that decision to BigUint's own forwarding. -macro_rules! bigint_sub { - ($a:expr, $a_owned:expr, $a_data:expr, $b:expr, $b_owned:expr, $b_data:expr) => { - match ($a.sign, $b.sign) { - (_, NoSign) => $a_owned, - (NoSign, _) => -$b_owned, - // opposite signs => keep the sign of the left with the sum of magnitudes - (Plus, Minus) | (Minus, Plus) => - BigInt::from_biguint($a.sign, $a_data + $b_data), - // same sign => keep or toggle the sign of the left with the difference of magnitudes - (Plus, Plus) | (Minus, Minus) => - match $a.data.cmp(&$b.data) { - Less => BigInt::from_biguint(-$a.sign, $b_data - $a_data), - Greater => BigInt::from_biguint($a.sign, $a_data - $b_data), - Equal => Zero::zero(), - }, - } - }; -} - -impl<'a, 'b> Sub<&'b BigInt> for &'a BigInt { - type Output = BigInt; - - #[inline] - fn sub(self, other: &BigInt) -> BigInt { - bigint_sub!(self, - self.clone(), - &self.data, - other, - other.clone(), - &other.data) - } -} - -impl<'a> Sub for &'a BigInt { - type Output = BigInt; - - #[inline] - fn sub(self, other: BigInt) -> BigInt { - bigint_sub!(self, self.clone(), &self.data, other, other, other.data) - } -} - -impl<'a> Sub<&'a BigInt> for BigInt { - type Output = BigInt; - - #[inline] - fn sub(self, other: &BigInt) -> BigInt { - bigint_sub!(self, self, self.data, other, other.clone(), &other.data) - } -} - -impl Sub for BigInt { - type Output = BigInt; - - #[inline] - fn sub(self, other: BigInt) -> BigInt { - bigint_sub!(self, self, self.data, other, other, other.data) - } -} - -forward_all_binop_to_ref_ref!(impl Mul for BigInt, mul); - -impl<'a, 'b> Mul<&'b BigInt> for &'a BigInt { - type Output = BigInt; - - #[inline] - fn mul(self, other: &BigInt) -> BigInt { - BigInt::from_biguint(self.sign * other.sign, &self.data * &other.data) - } -} - -forward_all_binop_to_ref_ref!(impl Div for BigInt, div); - -impl<'a, 'b> Div<&'b BigInt> for &'a BigInt { - type Output = BigInt; - - #[inline] - fn div(self, other: &BigInt) -> BigInt { - let (q, _) = self.div_rem(other); - q - } -} - -forward_all_binop_to_ref_ref!(impl Rem for BigInt, rem); - -impl<'a, 'b> Rem<&'b BigInt> for &'a BigInt { - type Output = BigInt; - - #[inline] - fn rem(self, other: &BigInt) -> BigInt { - let (_, r) = self.div_rem(other); - r - } -} - -impl Neg for BigInt { - type Output = BigInt; - - #[inline] - fn neg(mut self) -> BigInt { - self.sign = -self.sign; - self - } -} - -impl<'a> Neg for &'a BigInt { - type Output = BigInt; - - #[inline] - fn neg(self) -> BigInt { - -self.clone() - } -} - -impl CheckedAdd for BigInt { - #[inline] - fn checked_add(&self, v: &BigInt) -> Option { - return Some(self.add(v)); - } -} - -impl CheckedSub for BigInt { - #[inline] - fn checked_sub(&self, v: &BigInt) -> Option { - return Some(self.sub(v)); - } -} - -impl CheckedMul for BigInt { - #[inline] - fn checked_mul(&self, v: &BigInt) -> Option { - return Some(self.mul(v)); - } -} - -impl CheckedDiv for BigInt { - #[inline] - fn checked_div(&self, v: &BigInt) -> Option { - if v.is_zero() { - return None; - } - return Some(self.div(v)); - } -} - -impl Integer for BigInt { - #[inline] - fn div_rem(&self, other: &BigInt) -> (BigInt, BigInt) { - // r.sign == self.sign - let (d_ui, r_ui) = self.data.div_mod_floor(&other.data); - let d = BigInt::from_biguint(self.sign, d_ui); - let r = BigInt::from_biguint(self.sign, r_ui); - if other.is_negative() { - (-d, r) - } else { - (d, r) - } - } - - #[inline] - fn div_floor(&self, other: &BigInt) -> BigInt { - let (d, _) = self.div_mod_floor(other); - d - } - - #[inline] - fn mod_floor(&self, other: &BigInt) -> BigInt { - let (_, m) = self.div_mod_floor(other); - m - } - - fn div_mod_floor(&self, other: &BigInt) -> (BigInt, BigInt) { - // m.sign == other.sign - let (d_ui, m_ui) = self.data.div_rem(&other.data); - let d = BigInt::from_biguint(Plus, d_ui); - let m = BigInt::from_biguint(Plus, m_ui); - let one: BigInt = One::one(); - match (self.sign, other.sign) { - (_, NoSign) => panic!(), - (Plus, Plus) | (NoSign, Plus) => (d, m), - (Plus, Minus) | (NoSign, Minus) => { - if m.is_zero() { - (-d, Zero::zero()) - } else { - (-d - one, m + other) - } - } - (Minus, Plus) => { - if m.is_zero() { - (-d, Zero::zero()) - } else { - (-d - one, other - m) - } - } - (Minus, Minus) => (d, -m), - } - } - - /// Calculates the Greatest Common Divisor (GCD) of the number and `other`. - /// - /// The result is always positive. - #[inline] - fn gcd(&self, other: &BigInt) -> BigInt { - BigInt::from_biguint(Plus, self.data.gcd(&other.data)) - } - - /// Calculates the Lowest Common Multiple (LCM) of the number and `other`. - #[inline] - fn lcm(&self, other: &BigInt) -> BigInt { - BigInt::from_biguint(Plus, self.data.lcm(&other.data)) - } - - /// Deprecated, use `is_multiple_of` instead. - #[inline] - fn divides(&self, other: &BigInt) -> bool { - return self.is_multiple_of(other); - } - - /// Returns `true` if the number is a multiple of `other`. - #[inline] - fn is_multiple_of(&self, other: &BigInt) -> bool { - self.data.is_multiple_of(&other.data) - } - - /// Returns `true` if the number is divisible by `2`. - #[inline] - fn is_even(&self) -> bool { - self.data.is_even() - } - - /// Returns `true` if the number is not divisible by `2`. - #[inline] - fn is_odd(&self) -> bool { - self.data.is_odd() - } -} - -impl ToPrimitive for BigInt { - #[inline] - fn to_i64(&self) -> Option { - match self.sign { - Plus => self.data.to_i64(), - NoSign => Some(0), - Minus => { - self.data.to_u64().and_then(|n| { - let m: u64 = 1 << 63; - if n < m { - Some(-(n as i64)) - } else if n == m { - Some(i64::MIN) - } else { - None - } - }) - } - } - } - - #[inline] - fn to_u64(&self) -> Option { - match self.sign { - Plus => self.data.to_u64(), - NoSign => Some(0), - Minus => None, - } - } - - #[inline] - fn to_f32(&self) -> Option { - self.data.to_f32().map(|n| { - if self.sign == Minus { - -n - } else { - n - } - }) - } - - #[inline] - fn to_f64(&self) -> Option { - self.data.to_f64().map(|n| { - if self.sign == Minus { - -n - } else { - n - } - }) - } -} - -impl FromPrimitive for BigInt { - #[inline] - fn from_i64(n: i64) -> Option { - Some(BigInt::from(n)) - } - - #[inline] - fn from_u64(n: u64) -> Option { - Some(BigInt::from(n)) - } - - #[inline] - fn from_f64(n: f64) -> Option { - if n >= 0.0 { - BigUint::from_f64(n).map(|x| BigInt::from_biguint(Plus, x)) - } else { - BigUint::from_f64(-n).map(|x| BigInt::from_biguint(Minus, x)) - } - } -} - -impl From for BigInt { - #[inline] - fn from(n: i64) -> Self { - if n >= 0 { - BigInt::from(n as u64) - } else { - let u = u64::MAX - (n as u64) + 1; - BigInt { - sign: Minus, - data: BigUint::from(u), - } - } - } -} - -macro_rules! impl_bigint_from_int { - ($T:ty) => { - impl From<$T> for BigInt { - #[inline] - fn from(n: $T) -> Self { - BigInt::from(n as i64) - } - } - } -} - -impl_bigint_from_int!(i8); -impl_bigint_from_int!(i16); -impl_bigint_from_int!(i32); -impl_bigint_from_int!(isize); - -impl From for BigInt { - #[inline] - fn from(n: u64) -> Self { - if n > 0 { - BigInt { - sign: Plus, - data: BigUint::from(n), - } - } else { - BigInt::zero() - } - } -} - -macro_rules! impl_bigint_from_uint { - ($T:ty) => { - impl From<$T> for BigInt { - #[inline] - fn from(n: $T) -> Self { - BigInt::from(n as u64) - } - } - } -} - -impl_bigint_from_uint!(u8); -impl_bigint_from_uint!(u16); -impl_bigint_from_uint!(u32); -impl_bigint_from_uint!(usize); - -impl From for BigInt { - #[inline] - fn from(n: BigUint) -> Self { - if n.is_zero() { - BigInt::zero() - } else { - BigInt { - sign: Plus, - data: n, - } - } - } -} - -#[cfg(feature = "serde")] -impl serde::Serialize for BigInt { - fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> - where S: serde::Serializer - { - (self.sign, &self.data).serialize(serializer) - } -} - -#[cfg(feature = "serde")] -impl serde::Deserialize for BigInt { - fn deserialize(deserializer: &mut D) -> Result - where D: serde::Deserializer - { - let (sign, data) = try!(serde::Deserialize::deserialize(deserializer)); - Ok(BigInt { - sign: sign, - data: data, - }) - } -} - -/// A generic trait for converting a value to a `BigInt`. -pub trait ToBigInt { - /// Converts the value of `self` to a `BigInt`. - fn to_bigint(&self) -> Option; -} - -impl ToBigInt for BigInt { - #[inline] - fn to_bigint(&self) -> Option { - Some(self.clone()) - } -} - -impl ToBigInt for BigUint { - #[inline] - fn to_bigint(&self) -> Option { - if self.is_zero() { - Some(Zero::zero()) - } else { - Some(BigInt { - sign: Plus, - data: self.clone(), - }) - } - } -} - -macro_rules! impl_to_bigint { - ($T:ty, $from_ty:path) => { - impl ToBigInt for $T { - #[inline] - fn to_bigint(&self) -> Option { - $from_ty(*self) - } - } - } -} - -impl_to_bigint!(isize, FromPrimitive::from_isize); -impl_to_bigint!(i8, FromPrimitive::from_i8); -impl_to_bigint!(i16, FromPrimitive::from_i16); -impl_to_bigint!(i32, FromPrimitive::from_i32); -impl_to_bigint!(i64, FromPrimitive::from_i64); -impl_to_bigint!(usize, FromPrimitive::from_usize); -impl_to_bigint!(u8, FromPrimitive::from_u8); -impl_to_bigint!(u16, FromPrimitive::from_u16); -impl_to_bigint!(u32, FromPrimitive::from_u32); -impl_to_bigint!(u64, FromPrimitive::from_u64); -impl_to_bigint!(f32, FromPrimitive::from_f32); -impl_to_bigint!(f64, FromPrimitive::from_f64); - -pub trait RandBigInt { - /// Generate a random `BigUint` of the given bit size. - fn gen_biguint(&mut self, bit_size: usize) -> BigUint; - - /// Generate a random BigInt of the given bit size. - fn gen_bigint(&mut self, bit_size: usize) -> BigInt; - - /// Generate a random `BigUint` less than the given bound. Fails - /// when the bound is zero. - fn gen_biguint_below(&mut self, bound: &BigUint) -> BigUint; - - /// Generate a random `BigUint` within the given range. The lower - /// bound is inclusive; the upper bound is exclusive. Fails when - /// the upper bound is not greater than the lower bound. - fn gen_biguint_range(&mut self, lbound: &BigUint, ubound: &BigUint) -> BigUint; - - /// Generate a random `BigInt` within the given range. The lower - /// bound is inclusive; the upper bound is exclusive. Fails when - /// the upper bound is not greater than the lower bound. - fn gen_bigint_range(&mut self, lbound: &BigInt, ubound: &BigInt) -> BigInt; -} - -#[cfg(any(feature = "rand", test))] -impl RandBigInt for R { - fn gen_biguint(&mut self, bit_size: usize) -> BigUint { - let (digits, rem) = bit_size.div_rem(&big_digit::BITS); - let mut data = Vec::with_capacity(digits + 1); - for _ in 0..digits { - data.push(self.gen()); - } - if rem > 0 { - let final_digit: BigDigit = self.gen(); - data.push(final_digit >> (big_digit::BITS - rem)); - } - BigUint::new(data) - } - - fn gen_bigint(&mut self, bit_size: usize) -> BigInt { - // Generate a random BigUint... - let biguint = self.gen_biguint(bit_size); - // ...and then randomly assign it a Sign... - let sign = if biguint.is_zero() { - // ...except that if the BigUint is zero, we need to try - // again with probability 0.5. This is because otherwise, - // the probability of generating a zero BigInt would be - // double that of any other number. - if self.gen() { - return self.gen_bigint(bit_size); - } else { - NoSign - } - } else if self.gen() { - Plus - } else { - Minus - }; - BigInt::from_biguint(sign, biguint) - } - - fn gen_biguint_below(&mut self, bound: &BigUint) -> BigUint { - assert!(!bound.is_zero()); - let bits = bound.bits(); - loop { - let n = self.gen_biguint(bits); - if n < *bound { - return n; - } - } - } - - fn gen_biguint_range(&mut self, lbound: &BigUint, ubound: &BigUint) -> BigUint { - assert!(*lbound < *ubound); - return lbound + self.gen_biguint_below(&(ubound - lbound)); - } - - fn gen_bigint_range(&mut self, lbound: &BigInt, ubound: &BigInt) -> BigInt { - assert!(*lbound < *ubound); - let delta = (ubound - lbound).to_biguint().unwrap(); - return lbound + self.gen_biguint_below(&delta).to_bigint().unwrap(); - } -} - -impl BigInt { - /// Creates and initializes a BigInt. - /// - /// The digits are in little-endian base 2^32. - #[inline] - pub fn new(sign: Sign, digits: Vec) -> BigInt { - BigInt::from_biguint(sign, BigUint::new(digits)) - } - - /// Creates and initializes a `BigInt`. - /// - /// The digits are in little-endian base 2^32. - #[inline] - pub fn from_biguint(sign: Sign, data: BigUint) -> BigInt { - if sign == NoSign || data.is_zero() { - return BigInt { - sign: NoSign, - data: Zero::zero(), - }; - } - BigInt { - sign: sign, - data: data, - } - } - - /// Creates and initializes a `BigInt`. - #[inline] - pub fn from_slice(sign: Sign, slice: &[BigDigit]) -> BigInt { - BigInt::from_biguint(sign, BigUint::from_slice(slice)) - } - - /// Creates and initializes a `BigInt`. - /// - /// The bytes are in big-endian byte order. - /// - /// # Examples - /// - /// ``` - /// use num_bigint::{BigInt, Sign}; - /// - /// assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"A"), - /// BigInt::parse_bytes(b"65", 10).unwrap()); - /// assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"AA"), - /// BigInt::parse_bytes(b"16705", 10).unwrap()); - /// assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"AB"), - /// BigInt::parse_bytes(b"16706", 10).unwrap()); - /// assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"Hello world!"), - /// BigInt::parse_bytes(b"22405534230753963835153736737", 10).unwrap()); - /// ``` - #[inline] - pub fn from_bytes_be(sign: Sign, bytes: &[u8]) -> BigInt { - BigInt::from_biguint(sign, BigUint::from_bytes_be(bytes)) - } - - /// Creates and initializes a `BigInt`. - /// - /// The bytes are in little-endian byte order. - #[inline] - pub fn from_bytes_le(sign: Sign, bytes: &[u8]) -> BigInt { - BigInt::from_biguint(sign, BigUint::from_bytes_le(bytes)) - } - - /// Returns the sign and the byte representation of the `BigInt` in little-endian byte order. - /// - /// # Examples - /// - /// ``` - /// use num_bigint::{ToBigInt, Sign}; - /// - /// let i = -1125.to_bigint().unwrap(); - /// assert_eq!(i.to_bytes_le(), (Sign::Minus, vec![101, 4])); - /// ``` - #[inline] - pub fn to_bytes_le(&self) -> (Sign, Vec) { - (self.sign, self.data.to_bytes_le()) - } - - /// Returns the sign and the byte representation of the `BigInt` in big-endian byte order. - /// - /// # Examples - /// - /// ``` - /// use num_bigint::{ToBigInt, Sign}; - /// - /// let i = -1125.to_bigint().unwrap(); - /// assert_eq!(i.to_bytes_be(), (Sign::Minus, vec![4, 101])); - /// ``` - #[inline] - pub fn to_bytes_be(&self) -> (Sign, Vec) { - (self.sign, self.data.to_bytes_be()) - } - - /// Returns the integer formatted as a string in the given radix. - /// `radix` must be in the range `[2, 36]`. - /// - /// # Examples - /// - /// ``` - /// use num_bigint::BigInt; - /// - /// let i = BigInt::parse_bytes(b"ff", 16).unwrap(); - /// assert_eq!(i.to_str_radix(16), "ff"); - /// ``` - #[inline] - pub fn to_str_radix(&self, radix: u32) -> String { - let mut v = to_str_radix_reversed(&self.data, radix); - - if self.is_negative() { - v.push(b'-'); - } - - v.reverse(); - unsafe { String::from_utf8_unchecked(v) } - } - - /// Returns the sign of the `BigInt` as a `Sign`. - /// - /// # Examples - /// - /// ``` - /// use num_bigint::{ToBigInt, Sign}; - /// - /// assert_eq!(ToBigInt::to_bigint(&1234).unwrap().sign(), Sign::Plus); - /// assert_eq!(ToBigInt::to_bigint(&-4321).unwrap().sign(), Sign::Minus); - /// assert_eq!(ToBigInt::to_bigint(&0).unwrap().sign(), Sign::NoSign); - /// ``` - #[inline] - pub fn sign(&self) -> Sign { - self.sign - } - - /// Creates and initializes a `BigInt`. - /// - /// # Examples - /// - /// ``` - /// use num_bigint::{BigInt, ToBigInt}; - /// - /// assert_eq!(BigInt::parse_bytes(b"1234", 10), ToBigInt::to_bigint(&1234)); - /// assert_eq!(BigInt::parse_bytes(b"ABCD", 16), ToBigInt::to_bigint(&0xABCD)); - /// assert_eq!(BigInt::parse_bytes(b"G", 16), None); - /// ``` - #[inline] - pub fn parse_bytes(buf: &[u8], radix: u32) -> Option { - str::from_utf8(buf).ok().and_then(|s| BigInt::from_str_radix(s, radix).ok()) - } - - /// Determines the fewest bits necessary to express the `BigInt`, - /// not including the sign. - pub fn bits(&self) -> usize { - self.data.bits() - } - - /// Converts this `BigInt` into a `BigUint`, if it's not negative. - #[inline] - pub fn to_biguint(&self) -> Option { - match self.sign { - Plus => Some(self.data.clone()), - NoSign => Some(Zero::zero()), - Minus => None, - } - } - - #[inline] - pub fn checked_add(&self, v: &BigInt) -> Option { - return Some(self.add(v)); - } - - #[inline] - pub fn checked_sub(&self, v: &BigInt) -> Option { - return Some(self.sub(v)); - } - - #[inline] - pub fn checked_mul(&self, v: &BigInt) -> Option { - return Some(self.mul(v)); - } - - #[inline] - pub fn checked_div(&self, v: &BigInt) -> Option { - if v.is_zero() { - return None; - } - return Some(self.div(v)); - } -} #[derive(Debug, PartialEq)] pub enum ParseBigIntError { @@ -3085,6 +111,9 @@ impl From for ParseBigIntError { } } +#[cfg(test)] +use std::hash; + #[cfg(test)] fn hash(x: &T) -> u64 { use std::hash::Hasher; @@ -3093,2206 +122,18 @@ fn hash(x: &T) -> u64 { hasher.finish() } -#[cfg(test)] -mod biguint_tests { - use integer::Integer; - use super::{BigDigit, BigUint, ToBigUint, big_digit}; - use super::{BigInt, RandBigInt, ToBigInt}; - use super::Sign::Plus; +#[macro_use] +mod macros; - use std::cmp::Ordering::{Less, Equal, Greater}; - use std::{f32, f64}; - use std::i64; - use std::iter::repeat; - use std::str::FromStr; - use std::{u8, u16, u32, u64, usize}; +mod biguint; +mod bigint; - use rand::thread_rng; - use traits::{Num, Zero, One, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv, ToPrimitive, - FromPrimitive, Float}; +pub use biguint::BigUint; +pub use biguint::ToBigUint; +pub use biguint::big_digit; +pub use biguint::big_digit::{BigDigit, DoubleBigDigit, ZERO_BIG_DIGIT}; - - /// Assert that an op works for all val/ref combinations - macro_rules! assert_op { - ($left:ident $op:tt $right:ident == $expected:expr) => { - assert_eq!((&$left) $op (&$right), $expected); - assert_eq!((&$left) $op $right.clone(), $expected); - assert_eq!($left.clone() $op (&$right), $expected); - assert_eq!($left.clone() $op $right.clone(), $expected); - }; - } - - #[test] - fn test_from_slice() { - fn check(slice: &[BigDigit], data: &[BigDigit]) { - assert!(BigUint::from_slice(slice).data == data); - } - check(&[1], &[1]); - check(&[0, 0, 0], &[]); - check(&[1, 2, 0, 0], &[1, 2]); - check(&[0, 0, 1, 2], &[0, 0, 1, 2]); - check(&[0, 0, 1, 2, 0, 0], &[0, 0, 1, 2]); - check(&[-1i32 as BigDigit], &[-1i32 as BigDigit]); - } - - #[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 = 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); - } - } - } - } - - #[test] - fn test_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!(super::hash(&a) == super::hash(&b)); - assert!(super::hash(&b) != super::hash(&c)); - assert!(super::hash(&c) == super::hash(&d)); - assert!(super::hash(&d) != super::hash(&e)); - } - - const BIT_TESTS: &'static [(&'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit])] = &[// LEFT RIGHT AND OR XOR - (&[], &[], &[], &[], &[]), - (&[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); - } - } - - #[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); - } - } - - #[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); - } - } - - #[test] - fn test_shl() { - fn check(s: &str, shift: usize, ans: &str) { - let opt_biguint = BigUint::from_str_radix(s, 16).ok(); - let bu = (opt_biguint.unwrap() << shift).to_str_radix(16); - assert_eq!(bu, 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 bu = (opt_biguint.unwrap() >> shift).to_str_radix(16); - assert_eq!(bu, 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"); - } - - const N1: BigDigit = -1i32 as BigDigit; - const N2: BigDigit = -2i32 as BigDigit; - - // `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 << (0 * big_digit::BITS))); - check(BigUint::new(vec![N1]), (1 << (1 * big_digit::BITS)) - 1); - check(BigUint::new(vec![0, 1]), (1 << (1 * big_digit::BITS))); - 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); - } - - // `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 << (0 * big_digit::BITS))); - check(BigUint::new(vec![N1]), (1 << (1 * big_digit::BITS)) - 1); - check(BigUint::new(vec![0, 1]), (1 << (1 * big_digit::BITS))); - 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] - 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 BigDigit])); - check!(u16, BigUint::from_slice(&[u16::MAX as BigDigit])); - check!(u32, BigUint::from_slice(&[u32::MAX])); - check!(u64, BigUint::from_slice(&[u32::MAX, u32::MAX])); - check!(usize, BigUint::from(usize::MAX as u64)); - } - - const SUM_TRIPLES: &'static [(&'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit])] = &[(&[], &[], &[]), - (&[], &[1], &[1]), - (&[1], &[1], &[2]), - (&[1], &[1, 1], &[2, 1]), - (&[1], &[N1], &[0, 1]), - (&[1], &[N1, N1], &[0, 0, 1]), - (&[N1, N1], &[N1, N1], &[N2, N1, 1]), - (&[1, 1, 1], &[N1, N1], &[0, 1, 2]), - (&[2, 2, 1], &[N1, N2], &[1, 1, 2])]; - - #[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); - } - } - - #[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); - } - } - - #[test] - #[should_panic] - fn test_sub_fail_on_underflow() { - let (a, b): (BigUint, BigUint) = (Zero::zero(), One::one()); - a - b; - } - - const M: u32 = ::std::u32::MAX; - const MUL_TRIPLES: &'static [(&'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit])] = &[(&[], &[], &[]), - (&[], &[1], &[]), - (&[2], &[], &[]), - (&[1], &[1], &[1]), - (&[2], &[3], &[6]), - (&[1], &[1, 1, 1], &[1, 1, 1]), - (&[1, 2, 3], &[3], &[3, 6, 9]), - (&[1, 1, 1], &[N1], &[N1, N1, N1]), - (&[1, 2, 3], &[N1], &[N1, N2, N2, 2]), - (&[1, 2, 3, 4], &[N1], &[N1, N2, N2, N2, 3]), - (&[N1], &[N1], &[1, N2]), - (&[N1, N1], &[N1], &[1, N1, N2]), - (&[N1, N1, N1], &[N1], &[1, N1, N1, N2]), - (&[N1, N1, N1, N1], &[N1], &[1, N1, N1, N1, N2]), - (&[M / 2 + 1], &[2], &[0, 1]), - (&[0, M / 2 + 1], &[2], &[0, 0, 1]), - (&[1, 2], &[1, 2, 3], &[1, 4, 7, 6]), - (&[N1, N1], &[N1, N1, N1], &[1, 0, N1, N2, N1]), - (&[N1, N1, N1], - &[N1, N1, N1, N1], - &[1, 0, 0, N1, N2, N1, N1]), - (&[0, 0, 1], &[1, 2, 3], &[0, 0, 1, 2, 3]), - (&[0, 0, 1], &[0, 0, 0, 1], &[0, 0, 0, 0, 0, 1])]; - - const DIV_REM_QUADRUPLES: &'static [(&'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit])] = &[(&[1], &[2], &[], &[1]), - (&[1, 1], &[2], &[M / 2 + 1], &[1]), - (&[1, 1, 1], &[2], &[M / 2 + 1, M / 2 + 1], &[1]), - (&[0, 1], &[N1], &[1], &[1]), - (&[N1, N1], &[N2], &[2, 1], &[3])]; - - #[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); - } - - 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_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_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!(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 = big_digit::BITS; - 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::())), - (4, - format!("2{}1", repeat("0").take(bits / 2 - 1).collect::())), - (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::()))]), - (BigUint::from_slice(&[1, 2, 3]), - vec![(2, - format!("11{}10{}1", - repeat("0").take(bits - 2).collect::(), - repeat("0").take(bits - 1).collect::())), - (4, - format!("3{}2{}1", - repeat("0").take(bits / 2 - 1).collect::(), - repeat("0").take(bits / 2 - 1).collect::())), - (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::(), - repeat("0").take(bits / 4 - 1).collect::()))])] - } - - #[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_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 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); - } - - #[test] - fn test_all_str_radix() { - 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_rand() { - let mut rng = thread_rng(); - let _n: BigUint = rng.gen_biguint(137); - assert!(rng.gen_biguint(0).is_zero()); - } - - #[test] - fn test_rand_range() { - let mut rng = thread_rng(); - - for _ in 0..10 { - assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_usize(236).unwrap(), - &FromPrimitive::from_usize(237).unwrap()), - FromPrimitive::from_usize(236).unwrap()); - } - - let l = FromPrimitive::from_usize(403469000 + 2352).unwrap(); - let u = FromPrimitive::from_usize(403469000 + 3513).unwrap(); - for _ in 0..1000 { - let n: BigUint = rng.gen_biguint_below(&u); - assert!(n < u); - - let n: BigUint = rng.gen_biguint_range(&l, &u); - assert!(n >= l); - assert!(n < u); - } - } - - #[test] - #[should_panic] - fn test_zero_rand_range() { - thread_rng().gen_biguint_range(&FromPrimitive::from_usize(54).unwrap(), - &FromPrimitive::from_usize(54).unwrap()); - } - - #[test] - #[should_panic] - fn test_negative_rand_range() { - let mut rng = thread_rng(); - let l = FromPrimitive::from_usize(2352).unwrap(); - let u = FromPrimitive::from_usize(3513).unwrap(); - // Switching u and l should fail: - let _n: BigUint = rng.gen_biguint_range(&u, &l); - } - - #[test] - fn test_sub_sign() { - use super::sub_sign; - let a = BigInt::from_str_radix("265252859812191058636308480000000", 10).unwrap(); - let b = BigInt::from_str_radix("26525285981219105863630848000000", 10).unwrap(); - - assert_eq!(sub_sign(&a.data.data[..], &b.data.data[..]), &a - &b); - assert_eq!(sub_sign(&b.data.data[..], &a.data.data[..]), &b - &a); - } - - fn test_mul_divide_torture_count(count: usize) { - use rand::{SeedableRng, StdRng, Rng}; - - let bits_max = 1 << 12; - let seed: &[_] = &[1, 2, 3, 4]; - let mut rng: StdRng = SeedableRng::from_seed(seed); - - for _ in 0..count { - // Test with numbers of random sizes: - let xbits = rng.gen_range(0, bits_max); - let ybits = rng.gen_range(0, bits_max); - - let x = rng.gen_biguint(xbits); - let y = rng.gen_biguint(ybits); - - if x.is_zero() || y.is_zero() { - continue; - } - - let prod = &x * &y; - assert_eq!(&prod / &x, y); - assert_eq!(&prod / &y, x); - } - } - - #[test] - fn test_mul_divide_torture() { - test_mul_divide_torture_count(1000); - } - - #[test] - #[ignore] - fn test_mul_divide_torture_long() { - test_mul_divide_torture_count(1000000); - } -} - -#[cfg(test)] -mod bigint_tests { - use super::{BigDigit, BigUint}; - use super::{Sign, BigInt, RandBigInt, ToBigInt, big_digit}; - use super::Sign::{Minus, NoSign, Plus}; - - use std::cmp::Ordering::{Less, Equal, Greater}; - use std::{f32, f64}; - use std::{i8, i16, i32, i64, isize}; - use std::iter::repeat; - use std::{u8, u16, u32, u64, usize}; - use std::ops::Neg; - - use rand::thread_rng; - - use integer::Integer; - use traits::{Zero, One, Signed, ToPrimitive, FromPrimitive, Num, Float}; - - /// Assert that an op works for all val/ref combinations - macro_rules! assert_op { - ($left:ident $op:tt $right:ident == $expected:expr) => { - assert_eq!((&$left) $op (&$right), $expected); - assert_eq!((&$left) $op $right.clone(), $expected); - assert_eq!($left.clone() $op (&$right), $expected); - assert_eq!($left.clone() $op $right.clone(), $expected); - }; - } - - #[test] - fn test_from_biguint() { - fn check(inp_s: Sign, inp_n: usize, ans_s: Sign, ans_n: usize) { - let inp = BigInt::from_biguint(inp_s, FromPrimitive::from_usize(inp_n).unwrap()); - let ans = BigInt { - sign: ans_s, - data: FromPrimitive::from_usize(ans_n).unwrap(), - }; - assert_eq!(inp, ans); - } - check(Plus, 1, Plus, 1); - check(Plus, 0, NoSign, 0); - check(Minus, 1, Minus, 1); - check(NoSign, 1, NoSign, 0); - } - - #[test] - fn test_from_bytes_be() { - fn check(s: &str, result: &str) { - assert_eq!(BigInt::from_bytes_be(Plus, s.as_bytes()), - BigInt::parse_bytes(result.as_bytes(), 10).unwrap()); - } - check("A", "65"); - check("AA", "16705"); - check("AB", "16706"); - check("Hello world!", "22405534230753963835153736737"); - assert_eq!(BigInt::from_bytes_be(Plus, &[]), Zero::zero()); - assert_eq!(BigInt::from_bytes_be(Minus, &[]), Zero::zero()); - } - - #[test] - fn test_to_bytes_be() { - fn check(s: &str, result: &str) { - let b = BigInt::parse_bytes(result.as_bytes(), 10).unwrap(); - let (sign, v) = b.to_bytes_be(); - assert_eq!((Plus, s.as_bytes()), (sign, &*v)); - } - check("A", "65"); - check("AA", "16705"); - check("AB", "16706"); - check("Hello world!", "22405534230753963835153736737"); - let b: BigInt = Zero::zero(); - assert_eq!(b.to_bytes_be(), (NoSign, vec![0])); - - // Test with leading/trailing zero bytes and a full BigDigit of value 0 - let b = BigInt::from_str_radix("00010000000000000200", 16).unwrap(); - assert_eq!(b.to_bytes_be(), (Plus, vec![1, 0, 0, 0, 0, 0, 0, 2, 0])); - } - - #[test] - fn test_from_bytes_le() { - fn check(s: &str, result: &str) { - assert_eq!(BigInt::from_bytes_le(Plus, s.as_bytes()), - BigInt::parse_bytes(result.as_bytes(), 10).unwrap()); - } - check("A", "65"); - check("AA", "16705"); - check("BA", "16706"); - check("!dlrow olleH", "22405534230753963835153736737"); - assert_eq!(BigInt::from_bytes_le(Plus, &[]), Zero::zero()); - assert_eq!(BigInt::from_bytes_le(Minus, &[]), Zero::zero()); - } - - #[test] - fn test_to_bytes_le() { - fn check(s: &str, result: &str) { - let b = BigInt::parse_bytes(result.as_bytes(), 10).unwrap(); - let (sign, v) = b.to_bytes_le(); - assert_eq!((Plus, s.as_bytes()), (sign, &*v)); - } - check("A", "65"); - check("AA", "16705"); - check("BA", "16706"); - check("!dlrow olleH", "22405534230753963835153736737"); - let b: BigInt = Zero::zero(); - assert_eq!(b.to_bytes_le(), (NoSign, vec![0])); - - // Test with leading/trailing zero bytes and a full BigDigit of value 0 - let b = BigInt::from_str_radix("00010000000000000200", 16).unwrap(); - assert_eq!(b.to_bytes_le(), (Plus, vec![0, 2, 0, 0, 0, 0, 0, 0, 1])); - } - - #[test] - fn test_cmp() { - let vs: [&[BigDigit]; 4] = [&[2 as BigDigit], &[1, 1], &[2, 1], &[1, 1, 1]]; - let mut nums = Vec::new(); - for s in vs.iter().rev() { - nums.push(BigInt::from_slice(Minus, *s)); - } - nums.push(Zero::zero()); - nums.extend(vs.iter().map(|s| BigInt::from_slice(Plus, *s))); - - for (i, ni) in nums.iter().enumerate() { - for (j0, nj) in nums[i..].iter().enumerate() { - let j = i + j0; - 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); - } - } - } - } - - - #[test] - fn test_hash() { - let a = BigInt::new(NoSign, vec![]); - let b = BigInt::new(NoSign, vec![0]); - let c = BigInt::new(Plus, vec![1]); - let d = BigInt::new(Plus, vec![1, 0, 0, 0, 0, 0]); - let e = BigInt::new(Plus, vec![0, 0, 0, 0, 0, 1]); - let f = BigInt::new(Minus, vec![1]); - assert!(super::hash(&a) == super::hash(&b)); - assert!(super::hash(&b) != super::hash(&c)); - assert!(super::hash(&c) == super::hash(&d)); - assert!(super::hash(&d) != super::hash(&e)); - assert!(super::hash(&c) != super::hash(&f)); - } - - #[test] - fn test_convert_i64() { - fn check(b1: BigInt, i: i64) { - let b2: BigInt = FromPrimitive::from_i64(i).unwrap(); - assert!(b1 == b2); - assert!(b1.to_i64().unwrap() == i); - } - - check(Zero::zero(), 0); - check(One::one(), 1); - check(i64::MIN.to_bigint().unwrap(), i64::MIN); - check(i64::MAX.to_bigint().unwrap(), i64::MAX); - - assert_eq!((i64::MAX as u64 + 1).to_bigint().unwrap().to_i64(), None); - - assert_eq!(BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3, 4, 5])).to_i64(), - None); - - assert_eq!(BigInt::from_biguint(Minus, - BigUint::new(vec![1, 0, 0, 1 << (big_digit::BITS - 1)])) - .to_i64(), - None); - - assert_eq!(BigInt::from_biguint(Minus, BigUint::new(vec![1, 2, 3, 4, 5])).to_i64(), - None); - } - - #[test] - fn test_convert_u64() { - fn check(b1: BigInt, u: u64) { - let b2: BigInt = FromPrimitive::from_u64(u).unwrap(); - assert!(b1 == b2); - assert!(b1.to_u64().unwrap() == u); - } - - check(Zero::zero(), 0); - check(One::one(), 1); - check(u64::MIN.to_bigint().unwrap(), u64::MIN); - check(u64::MAX.to_bigint().unwrap(), u64::MAX); - - assert_eq!(BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3, 4, 5])).to_u64(), - None); - - let max_value: BigUint = FromPrimitive::from_u64(u64::MAX).unwrap(); - assert_eq!(BigInt::from_biguint(Minus, max_value).to_u64(), None); - assert_eq!(BigInt::from_biguint(Minus, BigUint::new(vec![1, 2, 3, 4, 5])).to_u64(), - None); - } - - #[test] - fn test_convert_f32() { - fn check(b1: &BigInt, f: f32) { - let b2 = BigInt::from_f32(f).unwrap(); - assert_eq!(b1, &b2); - assert_eq!(b1.to_f32().unwrap(), f); - let neg_b1 = -b1; - let neg_b2 = BigInt::from_f32(-f).unwrap(); - assert_eq!(neg_b1, neg_b2); - assert_eq!(neg_b1.to_f32().unwrap(), -f); - } - - check(&BigInt::zero(), 0.0); - check(&BigInt::one(), 1.0); - check(&BigInt::from(u16::MAX), 2.0.powi(16) - 1.0); - check(&BigInt::from(1u64 << 32), 2.0.powi(32)); - check(&BigInt::from_slice(Plus, &[0, 0, 1]), 2.0.powi(64)); - check(&((BigInt::one() << 100) + (BigInt::one() << 123)), - 2.0.powi(100) + 2.0.powi(123)); - check(&(BigInt::one() << 127), 2.0.powi(127)); - check(&(BigInt::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 = BigInt::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 mut n: i64 = 0b0000000000111111111111111111111111011111111111111111111111111111; - assert!((n as f64) as f32 != n as f32); - assert_eq!(BigInt::from(n).to_f32(), Some(n as f32)); - n = -n; - assert!((n as f64) as f32 != n as f32); - assert_eq!(BigInt::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 = BigInt::from(1u64 << 25); - for _ in 0..64 { - assert_eq!(b.to_f32(), Some(f)); - f *= 2.0; - b = b << 1; - } - - // rounding - assert_eq!(BigInt::from_f32(-f32::consts::PI), - Some(BigInt::from(-3i32))); - assert_eq!(BigInt::from_f32(-f32::consts::E), Some(BigInt::from(-2i32))); - assert_eq!(BigInt::from_f32(-0.99999), Some(BigInt::zero())); - assert_eq!(BigInt::from_f32(-0.5), Some(BigInt::zero())); - assert_eq!(BigInt::from_f32(-0.0), Some(BigInt::zero())); - assert_eq!(BigInt::from_f32(f32::MIN_POSITIVE / 2.0), - Some(BigInt::zero())); - assert_eq!(BigInt::from_f32(f32::MIN_POSITIVE), Some(BigInt::zero())); - assert_eq!(BigInt::from_f32(0.5), Some(BigInt::zero())); - assert_eq!(BigInt::from_f32(0.99999), Some(BigInt::zero())); - assert_eq!(BigInt::from_f32(f32::consts::E), Some(BigInt::from(2u32))); - assert_eq!(BigInt::from_f32(f32::consts::PI), Some(BigInt::from(3u32))); - - // special float values - assert_eq!(BigInt::from_f32(f32::NAN), None); - assert_eq!(BigInt::from_f32(f32::INFINITY), None); - assert_eq!(BigInt::from_f32(f32::NEG_INFINITY), None); - - // largest BigInt that will round to a finite f32 value - let big_num = (BigInt::one() << 128) - BigInt::one() - (BigInt::one() << (128 - 25)); - assert_eq!(big_num.to_f32(), Some(f32::MAX)); - assert_eq!((&big_num + BigInt::one()).to_f32(), None); - assert_eq!((-&big_num).to_f32(), Some(f32::MIN)); - assert_eq!(((-&big_num) - BigInt::one()).to_f32(), None); - - assert_eq!(((BigInt::one() << 128) - BigInt::one()).to_f32(), None); - assert_eq!((BigInt::one() << 128).to_f32(), None); - assert_eq!((-((BigInt::one() << 128) - BigInt::one())).to_f32(), None); - assert_eq!((-(BigInt::one() << 128)).to_f32(), None); - } - - #[test] - fn test_convert_f64() { - fn check(b1: &BigInt, f: f64) { - let b2 = BigInt::from_f64(f).unwrap(); - assert_eq!(b1, &b2); - assert_eq!(b1.to_f64().unwrap(), f); - let neg_b1 = -b1; - let neg_b2 = BigInt::from_f64(-f).unwrap(); - assert_eq!(neg_b1, neg_b2); - assert_eq!(neg_b1.to_f64().unwrap(), -f); - } - - check(&BigInt::zero(), 0.0); - check(&BigInt::one(), 1.0); - check(&BigInt::from(u32::MAX), 2.0.powi(32) - 1.0); - check(&BigInt::from(1u64 << 32), 2.0.powi(32)); - check(&BigInt::from_slice(Plus, &[0, 0, 1]), 2.0.powi(64)); - check(&((BigInt::one() << 100) + (BigInt::one() << 152)), - 2.0.powi(100) + 2.0.powi(152)); - check(&(BigInt::one() << 1023), 2.0.powi(1023)); - check(&(BigInt::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 = BigInt::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 = BigInt::from(1u64 << 54); - for _ in 0..128 { - assert_eq!(b.to_f64(), Some(f)); - f *= 2.0; - b = b << 1; - } - - // rounding - assert_eq!(BigInt::from_f64(-f64::consts::PI), - Some(BigInt::from(-3i32))); - assert_eq!(BigInt::from_f64(-f64::consts::E), Some(BigInt::from(-2i32))); - assert_eq!(BigInt::from_f64(-0.99999), Some(BigInt::zero())); - assert_eq!(BigInt::from_f64(-0.5), Some(BigInt::zero())); - assert_eq!(BigInt::from_f64(-0.0), Some(BigInt::zero())); - assert_eq!(BigInt::from_f64(f64::MIN_POSITIVE / 2.0), - Some(BigInt::zero())); - assert_eq!(BigInt::from_f64(f64::MIN_POSITIVE), Some(BigInt::zero())); - assert_eq!(BigInt::from_f64(0.5), Some(BigInt::zero())); - assert_eq!(BigInt::from_f64(0.99999), Some(BigInt::zero())); - assert_eq!(BigInt::from_f64(f64::consts::E), Some(BigInt::from(2u32))); - assert_eq!(BigInt::from_f64(f64::consts::PI), Some(BigInt::from(3u32))); - - // special float values - assert_eq!(BigInt::from_f64(f64::NAN), None); - assert_eq!(BigInt::from_f64(f64::INFINITY), None); - assert_eq!(BigInt::from_f64(f64::NEG_INFINITY), None); - - // largest BigInt that will round to a finite f64 value - let big_num = (BigInt::one() << 1024) - BigInt::one() - (BigInt::one() << (1024 - 54)); - assert_eq!(big_num.to_f64(), Some(f64::MAX)); - assert_eq!((&big_num + BigInt::one()).to_f64(), None); - assert_eq!((-&big_num).to_f64(), Some(f64::MIN)); - assert_eq!(((-&big_num) - BigInt::one()).to_f64(), None); - - assert_eq!(((BigInt::one() << 1024) - BigInt::one()).to_f64(), None); - assert_eq!((BigInt::one() << 1024).to_f64(), None); - assert_eq!((-((BigInt::one() << 1024) - BigInt::one())).to_f64(), None); - assert_eq!((-(BigInt::one() << 1024)).to_f64(), None); - } - - #[test] - fn test_convert_to_biguint() { - fn check(n: BigInt, ans_1: BigUint) { - assert_eq!(n.to_biguint().unwrap(), ans_1); - assert_eq!(n.to_biguint().unwrap().to_bigint().unwrap(), n); - } - let zero: BigInt = Zero::zero(); - let unsigned_zero: BigUint = Zero::zero(); - let positive = BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3])); - let negative = -&positive; - - check(zero, unsigned_zero); - check(positive, BigUint::new(vec![1, 2, 3])); - - assert_eq!(negative.to_biguint(), None); - } - - #[test] - fn test_convert_from_uint() { - macro_rules! check { - ($ty:ident, $max:expr) => { - assert_eq!(BigInt::from($ty::zero()), BigInt::zero()); - assert_eq!(BigInt::from($ty::one()), BigInt::one()); - assert_eq!(BigInt::from($ty::MAX - $ty::one()), $max - BigInt::one()); - assert_eq!(BigInt::from($ty::MAX), $max); - } - } - - check!(u8, BigInt::from_slice(Plus, &[u8::MAX as BigDigit])); - check!(u16, BigInt::from_slice(Plus, &[u16::MAX as BigDigit])); - check!(u32, BigInt::from_slice(Plus, &[u32::MAX as BigDigit])); - check!(u64, - BigInt::from_slice(Plus, &[u32::MAX as BigDigit, u32::MAX as BigDigit])); - check!(usize, BigInt::from(usize::MAX as u64)); - } - - #[test] - fn test_convert_from_int() { - macro_rules! check { - ($ty:ident, $min:expr, $max:expr) => { - assert_eq!(BigInt::from($ty::MIN), $min); - assert_eq!(BigInt::from($ty::MIN + $ty::one()), $min + BigInt::one()); - assert_eq!(BigInt::from(-$ty::one()), -BigInt::one()); - assert_eq!(BigInt::from($ty::zero()), BigInt::zero()); - assert_eq!(BigInt::from($ty::one()), BigInt::one()); - assert_eq!(BigInt::from($ty::MAX - $ty::one()), $max - BigInt::one()); - assert_eq!(BigInt::from($ty::MAX), $max); - } - } - - check!(i8, - BigInt::from_slice(Minus, &[1 << 7]), - BigInt::from_slice(Plus, &[i8::MAX as BigDigit])); - check!(i16, - BigInt::from_slice(Minus, &[1 << 15]), - BigInt::from_slice(Plus, &[i16::MAX as BigDigit])); - check!(i32, - BigInt::from_slice(Minus, &[1 << 31]), - BigInt::from_slice(Plus, &[i32::MAX as BigDigit])); - check!(i64, - BigInt::from_slice(Minus, &[0, 1 << 31]), - BigInt::from_slice(Plus, &[u32::MAX as BigDigit, i32::MAX as BigDigit])); - check!(isize, - BigInt::from(isize::MIN as i64), - BigInt::from(isize::MAX as i64)); - } - - #[test] - fn test_convert_from_biguint() { - assert_eq!(BigInt::from(BigUint::zero()), BigInt::zero()); - assert_eq!(BigInt::from(BigUint::one()), BigInt::one()); - assert_eq!(BigInt::from(BigUint::from_slice(&[1, 2, 3])), - BigInt::from_slice(Plus, &[1, 2, 3])); - } - - const N1: BigDigit = -1i32 as BigDigit; - const N2: BigDigit = -2i32 as BigDigit; - - const SUM_TRIPLES: &'static [(&'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit])] = &[(&[], &[], &[]), - (&[], &[1], &[1]), - (&[1], &[1], &[2]), - (&[1], &[1, 1], &[2, 1]), - (&[1], &[N1], &[0, 1]), - (&[1], &[N1, N1], &[0, 0, 1]), - (&[N1, N1], &[N1, N1], &[N2, N1, 1]), - (&[1, 1, 1], &[N1, N1], &[0, 1, 2]), - (&[2, 2, 1], &[N1, N2], &[1, 1, 2])]; - - #[test] - fn test_add() { - for elm in SUM_TRIPLES.iter() { - let (a_vec, b_vec, c_vec) = *elm; - let a = BigInt::from_slice(Plus, a_vec); - let b = BigInt::from_slice(Plus, b_vec); - let c = BigInt::from_slice(Plus, c_vec); - let (na, nb, nc) = (-&a, -&b, -&c); - - assert_op!(a + b == c); - assert_op!(b + a == c); - assert_op!(c + na == b); - assert_op!(c + nb == a); - assert_op!(a + nc == nb); - assert_op!(b + nc == na); - assert_op!(na + nb == nc); - assert_op!(a + na == Zero::zero()); - } - } - - #[test] - fn test_sub() { - for elm in SUM_TRIPLES.iter() { - let (a_vec, b_vec, c_vec) = *elm; - let a = BigInt::from_slice(Plus, a_vec); - let b = BigInt::from_slice(Plus, b_vec); - let c = BigInt::from_slice(Plus, c_vec); - let (na, nb, nc) = (-&a, -&b, -&c); - - assert_op!(c - a == b); - assert_op!(c - b == a); - assert_op!(nb - a == nc); - assert_op!(na - b == nc); - assert_op!(b - na == c); - assert_op!(a - nb == c); - assert_op!(nc - na == nb); - assert_op!(a - a == Zero::zero()); - } - } - - const M: u32 = ::std::u32::MAX; - static MUL_TRIPLES: &'static [(&'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit])] = &[(&[], &[], &[]), - (&[], &[1], &[]), - (&[2], &[], &[]), - (&[1], &[1], &[1]), - (&[2], &[3], &[6]), - (&[1], &[1, 1, 1], &[1, 1, 1]), - (&[1, 2, 3], &[3], &[3, 6, 9]), - (&[1, 1, 1], &[N1], &[N1, N1, N1]), - (&[1, 2, 3], &[N1], &[N1, N2, N2, 2]), - (&[1, 2, 3, 4], &[N1], &[N1, N2, N2, N2, 3]), - (&[N1], &[N1], &[1, N2]), - (&[N1, N1], &[N1], &[1, N1, N2]), - (&[N1, N1, N1], &[N1], &[1, N1, N1, N2]), - (&[N1, N1, N1, N1], &[N1], &[1, N1, N1, N1, N2]), - (&[M / 2 + 1], &[2], &[0, 1]), - (&[0, M / 2 + 1], &[2], &[0, 0, 1]), - (&[1, 2], &[1, 2, 3], &[1, 4, 7, 6]), - (&[N1, N1], &[N1, N1, N1], &[1, 0, N1, N2, N1]), - (&[N1, N1, N1], - &[N1, N1, N1, N1], - &[1, 0, 0, N1, N2, N1, N1]), - (&[0, 0, 1], &[1, 2, 3], &[0, 0, 1, 2, 3]), - (&[0, 0, 1], &[0, 0, 0, 1], &[0, 0, 0, 0, 0, 1])]; - - static DIV_REM_QUADRUPLES: &'static [(&'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit], - &'static [BigDigit])] = &[(&[1], &[2], &[], &[1]), - (&[1, 1], &[2], &[M / 2 + 1], &[1]), - (&[1, 1, 1], &[2], &[M / 2 + 1, M / 2 + 1], &[1]), - (&[0, 1], &[N1], &[1], &[1]), - (&[N1, N1], &[N2], &[2, 1], &[3])]; - - #[test] - fn test_mul() { - for elm in MUL_TRIPLES.iter() { - let (a_vec, b_vec, c_vec) = *elm; - let a = BigInt::from_slice(Plus, a_vec); - let b = BigInt::from_slice(Plus, b_vec); - let c = BigInt::from_slice(Plus, c_vec); - let (na, nb, nc) = (-&a, -&b, -&c); - - assert_op!(a * b == c); - assert_op!(b * a == c); - assert_op!(na * nb == c); - - assert_op!(na * b == nc); - assert_op!(nb * a == nc); - } - - for elm in DIV_REM_QUADRUPLES.iter() { - let (a_vec, b_vec, c_vec, d_vec) = *elm; - let a = BigInt::from_slice(Plus, a_vec); - let b = BigInt::from_slice(Plus, b_vec); - let c = BigInt::from_slice(Plus, c_vec); - let d = BigInt::from_slice(Plus, d_vec); - - assert!(a == &b * &c + &d); - assert!(a == &c * &b + &d); - } - } - - #[test] - fn test_div_mod_floor() { - fn check_sub(a: &BigInt, b: &BigInt, ans_d: &BigInt, ans_m: &BigInt) { - let (d, m) = a.div_mod_floor(b); - if !m.is_zero() { - assert_eq!(m.sign, b.sign); - } - assert!(m.abs() <= b.abs()); - assert!(*a == b * &d + &m); - assert!(d == *ans_d); - assert!(m == *ans_m); - } - - fn check(a: &BigInt, b: &BigInt, d: &BigInt, m: &BigInt) { - if m.is_zero() { - check_sub(a, b, d, m); - check_sub(a, &b.neg(), &d.neg(), m); - check_sub(&a.neg(), b, &d.neg(), m); - check_sub(&a.neg(), &b.neg(), d, m); - } else { - let one: BigInt = One::one(); - check_sub(a, b, d, m); - check_sub(a, &b.neg(), &(d.neg() - &one), &(m - b)); - check_sub(&a.neg(), b, &(d.neg() - &one), &(b - m)); - check_sub(&a.neg(), &b.neg(), d, &m.neg()); - } - } - - for elm in MUL_TRIPLES.iter() { - let (a_vec, b_vec, c_vec) = *elm; - let a = BigInt::from_slice(Plus, a_vec); - let b = BigInt::from_slice(Plus, b_vec); - let c = BigInt::from_slice(Plus, c_vec); - - if !a.is_zero() { - check(&c, &a, &b, &Zero::zero()); - } - if !b.is_zero() { - check(&c, &b, &a, &Zero::zero()); - } - } - - for elm in DIV_REM_QUADRUPLES.iter() { - let (a_vec, b_vec, c_vec, d_vec) = *elm; - let a = BigInt::from_slice(Plus, a_vec); - let b = BigInt::from_slice(Plus, b_vec); - let c = BigInt::from_slice(Plus, c_vec); - let d = BigInt::from_slice(Plus, d_vec); - - if !b.is_zero() { - check(&a, &b, &c, &d); - } - } - } - - - #[test] - fn test_div_rem() { - fn check_sub(a: &BigInt, b: &BigInt, ans_q: &BigInt, ans_r: &BigInt) { - let (q, r) = a.div_rem(b); - if !r.is_zero() { - assert_eq!(r.sign, a.sign); - } - assert!(r.abs() <= b.abs()); - assert!(*a == b * &q + &r); - assert!(q == *ans_q); - assert!(r == *ans_r); - - 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); - } - - fn check(a: &BigInt, b: &BigInt, q: &BigInt, r: &BigInt) { - check_sub(a, b, q, r); - check_sub(a, &b.neg(), &q.neg(), r); - check_sub(&a.neg(), b, &q.neg(), &r.neg()); - check_sub(&a.neg(), &b.neg(), q, &r.neg()); - } - for elm in MUL_TRIPLES.iter() { - let (a_vec, b_vec, c_vec) = *elm; - let a = BigInt::from_slice(Plus, a_vec); - let b = BigInt::from_slice(Plus, b_vec); - let c = BigInt::from_slice(Plus, c_vec); - - if !a.is_zero() { - check(&c, &a, &b, &Zero::zero()); - } - if !b.is_zero() { - check(&c, &b, &a, &Zero::zero()); - } - } - - for elm in DIV_REM_QUADRUPLES.iter() { - let (a_vec, b_vec, c_vec, d_vec) = *elm; - let a = BigInt::from_slice(Plus, a_vec); - let b = BigInt::from_slice(Plus, b_vec); - let c = BigInt::from_slice(Plus, c_vec); - let d = BigInt::from_slice(Plus, d_vec); - - if !b.is_zero() { - check(&a, &b, &c, &d); - } - } - } - - #[test] - fn test_checked_add() { - for elm in SUM_TRIPLES.iter() { - let (a_vec, b_vec, c_vec) = *elm; - let a = BigInt::from_slice(Plus, a_vec); - let b = BigInt::from_slice(Plus, b_vec); - let c = BigInt::from_slice(Plus, c_vec); - - assert!(a.checked_add(&b).unwrap() == c); - assert!(b.checked_add(&a).unwrap() == c); - assert!(c.checked_add(&(-&a)).unwrap() == b); - assert!(c.checked_add(&(-&b)).unwrap() == a); - assert!(a.checked_add(&(-&c)).unwrap() == (-&b)); - assert!(b.checked_add(&(-&c)).unwrap() == (-&a)); - assert!((-&a).checked_add(&(-&b)).unwrap() == (-&c)); - assert!(a.checked_add(&(-&a)).unwrap() == Zero::zero()); - } - } - - #[test] - fn test_checked_sub() { - for elm in SUM_TRIPLES.iter() { - let (a_vec, b_vec, c_vec) = *elm; - let a = BigInt::from_slice(Plus, a_vec); - let b = BigInt::from_slice(Plus, b_vec); - let c = BigInt::from_slice(Plus, c_vec); - - assert!(c.checked_sub(&a).unwrap() == b); - assert!(c.checked_sub(&b).unwrap() == a); - assert!((-&b).checked_sub(&a).unwrap() == (-&c)); - assert!((-&a).checked_sub(&b).unwrap() == (-&c)); - assert!(b.checked_sub(&(-&a)).unwrap() == c); - assert!(a.checked_sub(&(-&b)).unwrap() == c); - assert!((-&c).checked_sub(&(-&a)).unwrap() == (-&b)); - assert!(a.checked_sub(&a).unwrap() == Zero::zero()); - } - } - - #[test] - fn test_checked_mul() { - for elm in MUL_TRIPLES.iter() { - let (a_vec, b_vec, c_vec) = *elm; - let a = BigInt::from_slice(Plus, a_vec); - let b = BigInt::from_slice(Plus, b_vec); - let c = BigInt::from_slice(Plus, c_vec); - - assert!(a.checked_mul(&b).unwrap() == c); - assert!(b.checked_mul(&a).unwrap() == c); - - 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 = BigInt::from_slice(Plus, a_vec); - let b = BigInt::from_slice(Plus, b_vec); - let c = BigInt::from_slice(Plus, c_vec); - let d = BigInt::from_slice(Plus, d_vec); - - assert!(a == b.checked_mul(&c).unwrap() + &d); - assert!(a == c.checked_mul(&b).unwrap() + &d); - } - } - #[test] - fn test_checked_div() { - for elm in MUL_TRIPLES.iter() { - let (a_vec, b_vec, c_vec) = *elm; - let a = BigInt::from_slice(Plus, a_vec); - let b = BigInt::from_slice(Plus, b_vec); - let c = BigInt::from_slice(Plus, c_vec); - - if !a.is_zero() { - assert!(c.checked_div(&a).unwrap() == b); - assert!((-&c).checked_div(&(-&a)).unwrap() == b); - assert!((-&c).checked_div(&a).unwrap() == -&b); - } - if !b.is_zero() { - assert!(c.checked_div(&b).unwrap() == a); - assert!((-&c).checked_div(&(-&b)).unwrap() == a); - assert!((-&c).checked_div(&b).unwrap() == -&a); - } - - assert!(c.checked_div(&Zero::zero()).is_none()); - assert!((-&c).checked_div(&Zero::zero()).is_none()); - } - } - - #[test] - fn test_gcd() { - fn check(a: isize, b: isize, c: isize) { - let big_a: BigInt = FromPrimitive::from_isize(a).unwrap(); - let big_b: BigInt = FromPrimitive::from_isize(b).unwrap(); - let big_c: BigInt = FromPrimitive::from_isize(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); - check(3, -3, 3); - check(-6, 3, 3); - check(-4, -2, 2); - } - - #[test] - fn test_lcm() { - fn check(a: isize, b: isize, c: isize) { - let big_a: BigInt = FromPrimitive::from_isize(a).unwrap(); - let big_b: BigInt = FromPrimitive::from_isize(b).unwrap(); - let big_c: BigInt = FromPrimitive::from_isize(c).unwrap(); - - assert_eq!(big_a.lcm(&big_b), big_c); - } - - check(1, 0, 0); - check(0, 1, 0); - check(1, 1, 1); - check(-1, 1, 1); - check(1, -1, 1); - check(-1, -1, 1); - check(8, 9, 72); - check(11, 5, 55); - } - - #[test] - fn test_abs_sub() { - let zero: BigInt = Zero::zero(); - let one: BigInt = One::one(); - assert_eq!((-&one).abs_sub(&one), zero); - let one: BigInt = One::one(); - let zero: BigInt = Zero::zero(); - assert_eq!(one.abs_sub(&one), zero); - let one: BigInt = One::one(); - let zero: BigInt = Zero::zero(); - assert_eq!(one.abs_sub(&zero), one); - let one: BigInt = One::one(); - let two: BigInt = FromPrimitive::from_isize(2).unwrap(); - assert_eq!(one.abs_sub(&-&one), two); - } - - #[test] - fn test_from_str_radix() { - fn check(s: &str, ans: Option) { - let ans = ans.map(|n| { - let x: BigInt = FromPrimitive::from_isize(n).unwrap(); - x - }); - assert_eq!(BigInt::from_str_radix(s, 10).ok(), ans); - } - check("10", Some(10)); - check("1", Some(1)); - check("0", Some(0)); - check("-1", Some(-1)); - check("-10", Some(-10)); - check("+10", Some(10)); - check("--7", None); - check("++5", None); - check("+-9", None); - check("-+3", None); - check("Z", None); - check("_", None); - - // issue 10522, this hit an edge case that caused it to - // attempt to allocate a vector of size (-1u) == huge. - let x: BigInt = format!("1{}", repeat("0").take(36).collect::()).parse().unwrap(); - let _y = x.to_string(); - } - - #[test] - fn test_lower_hex() { - let a = BigInt::parse_bytes(b"A", 16).unwrap(); - let hello = BigInt::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 = BigInt::parse_bytes(b"A", 16).unwrap(); - let hello = BigInt::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 = BigInt::parse_bytes(b"A", 16).unwrap(); - let hello = BigInt::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 = BigInt::parse_bytes(b"A", 16).unwrap(); - let hello = BigInt::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 = BigInt::parse_bytes(b"A", 16).unwrap(); - let hello = BigInt::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_neg() { - assert!(-BigInt::new(Plus, vec![1, 1, 1]) == BigInt::new(Minus, vec![1, 1, 1])); - assert!(-BigInt::new(Minus, vec![1, 1, 1]) == BigInt::new(Plus, vec![1, 1, 1])); - let zero: BigInt = Zero::zero(); - assert_eq!(-&zero, zero); - } - - #[test] - fn test_rand() { - let mut rng = thread_rng(); - let _n: BigInt = rng.gen_bigint(137); - assert!(rng.gen_bigint(0).is_zero()); - } - - #[test] - fn test_rand_range() { - let mut rng = thread_rng(); - - for _ in 0..10 { - assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_usize(236).unwrap(), - &FromPrimitive::from_usize(237).unwrap()), - FromPrimitive::from_usize(236).unwrap()); - } - - fn check(l: BigInt, u: BigInt) { - let mut rng = thread_rng(); - for _ in 0..1000 { - let n: BigInt = rng.gen_bigint_range(&l, &u); - assert!(n >= l); - assert!(n < u); - } - } - let l: BigInt = FromPrimitive::from_usize(403469000 + 2352).unwrap(); - let u: BigInt = FromPrimitive::from_usize(403469000 + 3513).unwrap(); - check(l.clone(), u.clone()); - check(-l.clone(), u.clone()); - check(-u.clone(), -l.clone()); - } - - #[test] - #[should_panic] - fn test_zero_rand_range() { - thread_rng().gen_bigint_range(&FromPrimitive::from_isize(54).unwrap(), - &FromPrimitive::from_isize(54).unwrap()); - } - - #[test] - #[should_panic] - fn test_negative_rand_range() { - let mut rng = thread_rng(); - let l = FromPrimitive::from_usize(2352).unwrap(); - let u = FromPrimitive::from_usize(3513).unwrap(); - // Switching u and l should fail: - let _n: BigInt = rng.gen_bigint_range(&u, &l); - } -} +pub use bigint::Sign; +pub use bigint::BigInt; +pub use bigint::ToBigInt; +pub use bigint::RandBigInt; diff --git a/bigint/src/macros.rs b/bigint/src/macros.rs new file mode 100644 index 0000000..39f45a4 --- /dev/null +++ b/bigint/src/macros.rs @@ -0,0 +1,133 @@ + +macro_rules! forward_val_val_binop { + (impl $imp:ident for $res:ty, $method:ident) => { + impl $imp<$res> for $res { + type Output = $res; + + #[inline] + fn $method(self, other: $res) -> $res { + // forward to val-ref + $imp::$method(self, &other) + } + } + } +} + +macro_rules! forward_val_val_binop_commutative { + (impl $imp:ident for $res:ty, $method:ident) => { + impl $imp<$res> for $res { + type Output = $res; + + #[inline] + fn $method(self, other: $res) -> $res { + // forward to val-ref, with the larger capacity as val + if self.data.capacity() >= other.data.capacity() { + $imp::$method(self, &other) + } else { + $imp::$method(other, &self) + } + } + } + } +} + +macro_rules! forward_ref_val_binop { + (impl $imp:ident for $res:ty, $method:ident) => { + impl<'a> $imp<$res> for &'a $res { + type Output = $res; + + #[inline] + fn $method(self, other: $res) -> $res { + // forward to ref-ref + $imp::$method(self, &other) + } + } + } +} + +macro_rules! forward_ref_val_binop_commutative { + (impl $imp:ident for $res:ty, $method:ident) => { + impl<'a> $imp<$res> for &'a $res { + type Output = $res; + + #[inline] + fn $method(self, other: $res) -> $res { + // reverse, forward to val-ref + $imp::$method(other, self) + } + } + } +} + +macro_rules! forward_val_ref_binop { + (impl $imp:ident for $res:ty, $method:ident) => { + impl<'a> $imp<&'a $res> for $res { + type Output = $res; + + #[inline] + fn $method(self, other: &$res) -> $res { + // forward to ref-ref + $imp::$method(&self, other) + } + } + } +} + +macro_rules! forward_ref_ref_binop { + (impl $imp:ident for $res:ty, $method:ident) => { + impl<'a, 'b> $imp<&'b $res> for &'a $res { + type Output = $res; + + #[inline] + fn $method(self, other: &$res) -> $res { + // forward to val-ref + $imp::$method(self.clone(), other) + } + } + } +} + +macro_rules! forward_ref_ref_binop_commutative { + (impl $imp:ident for $res:ty, $method:ident) => { + impl<'a, 'b> $imp<&'b $res> for &'a $res { + type Output = $res; + + #[inline] + fn $method(self, other: &$res) -> $res { + // forward to val-ref, choosing the larger to clone + if self.data.len() >= other.data.len() { + $imp::$method(self.clone(), other) + } else { + $imp::$method(other.clone(), self) + } + } + } + } +} + +// Forward everything to ref-ref, when reusing storage is not helpful +macro_rules! forward_all_binop_to_ref_ref { + (impl $imp:ident for $res:ty, $method:ident) => { + forward_val_val_binop!(impl $imp for $res, $method); + forward_val_ref_binop!(impl $imp for $res, $method); + forward_ref_val_binop!(impl $imp for $res, $method); + }; +} + +// Forward everything to val-ref, so LHS storage can be reused +macro_rules! forward_all_binop_to_val_ref { + (impl $imp:ident for $res:ty, $method:ident) => { + forward_val_val_binop!(impl $imp for $res, $method); + forward_ref_val_binop!(impl $imp for $res, $method); + forward_ref_ref_binop!(impl $imp for $res, $method); + }; +} + +// Forward everything to val-ref, commutatively, so either LHS or RHS storage can be reused +macro_rules! forward_all_binop_to_val_ref_commutative { + (impl $imp:ident for $res:ty, $method:ident) => { + forward_val_val_binop_commutative!(impl $imp for $res, $method); + forward_ref_val_binop_commutative!(impl $imp for $res, $method); + forward_ref_ref_binop_commutative!(impl $imp for $res, $method); + }; +} diff --git a/bigint/src/tests/bigint.rs b/bigint/src/tests/bigint.rs new file mode 100644 index 0000000..bb8899e --- /dev/null +++ b/bigint/src/tests/bigint.rs @@ -0,0 +1,954 @@ +use {BigDigit, BigUint, big_digit}; +use {Sign, BigInt, RandBigInt, ToBigInt}; +use Sign::{Minus, NoSign, Plus}; + +use std::cmp::Ordering::{Less, Equal, Greater}; +use std::{f32, f64}; +use std::{i8, i16, i32, i64, isize}; +use std::iter::repeat; +use std::{u8, u16, u32, u64, usize}; +use std::ops::Neg; + +use rand::thread_rng; + +use integer::Integer; +use traits::{Zero, One, Signed, ToPrimitive, FromPrimitive, Num, Float}; + +/// Assert that an op works for all val/ref combinations +macro_rules! assert_op { + ($left:ident $op:tt $right:ident == $expected:expr) => { + assert_eq!((&$left) $op (&$right), $expected); + assert_eq!((&$left) $op $right.clone(), $expected); + assert_eq!($left.clone() $op (&$right), $expected); + assert_eq!($left.clone() $op $right.clone(), $expected); + }; +} + +#[test] +fn test_from_biguint() { + fn check(inp_s: Sign, inp_n: usize, ans_s: Sign, ans_n: usize) { + let inp = BigInt::from_biguint(inp_s, FromPrimitive::from_usize(inp_n).unwrap()); + let ans = BigInt { + sign: ans_s, + data: FromPrimitive::from_usize(ans_n).unwrap(), + }; + assert_eq!(inp, ans); + } + check(Plus, 1, Plus, 1); + check(Plus, 0, NoSign, 0); + check(Minus, 1, Minus, 1); + check(NoSign, 1, NoSign, 0); +} + +#[test] +fn test_from_bytes_be() { + fn check(s: &str, result: &str) { + assert_eq!(BigInt::from_bytes_be(Plus, s.as_bytes()), + BigInt::parse_bytes(result.as_bytes(), 10).unwrap()); + } + check("A", "65"); + check("AA", "16705"); + check("AB", "16706"); + check("Hello world!", "22405534230753963835153736737"); + assert_eq!(BigInt::from_bytes_be(Plus, &[]), Zero::zero()); + assert_eq!(BigInt::from_bytes_be(Minus, &[]), Zero::zero()); +} + +#[test] +fn test_to_bytes_be() { + fn check(s: &str, result: &str) { + let b = BigInt::parse_bytes(result.as_bytes(), 10).unwrap(); + let (sign, v) = b.to_bytes_be(); + assert_eq!((Plus, s.as_bytes()), (sign, &*v)); + } + check("A", "65"); + check("AA", "16705"); + check("AB", "16706"); + check("Hello world!", "22405534230753963835153736737"); + let b: BigInt = Zero::zero(); + assert_eq!(b.to_bytes_be(), (NoSign, vec![0])); + + // Test with leading/trailing zero bytes and a full BigDigit of value 0 + let b = BigInt::from_str_radix("00010000000000000200", 16).unwrap(); + assert_eq!(b.to_bytes_be(), (Plus, vec![1, 0, 0, 0, 0, 0, 0, 2, 0])); +} + +#[test] +fn test_from_bytes_le() { + fn check(s: &str, result: &str) { + assert_eq!(BigInt::from_bytes_le(Plus, s.as_bytes()), + BigInt::parse_bytes(result.as_bytes(), 10).unwrap()); + } + check("A", "65"); + check("AA", "16705"); + check("BA", "16706"); + check("!dlrow olleH", "22405534230753963835153736737"); + assert_eq!(BigInt::from_bytes_le(Plus, &[]), Zero::zero()); + assert_eq!(BigInt::from_bytes_le(Minus, &[]), Zero::zero()); +} + +#[test] +fn test_to_bytes_le() { + fn check(s: &str, result: &str) { + let b = BigInt::parse_bytes(result.as_bytes(), 10).unwrap(); + let (sign, v) = b.to_bytes_le(); + assert_eq!((Plus, s.as_bytes()), (sign, &*v)); + } + check("A", "65"); + check("AA", "16705"); + check("BA", "16706"); + check("!dlrow olleH", "22405534230753963835153736737"); + let b: BigInt = Zero::zero(); + assert_eq!(b.to_bytes_le(), (NoSign, vec![0])); + + // Test with leading/trailing zero bytes and a full BigDigit of value 0 + let b = BigInt::from_str_radix("00010000000000000200", 16).unwrap(); + assert_eq!(b.to_bytes_le(), (Plus, vec![0, 2, 0, 0, 0, 0, 0, 0, 1])); +} + +#[test] +fn test_cmp() { + let vs: [&[BigDigit]; 4] = [&[2 as BigDigit], &[1, 1], &[2, 1], &[1, 1, 1]]; + let mut nums = Vec::new(); + for s in vs.iter().rev() { + nums.push(BigInt::from_slice(Minus, *s)); + } + nums.push(Zero::zero()); + nums.extend(vs.iter().map(|s| BigInt::from_slice(Plus, *s))); + + for (i, ni) in nums.iter().enumerate() { + for (j0, nj) in nums[i..].iter().enumerate() { + let j = i + j0; + 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); + } + } + } +} + + +#[test] +fn test_hash() { + use hash; + + let a = BigInt::new(NoSign, vec![]); + let b = BigInt::new(NoSign, vec![0]); + let c = BigInt::new(Plus, vec![1]); + let d = BigInt::new(Plus, vec![1, 0, 0, 0, 0, 0]); + let e = BigInt::new(Plus, vec![0, 0, 0, 0, 0, 1]); + let f = BigInt::new(Minus, vec![1]); + assert!(hash(&a) == hash(&b)); + assert!(hash(&b) != hash(&c)); + assert!(hash(&c) == hash(&d)); + assert!(hash(&d) != hash(&e)); + assert!(hash(&c) != hash(&f)); +} + +#[test] +fn test_convert_i64() { + fn check(b1: BigInt, i: i64) { + let b2: BigInt = FromPrimitive::from_i64(i).unwrap(); + assert!(b1 == b2); + assert!(b1.to_i64().unwrap() == i); + } + + check(Zero::zero(), 0); + check(One::one(), 1); + check(i64::MIN.to_bigint().unwrap(), i64::MIN); + check(i64::MAX.to_bigint().unwrap(), i64::MAX); + + assert_eq!((i64::MAX as u64 + 1).to_bigint().unwrap().to_i64(), None); + + assert_eq!(BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3, 4, 5])).to_i64(), + None); + + assert_eq!(BigInt::from_biguint(Minus, + BigUint::new(vec![1, 0, 0, 1 << (big_digit::BITS - 1)])) + .to_i64(), + None); + + assert_eq!(BigInt::from_biguint(Minus, BigUint::new(vec![1, 2, 3, 4, 5])).to_i64(), + None); +} + +#[test] +fn test_convert_u64() { + fn check(b1: BigInt, u: u64) { + let b2: BigInt = FromPrimitive::from_u64(u).unwrap(); + assert!(b1 == b2); + assert!(b1.to_u64().unwrap() == u); + } + + check(Zero::zero(), 0); + check(One::one(), 1); + check(u64::MIN.to_bigint().unwrap(), u64::MIN); + check(u64::MAX.to_bigint().unwrap(), u64::MAX); + + assert_eq!(BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3, 4, 5])).to_u64(), + None); + + let max_value: BigUint = FromPrimitive::from_u64(u64::MAX).unwrap(); + assert_eq!(BigInt::from_biguint(Minus, max_value).to_u64(), None); + assert_eq!(BigInt::from_biguint(Minus, BigUint::new(vec![1, 2, 3, 4, 5])).to_u64(), + None); +} + +#[test] +fn test_convert_f32() { + fn check(b1: &BigInt, f: f32) { + let b2 = BigInt::from_f32(f).unwrap(); + assert_eq!(b1, &b2); + assert_eq!(b1.to_f32().unwrap(), f); + let neg_b1 = -b1; + let neg_b2 = BigInt::from_f32(-f).unwrap(); + assert_eq!(neg_b1, neg_b2); + assert_eq!(neg_b1.to_f32().unwrap(), -f); + } + + check(&BigInt::zero(), 0.0); + check(&BigInt::one(), 1.0); + check(&BigInt::from(u16::MAX), 2.0.powi(16) - 1.0); + check(&BigInt::from(1u64 << 32), 2.0.powi(32)); + check(&BigInt::from_slice(Plus, &[0, 0, 1]), 2.0.powi(64)); + check(&((BigInt::one() << 100) + (BigInt::one() << 123)), + 2.0.powi(100) + 2.0.powi(123)); + check(&(BigInt::one() << 127), 2.0.powi(127)); + check(&(BigInt::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 = BigInt::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 mut n: i64 = 0b0000000000111111111111111111111111011111111111111111111111111111; + assert!((n as f64) as f32 != n as f32); + assert_eq!(BigInt::from(n).to_f32(), Some(n as f32)); + n = -n; + assert!((n as f64) as f32 != n as f32); + assert_eq!(BigInt::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 = BigInt::from(1u64 << 25); + for _ in 0..64 { + assert_eq!(b.to_f32(), Some(f)); + f *= 2.0; + b = b << 1; + } + + // rounding + assert_eq!(BigInt::from_f32(-f32::consts::PI), + Some(BigInt::from(-3i32))); + assert_eq!(BigInt::from_f32(-f32::consts::E), Some(BigInt::from(-2i32))); + assert_eq!(BigInt::from_f32(-0.99999), Some(BigInt::zero())); + assert_eq!(BigInt::from_f32(-0.5), Some(BigInt::zero())); + assert_eq!(BigInt::from_f32(-0.0), Some(BigInt::zero())); + assert_eq!(BigInt::from_f32(f32::MIN_POSITIVE / 2.0), + Some(BigInt::zero())); + assert_eq!(BigInt::from_f32(f32::MIN_POSITIVE), Some(BigInt::zero())); + assert_eq!(BigInt::from_f32(0.5), Some(BigInt::zero())); + assert_eq!(BigInt::from_f32(0.99999), Some(BigInt::zero())); + assert_eq!(BigInt::from_f32(f32::consts::E), Some(BigInt::from(2u32))); + assert_eq!(BigInt::from_f32(f32::consts::PI), Some(BigInt::from(3u32))); + + // special float values + assert_eq!(BigInt::from_f32(f32::NAN), None); + assert_eq!(BigInt::from_f32(f32::INFINITY), None); + assert_eq!(BigInt::from_f32(f32::NEG_INFINITY), None); + + // largest BigInt that will round to a finite f32 value + let big_num = (BigInt::one() << 128) - BigInt::one() - (BigInt::one() << (128 - 25)); + assert_eq!(big_num.to_f32(), Some(f32::MAX)); + assert_eq!((&big_num + BigInt::one()).to_f32(), None); + assert_eq!((-&big_num).to_f32(), Some(f32::MIN)); + assert_eq!(((-&big_num) - BigInt::one()).to_f32(), None); + + assert_eq!(((BigInt::one() << 128) - BigInt::one()).to_f32(), None); + assert_eq!((BigInt::one() << 128).to_f32(), None); + assert_eq!((-((BigInt::one() << 128) - BigInt::one())).to_f32(), None); + assert_eq!((-(BigInt::one() << 128)).to_f32(), None); +} + +#[test] +fn test_convert_f64() { + fn check(b1: &BigInt, f: f64) { + let b2 = BigInt::from_f64(f).unwrap(); + assert_eq!(b1, &b2); + assert_eq!(b1.to_f64().unwrap(), f); + let neg_b1 = -b1; + let neg_b2 = BigInt::from_f64(-f).unwrap(); + assert_eq!(neg_b1, neg_b2); + assert_eq!(neg_b1.to_f64().unwrap(), -f); + } + + check(&BigInt::zero(), 0.0); + check(&BigInt::one(), 1.0); + check(&BigInt::from(u32::MAX), 2.0.powi(32) - 1.0); + check(&BigInt::from(1u64 << 32), 2.0.powi(32)); + check(&BigInt::from_slice(Plus, &[0, 0, 1]), 2.0.powi(64)); + check(&((BigInt::one() << 100) + (BigInt::one() << 152)), + 2.0.powi(100) + 2.0.powi(152)); + check(&(BigInt::one() << 1023), 2.0.powi(1023)); + check(&(BigInt::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 = BigInt::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 = BigInt::from(1u64 << 54); + for _ in 0..128 { + assert_eq!(b.to_f64(), Some(f)); + f *= 2.0; + b = b << 1; + } + + // rounding + assert_eq!(BigInt::from_f64(-f64::consts::PI), + Some(BigInt::from(-3i32))); + assert_eq!(BigInt::from_f64(-f64::consts::E), Some(BigInt::from(-2i32))); + assert_eq!(BigInt::from_f64(-0.99999), Some(BigInt::zero())); + assert_eq!(BigInt::from_f64(-0.5), Some(BigInt::zero())); + assert_eq!(BigInt::from_f64(-0.0), Some(BigInt::zero())); + assert_eq!(BigInt::from_f64(f64::MIN_POSITIVE / 2.0), + Some(BigInt::zero())); + assert_eq!(BigInt::from_f64(f64::MIN_POSITIVE), Some(BigInt::zero())); + assert_eq!(BigInt::from_f64(0.5), Some(BigInt::zero())); + assert_eq!(BigInt::from_f64(0.99999), Some(BigInt::zero())); + assert_eq!(BigInt::from_f64(f64::consts::E), Some(BigInt::from(2u32))); + assert_eq!(BigInt::from_f64(f64::consts::PI), Some(BigInt::from(3u32))); + + // special float values + assert_eq!(BigInt::from_f64(f64::NAN), None); + assert_eq!(BigInt::from_f64(f64::INFINITY), None); + assert_eq!(BigInt::from_f64(f64::NEG_INFINITY), None); + + // largest BigInt that will round to a finite f64 value + let big_num = (BigInt::one() << 1024) - BigInt::one() - (BigInt::one() << (1024 - 54)); + assert_eq!(big_num.to_f64(), Some(f64::MAX)); + assert_eq!((&big_num + BigInt::one()).to_f64(), None); + assert_eq!((-&big_num).to_f64(), Some(f64::MIN)); + assert_eq!(((-&big_num) - BigInt::one()).to_f64(), None); + + assert_eq!(((BigInt::one() << 1024) - BigInt::one()).to_f64(), None); + assert_eq!((BigInt::one() << 1024).to_f64(), None); + assert_eq!((-((BigInt::one() << 1024) - BigInt::one())).to_f64(), None); + assert_eq!((-(BigInt::one() << 1024)).to_f64(), None); +} + +#[test] +fn test_convert_to_biguint() { + fn check(n: BigInt, ans_1: BigUint) { + assert_eq!(n.to_biguint().unwrap(), ans_1); + assert_eq!(n.to_biguint().unwrap().to_bigint().unwrap(), n); + } + let zero: BigInt = Zero::zero(); + let unsigned_zero: BigUint = Zero::zero(); + let positive = BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3])); + let negative = -&positive; + + check(zero, unsigned_zero); + check(positive, BigUint::new(vec![1, 2, 3])); + + assert_eq!(negative.to_biguint(), None); +} + +#[test] +fn test_convert_from_uint() { + macro_rules! check { + ($ty:ident, $max:expr) => { + assert_eq!(BigInt::from($ty::zero()), BigInt::zero()); + assert_eq!(BigInt::from($ty::one()), BigInt::one()); + assert_eq!(BigInt::from($ty::MAX - $ty::one()), $max - BigInt::one()); + assert_eq!(BigInt::from($ty::MAX), $max); + } + } + + check!(u8, BigInt::from_slice(Plus, &[u8::MAX as BigDigit])); + check!(u16, BigInt::from_slice(Plus, &[u16::MAX as BigDigit])); + check!(u32, BigInt::from_slice(Plus, &[u32::MAX as BigDigit])); + check!(u64, + BigInt::from_slice(Plus, &[u32::MAX as BigDigit, u32::MAX as BigDigit])); + check!(usize, BigInt::from(usize::MAX as u64)); +} + +#[test] +fn test_convert_from_int() { + macro_rules! check { + ($ty:ident, $min:expr, $max:expr) => { + assert_eq!(BigInt::from($ty::MIN), $min); + assert_eq!(BigInt::from($ty::MIN + $ty::one()), $min + BigInt::one()); + assert_eq!(BigInt::from(-$ty::one()), -BigInt::one()); + assert_eq!(BigInt::from($ty::zero()), BigInt::zero()); + assert_eq!(BigInt::from($ty::one()), BigInt::one()); + assert_eq!(BigInt::from($ty::MAX - $ty::one()), $max - BigInt::one()); + assert_eq!(BigInt::from($ty::MAX), $max); + } + } + + check!(i8, + BigInt::from_slice(Minus, &[1 << 7]), + BigInt::from_slice(Plus, &[i8::MAX as BigDigit])); + check!(i16, + BigInt::from_slice(Minus, &[1 << 15]), + BigInt::from_slice(Plus, &[i16::MAX as BigDigit])); + check!(i32, + BigInt::from_slice(Minus, &[1 << 31]), + BigInt::from_slice(Plus, &[i32::MAX as BigDigit])); + check!(i64, + BigInt::from_slice(Minus, &[0, 1 << 31]), + BigInt::from_slice(Plus, &[u32::MAX as BigDigit, i32::MAX as BigDigit])); + check!(isize, + BigInt::from(isize::MIN as i64), + BigInt::from(isize::MAX as i64)); +} + +#[test] +fn test_convert_from_biguint() { + assert_eq!(BigInt::from(BigUint::zero()), BigInt::zero()); + assert_eq!(BigInt::from(BigUint::one()), BigInt::one()); + assert_eq!(BigInt::from(BigUint::from_slice(&[1, 2, 3])), + BigInt::from_slice(Plus, &[1, 2, 3])); +} + +const N1: BigDigit = -1i32 as BigDigit; +const N2: BigDigit = -2i32 as BigDigit; + +const SUM_TRIPLES: &'static [(&'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit])] = &[(&[], &[], &[]), + (&[], &[1], &[1]), + (&[1], &[1], &[2]), + (&[1], &[1, 1], &[2, 1]), + (&[1], &[N1], &[0, 1]), + (&[1], &[N1, N1], &[0, 0, 1]), + (&[N1, N1], &[N1, N1], &[N2, N1, 1]), + (&[1, 1, 1], &[N1, N1], &[0, 1, 2]), + (&[2, 2, 1], &[N1, N2], &[1, 1, 2])]; + +#[test] +fn test_add() { + for elm in SUM_TRIPLES.iter() { + let (a_vec, b_vec, c_vec) = *elm; + let a = BigInt::from_slice(Plus, a_vec); + let b = BigInt::from_slice(Plus, b_vec); + let c = BigInt::from_slice(Plus, c_vec); + let (na, nb, nc) = (-&a, -&b, -&c); + + assert_op!(a + b == c); + assert_op!(b + a == c); + assert_op!(c + na == b); + assert_op!(c + nb == a); + assert_op!(a + nc == nb); + assert_op!(b + nc == na); + assert_op!(na + nb == nc); + assert_op!(a + na == Zero::zero()); + } +} + +#[test] +fn test_sub() { + for elm in SUM_TRIPLES.iter() { + let (a_vec, b_vec, c_vec) = *elm; + let a = BigInt::from_slice(Plus, a_vec); + let b = BigInt::from_slice(Plus, b_vec); + let c = BigInt::from_slice(Plus, c_vec); + let (na, nb, nc) = (-&a, -&b, -&c); + + assert_op!(c - a == b); + assert_op!(c - b == a); + assert_op!(nb - a == nc); + assert_op!(na - b == nc); + assert_op!(b - na == c); + assert_op!(a - nb == c); + assert_op!(nc - na == nb); + assert_op!(a - a == Zero::zero()); + } +} + +const M: u32 = ::std::u32::MAX; +static MUL_TRIPLES: &'static [(&'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit])] = &[(&[], &[], &[]), + (&[], &[1], &[]), + (&[2], &[], &[]), + (&[1], &[1], &[1]), + (&[2], &[3], &[6]), + (&[1], &[1, 1, 1], &[1, 1, 1]), + (&[1, 2, 3], &[3], &[3, 6, 9]), + (&[1, 1, 1], &[N1], &[N1, N1, N1]), + (&[1, 2, 3], &[N1], &[N1, N2, N2, 2]), + (&[1, 2, 3, 4], &[N1], &[N1, N2, N2, N2, 3]), + (&[N1], &[N1], &[1, N2]), + (&[N1, N1], &[N1], &[1, N1, N2]), + (&[N1, N1, N1], &[N1], &[1, N1, N1, N2]), + (&[N1, N1, N1, N1], &[N1], &[1, N1, N1, N1, N2]), + (&[M / 2 + 1], &[2], &[0, 1]), + (&[0, M / 2 + 1], &[2], &[0, 0, 1]), + (&[1, 2], &[1, 2, 3], &[1, 4, 7, 6]), + (&[N1, N1], &[N1, N1, N1], &[1, 0, N1, N2, N1]), + (&[N1, N1, N1], + &[N1, N1, N1, N1], + &[1, 0, 0, N1, N2, N1, N1]), + (&[0, 0, 1], &[1, 2, 3], &[0, 0, 1, 2, 3]), + (&[0, 0, 1], &[0, 0, 0, 1], &[0, 0, 0, 0, 0, 1])]; + +static DIV_REM_QUADRUPLES: &'static [(&'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit])] = &[(&[1], &[2], &[], &[1]), + (&[1, 1], &[2], &[M / 2 + 1], &[1]), + (&[1, 1, 1], &[2], &[M / 2 + 1, M / 2 + 1], &[1]), + (&[0, 1], &[N1], &[1], &[1]), + (&[N1, N1], &[N2], &[2, 1], &[3])]; + +#[test] +fn test_mul() { + for elm in MUL_TRIPLES.iter() { + let (a_vec, b_vec, c_vec) = *elm; + let a = BigInt::from_slice(Plus, a_vec); + let b = BigInt::from_slice(Plus, b_vec); + let c = BigInt::from_slice(Plus, c_vec); + let (na, nb, nc) = (-&a, -&b, -&c); + + assert_op!(a * b == c); + assert_op!(b * a == c); + assert_op!(na * nb == c); + + assert_op!(na * b == nc); + assert_op!(nb * a == nc); + } + + for elm in DIV_REM_QUADRUPLES.iter() { + let (a_vec, b_vec, c_vec, d_vec) = *elm; + let a = BigInt::from_slice(Plus, a_vec); + let b = BigInt::from_slice(Plus, b_vec); + let c = BigInt::from_slice(Plus, c_vec); + let d = BigInt::from_slice(Plus, d_vec); + + assert!(a == &b * &c + &d); + assert!(a == &c * &b + &d); + } +} + +#[test] +fn test_div_mod_floor() { + fn check_sub(a: &BigInt, b: &BigInt, ans_d: &BigInt, ans_m: &BigInt) { + let (d, m) = a.div_mod_floor(b); + if !m.is_zero() { + assert_eq!(m.sign, b.sign); + } + assert!(m.abs() <= b.abs()); + assert!(*a == b * &d + &m); + assert!(d == *ans_d); + assert!(m == *ans_m); + } + + fn check(a: &BigInt, b: &BigInt, d: &BigInt, m: &BigInt) { + if m.is_zero() { + check_sub(a, b, d, m); + check_sub(a, &b.neg(), &d.neg(), m); + check_sub(&a.neg(), b, &d.neg(), m); + check_sub(&a.neg(), &b.neg(), d, m); + } else { + let one: BigInt = One::one(); + check_sub(a, b, d, m); + check_sub(a, &b.neg(), &(d.neg() - &one), &(m - b)); + check_sub(&a.neg(), b, &(d.neg() - &one), &(b - m)); + check_sub(&a.neg(), &b.neg(), d, &m.neg()); + } + } + + for elm in MUL_TRIPLES.iter() { + let (a_vec, b_vec, c_vec) = *elm; + let a = BigInt::from_slice(Plus, a_vec); + let b = BigInt::from_slice(Plus, b_vec); + let c = BigInt::from_slice(Plus, c_vec); + + if !a.is_zero() { + check(&c, &a, &b, &Zero::zero()); + } + if !b.is_zero() { + check(&c, &b, &a, &Zero::zero()); + } + } + + for elm in DIV_REM_QUADRUPLES.iter() { + let (a_vec, b_vec, c_vec, d_vec) = *elm; + let a = BigInt::from_slice(Plus, a_vec); + let b = BigInt::from_slice(Plus, b_vec); + let c = BigInt::from_slice(Plus, c_vec); + let d = BigInt::from_slice(Plus, d_vec); + + if !b.is_zero() { + check(&a, &b, &c, &d); + } + } +} + + +#[test] +fn test_div_rem() { + fn check_sub(a: &BigInt, b: &BigInt, ans_q: &BigInt, ans_r: &BigInt) { + let (q, r) = a.div_rem(b); + if !r.is_zero() { + assert_eq!(r.sign, a.sign); + } + assert!(r.abs() <= b.abs()); + assert!(*a == b * &q + &r); + assert!(q == *ans_q); + assert!(r == *ans_r); + + 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); + } + + fn check(a: &BigInt, b: &BigInt, q: &BigInt, r: &BigInt) { + check_sub(a, b, q, r); + check_sub(a, &b.neg(), &q.neg(), r); + check_sub(&a.neg(), b, &q.neg(), &r.neg()); + check_sub(&a.neg(), &b.neg(), q, &r.neg()); + } + for elm in MUL_TRIPLES.iter() { + let (a_vec, b_vec, c_vec) = *elm; + let a = BigInt::from_slice(Plus, a_vec); + let b = BigInt::from_slice(Plus, b_vec); + let c = BigInt::from_slice(Plus, c_vec); + + if !a.is_zero() { + check(&c, &a, &b, &Zero::zero()); + } + if !b.is_zero() { + check(&c, &b, &a, &Zero::zero()); + } + } + + for elm in DIV_REM_QUADRUPLES.iter() { + let (a_vec, b_vec, c_vec, d_vec) = *elm; + let a = BigInt::from_slice(Plus, a_vec); + let b = BigInt::from_slice(Plus, b_vec); + let c = BigInt::from_slice(Plus, c_vec); + let d = BigInt::from_slice(Plus, d_vec); + + if !b.is_zero() { + check(&a, &b, &c, &d); + } + } +} + +#[test] +fn test_checked_add() { + for elm in SUM_TRIPLES.iter() { + let (a_vec, b_vec, c_vec) = *elm; + let a = BigInt::from_slice(Plus, a_vec); + let b = BigInt::from_slice(Plus, b_vec); + let c = BigInt::from_slice(Plus, c_vec); + + assert!(a.checked_add(&b).unwrap() == c); + assert!(b.checked_add(&a).unwrap() == c); + assert!(c.checked_add(&(-&a)).unwrap() == b); + assert!(c.checked_add(&(-&b)).unwrap() == a); + assert!(a.checked_add(&(-&c)).unwrap() == (-&b)); + assert!(b.checked_add(&(-&c)).unwrap() == (-&a)); + assert!((-&a).checked_add(&(-&b)).unwrap() == (-&c)); + assert!(a.checked_add(&(-&a)).unwrap() == Zero::zero()); + } +} + +#[test] +fn test_checked_sub() { + for elm in SUM_TRIPLES.iter() { + let (a_vec, b_vec, c_vec) = *elm; + let a = BigInt::from_slice(Plus, a_vec); + let b = BigInt::from_slice(Plus, b_vec); + let c = BigInt::from_slice(Plus, c_vec); + + assert!(c.checked_sub(&a).unwrap() == b); + assert!(c.checked_sub(&b).unwrap() == a); + assert!((-&b).checked_sub(&a).unwrap() == (-&c)); + assert!((-&a).checked_sub(&b).unwrap() == (-&c)); + assert!(b.checked_sub(&(-&a)).unwrap() == c); + assert!(a.checked_sub(&(-&b)).unwrap() == c); + assert!((-&c).checked_sub(&(-&a)).unwrap() == (-&b)); + assert!(a.checked_sub(&a).unwrap() == Zero::zero()); + } +} + +#[test] +fn test_checked_mul() { + for elm in MUL_TRIPLES.iter() { + let (a_vec, b_vec, c_vec) = *elm; + let a = BigInt::from_slice(Plus, a_vec); + let b = BigInt::from_slice(Plus, b_vec); + let c = BigInt::from_slice(Plus, c_vec); + + assert!(a.checked_mul(&b).unwrap() == c); + assert!(b.checked_mul(&a).unwrap() == c); + + 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 = BigInt::from_slice(Plus, a_vec); + let b = BigInt::from_slice(Plus, b_vec); + let c = BigInt::from_slice(Plus, c_vec); + let d = BigInt::from_slice(Plus, d_vec); + + assert!(a == b.checked_mul(&c).unwrap() + &d); + assert!(a == c.checked_mul(&b).unwrap() + &d); + } +} +#[test] +fn test_checked_div() { + for elm in MUL_TRIPLES.iter() { + let (a_vec, b_vec, c_vec) = *elm; + let a = BigInt::from_slice(Plus, a_vec); + let b = BigInt::from_slice(Plus, b_vec); + let c = BigInt::from_slice(Plus, c_vec); + + if !a.is_zero() { + assert!(c.checked_div(&a).unwrap() == b); + assert!((-&c).checked_div(&(-&a)).unwrap() == b); + assert!((-&c).checked_div(&a).unwrap() == -&b); + } + if !b.is_zero() { + assert!(c.checked_div(&b).unwrap() == a); + assert!((-&c).checked_div(&(-&b)).unwrap() == a); + assert!((-&c).checked_div(&b).unwrap() == -&a); + } + + assert!(c.checked_div(&Zero::zero()).is_none()); + assert!((-&c).checked_div(&Zero::zero()).is_none()); + } +} + +#[test] +fn test_gcd() { + fn check(a: isize, b: isize, c: isize) { + let big_a: BigInt = FromPrimitive::from_isize(a).unwrap(); + let big_b: BigInt = FromPrimitive::from_isize(b).unwrap(); + let big_c: BigInt = FromPrimitive::from_isize(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); + check(3, -3, 3); + check(-6, 3, 3); + check(-4, -2, 2); +} + +#[test] +fn test_lcm() { + fn check(a: isize, b: isize, c: isize) { + let big_a: BigInt = FromPrimitive::from_isize(a).unwrap(); + let big_b: BigInt = FromPrimitive::from_isize(b).unwrap(); + let big_c: BigInt = FromPrimitive::from_isize(c).unwrap(); + + assert_eq!(big_a.lcm(&big_b), big_c); + } + + check(1, 0, 0); + check(0, 1, 0); + check(1, 1, 1); + check(-1, 1, 1); + check(1, -1, 1); + check(-1, -1, 1); + check(8, 9, 72); + check(11, 5, 55); +} + +#[test] +fn test_abs_sub() { + let zero: BigInt = Zero::zero(); + let one: BigInt = One::one(); + assert_eq!((-&one).abs_sub(&one), zero); + let one: BigInt = One::one(); + let zero: BigInt = Zero::zero(); + assert_eq!(one.abs_sub(&one), zero); + let one: BigInt = One::one(); + let zero: BigInt = Zero::zero(); + assert_eq!(one.abs_sub(&zero), one); + let one: BigInt = One::one(); + let two: BigInt = FromPrimitive::from_isize(2).unwrap(); + assert_eq!(one.abs_sub(&-&one), two); +} + +#[test] +fn test_from_str_radix() { + fn check(s: &str, ans: Option) { + let ans = ans.map(|n| { + let x: BigInt = FromPrimitive::from_isize(n).unwrap(); + x + }); + assert_eq!(BigInt::from_str_radix(s, 10).ok(), ans); + } + check("10", Some(10)); + check("1", Some(1)); + check("0", Some(0)); + check("-1", Some(-1)); + check("-10", Some(-10)); + check("+10", Some(10)); + check("--7", None); + check("++5", None); + check("+-9", None); + check("-+3", None); + check("Z", None); + check("_", None); + + // issue 10522, this hit an edge case that caused it to + // attempt to allocate a vector of size (-1u) == huge. + let x: BigInt = format!("1{}", repeat("0").take(36).collect::()).parse().unwrap(); + let _y = x.to_string(); +} + +#[test] +fn test_lower_hex() { + let a = BigInt::parse_bytes(b"A", 16).unwrap(); + let hello = BigInt::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 = BigInt::parse_bytes(b"A", 16).unwrap(); + let hello = BigInt::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 = BigInt::parse_bytes(b"A", 16).unwrap(); + let hello = BigInt::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 = BigInt::parse_bytes(b"A", 16).unwrap(); + let hello = BigInt::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 = BigInt::parse_bytes(b"A", 16).unwrap(); + let hello = BigInt::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_neg() { + assert!(-BigInt::new(Plus, vec![1, 1, 1]) == BigInt::new(Minus, vec![1, 1, 1])); + assert!(-BigInt::new(Minus, vec![1, 1, 1]) == BigInt::new(Plus, vec![1, 1, 1])); + let zero: BigInt = Zero::zero(); + assert_eq!(-&zero, zero); +} + +#[test] +fn test_rand() { + let mut rng = thread_rng(); + let _n: BigInt = rng.gen_bigint(137); + assert!(rng.gen_bigint(0).is_zero()); +} + +#[test] +fn test_rand_range() { + let mut rng = thread_rng(); + + for _ in 0..10 { + assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_usize(236).unwrap(), + &FromPrimitive::from_usize(237).unwrap()), + FromPrimitive::from_usize(236).unwrap()); + } + + fn check(l: BigInt, u: BigInt) { + let mut rng = thread_rng(); + for _ in 0..1000 { + let n: BigInt = rng.gen_bigint_range(&l, &u); + assert!(n >= l); + assert!(n < u); + } + } + let l: BigInt = FromPrimitive::from_usize(403469000 + 2352).unwrap(); + let u: BigInt = FromPrimitive::from_usize(403469000 + 3513).unwrap(); + check(l.clone(), u.clone()); + check(-l.clone(), u.clone()); + check(-u.clone(), -l.clone()); +} + +#[test] +#[should_panic] +fn test_zero_rand_range() { + thread_rng().gen_bigint_range(&FromPrimitive::from_isize(54).unwrap(), + &FromPrimitive::from_isize(54).unwrap()); +} + +#[test] +#[should_panic] +fn test_negative_rand_range() { + let mut rng = thread_rng(); + let l = FromPrimitive::from_usize(2352).unwrap(); + let u = FromPrimitive::from_usize(3513).unwrap(); + // Switching u and l should fail: + let _n: BigInt = rng.gen_bigint_range(&u, &l); +} diff --git a/bigint/src/tests/biguint.rs b/bigint/src/tests/biguint.rs new file mode 100644 index 0000000..87a223f --- /dev/null +++ b/bigint/src/tests/biguint.rs @@ -0,0 +1,1236 @@ +use integer::Integer; +use {BigDigit, BigUint, ToBigUint, big_digit}; +use {BigInt, RandBigInt, ToBigInt}; +use Sign::Plus; + +use std::cmp::Ordering::{Less, Equal, Greater}; +use std::{f32, f64}; +use std::i64; +use std::iter::repeat; +use std::str::FromStr; +use std::{u8, u16, u32, u64, usize}; + +use rand::thread_rng; +use traits::{Num, Zero, One, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv, ToPrimitive, + FromPrimitive, Float}; + + +/// Assert that an op works for all val/ref combinations +macro_rules! assert_op { + ($left:ident $op:tt $right:ident == $expected:expr) => { + assert_eq!((&$left) $op (&$right), $expected); + assert_eq!((&$left) $op $right.clone(), $expected); + assert_eq!($left.clone() $op (&$right), $expected); + assert_eq!($left.clone() $op $right.clone(), $expected); + }; +} + +#[test] +fn test_from_slice() { + fn check(slice: &[BigDigit], data: &[BigDigit]) { + assert!(BigUint::from_slice(slice).data == data); + } + check(&[1], &[1]); + check(&[0, 0, 0], &[]); + check(&[1, 2, 0, 0], &[1, 2]); + check(&[0, 0, 1, 2], &[0, 0, 1, 2]); + check(&[0, 0, 1, 2, 0, 0], &[0, 0, 1, 2]); + check(&[-1i32 as BigDigit], &[-1i32 as BigDigit]); +} + +#[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 = 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); + } + } + } +} + +#[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)); +} + +const BIT_TESTS: &'static [(&'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit])] = &[// LEFT RIGHT AND OR XOR + (&[], &[], &[], &[], &[]), + (&[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); + } +} + +#[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); + } +} + +#[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); + } +} + +#[test] +fn test_shl() { + fn check(s: &str, shift: usize, ans: &str) { + let opt_biguint = BigUint::from_str_radix(s, 16).ok(); + let bu = (opt_biguint.unwrap() << shift).to_str_radix(16); + assert_eq!(bu, 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 bu = (opt_biguint.unwrap() >> shift).to_str_radix(16); + assert_eq!(bu, 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"); +} + +const N1: BigDigit = -1i32 as BigDigit; +const N2: BigDigit = -2i32 as BigDigit; + +// `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 << (0 * big_digit::BITS))); + check(BigUint::new(vec![N1]), (1 << (1 * big_digit::BITS)) - 1); + check(BigUint::new(vec![0, 1]), (1 << (1 * big_digit::BITS))); + 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); +} + +// `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 << (0 * big_digit::BITS))); + check(BigUint::new(vec![N1]), (1 << (1 * big_digit::BITS)) - 1); + check(BigUint::new(vec![0, 1]), (1 << (1 * big_digit::BITS))); + 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] +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 BigDigit])); + check!(u16, BigUint::from_slice(&[u16::MAX as BigDigit])); + check!(u32, BigUint::from_slice(&[u32::MAX])); + check!(u64, BigUint::from_slice(&[u32::MAX, u32::MAX])); + check!(usize, BigUint::from(usize::MAX as u64)); +} + +const SUM_TRIPLES: &'static [(&'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit])] = &[(&[], &[], &[]), + (&[], &[1], &[1]), + (&[1], &[1], &[2]), + (&[1], &[1, 1], &[2, 1]), + (&[1], &[N1], &[0, 1]), + (&[1], &[N1, N1], &[0, 0, 1]), + (&[N1, N1], &[N1, N1], &[N2, N1, 1]), + (&[1, 1, 1], &[N1, N1], &[0, 1, 2]), + (&[2, 2, 1], &[N1, N2], &[1, 1, 2])]; + +#[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); + } +} + +#[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); + } +} + +#[test] +#[should_panic] +fn test_sub_fail_on_underflow() { + let (a, b): (BigUint, BigUint) = (Zero::zero(), One::one()); + a - b; +} + +const M: u32 = ::std::u32::MAX; +const MUL_TRIPLES: &'static [(&'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit])] = &[(&[], &[], &[]), + (&[], &[1], &[]), + (&[2], &[], &[]), + (&[1], &[1], &[1]), + (&[2], &[3], &[6]), + (&[1], &[1, 1, 1], &[1, 1, 1]), + (&[1, 2, 3], &[3], &[3, 6, 9]), + (&[1, 1, 1], &[N1], &[N1, N1, N1]), + (&[1, 2, 3], &[N1], &[N1, N2, N2, 2]), + (&[1, 2, 3, 4], &[N1], &[N1, N2, N2, N2, 3]), + (&[N1], &[N1], &[1, N2]), + (&[N1, N1], &[N1], &[1, N1, N2]), + (&[N1, N1, N1], &[N1], &[1, N1, N1, N2]), + (&[N1, N1, N1, N1], &[N1], &[1, N1, N1, N1, N2]), + (&[M / 2 + 1], &[2], &[0, 1]), + (&[0, M / 2 + 1], &[2], &[0, 0, 1]), + (&[1, 2], &[1, 2, 3], &[1, 4, 7, 6]), + (&[N1, N1], &[N1, N1, N1], &[1, 0, N1, N2, N1]), + (&[N1, N1, N1], + &[N1, N1, N1, N1], + &[1, 0, 0, N1, N2, N1, N1]), + (&[0, 0, 1], &[1, 2, 3], &[0, 0, 1, 2, 3]), + (&[0, 0, 1], &[0, 0, 0, 1], &[0, 0, 0, 0, 0, 1])]; + +const DIV_REM_QUADRUPLES: &'static [(&'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit])] = &[(&[1], &[2], &[], &[1]), + (&[1, 1], &[2], &[M / 2 + 1], &[1]), + (&[1, 1, 1], &[2], &[M / 2 + 1, M / 2 + 1], &[1]), + (&[0, 1], &[N1], &[1], &[1]), + (&[N1, N1], &[N2], &[2, 1], &[3])]; + +#[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); + } + + 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_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_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!(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 = big_digit::BITS; + 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::())), + (4, + format!("2{}1", repeat("0").take(bits / 2 - 1).collect::())), + (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::()))]), + (BigUint::from_slice(&[1, 2, 3]), + vec![(2, + format!("11{}10{}1", + repeat("0").take(bits - 2).collect::(), + repeat("0").take(bits - 1).collect::())), + (4, + format!("3{}2{}1", + repeat("0").take(bits / 2 - 1).collect::(), + repeat("0").take(bits / 2 - 1).collect::())), + (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::(), + repeat("0").take(bits / 4 - 1).collect::()))])] +} + +#[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_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 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); +} + +#[test] +fn test_all_str_radix() { + 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_rand() { + let mut rng = thread_rng(); + let _n: BigUint = rng.gen_biguint(137); + assert!(rng.gen_biguint(0).is_zero()); +} + +#[test] +fn test_rand_range() { + let mut rng = thread_rng(); + + for _ in 0..10 { + assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_usize(236).unwrap(), + &FromPrimitive::from_usize(237).unwrap()), + FromPrimitive::from_usize(236).unwrap()); + } + + let l = FromPrimitive::from_usize(403469000 + 2352).unwrap(); + let u = FromPrimitive::from_usize(403469000 + 3513).unwrap(); + for _ in 0..1000 { + let n: BigUint = rng.gen_biguint_below(&u); + assert!(n < u); + + let n: BigUint = rng.gen_biguint_range(&l, &u); + assert!(n >= l); + assert!(n < u); + } +} + +#[test] +#[should_panic] +fn test_zero_rand_range() { + thread_rng().gen_biguint_range(&FromPrimitive::from_usize(54).unwrap(), + &FromPrimitive::from_usize(54).unwrap()); +} + +#[test] +#[should_panic] +fn test_negative_rand_range() { + let mut rng = thread_rng(); + let l = FromPrimitive::from_usize(2352).unwrap(); + let u = FromPrimitive::from_usize(3513).unwrap(); + // Switching u and l should fail: + let _n: BigUint = rng.gen_biguint_range(&u, &l); +} + +fn test_mul_divide_torture_count(count: usize) { + use rand::{SeedableRng, StdRng, Rng}; + + let bits_max = 1 << 12; + let seed: &[_] = &[1, 2, 3, 4]; + let mut rng: StdRng = SeedableRng::from_seed(seed); + + for _ in 0..count { + // Test with numbers of random sizes: + let xbits = rng.gen_range(0, bits_max); + let ybits = rng.gen_range(0, bits_max); + + let x = rng.gen_biguint(xbits); + let y = rng.gen_biguint(ybits); + + if x.is_zero() || y.is_zero() { + continue; + } + + let prod = &x * &y; + assert_eq!(&prod / &x, y); + assert_eq!(&prod / &y, x); + } +} + +#[test] +fn test_mul_divide_torture() { + test_mul_divide_torture_count(1000); +} + +#[test] +#[ignore] +fn test_mul_divide_torture_long() { + test_mul_divide_torture_count(1000000); +}