From 791264ddfcccdc39fabb1d89d14355f272e59cfd Mon Sep 17 00:00:00 2001 From: Renato Zannon Date: Tue, 20 Jan 2015 17:17:41 -0200 Subject: [PATCH] Rename BigDigit module to big_digit Without this rename, the library fails to compile on Rust master, since rust-lang/rust#21269 has landed. --- src/bigint.rs | 64 +++++++++++++++++++++++++-------------------------- 1 file changed, 32 insertions(+), 32 deletions(-) diff --git a/src/bigint.rs b/src/bigint.rs index f52029d..db7e3fd 100644 --- a/src/bigint.rs +++ b/src/bigint.rs @@ -84,7 +84,7 @@ pub const ZERO_BIG_DIGIT: BigDigit = 0; static ZERO_VEC: [BigDigit; 1] = [ZERO_BIG_DIGIT]; #[allow(non_snake_case)] -pub mod BigDigit { +pub mod big_digit { use super::BigDigit; use super::DoubleBigDigit; @@ -115,7 +115,7 @@ pub mod BigDigit { /// A big unsigned integer type. /// /// A `BigUint`-typed value `BigUint { data: vec!(a, b, c) }` represents a number -/// `(a + b * BigDigit::BASE + c * BigDigit::BASE^2)`. +/// `(a + b * big_digit::BASE + c * big_digit::BASE^2)`. #[derive(Clone, RustcEncodable, RustcDecodable)] pub struct BigUint { data: Vec @@ -292,8 +292,8 @@ impl<'a> Shl for &'a BigUint { #[inline] fn shl(self, rhs: usize) -> BigUint { - let n_unit = rhs / BigDigit::BITS; - let n_bits = rhs % BigDigit::BITS; + let n_unit = rhs / big_digit::BITS; + let n_bits = rhs % big_digit::BITS; return self.shl_unit(n_unit).shl_bits(n_bits); } } @@ -310,8 +310,8 @@ impl<'a> Shr for &'a BigUint { #[inline] fn shr(self, rhs: usize) -> BigUint { - let n_unit = rhs / BigDigit::BITS; - let n_bits = rhs % BigDigit::BITS; + let n_unit = rhs / big_digit::BITS; + let n_bits = rhs % big_digit::BITS; return self.shr_unit(n_unit).shr_bits(n_bits); } } @@ -342,7 +342,7 @@ impl<'a, 'b> Add<&'b BigUint> for &'a BigUint { let mut carry = 0; let mut sum: Vec = a.data.iter().zip(b.data.iter().chain(zeros)).map(|(ai, bi)| { - let (hi, lo) = BigDigit::from_doublebigdigit( + let (hi, lo) = big_digit::from_doublebigdigit( (*ai as DoubleBigDigit) + (*bi as DoubleBigDigit) + (carry as DoubleBigDigit)); carry = hi; lo @@ -364,8 +364,8 @@ impl<'a, 'b> Sub<&'b BigUint> for &'a BigUint { let mut borrow = 0is; let diff: Vec = a.take(new_len).zip(b).map(|(ai, bi)| { - let (hi, lo) = BigDigit::from_doublebigdigit( - BigDigit::BASE + let (hi, lo) = big_digit::from_doublebigdigit( + big_digit::BASE + (*ai as DoubleBigDigit) - (*bi as DoubleBigDigit) - (borrow as DoubleBigDigit) @@ -427,7 +427,7 @@ impl<'a, 'b> Mul<&'b BigUint> for &'a BigUint { let mut carry = 0; let mut prod: Vec = a.data.iter().map(|ai| { - let (hi, lo) = BigDigit::from_doublebigdigit( + let (hi, lo) = big_digit::from_doublebigdigit( (*ai as DoubleBigDigit) * (n as DoubleBigDigit) + (carry as DoubleBigDigit) ); carry = hi; @@ -559,11 +559,11 @@ impl Integer for BigUint { let mut shift = 0; let mut n = *other.data.last().unwrap(); - while n < (1 << BigDigit::BITS - 2) { + while n < (1 << big_digit::BITS - 2) { n <<= 1; shift += 1; } - assert!(shift < BigDigit::BITS); + assert!(shift < big_digit::BITS); let (d, m) = div_mod_floor_inner(self << shift, other << shift); return (d, m >> shift); @@ -611,9 +611,9 @@ impl Integer for BigUint { let mut d = Vec::with_capacity(an.len()); let mut carry = 0; for elt in an.iter().rev() { - let ai = BigDigit::to_doublebigdigit(carry, *elt); + let ai = big_digit::to_doublebigdigit(carry, *elt); let di = ai / (bn as DoubleBigDigit); - assert!(di < BigDigit::BASE); + assert!(di < big_digit::BASE); carry = (ai % (bn as DoubleBigDigit)) as BigDigit; d.push(di as BigDigit) } @@ -693,7 +693,7 @@ impl ToPrimitive for BigUint { match self.data.len() { 0 => Some(0), 1 => Some(self.data[0] as u64), - 2 => Some(BigDigit::to_doublebigdigit(self.data[1], self.data[0]) + 2 => Some(big_digit::to_doublebigdigit(self.data[1], self.data[0]) as u64), _ => None } @@ -715,7 +715,7 @@ impl FromPrimitive for BigUint { // `DoubleBigDigit` size dependent #[inline] fn from_u64(n: u64) -> Option { - let n = match BigDigit::from_doublebigdigit(n) { + let n = match big_digit::from_doublebigdigit(n) { (0, 0) => Zero::zero(), (0, n0) => BigUint::new(vec!(n0)), (n1, n0) => BigUint::new(vec!(n0, n1)) @@ -775,7 +775,7 @@ impl_to_biguint!(u64, FromPrimitive::from_u64); fn to_str_radix(me: &BigUint, radix: usize) -> String { assert!(1 < radix && radix <= 16, "The radix must be within (1, 16]"); let (base, max_len) = get_radix_base(radix); - if base == BigDigit::BASE { + if base == big_digit::BASE { return fill_concat(&me.data[], radix, max_len) } return fill_concat(&convert_base(me, base)[], radix, max_len); @@ -898,7 +898,7 @@ impl BigUint { let mut carry = 0; let mut shifted: Vec = self.data.iter().map(|elem| { - let (hi, lo) = BigDigit::from_doublebigdigit( + let (hi, lo) = big_digit::from_doublebigdigit( (*elem as DoubleBigDigit) << n_bits | (carry as DoubleBigDigit) ); carry = hi; @@ -923,7 +923,7 @@ impl BigUint { let mut shifted_rev = Vec::with_capacity(self.data.len()); for elem in self.data.iter().rev() { shifted_rev.push((*elem >> n_bits) | borrow); - borrow = *elem << (BigDigit::BITS - n_bits); + borrow = *elem << (big_digit::BITS - n_bits); } let shifted = { shifted_rev.reverse(); shifted_rev }; return BigUint::new(shifted); @@ -933,7 +933,7 @@ impl BigUint { pub fn bits(&self) -> usize { if self.is_zero() { return 0; } let zeros = self.data.last().unwrap().leading_zeros(); - return self.data.len()*BigDigit::BITS - zeros; + return self.data.len()*big_digit::BITS - zeros; } } @@ -1489,14 +1489,14 @@ pub trait RandBigInt { impl RandBigInt for R { fn gen_biguint(&mut self, bit_size: usize) -> BigUint { - let (digits, rem) = bit_size.div_rem(&BigDigit::BITS); + let (digits, rem) = bit_size.div_rem(&big_digit::BITS); let mut data = Vec::with_capacity(digits+1); for _ in range(0, digits) { data.push(self.gen()); } if rem > 0 { let final_digit: BigDigit = self.gen(); - data.push(final_digit >> (BigDigit::BITS - rem)); + data.push(final_digit >> (big_digit::BITS - rem)); } BigUint::new(data) } @@ -1620,7 +1620,7 @@ impl BigInt { #[cfg(test)] mod biguint_tests { use Integer; - use super::{BigDigit, BigUint, ToBigUint, to_str_radix}; + use super::{BigDigit, BigUint, ToBigUint, to_str_radix, big_digit}; use super::{BigInt, RandBigInt, ToBigInt}; use super::Sign::Plus; @@ -1993,9 +1993,9 @@ mod biguint_tests { check(i64::MAX.to_biguint().unwrap(), i64::MAX); check(BigUint::new(vec!( )), 0); - check(BigUint::new(vec!( 1 )), (1 << (0*BigDigit::BITS))); - check(BigUint::new(vec!(-1 )), (1 << (1*BigDigit::BITS)) - 1); - check(BigUint::new(vec!( 0, 1 )), (1 << (1*BigDigit::BITS))); + check(BigUint::new(vec!( 1 )), (1 << (0*big_digit::BITS))); + check(BigUint::new(vec!(-1 )), (1 << (1*big_digit::BITS)) - 1); + check(BigUint::new(vec!( 0, 1 )), (1 << (1*big_digit::BITS))); check(BigUint::new(vec!(-1, -1 >> 1)), i64::MAX); assert_eq!(i64::MIN.to_biguint(), None); @@ -2019,9 +2019,9 @@ mod biguint_tests { check(u64::MAX.to_biguint().unwrap(), u64::MAX); check(BigUint::new(vec!( )), 0); - check(BigUint::new(vec!( 1 )), (1 << (0*BigDigit::BITS))); - check(BigUint::new(vec!(-1 )), (1 << (1*BigDigit::BITS)) - 1); - check(BigUint::new(vec!( 0, 1)), (1 << (1*BigDigit::BITS))); + check(BigUint::new(vec!( 1 )), (1 << (0*big_digit::BITS))); + check(BigUint::new(vec!(-1 )), (1 << (1*big_digit::BITS)) - 1); + check(BigUint::new(vec!( 0, 1)), (1 << (1*big_digit::BITS))); check(BigUint::new(vec!(-1, -1)), u64::MAX); assert_eq!(BigUint::new(vec!( 0, 0, 1)).to_u64(), None); @@ -2303,7 +2303,7 @@ mod biguint_tests { } fn to_str_pairs() -> Vec<(BigUint, Vec<(usize, String)>)> { - let bits = BigDigit::BITS; + let bits = big_digit::BITS; vec!(( Zero::zero(), vec!( (2, "0".to_string()), (3, "0".to_string()) )), ( BigUint::from_slice(&[ 0xff ]), vec!( @@ -2487,7 +2487,7 @@ mod biguint_tests { mod bigint_tests { use Integer; use super::{BigDigit, BigUint, ToBigUint}; - use super::{Sign, BigInt, RandBigInt, ToBigInt}; + use super::{Sign, BigInt, RandBigInt, ToBigInt, big_digit}; use super::Sign::{Minus, NoSign, Plus}; use std::cmp::Ordering::{Less, Equal, Greater}; @@ -2594,7 +2594,7 @@ mod bigint_tests { None); assert_eq!( - BigInt::from_biguint(Minus, BigUint::new(vec!(1,0,0,1<<(BigDigit::BITS-1)))).to_i64(), + BigInt::from_biguint(Minus, BigUint::new(vec!(1,0,0,1<<(big_digit::BITS-1)))).to_i64(), None); assert_eq!(