rollup merge of #17355 : gamazeps/issue17210

[rust.git] / src / libnum / bigint.rs

diff --git a/src/libnum/bigint.rs b/src/libnum/bigint.rs
index 68cfe061121eab064daec80244deae6ae448f1c8..efa3402073f2eff827a091aae9f24487b3f50a8e 100644 (file)
--- a/src/libnum/bigint.rs
+++ b/src/libnum/bigint.rs
@@ -19,6 +19,7 @@
 //! ## Example
 //!
 //! ```rust
+//! # #![allow(deprecated)]
 //! use num::bigint::BigUint;
 //! use std::num::{Zero, One};
 //! use std::mem::replace;
@@ -42,6 +43,7 @@
 //! It's easy to generate large random numbers:
 //!
 //! ```rust
+//! # #![allow(deprecated)]
 //! use num::bigint::{ToBigInt, RandBigInt};
 //! use std::rand;
 //!
@@ -616,7 +618,7 @@ impl ToBigUint for BigInt {
     fn to_biguint(&self) -> Option<BigUint> {
         if self.sign == Plus {
             Some(self.data.clone())
-        } else if self.sign == Zero {
+        } else if self.sign == NoSign {
             Some(Zero::zero())
         } else {
             None
@@ -807,7 +809,7 @@ fn shr_bits(&self, n_bits: uint) -> BigUint {
     pub fn bits(&self) -> uint {
         if self.is_zero() { return 0; }
         let zeros = self.data.last().unwrap().leading_zeros();
-        return self.data.len()*BigDigit::bits - (zeros as uint);
+        return self.data.len()*BigDigit::bits - zeros;
     }
 }
 
@@ -836,7 +838,7 @@ fn get_radix_base(radix: uint) -> (DoubleBigDigit, uint) {
 
 /// A Sign is a `BigInt`'s composing element.
 #[deriving(PartialEq, PartialOrd, Eq, Ord, Clone, Show)]
-pub enum Sign { Minus, Zero, Plus }
+pub enum Sign { Minus, NoSign, Plus }
 
 impl Neg<Sign> for Sign {
     /// Negate Sign value.
@@ -844,7 +846,7 @@ impl Neg<Sign> for Sign {
     fn neg(&self) -> Sign {
         match *self {
           Minus => Plus,
-          Zero  => Zero,
+          NoSign  => NoSign,
           Plus  => Minus
         }
     }
@@ -880,7 +882,7 @@ fn cmp(&self, other: &BigInt) -> Ordering {
         if scmp != Equal { return scmp; }
 
         match self.sign {
-            Zero  => Equal,
+            NoSign  => Equal,
             Plus  => self.data.cmp(&other.data),
             Minus => other.data.cmp(&self.data),
         }
@@ -931,11 +933,11 @@ fn shr(&self, rhs: &uint) -> BigInt {
 impl Zero for BigInt {
     #[inline]
     fn zero() -> BigInt {
-        BigInt::from_biguint(Zero, Zero::zero())
+        BigInt::from_biguint(NoSign, Zero::zero())
     }
 
     #[inline]
-    fn is_zero(&self) -> bool { self.sign == Zero }
+    fn is_zero(&self) -> bool { self.sign == NoSign }
 }
 
 impl One for BigInt {
@@ -949,7 +951,7 @@ impl Signed for BigInt {
     #[inline]
     fn abs(&self) -> BigInt {
         match self.sign {
-            Plus | Zero => self.clone(),
+            Plus | NoSign => self.clone(),
             Minus => BigInt::from_biguint(Plus, self.data.clone())
         }
     }
@@ -964,7 +966,7 @@ fn signum(&self) -> BigInt {
         match self.sign {
             Plus  => BigInt::from_biguint(Plus, One::one()),
             Minus => BigInt::from_biguint(Minus, One::one()),
-            Zero  => Zero::zero(),
+            NoSign  => Zero::zero(),
         }
     }
 
@@ -979,8 +981,8 @@ impl Add<BigInt, BigInt> for BigInt {
     #[inline]
     fn add(&self, other: &BigInt) -> BigInt {
         match (self.sign, other.sign) {
-            (Zero, _)      => other.clone(),
-            (_,    Zero)   => self.clone(),
+            (NoSign, _)      => other.clone(),
+            (_,    NoSign)   => self.clone(),
             (Plus, Plus)   => BigInt::from_biguint(Plus, self.data + other.data),
             (Plus, Minus)  => self - (-*other),
             (Minus, Plus)  => other - (-*self),
@@ -993,8 +995,8 @@ impl Sub<BigInt, BigInt> for BigInt {
     #[inline]
     fn sub(&self, other: &BigInt) -> BigInt {
         match (self.sign, other.sign) {
-            (Zero, _)    => -other,
-            (_,    Zero) => self.clone(),
+            (NoSign, _)    => -other,
+            (_,    NoSign) => self.clone(),
             (Plus, Plus) => match self.data.cmp(&other.data) {
                 Less    => BigInt::from_biguint(Minus, other.data - self.data),
                 Greater => BigInt::from_biguint(Plus, self.data - other.data),
@@ -1011,7 +1013,7 @@ impl Mul<BigInt, BigInt> for BigInt {
     #[inline]
     fn mul(&self, other: &BigInt) -> BigInt {
         match (self.sign, other.sign) {
-            (Zero, _)     | (_,     Zero)  => Zero::zero(),
+            (NoSign, _)     | (_,     NoSign)  => Zero::zero(),
             (Plus, Plus)  | (Minus, Minus) => {
                 BigInt::from_biguint(Plus, self.data * other.data)
             },
@@ -1085,9 +1087,9 @@ fn div_rem(&self, other: &BigInt) -> (BigInt, BigInt) {
         let d = BigInt::from_biguint(Plus, d_ui);
         let r = BigInt::from_biguint(Plus, r_ui);
         match (self.sign, other.sign) {
-            (_,    Zero)   => fail!(),
-            (Plus, Plus)  | (Zero, Plus)  => ( d,  r),
-            (Plus, Minus) | (Zero, Minus) => (-d,  r),
+            (_,    NoSign)   => fail!(),
+            (Plus, Plus)  | (NoSign, Plus)  => ( d,  r),
+            (Plus, Minus) | (NoSign, Minus) => (-d,  r),
             (Minus, Plus)                 => (-d, -r),
             (Minus, Minus)                => ( d, -r)
         }
@@ -1111,9 +1113,9 @@ fn div_mod_floor(&self, other: &BigInt) -> (BigInt, BigInt) {
         let d = BigInt::from_biguint(Plus, d_ui);
         let m = BigInt::from_biguint(Plus, m_ui);
         match (self.sign, other.sign) {
-            (_,    Zero)   => fail!(),
-            (Plus, Plus)  | (Zero, Plus)  => (d, m),
-            (Plus, Minus) | (Zero, Minus) => if m.is_zero() {
+            (_,    NoSign)   => fail!(),
+            (Plus, Plus)  | (NoSign, Plus)  => (d, m),
+            (Plus, Minus) | (NoSign, Minus) => if m.is_zero() {
                 (-d, Zero::zero())
             } else {
                 (-d - One::one(), m + *other)
@@ -1164,7 +1166,7 @@ impl ToPrimitive for BigInt {
     fn to_i64(&self) -> Option<i64> {
         match self.sign {
             Plus  => self.data.to_i64(),
-            Zero  => Some(0),
+            NoSign  => Some(0),
             Minus => {
                 self.data.to_u64().and_then(|n| {
                     let m: u64 = 1 << 63;
@@ -1184,7 +1186,7 @@ fn to_i64(&self) -> Option<i64> {
     fn to_u64(&self) -> Option<u64> {
         match self.sign {
             Plus => self.data.to_u64(),
-            Zero => Some(0),
+            NoSign => Some(0),
             Minus => None
         }
     }
@@ -1270,7 +1272,7 @@ impl ToStrRadix for BigInt {
     fn to_str_radix(&self, radix: uint) -> String {
         match self.sign {
             Plus  => self.data.to_str_radix(radix),
-            Zero  => "0".to_string(),
+            NoSign  => "0".to_string(),
             Minus => format!("-{}", self.data.to_str_radix(radix)),
         }
     }
@@ -1332,7 +1334,7 @@ fn gen_bigint(&mut self, bit_size: uint) -> BigInt {
             if self.gen() {
                 return self.gen_bigint(bit_size);
             } else {
-                Zero
+                NoSign
             }
         } else if self.gen() {
             Plus
@@ -1383,8 +1385,8 @@ pub fn new(sign: Sign, digits: Vec<BigDigit>) -> BigInt {
     /// The digits are be in base 2^32.
     #[inline]
     pub fn from_biguint(sign: Sign, data: BigUint) -> BigInt {
-        if sign == Zero || data.is_zero() {
-            return BigInt { sign: Zero, data: Zero::zero() };
+        if sign == NoSign || data.is_zero() {
+            return BigInt { sign: NoSign, data: Zero::zero() };
         }
         BigInt { sign: sign, data: data }
     }
@@ -1413,7 +1415,7 @@ pub fn parse_bytes(buf: &[u8], radix: uint) -> Option<BigInt> {
     pub fn to_biguint(&self) -> Option<BigUint> {
         match self.sign {
             Plus => Some(self.data.clone()),
-            Zero => Some(Zero::zero()),
+            NoSign => Some(Zero::zero()),
             Minus => None
         }
     }
@@ -1978,10 +1980,10 @@ fn test_div_rem() {
     #[test]
     fn test_checked_add() {
         for elm in sum_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigUint::from_slice(aVec);
-            let b = BigUint::from_slice(bVec);
-            let c = BigUint::from_slice(cVec);
+            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);
@@ -1991,10 +1993,10 @@ fn test_checked_add() {
     #[test]
     fn test_checked_sub() {
         for elm in sum_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigUint::from_slice(aVec);
-            let b = BigUint::from_slice(bVec);
-            let c = BigUint::from_slice(cVec);
+            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);
@@ -2011,21 +2013,21 @@ fn test_checked_sub() {
     #[test]
     fn test_checked_mul() {
         for elm in mul_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigUint::from_slice(aVec);
-            let b = BigUint::from_slice(bVec);
-            let c = BigUint::from_slice(cVec);
+            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 (aVec, bVec, cVec, dVec) = *elm;
-            let a = BigUint::from_slice(aVec);
-            let b = BigUint::from_slice(bVec);
-            let c = BigUint::from_slice(cVec);
-            let d = BigUint::from_slice(dVec);
+            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);
@@ -2035,10 +2037,10 @@ fn test_checked_mul() {
     #[test]
     fn test_checked_div() {
         for elm in mul_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigUint::from_slice(aVec);
-            let b = BigUint::from_slice(bVec);
-            let c = BigUint::from_slice(cVec);
+            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);
@@ -2286,7 +2288,7 @@ fn test_negative_rand_range() {
 mod bigint_tests {
     use Integer;
     use super::{BigDigit, BigUint, ToBigUint};
-    use super::{Sign, Minus, Zero, Plus, BigInt, RandBigInt, ToBigInt};
+    use super::{Sign, Minus, NoSign, Plus, BigInt, RandBigInt, ToBigInt};
 
     use std::cmp::{Less, Equal, Greater};
     use std::i64;
@@ -2305,9 +2307,9 @@ fn check(inp_s: Sign, inp_n: uint, ans_s: Sign, ans_n: uint) {
             assert_eq!(inp, ans);
         }
         check(Plus, 1, Plus, 1);
-        check(Plus, 0, Zero, 0);
+        check(Plus, 0, NoSign, 0);
         check(Minus, 1, Minus, 1);
-        check(Zero, 1, Zero, 0);
+        check(NoSign, 1, NoSign, 0);
     }
 
     #[test]
@@ -2355,8 +2357,8 @@ fn test_cmp() {
 
     #[test]
     fn test_hash() {
-        let a = BigInt::new(Zero, vec!());
-        let b = BigInt::new(Zero, vec!(0));
+        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));
@@ -2651,10 +2653,10 @@ fn check(a: &BigInt, b: &BigInt, q: &BigInt, r: &BigInt) {
     #[test]
     fn test_checked_add() {
         for elm in sum_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigInt::from_slice(Plus, aVec);
-            let b = BigInt::from_slice(Plus, bVec);
-            let c = BigInt::from_slice(Plus, cVec);
+            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);
@@ -2670,10 +2672,10 @@ fn test_checked_add() {
     #[test]
     fn test_checked_sub() {
         for elm in sum_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigInt::from_slice(Plus, aVec);
-            let b = BigInt::from_slice(Plus, bVec);
-            let c = BigInt::from_slice(Plus, cVec);
+            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);
@@ -2689,10 +2691,10 @@ fn test_checked_sub() {
     #[test]
     fn test_checked_mul() {
         for elm in mul_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigInt::from_slice(Plus, aVec);
-            let b = BigInt::from_slice(Plus, bVec);
-            let c = BigInt::from_slice(Plus, cVec);
+            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);
@@ -2702,11 +2704,11 @@ fn test_checked_mul() {
         }
 
         for elm in div_rem_quadruples.iter() {
-            let (aVec, bVec, cVec, dVec) = *elm;
-            let a = BigInt::from_slice(Plus, aVec);
-            let b = BigInt::from_slice(Plus, bVec);
-            let c = BigInt::from_slice(Plus, cVec);
-            let d = BigInt::from_slice(Plus, dVec);
+            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);
@@ -2715,10 +2717,10 @@ fn test_checked_mul() {
     #[test]
     fn test_checked_div() {
         for elm in mul_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigInt::from_slice(Plus, aVec);
-            let b = BigInt::from_slice(Plus, bVec);
-            let c = BigInt::from_slice(Plus, cVec);
+            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);