//! ## Example
//!
//! ```rust
+//! # #![allow(deprecated)]
//! use num::bigint::BigUint;
//! use std::num::{Zero, One};
//! use std::mem::replace;
//! It's easy to generate large random numbers:
//!
//! ```rust
+//! # #![allow(deprecated)]
//! use num::bigint::{ToBigInt, RandBigInt};
//! use std::rand;
//!
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
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;
}
}
/// 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.
fn neg(&self) -> Sign {
match *self {
Minus => Plus,
- Zero => Zero,
+ NoSign => NoSign,
Plus => Minus
}
}
if scmp != Equal { return scmp; }
match self.sign {
- Zero => Equal,
+ NoSign => Equal,
Plus => self.data.cmp(&other.data),
Minus => other.data.cmp(&self.data),
}
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 {
#[inline]
fn abs(&self) -> BigInt {
match self.sign {
- Plus | Zero => self.clone(),
+ Plus | NoSign => self.clone(),
Minus => BigInt::from_biguint(Plus, self.data.clone())
}
}
match self.sign {
Plus => BigInt::from_biguint(Plus, One::one()),
Minus => BigInt::from_biguint(Minus, One::one()),
- Zero => Zero::zero(),
+ NoSign => Zero::zero(),
}
}
#[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),
#[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),
#[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)
},
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)
}
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)
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;
fn to_u64(&self) -> Option<u64> {
match self.sign {
Plus => self.data.to_u64(),
- Zero => Some(0),
+ NoSign => Some(0),
Minus => None
}
}
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)),
}
}
if self.gen() {
return self.gen_bigint(bit_size);
} else {
- Zero
+ NoSign
}
} else if self.gen() {
Plus
/// 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 }
}
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
}
}
#[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);
#[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);
#[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);
#[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);
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;
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]
#[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));
#[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);
#[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);
#[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);
}
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);
#[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);