Merge pull request #30 from gifnksm/master

Add numeric functions and traits that provide numeric traits for generic mathematics.

Author: alexcrichton

benches/shootout-pidigits.rs

@@ -41,15 +41,12 @@
 extern crate num;
 extern crate test;
 
-use std::from_str::FromStr;
-use std::num::One;
-use std::num::Zero;
+use std::str::FromStr;
 use std::num::FromPrimitive;
 
 use test::Bencher;
 
-use num::Integer;
-use num::bigint::BigInt;
+use num::{BigInt, Integer, One, Zero};
 
 struct Context {
     numer: BigInt,

src/bigint.rs

@@ -19,8 +19,7 @@
 //! ## Example
 //!
 //! ```rust
-//! use num::bigint::BigUint;
-//! use std::num::{Zero, One};
+//! use num::{BigUint, Zero, One};
 //! use std::mem::replace;
 //!
 //! // Calculate large fibonacci numbers.
@@ -61,14 +60,14 @@ use rand::Rng;
 
 use std::{cmp, fmt, hash};
 use std::default::Default;
-use std::from_str::FromStr;
-use std::num::CheckedDiv;
-use std::num::{ToPrimitive, FromPrimitive};
-use std::num::{Zero, One, FromStrRadix};
-use std::str;
-use std::string::String;
+use std::iter::{AdditiveIterator, MultiplicativeIterator};
+use std::num::{Int, ToPrimitive, FromPrimitive};
+use std::num::FromStrRadix;
+use std::str::{mod, FromStr};
 use std::{i64, u64};
 
+use {Num, Unsigned, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv, Signed, Zero, One};
+
 /// A `BigDigit` is a `BigUint`'s composing element.
 pub type BigDigit = u32;
 
@@ -739,6 +738,20 @@ impl FromStrRadix for BigUint {
     }
 }
 
+impl<T: Iterator<BigUint>> AdditiveIterator<BigUint> for T {
+    fn sum(&mut self) -> BigUint {
+        let init: BigUint = Zero::zero();
+        self.fold(init, |acc, x| acc + x)
+    }
+}
+
+impl<T: Iterator<BigUint>> MultiplicativeIterator<BigUint> for T {
+    fn product(&mut self) -> BigUint {
+        let init: BigUint = One::one();
+        self.fold(init, |acc, x| acc * x)
+    }
+}
+
 impl BigUint {
     /// Creates and initializes a `BigUint`.
     ///
@@ -1084,7 +1097,6 @@ impl CheckedDiv for BigInt {
     }
 }
 
-
 impl Integer for BigInt {
     #[inline]
     fn div_rem(&self, other: &BigInt) -> (BigInt, BigInt) {
@@ -1374,6 +1386,20 @@ impl<R: Rng> RandBigInt for R {
     }
 }
 
+impl<T: Iterator<BigInt>> AdditiveIterator<BigInt> for T {
+    fn sum(&mut self) -> BigInt {
+        let init: BigInt = Zero::zero();
+        self.fold(init, |acc, x| acc + x)
+    }
+}
+
+impl<T: Iterator<BigInt>> MultiplicativeIterator<BigInt> for T {
+    fn product(&mut self) -> BigInt {
+        let init: BigInt = One::one();
+        self.fold(init, |acc, x| acc * x)
+    }
+}
+
 impl BigInt {
     /// Creates and initializes a BigInt.
     ///
@@ -1416,6 +1442,29 @@ impl BigInt {
             Minus => None
         }
     }
+
+    #[inline]
+    pub fn checked_add(&self, v: &BigInt) -> Option<BigInt> {
+        return Some(self.add(v));
+    }
+
+    #[inline]
+    pub fn checked_sub(&self, v: &BigInt) -> Option<BigInt> {
+        return Some(self.sub(v));
+    }
+
+    #[inline]
+    pub fn checked_mul(&self, v: &BigInt) -> Option<BigInt> {
+        return Some(self.mul(v));
+    }
+
+    #[inline]
+    pub fn checked_div(&self, v: &BigInt) -> Option<BigInt> {
+        if v.is_zero() {
+            return None;
+        }
+        return Some(self.div(v));
+    }
 }
 
 #[cfg(test)]
@@ -1425,15 +1474,16 @@ mod biguint_tests {
     use super::{Plus, BigInt, RandBigInt, ToBigInt};
 
     use std::cmp::{Less, Equal, Greater};
-    use std::from_str::FromStr;
+    use std::str::FromStr;
     use std::i64;
-    use std::num::{Zero, One, FromStrRadix};
+    use std::num::FromStrRadix;
     use std::num::{ToPrimitive, FromPrimitive};
-    use std::num::CheckedDiv;
     use std::rand::task_rng;
     use std::u64;
     use std::hash::hash;
 
+    use {Zero, One, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv};
+
     #[test]
     fn test_from_slice() {
         fn check(slice: &[BigDigit], data: &[BigDigit]) {
@@ -2289,13 +2339,14 @@ mod bigint_tests {
 
     use std::cmp::{Less, Equal, Greater};
     use std::i64;
-    use std::num::CheckedDiv;
-    use std::num::{Zero, One, FromStrRadix};
+    use std::num::FromStrRadix;
     use std::num::{ToPrimitive, FromPrimitive};
     use std::rand::task_rng;
     use std::u64;
     use std::hash::hash;
 
+    use {Zero, One, Signed};
+
     #[test]
     fn test_from_biguint() {
         fn check(inp_s: Sign, inp_n: uint, ans_s: Sign, ans_n: uint) {
@@ -2882,7 +2933,9 @@ mod bench {
     use super::BigUint;
     use std::iter;
     use std::mem::replace;
-    use std::num::{FromPrimitive, Zero, One};
+    use std::num::FromPrimitive;
+
+    use {Zero, One};
 
     fn factorial(n: uint) -> BigUint {
         let mut f: BigUint = One::one();

src/complex.rs

@@ -12,7 +12,10 @@
 //! Complex numbers.
 
 use std::fmt;
-use std::num::{Zero, One};
+use std::num::FloatMath;
+use std::iter::{AdditiveIterator, MultiplicativeIterator};
+
+use {Zero, One, Num};
 
 // FIXME #1284: handle complex NaN & infinity etc. This
 // probably doesn't map to C's _Complex correctly.
@@ -80,7 +83,7 @@ impl<T: Clone + FloatMath> Complex<T> {
     }
 }
 
-impl<T: Clone + FloatMath> Complex<T> {
+impl<T: Clone + FloatMath + Num> Complex<T> {
     /// Calculate the principal Arg of self.
     #[inline]
     pub fn arg(&self) -> T {
@@ -172,14 +175,30 @@ impl<T: fmt::Show + Num + PartialOrd> fmt::Show for Complex<T> {
     }
 }
 
+impl<A: Clone + Num, T: Iterator<Complex<A>>> AdditiveIterator<Complex<A>> for T {
+    fn sum(&mut self) -> Complex<A> {
+        let init: Complex<A> = Zero::zero();
+        self.fold(init, |acc, x| acc + x)
+    }
+}
+
+impl<A: Clone + Num, T: Iterator<Complex<A>>> MultiplicativeIterator<Complex<A>> for T {
+    fn product(&mut self) -> Complex<A> {
+        let init: Complex<A> = One::one();
+        self.fold(init, |acc, x| acc * x)
+    }
+}
+
 #[cfg(test)]
 mod test {
     #![allow(non_upper_case_globals)]
 
     use super::{Complex64, Complex};
-    use std::num::{Zero, One, Float};
+    use std::num::Float;
     use std::hash::hash;
 
+    use {Zero, One};
+
     pub const _0_0i : Complex64 = Complex { re: 0.0, im: 0.0 };
     pub const _1_0i : Complex64 = Complex { re: 1.0, im: 0.0 };
     pub const _1_1i : Complex64 = Complex { re: 1.0, im: 1.0 };
@@ -280,7 +299,7 @@ mod test {
 
     mod arith {
         use super::{_0_0i, _1_0i, _1_1i, _0_1i, _neg1_1i, _05_05i, all_consts};
-        use std::num::Zero;
+        use Zero;
 
         #[test]
         fn test_add() {

src/integer.rs

@@ -10,6 +10,8 @@
 
 //! Integer trait and functions.
 
+use {Num, Signed};
+
 pub trait Integer: Num + PartialOrd
                  + Div<Self, Self>
                  + Rem<Self, Self> {