xeos
/
num-traits
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #40 from gifnksm/master 

update to latest rustc
This commit is contained in:
Alex Crichton 2014-12-16 10:37:52 -05:00
parent 32ae02d87d a325a566c6
commit 9428f0f100
7 changed files with 414 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
benches/shootout-pidigits.rs
View File

@ -70,24 +70,24 @@ impl Context {
fn extract_digit(&self) -> int {
if self.numer > self.accum {return -1;}
let (q, r) =
(self.numer * Context::from_int(3) + self.accum)
(&self.numer * Context::from_int(3) + &self.accum)
.div_rem(&self.denom);
if r + self.numer >= self.denom {return -1;}
if r + &self.numer >= self.denom {return -1;}
q.to_int().unwrap()
}
fn next_term(&mut self, k: int) {
let y2 = Context::from_int(k * 2 + 1);
self.accum = (self.accum + (self.numer << 1)) * y2;
self.numer = self.numer * Context::from_int(k);
self.denom = self.denom * y2;
self.accum = (&self.accum + (&self.numer << 1)) * &y2;
self.numer = &self.numer * Context::from_int(k);
self.denom = &self.denom * y2;
}
fn eliminate_digit(&mut self, d: int) {
let d = Context::from_int(d);
let ten = Context::from_int(10);
self.accum = (self.accum - self.denom * d) * ten;
self.numer = self.numer * ten;
self.accum = (&self.accum - &self.denom * d) * &ten;
self.numer = &self.numer * ten;
}
}

330
src/bigint.rs
View File

@ -27,7 +27,7 @@
//! let mut f0: BigUint = Zero::zero();
//! let mut f1: BigUint = One::one();
//! for _ in range(0, n) {
//! let f2 = f0 + f1;
//! let f2 = f0 + &f1;
//! // This is a low cost way of swapping f0 with f1 and f1 with f2.
//! f0 = replace(&mut f1, f2);
//! }
@ -183,14 +183,60 @@ impl FromStr for BigUint {
impl Num for BigUint {}
impl BitAnd<BigUint, BigUint> for BigUint {
fn bitand(&self, other: &BigUint) -> BigUint {
macro_rules! forward_val_val_binop {
(impl $imp:ident for $res:ty, $method:ident) => {
impl $imp<$res, $res> for $res {
#[inline]
fn $method(self, other: $res) -> $res {
(&self).$method(&other)
}
}
}
}
macro_rules! forward_ref_val_binop {
(impl $imp:ident for $res:ty, $method:ident) => {
impl<'a> $imp<$res, $res> for &'a $res {
#[inline]
fn $method(self, other: $res) -> $res {
self.$method(&other)
}
}
}
}
macro_rules! forward_val_ref_binop {
(impl $imp:ident for $res:ty, $method:ident) => {
impl<'a> $imp<&'a $res, $res> for $res {
#[inline]
fn $method(self, other: &$res) -> $res {
(&self).$method(other)
}
}
}
}
macro_rules! forward_all_binop {
(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_val_ref_binop!(impl $imp for $res, $method)
};
}
forward_all_binop!(impl BitAnd for BigUint, bitand)
impl<'a, 'b> BitAnd<&'b BigUint, BigUint> for &'a BigUint {
#[inline]
fn bitand(self, other: &BigUint) -> BigUint {
BigUint::new(self.data.iter().zip(other.data.iter()).map(|(ai, bi)| *ai & *bi).collect())
}
}
impl BitOr<BigUint, BigUint> for BigUint {
fn bitor(&self, other: &BigUint) -> BigUint {
forward_all_binop!(impl BitOr for BigUint, bitor)
impl<'a, 'b> BitOr<&'b BigUint, BigUint> for &'a BigUint {
fn bitor(self, other: &BigUint) -> BigUint {
let zeros = ZERO_VEC.iter().cycle();
let (a, b) = if self.data.len() > other.data.len() { (self, other) } else { (other, self) };
let ored = a.data.iter().zip(b.data.iter().chain(zeros)).map(
@ -200,8 +246,10 @@ impl BitOr<BigUint, BigUint> for BigUint {
}
}
impl BitXor<BigUint, BigUint> for BigUint {
fn bitxor(&self, other: &BigUint) -> BigUint {
forward_all_binop!(impl BitXor for BigUint, bitxor)
impl<'a, 'b> BitXor<&'b BigUint, BigUint> for &'a BigUint {
fn bitxor(self, other: &BigUint) -> BigUint {
let zeros = ZERO_VEC.iter().cycle();
let (a, b) = if self.data.len() > other.data.len() { (self, other) } else { (other, self) };
let xored = a.data.iter().zip(b.data.iter().chain(zeros)).map(
@ -213,18 +261,28 @@ impl BitXor<BigUint, BigUint> for BigUint {
impl Shl<uint, BigUint> for BigUint {
#[inline]
fn shl(&self, rhs: &uint) -> BigUint {
let n_unit = *rhs / BigDigit::BITS;
let n_bits = *rhs % BigDigit::BITS;
fn shl(self, rhs: uint) -> BigUint { (&self) << rhs }
}
impl<'a> Shl<uint, BigUint> for &'a BigUint {
#[inline]
fn shl(self, rhs: uint) -> BigUint {
let n_unit = rhs / BigDigit::BITS;
let n_bits = rhs % BigDigit::BITS;
return self.shl_unit(n_unit).shl_bits(n_bits);
}
}
impl Shr<uint, BigUint> for BigUint {
#[inline]
fn shr(&self, rhs: &uint) -> BigUint {
let n_unit = *rhs / BigDigit::BITS;
let n_bits = *rhs % BigDigit::BITS;
fn shr(self, rhs: uint) -> BigUint { (&self) >> rhs }
}
impl<'a> Shr<uint, BigUint> for &'a BigUint {
#[inline]
fn shr(self, rhs: uint) -> BigUint {
let n_unit = rhs / BigDigit::BITS;
let n_bits = rhs % BigDigit::BITS;
return self.shr_unit(n_unit).shr_bits(n_bits);
}
}
@ -244,8 +302,10 @@ impl One for BigUint {
impl Unsigned for BigUint {}
impl Add<BigUint, BigUint> for BigUint {
fn add(&self, other: &BigUint) -> BigUint {
forward_all_binop!(impl Add for BigUint, add)
impl<'a, 'b> Add<&'b BigUint, BigUint> for &'a BigUint {
fn add(self, other: &BigUint) -> BigUint {
let zeros = ZERO_VEC.iter().cycle();
let (a, b) = if self.data.len() > other.data.len() { (self, other) } else { (other, self) };
@ -261,8 +321,10 @@ impl Add<BigUint, BigUint> for BigUint {
}
}
impl Sub<BigUint, BigUint> for BigUint {
fn sub(&self, other: &BigUint) -> BigUint {
forward_all_binop!(impl Sub for BigUint, sub)
impl<'a, 'b> Sub<&'b BigUint, BigUint> for &'a BigUint {
fn sub(self, other: &BigUint) -> BigUint {
let new_len = cmp::max(self.data.len(), other.data.len());
let zeros = ZERO_VEC.iter().cycle();
let (a, b) = (self.data.iter().chain(zeros.clone()), other.data.iter().chain(zeros));
@ -289,8 +351,11 @@ impl Sub<BigUint, BigUint> for BigUint {
}
}
impl Mul<BigUint, BigUint> for BigUint {
fn mul(&self, other: &BigUint) -> BigUint {
forward_all_binop!(impl Mul for BigUint, mul)
impl<'a, 'b> Mul<&'b BigUint, BigUint> for &'a BigUint {
fn mul(self, other: &BigUint) -> BigUint {
if self.is_zero() || other.is_zero() { return Zero::zero(); }
let (s_len, o_len) = (self.data.len(), other.data.len());
@ -306,15 +371,15 @@ impl Mul<BigUint, BigUint> for BigUint {
let (s_hi, s_lo) = cut_at(self, half_len);
let (o_hi, o_lo) = cut_at(other, half_len);
let ll = s_lo * o_lo;
let hh = s_hi * o_hi;
let ll = &s_lo * &o_lo;
let hh = &s_hi * &o_hi;
let mm = {
let (s1, n1) = sub_sign(s_hi, s_lo);
let (s2, n2) = sub_sign(o_hi, o_lo);
match (s1, s2) {
(Equal, _) | (_, Equal) => hh + ll,
(Less, Greater) | (Greater, Less) => hh + ll + (n1 * n2),
(Less, Less) | (Greater, Greater) => hh + ll - (n1 * n2)
(Equal, _) | (_, Equal) => &hh + &ll,
(Less, Greater) | (Greater, Less) => &hh + &ll + (n1 * n2),
(Less, Less) | (Greater, Greater) => &hh + &ll - (n1 * n2)
}
};
@ -323,7 +388,7 @@ impl Mul<BigUint, BigUint> for BigUint {
fn mul_digit(a: &BigUint, n: BigDigit) -> BigUint {
if n == 0 { return Zero::zero(); }
if n == 1 { return (*a).clone(); }
if n == 1 { return a.clone(); }
let mut carry = 0;
let mut prod: Vec<BigDigit> = a.data.iter().map(|ai| {
@ -355,17 +420,22 @@ impl Mul<BigUint, BigUint> for BigUint {
}
}
impl Div<BigUint, BigUint> for BigUint {
forward_all_binop!(impl Div for BigUint, div)
impl<'a, 'b> Div<&'b BigUint, BigUint> for &'a BigUint {
#[inline]
fn div(&self, other: &BigUint) -> BigUint {
fn div(self, other: &BigUint) -> BigUint {
let (q, _) = self.div_rem(other);
return q;
}
}
impl Rem<BigUint, BigUint> for BigUint {
forward_all_binop!(impl Rem for BigUint, rem)
impl<'a, 'b> Rem<&'b BigUint, BigUint> for &'a BigUint {
#[inline]
fn rem(&self, other: &BigUint) -> BigUint {
fn rem(self, other: &BigUint) -> BigUint {
let (_, r) = self.div_rem(other);
return r;
}
@ -446,7 +516,7 @@ impl Integer for BigUint {
shift += 1;
}
assert!(shift < BigDigit::BITS);
let (d, m) = div_mod_floor_inner(*self << shift, *other << shift);
let (d, m) = div_mod_floor_inner(self << shift, other << shift);
return (d, m >> shift);
@ -457,14 +527,14 @@ impl Integer for BigUint {
while m >= b {
let (d0, d_unit, b_unit) = div_estimate(&m, &b, n);
let mut d0 = d0;
let mut prod = b * d0;
let mut prod = &b * &d0;
while prod > m {
// FIXME(#5992): assignment operator overloads
// d0 -= d_unit
d0 = d0 - d_unit;
// d0 -= &d_unit
d0 = d0 - &d_unit;
// FIXME(#5992): assignment operator overloads
// prod -= b_unit;
prod = prod - b_unit
// prod -= &b_unit;
prod = prod - &b_unit
}
if d0.is_zero() {
n = 2;
@ -522,7 +592,7 @@ impl Integer for BigUint {
let mut n = (*other).clone();
while !m.is_zero() {
let temp = m;
m = n % temp;
m = n % &temp;
n = temp;
}
return n;
@ -530,16 +600,16 @@ impl Integer for BigUint {
/// Calculates the Lowest Common Multiple (LCM) of the number and `other`.
#[inline]
fn lcm(&self, other: &BigUint) -> BigUint { ((*self * *other) / self.gcd(other)) }
fn lcm(&self, other: &BigUint) -> BigUint { ((self * other) / self.gcd(other)) }
/// Deprecated, use `is_multiple_of` instead.
#[deprecated = "function renamed to `is_multiple_of`"]
#[inline]
fn divides(&self, other: &BigUint) -> bool { return self.is_multiple_of(other); }
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() }
fn is_multiple_of(&self, other: &BigUint) -> bool { (self % other).is_zero() }
/// Returns `true` if the number is divisible by `2`.
#[inline]
@ -720,8 +790,8 @@ impl FromStrRadix for BigUint {
match d {
Some(d) => {
// FIXME(#5992): assignment operator overloads
// n += d * power;
n = n + d * power;
// n += d * &power;
n = n + d * &power;
}
None => { return None; }
}
@ -733,8 +803,8 @@ impl FromStrRadix for BigUint {
}
end -= unit_len;
// FIXME(#5992): assignment operator overloads
// power *= base_num;
power = power * base_num;
// power *= &base_num;
power = power * &base_num;
}
}
}
@ -938,15 +1008,25 @@ impl Num for BigInt {}
impl Shl<uint, BigInt> for BigInt {
#[inline]
fn shl(&self, rhs: &uint) -> BigInt {
BigInt::from_biguint(self.sign, self.data << *rhs)
fn shl(self, rhs: uint) -> BigInt { (&self) << rhs }
}
impl<'a> Shl<uint, BigInt> for &'a BigInt {
#[inline]
fn shl(self, rhs: uint) -> BigInt {
BigInt::from_biguint(self.sign, &self.data << rhs)
}
}
impl Shr<uint, BigInt> for BigInt {
#[inline]
fn shr(&self, rhs: &uint) -> BigInt {
BigInt::from_biguint(self.sign, self.data >> *rhs)
fn shr(self, rhs: uint) -> BigInt { (&self) >> rhs }
}
impl<'a> Shr<uint, BigInt> for &'a BigInt {
#[inline]
fn shr(self, rhs: uint) -> BigInt {
BigInt::from_biguint(self.sign, &self.data >> rhs)
}
}
@ -978,7 +1058,7 @@ impl Signed for BigInt {
#[inline]
fn abs_sub(&self, other: &BigInt) -> BigInt {
if *self <= *other { Zero::zero() } else { *self - *other }
if *self <= *other { Zero::zero() } else { self - other }
}
#[inline]
@ -997,64 +1077,74 @@ impl Signed for BigInt {
fn is_negative(&self) -> bool { self.sign == Minus }
}
impl Add<BigInt, BigInt> for BigInt {
forward_all_binop!(impl Add for BigInt, add)
impl<'a, 'b> Add<&'b BigInt, BigInt> for &'a BigInt {
#[inline]
fn add(&self, other: &BigInt) -> BigInt {
fn add(self, other: &BigInt) -> BigInt {
match (self.sign, other.sign) {
(NoSign, _) => other.clone(),
(_, NoSign) => self.clone(),
(Plus, Plus) => BigInt::from_biguint(Plus, self.data + other.data),
(Plus, Minus) => *self - (-*other),
(Minus, Plus) => *other - (-*self),
(Plus, Plus) => BigInt::from_biguint(Plus, &self.data + &other.data),
(Plus, Minus) => self - (-*other),
(Minus, Plus) => other - (-*self),
(Minus, Minus) => -((-*self) + (-*other))
}
}
}
impl Sub<BigInt, BigInt> for BigInt {
forward_all_binop!(impl Sub for BigInt, sub)
impl<'a, 'b> Sub<&'b BigInt, BigInt> for &'a BigInt {
#[inline]
fn sub(&self, other: &BigInt) -> BigInt {
fn sub(self, other: &BigInt) -> BigInt {
match (self.sign, other.sign) {
(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),
Less => BigInt::from_biguint(Minus, &other.data - &self.data),
Greater => BigInt::from_biguint(Plus, &self.data - &other.data),
Equal => Zero::zero()
},
(Plus, Minus) => *self + (-*other),
(Minus, Plus) => -((-*self) + *other),
(Plus, Minus) => self + (-*other),
(Minus, Plus) => -((-*self) + other),
(Minus, Minus) => (-*other) - (-*self)
}
}
}
impl Mul<BigInt, BigInt> for BigInt {
forward_all_binop!(impl Mul for BigInt, mul)
impl<'a, 'b> Mul<&'b BigInt, BigInt> for &'a BigInt {
#[inline]
fn mul(&self, other: &BigInt) -> BigInt {
fn mul(self, other: &BigInt) -> BigInt {
match (self.sign, other.sign) {
(NoSign, _) | (_, NoSign) => Zero::zero(),
(Plus, Plus) | (Minus, Minus) => {
BigInt::from_biguint(Plus, self.data * other.data)
BigInt::from_biguint(Plus, &self.data * &other.data)
},
(Plus, Minus) | (Minus, Plus) => {
BigInt::from_biguint(Minus, self.data * other.data)
BigInt::from_biguint(Minus, &self.data * &other.data)
}
}
}
}
impl Div<BigInt, BigInt> for BigInt {
forward_all_binop!(impl Div for BigInt, div)
impl<'a, 'b> Div<&'b BigInt, BigInt> for &'a BigInt {
#[inline]
fn div(&self, other: &BigInt) -> BigInt {
fn div(self, other: &BigInt) -> BigInt {
let (q, _) = self.div_rem(other);
q
}
}
impl Rem<BigInt, BigInt> for BigInt {
forward_all_binop!(impl Rem for BigInt, rem)
impl<'a, 'b> Rem<&'b BigInt, BigInt> for &'a BigInt {
#[inline]
fn rem(&self, other: &BigInt) -> BigInt {
fn rem(self, other: &BigInt) -> BigInt {
let (_, r) = self.div_rem(other);
r
}
@ -1131,19 +1221,24 @@ impl Integer for BigInt {
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() {
(Plus, Minus) | (NoSign, Minus) => {
if m.is_zero() {
(-d, Zero::zero())
} else {
(-d - One::one(), m + *other)
(-d - one, m + other)
}
},
(Minus, Plus) => if m.is_zero() {
(Minus, Plus) => {
if m.is_zero() {
(-d, Zero::zero())
} else {
(-d - One::one(), *other - m)
},
(-d - one, other - m)
}
}
(Minus, Minus) => (d, -m)
}
}
@ -1374,7 +1469,7 @@ impl<R: Rng> RandBigInt for R {
ubound: &BigUint)
-> BigUint {
assert!(*lbound < *ubound);
return *lbound + self.gen_biguint_below(&(*ubound - *lbound));
return lbound + self.gen_biguint_below(&(ubound - lbound));
}
fn gen_bigint_range(&mut self,
@ -1382,8 +1477,8 @@ impl<R: Rng> RandBigInt for R {
ubound: &BigInt)
-> BigInt {
assert!(*lbound < *ubound);
let delta = (*ubound - *lbound).to_biguint().unwrap();
return *lbound + self.gen_biguint_below(&delta).to_bigint().unwrap();
let delta = (ubound - lbound).to_biguint().unwrap();
return lbound + self.gen_biguint_below(&delta).to_bigint().unwrap();
}
}
@ -1912,8 +2007,8 @@ mod biguint_tests {
let b = BigUint::from_slice(b_vec);
let c = BigUint::from_slice(c_vec);
assert!(a + b == c);
assert!(b + a == c);
assert!(&a + &b == c);
assert!(&b + &a == c);
}
}
@ -1925,8 +2020,8 @@ mod biguint_tests {
let b = BigUint::from_slice(b_vec);
let c = BigUint::from_slice(c_vec);
assert!(c - a == b);
assert!(c - b == a);
assert!(&c - &a == b);
assert!(&c - &b == a);
}
}
@ -1983,8 +2078,8 @@ mod biguint_tests {
let b = BigUint::from_slice(b_vec);
let c = BigUint::from_slice(c_vec);
assert!(a * b == c);
assert!(b * a == c);
assert!(&a * &b == c);
assert!(&b * &a == c);
}
for elm in DIV_REM_QUADRUPLES.iter() {
@ -1994,8 +2089,8 @@ mod biguint_tests {
let c = BigUint::from_slice(c_vec);
let d = BigUint::from_slice(d_vec);
assert!(a == b * c + d);
assert!(a == c * b + d);
assert!(a == &b * &c + &d);
assert!(a == &c * &b + &d);
}
}
@ -2078,8 +2173,8 @@ mod biguint_tests {
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);
assert!(a == b.checked_mul(&c).unwrap() + &d);
assert!(a == c.checked_mul(&b).unwrap() + &d);
}
}
@ -2149,8 +2244,8 @@ mod biguint_tests {
assert!(thousand.is_even());
assert!(big.is_even());
assert!(bigger.is_odd());
assert!((one << 64).is_even());
assert!(((one << 64) + one).is_odd());
assert!((&one << 64).is_even());
assert!(((&one << 64) + one).is_odd());
}
fn to_str_pairs() -> Vec<(BigUint, Vec<(uint, String)>)> {
@ -2252,7 +2347,8 @@ mod biguint_tests {
for i in range(2, n + 1) {
// FIXME(#5992): assignment operator overloads
// f *= FromPrimitive::from_uint(i);
f = f * FromPrimitive::from_uint(i).unwrap();
let bu: BigUint = FromPrimitive::from_uint(i).unwrap();
f = f * bu;
}
return f;
}
@ -2513,14 +2609,14 @@ mod bigint_tests {
let b = BigInt::from_slice(Plus, b_vec);
let c = BigInt::from_slice(Plus, c_vec);
assert!(a + b == c);
assert!(b + a == c);
assert!(c + (-a) == b);
assert!(c + (-b) == a);
assert!(a + (-c) == (-b));
assert!(b + (-c) == (-a));
assert!(&a + &b == c);
assert!(&b + &a == c);
assert!(&c + (-a) == b);
assert!(&c + (-b) == a);
assert!(&a + (-c) == (-b));
assert!(&b + (-c) == (-a));
assert!((-a) + (-b) == (-c))
assert!(a + (-a) == Zero::zero());
assert!(&a + (-a) == Zero::zero());
}
}
@ -2532,14 +2628,14 @@ mod bigint_tests {
let b = BigInt::from_slice(Plus, b_vec);
let c = BigInt::from_slice(Plus, c_vec);
assert!(c - a == b);
assert!(c - b == a);
assert!((-b) - a == (-c))
assert!((-a) - b == (-c))
assert!(b - (-a) == c);
assert!(a - (-b) == c);
assert!(&c - &a == b);
assert!(&c - &b == a);
assert!((-b) - &a == (-c))
assert!((-a) - &b == (-c))
assert!(&b - (-a) == c);
assert!(&a - (-b) == c);
assert!((-c) - (-a) == (-b));
assert!(a - a == Zero::zero());
assert!(&a - &a == Zero::zero());
}
}
@ -2589,11 +2685,11 @@ mod bigint_tests {
let b = BigInt::from_slice(Plus, b_vec);
let c = BigInt::from_slice(Plus, c_vec);
assert!(a * b == c);
assert!(b * a == c);
assert!(&a * &b == c);
assert!(&b * &a == c);
assert!((-a) * b == -c);
assert!((-b) * a == -c);
assert!((-a) * &b == -c);
assert!((-b) * &a == -c);
}
for elm in DIV_REM_QUADRUPLES.iter() {
@ -2603,8 +2699,8 @@ mod bigint_tests {
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);
assert!(a == &b * &c + &d);
assert!(a == &c * &b + &d);
}
}
@ -2616,7 +2712,7 @@ mod bigint_tests {
assert_eq!(m.sign, b.sign);
}
assert!(m.abs() <= b.abs());
assert!(*a == (*b) * d + m);
assert!(*a == b * &d + &m);
assert!(d == *ans_d);
assert!(m == *ans_m);
}
@ -2628,9 +2724,10 @@ mod bigint_tests {
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::one()), &(*m - *b));
check_sub(&a.neg(), b, &(d.neg() - One::one()), &(*b - *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());
}
}
@ -2667,7 +2764,7 @@ mod bigint_tests {
assert_eq!(r.sign, a.sign);
}
assert!(r.abs() <= b.abs());
assert!(*a == (*b) * q + r);
assert!(*a == b * &q + &r);
assert!(q == *ans_q);
assert!(r == *ans_r);
}
@ -2761,8 +2858,8 @@ mod bigint_tests {
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);
assert!(a == b.checked_mul(&c).unwrap() + &d);
assert!(a == c.checked_mul(&b).unwrap() + &d);
}
}
#[test]
@ -2943,7 +3040,8 @@ mod bench {
fn factorial(n: uint) -> BigUint {
let mut f: BigUint = One::one();
for i in iter::range_inclusive(1, n) {
f = f * FromPrimitive::from_uint(i).unwrap();
let bu: BigUint = FromPrimitive::from_uint(i).unwrap();
f = f * bu;
}
f
}
@ -2952,7 +3050,7 @@ mod bench {
let mut f0: BigUint = Zero::zero();
let mut f1: BigUint = One::one();
for _ in range(0, n) {
let f2 = f0 + f1;
let f2 = f0 + &f1;
f0 = replace(&mut f1, f2);
}
f0

111
src/complex.rs
View File

@ -43,7 +43,7 @@ impl<T: Clone + Num> Complex<T> {
/// have a sqrt function), i.e. `re^2 + im^2`.
#[inline]
pub fn norm_sqr(&self) -> T {
self.re * self.re + self.im * self.im
self.re.clone() * self.re.clone() + self.im.clone() * self.im.clone()
}
@ -57,21 +57,21 @@ impl<T: Clone + Num> Complex<T> {
/// Multiplies `self` by the scalar `t`.
#[inline]
pub fn scale(&self, t: T) -> Complex<T> {
Complex::new(self.re * t, self.im * t)
Complex::new(self.re.clone() * t.clone(), self.im.clone() * t)
}
/// Divides `self` by the scalar `t`.
#[inline]
pub fn unscale(&self, t: T) -> Complex<T> {
Complex::new(self.re / t, self.im / t)
Complex::new(self.re.clone() / t.clone(), self.im.clone() / t)
}
/// Returns `1/self`
#[inline]
pub fn inv(&self) -> Complex<T> {
let norm_sqr = self.norm_sqr();
Complex::new(self.re / norm_sqr,
-self.im / norm_sqr)
Complex::new(self.re.clone() / norm_sqr.clone(),
-self.im.clone() / norm_sqr)
}
}
@ -79,7 +79,7 @@ impl<T: Clone + FloatMath> Complex<T> {
/// Calculate |self|
#[inline]
pub fn norm(&self) -> T {
self.re.hypot(self.im)
self.re.clone().hypot(self.im.clone())
}
}
@ -87,7 +87,7 @@ impl<T: Clone + FloatMath + Num> Complex<T> {
/// Calculate the principal Arg of self.
#[inline]
pub fn arg(&self) -> T {
self.im.atan2(self.re)
self.im.clone().atan2(self.re.clone())
}
/// Convert to polar form (r, theta), such that `self = r * exp(i
/// * theta)`
@ -102,38 +102,91 @@ impl<T: Clone + FloatMath + Num> Complex<T> {
}
}
/* arithmetic */
// (a + i b) + (c + i d) == (a + c) + i (b + d)
impl<T: Clone + Num> Add<Complex<T>, Complex<T>> for Complex<T> {
macro_rules! forward_val_val_binop {
(impl $imp:ident, $method:ident) => {
impl<T: Clone + Num> $imp<Complex<T>, Complex<T>> for Complex<T> {
#[inline]
fn add(&self, other: &Complex<T>) -> Complex<T> {
Complex::new(self.re + other.re, self.im + other.im)
fn $method(self, other: Complex<T>) -> Complex<T> {
(&self).$method(&other)
}
}
// (a + i b) - (c + i d) == (a - c) + i (b - d)
impl<T: Clone + Num> Sub<Complex<T>, Complex<T>> for Complex<T> {
#[inline]
fn sub(&self, other: &Complex<T>) -> Complex<T> {
Complex::new(self.re - other.re, self.im - other.im)
}
}
// (a + i b) * (c + i d) == (a*c - b*d) + i (a*d + b*c)
impl<T: Clone + Num> Mul<Complex<T>, Complex<T>> for Complex<T> {
#[inline]
fn mul(&self, other: &Complex<T>) -> Complex<T> {
Complex::new(self.re*other.re - self.im*other.im,
self.re*other.im + self.im*other.re)
}
}
macro_rules! forward_ref_val_binop {
(impl $imp:ident, $method:ident) => {
impl<'a, T: Clone + Num> $imp<Complex<T>, Complex<T>> for &'a Complex<T> {
#[inline]
fn $method(self, other: Complex<T>) -> Complex<T> {
self.$method(&other)
}
}
}
}
macro_rules! forward_val_ref_binop {
(impl $imp:ident, $method:ident) => {
impl<'a, T: Clone + Num> $imp<&'a Complex<T>, Complex<T>> for Complex<T> {
#[inline]
fn $method(self, other: &Complex<T>) -> Complex<T> {
(&self).$method(other)
}
}
}
}
macro_rules! forward_all_binop {
(impl $imp:ident, $method:ident) => {
forward_val_val_binop!(impl $imp, $method)
forward_ref_val_binop!(impl $imp, $method)
forward_val_ref_binop!(impl $imp, $method)
};
}
/* arithmetic */
forward_all_binop!(impl Add, add)
// (a + i b) + (c + i d) == (a + c) + i (b + d)
impl<'a, 'b, T: Clone + Num> Add<&'b Complex<T>, Complex<T>> for &'a Complex<T> {
#[inline]
fn add(self, other: &Complex<T>) -> Complex<T> {
Complex::new(self.re.clone() + other.re.clone(),
self.im.clone() + other.im.clone())
}
}
forward_all_binop!(impl Sub, sub)
// (a + i b) - (c + i d) == (a - c) + i (b - d)
impl<'a, 'b, T: Clone + Num> Sub<&'b Complex<T>, Complex<T>> for &'a Complex<T> {
#[inline]
fn sub(self, other: &Complex<T>) -> Complex<T> {
Complex::new(self.re.clone() - other.re.clone(),
self.im.clone() - other.im.clone())
}
}
forward_all_binop!(impl Mul, mul)
// (a + i b) * (c + i d) == (a*c - b*d) + i (a*d + b*c)
impl<'a, 'b, T: Clone + Num> Mul<&'b Complex<T>, Complex<T>> for &'a Complex<T> {
#[inline]
fn mul(self, other: &Complex<T>) -> Complex<T> {
Complex::new(self.re.clone() * other.re.clone() - self.im.clone() * other.im.clone(),
self.re.clone() * other.im.clone() + self.im.clone() * other.re.clone())
}
}
forward_all_binop!(impl Div, div)
// (a + i b) / (c + i d) == [(a + i b) * (c - i d)] / (c*c + d*d)
// == [(a*c + b*d) / (c*c + d*d)] + i [(b*c - a*d) / (c*c + d*d)]
impl<T: Clone + Num> Div<Complex<T>, Complex<T>> for Complex<T> {
impl<'a, 'b, T: Clone + Num> Div<&'b Complex<T>, Complex<T>> for &'a Complex<T> {
#[inline]
fn div(&self, other: &Complex<T>) -> Complex<T> {
fn div(self, other: &Complex<T>) -> Complex<T> {
let norm_sqr = other.norm_sqr();
Complex::new((self.re*other.re + self.im*other.im) / norm_sqr,
(self.im*other.re - self.re*other.im) / norm_sqr)
Complex::new((self.re.clone() * other.re.clone() + self.im.clone() * other.im.clone()) / norm_sqr.clone(),
(self.im.clone() * other.re.clone() - self.re.clone() * other.im.clone()) / norm_sqr)
}
}

16
src/integer.rs
View File

@ -134,9 +134,7 @@ pub trait Integer: Num + PartialOrd
/// assert_eq!((-1i).div_rem(&-2), ( 0, -1));
/// ~~~
#[inline]
fn div_rem(&self, other: &Self) -> (Self, Self) {
(*self / *other, *self % *other)
}
fn div_rem(&self, other: &Self) -> (Self, Self);
/// Simultaneous floored integer division and modulus.
/// Returns `(quotient, remainder)`.
@ -253,6 +251,12 @@ macro_rules! impl_integer_for_int {
/// Returns `true` if the number is not divisible by `2`
#[inline]
fn is_odd(&self) -> bool { !self.is_even() }
/// Simultaneous truncated integer division and modulus.
#[inline]
fn div_rem(&self, other: &$T) -> ($T, $T) {
(*self / *other, *self % *other)
}
}
#[cfg(test)]
@ -425,6 +429,12 @@ macro_rules! impl_integer_for_uint {
/// Returns `true` if the number is not divisible by `2`.
#[inline]
fn is_odd(&self) -> bool { !(*self).is_even() }
/// Simultaneous truncated integer division and modulus.
#[inline]
fn div_rem(&self, other: &$T) -> ($T, $T) {
(*self / *other, *self % *other)
}
}
#[cfg(test)]

10
src/iter.rs
View File

@ -45,7 +45,7 @@ impl<A: Add<A, A> + PartialOrd + Clone + ToPrimitive> Iterator<A> for Range<A> {
fn next(&mut self) -> Option<A> {
if self.state < self.stop {
let result = self.state.clone();
self.state = self.state + self.one;
self.state = self.state.clone() + self.one.clone();
Some(result)
} else {
None
@ -91,7 +91,7 @@ impl<A: Integer + PartialOrd + Clone + ToPrimitive> DoubleEndedIterator<A> for R
#[inline]
fn next_back(&mut self) -> Option<A> {
if self.stop > self.state {
self.stop = self.stop - self.one;
self.stop = self.stop.clone() - self.one.clone();
Some(self.stop.clone())
} else {
None
@ -151,7 +151,7 @@ impl<A: Sub<A, A> + Integer + PartialOrd + Clone + ToPrimitive> DoubleEndedItera
fn next_back(&mut self) -> Option<A> {
if self.range.stop > self.range.state {
let result = self.range.stop.clone();
self.range.stop = self.range.stop - self.range.one;
self.range.stop = self.range.stop.clone() - self.range.one.clone();
Some(result)
} else if !self.done && self.range.state == self.range.stop {
self.done = true;
@ -246,7 +246,7 @@ mod tests {
}
impl Add<Foo, Foo> for Foo {
fn add(&self, _: &Foo) -> Foo {
fn add(self, _: Foo) -> Foo {
Foo
}
}
@ -270,7 +270,7 @@ mod tests {
}
impl Mul<Foo, Foo> for Foo {
fn mul(&self, _: &Foo) -> Foo {
fn mul(self, _: Foo) -> Foo {
Foo
}
}

8
src/lib.rs
View File

@ -28,7 +28,7 @@
//! let mut approx = start.clone();
//!
//! for _ in range(0, iterations) {
//! approx = (approx + (start / approx)) /
//! approx = (&approx + (&start / &approx)) /
//! Ratio::from_integer(FromPrimitive::from_u64(2).unwrap());
//! }
//!
@ -123,15 +123,15 @@ pub fn abs_sub<T: Signed>(x: T, y: T) -> T {
/// assert_eq!(num::pow(2i, 4), 16);
/// ```
#[inline]
pub fn pow<T: One + Mul<T, T>>(mut base: T, mut exp: uint) -> T {
pub fn pow<T: Clone + One + Mul<T, T>>(mut base: T, mut exp: uint) -> T {
if exp == 1 { base }
else {
let mut acc = one::<T>();
while exp > 0 {
if (exp & 1) == 1 {
acc = acc * base;
acc = acc * base.clone();
}
base = base * base;
base = base.clone() * base;
exp = exp >> 1;
}
acc

111
src/rational.rs
View File

@ -92,10 +92,10 @@ impl<T: Clone + Integer + PartialOrd>
// FIXME(#5992): assignment operator overloads
// self.numer /= g;
self.numer = self.numer / g;
self.numer = self.numer.clone() / g.clone();
// FIXME(#5992): assignment operator overloads
// self.denom /= g;
self.denom = self.denom / g;
self.denom = self.denom.clone() / g;
// keep denom positive!
if self.denom < Zero::zero() {
@ -121,9 +121,10 @@ impl<T: Clone + Integer + PartialOrd>
#[inline]
pub fn floor(&self) -> Ratio<T> {
if *self < Zero::zero() {
Ratio::from_integer((self.numer - self.denom + One::one()) / self.denom)
let one: T = One::one();
Ratio::from_integer((self.numer.clone() - self.denom.clone() + one) / self.denom.clone())
} else {
Ratio::from_integer(self.numer / self.denom)
Ratio::from_integer(self.numer.clone() / self.denom.clone())
}
}
@ -131,9 +132,10 @@ impl<T: Clone + Integer + PartialOrd>
#[inline]
pub fn ceil(&self) -> Ratio<T> {
if *self < Zero::zero() {
Ratio::from_integer(self.numer / self.denom)
Ratio::from_integer(self.numer.clone() / self.denom.clone())
} else {
Ratio::from_integer((self.numer + self.denom - One::one()) / self.denom)
let one: T = One::one();
Ratio::from_integer((self.numer.clone() + self.denom.clone() - one) / self.denom.clone())
}
}
@ -141,7 +143,7 @@ impl<T: Clone + Integer + PartialOrd>
#[inline]
pub fn round(&self) -> Ratio<T> {
let one: T = One::one();
let two: T = one + one;
let two: T = one.clone() + one.clone();
// Find unsigned fractional part of rational number
let fractional = self.fract().abs();
@ -150,16 +152,17 @@ impl<T: Clone + Integer + PartialOrd>
// is, a/b >= 1/2, or a >= b/2. For odd denominators, we use
// a >= (b/2)+1. This avoids overflow issues.
let half_or_larger = if fractional.denom().is_even() {
*fractional.numer() >= *fractional.denom() / two
*fractional.numer() >= fractional.denom().clone() / two.clone()
} else {
*fractional.numer() >= (*fractional.denom() / two) + one
*fractional.numer() >= (fractional.denom().clone() / two.clone()) + one.clone()
};
if half_or_larger {
let one: Ratio<T> = One::one();
if *self >= Zero::zero() {
self.trunc() + One::one()
self.trunc() + one
} else {
self.trunc() - One::one()
self.trunc() - one
}
} else {
self.trunc()
@ -169,13 +172,13 @@ impl<T: Clone + Integer + PartialOrd>
/// Rounds towards zero.
#[inline]
pub fn trunc(&self) -> Ratio<T> {
Ratio::from_integer(self.numer / self.denom)
Ratio::from_integer(self.numer.clone() / self.denom.clone())
}
/// Returns the fractional part of a number.
#[inline]
pub fn fract(&self) -> Ratio<T> {
Ratio::new_raw(self.numer % self.denom, self.denom.clone())
Ratio::new_raw(self.numer.clone() % self.denom.clone(), self.denom.clone())
}
}
@ -212,11 +215,11 @@ macro_rules! cmp_impl {
};
// return something other than a Ratio<T>
(impl $imp:ident, $($method:ident -> $res:ty),*) => {
impl<T: Mul<T,T> + $imp> $imp for Ratio<T> {
impl<T: Clone + Mul<T,T> + $imp> $imp for Ratio<T> {
$(
#[inline]
fn $method(&self, other: &Ratio<T>) -> $res {
(self.numer * other.denom). $method (&(self.denom*other.numer))
(self.numer.clone() * other.denom.clone()). $method (&(self.denom.clone()*other.numer.clone()))
}
)*
}
@ -228,34 +231,78 @@ cmp_impl!(impl PartialOrd, lt -> bool, gt -> bool, le -> bool, ge -> bool,
cmp_impl!(impl Eq, )
cmp_impl!(impl Ord, cmp -> cmp::Ordering)
/* Arithmetic */
// a/b * c/d = (a*c)/(b*d)
impl<T: Clone + Integer + PartialOrd>
Mul<Ratio<T>,Ratio<T>> for Ratio<T> {
macro_rules! forward_val_val_binop {
(impl $imp:ident, $method:ident) => {
impl<T: Clone + Integer + PartialOrd> $imp<Ratio<T>, Ratio<T>> for Ratio<T> {
#[inline]
fn mul(&self, rhs: &Ratio<T>) -> Ratio<T> {
Ratio::new(self.numer * rhs.numer, self.denom * rhs.denom)
fn $method(self, other: Ratio<T>) -> Ratio<T> {
(&self).$method(&other)
}
}
}
}
// (a/b) / (c/d) = (a*d)/(b*c)
impl<T: Clone + Integer + PartialOrd>
Div<Ratio<T>,Ratio<T>> for Ratio<T> {
macro_rules! forward_ref_val_binop {
(impl $imp:ident, $method:ident) => {
impl<'a, T: Clone + Integer + PartialOrd> $imp<Ratio<T>, Ratio<T>> for &'a Ratio<T> {
#[inline]
fn div(&self, rhs: &Ratio<T>) -> Ratio<T> {
Ratio::new(self.numer * rhs.denom, self.denom * rhs.numer)
fn $method(self, other: Ratio<T>) -> Ratio<T> {
self.$method(&other)
}
}
}
}
macro_rules! forward_val_ref_binop {
(impl $imp:ident, $method:ident) => {
impl<'a, T: Clone + Integer + PartialOrd> $imp<&'a Ratio<T>, Ratio<T>> for Ratio<T> {
#[inline]
fn $method(self, other: &Ratio<T>) -> Ratio<T> {
(&self).$method(other)
}
}
}
}
macro_rules! forward_all_binop {
(impl $imp:ident, $method:ident) => {
forward_val_val_binop!(impl $imp, $method)
forward_ref_val_binop!(impl $imp, $method)
forward_val_ref_binop!(impl $imp, $method)
};
}
/* Arithmetic */
forward_all_binop!(impl Mul, mul)
// a/b * c/d = (a*c)/(b*d)
impl<'a, 'b, T: Clone + Integer + PartialOrd>
Mul<&'b Ratio<T>, Ratio<T>> for &'a Ratio<T> {
#[inline]
fn mul(self, rhs: &Ratio<T>) -> Ratio<T> {
Ratio::new(self.numer.clone() * rhs.numer.clone(), self.denom.clone() * rhs.denom.clone())
}
}
forward_all_binop!(impl Div, div)
// (a/b) / (c/d) = (a*d)/(b*c)
impl<'a, 'b, T: Clone + Integer + PartialOrd>
Div<&'b Ratio<T>, Ratio<T>> for &'a Ratio<T> {
#[inline]
fn div(self, rhs: &Ratio<T>) -> Ratio<T> {
Ratio::new(self.numer.clone() * rhs.denom.clone(), self.denom.clone() * rhs.numer.clone())
}
}
// Abstracts the a/b `op` c/d = (a*d `op` b*d) / (b*d) pattern
macro_rules! arith_impl {
(impl $imp:ident, $method:ident) => {
impl<T: Clone + Integer + PartialOrd>
$imp<Ratio<T>,Ratio<T>> for Ratio<T> {
forward_all_binop!(impl $imp, $method)
impl<'a, 'b, T: Clone + Integer + PartialOrd>
$imp<&'b Ratio<T>,Ratio<T>> for &'a Ratio<T> {
#[inline]
fn $method(&self, rhs: &Ratio<T>) -> Ratio<T> {
Ratio::new((self.numer * rhs.denom).$method(&(self.denom * rhs.numer)),
self.denom * rhs.denom)
fn $method(self, rhs: &Ratio<T>) -> Ratio<T> {
Ratio::new((self.numer.clone() * rhs.denom.clone()).$method(self.denom.clone() * rhs.numer.clone()),
self.denom.clone() * rhs.denom.clone())
}
}
}
@ -312,7 +359,7 @@ impl<T: Clone + Integer + PartialOrd>
#[inline]
fn abs_sub(&self, other: &Ratio<T>) -> Ratio<T> {
if *self <= *other { Zero::zero() } else { *self - *other }
if *self <= *other { Zero::zero() } else { self - other }
}
#[inline]