Implementation of std::iter::{Product, Sum}

This is relative to the
[issue 4](#4). This is a
very simple implementation, based on two macros. Maybe a more elegant
solution is possible for these, feel free to suggest.

Two tests for both `BigInt` and `BigUInt` have been added, one relative
to the `Sum`, the other to the `Product`.

Author: dodomorandi

src/bigint.rs

@@ -6,6 +6,7 @@ use std::cmp::Ordering::{self, Less, Greater, Equal};
 use std::{i64, u64};
 #[allow(unused_imports)]
 use std::ascii::AsciiExt;
+use std::iter::{Product, Sum};
 
 #[cfg(feature = "serde")]
 use serde;
@@ -1779,6 +1780,9 @@ impl BigInt {
     }
 }
 
+impl_sum_iter_type!(BigInt);
+impl_product_iter_type!(BigInt);
+
 /// Perform in-place two's complement of the given binary representation,
 /// in little-endian byte order.
 #[inline]

src/biguint.rs

@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 use std::default::Default;
-use std::iter::repeat;
+use std::iter::{repeat, Product, Sum};
 use std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Neg, Rem, Shl, Shr, Sub,
                AddAssign, BitAndAssign, BitOrAssign, BitXorAssign, DivAssign,
                MulAssign, RemAssign, ShlAssign, ShrAssign, SubAssign};
@@ -1690,6 +1690,9 @@ pub fn trailing_zeros(u: &BigUint) -> Option<usize> {
         .map(|(i, digit)| i * big_digit::BITS + digit.trailing_zeros() as usize)
 }
 
+impl_sum_iter_type!(BigUint);
+impl_product_iter_type!(BigUint);
+
 #[cfg(feature = "serde")]
 impl serde::Serialize for BigUint {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

src/macros.rs

@@ -314,3 +314,45 @@ macro_rules! promote_all_scalars {
         promote_signed_scalars!(impl $imp for $res, $method);
     }
 }
+
+macro_rules! impl_sum_iter_type {
+    ($res:ty) => {
+        impl Sum for $res {
+            impl_sum_iter_type!($res, $res);
+        }
+
+        impl<'a> Sum<&'a $res> for $res {
+            impl_sum_iter_type!($res, &'a $res);
+        }
+    };
+
+    ($res:ty, $item:ty) => {
+        fn sum<I>(iter: I) -> Self
+        where
+            I: Iterator<Item = $item>
+        {
+            iter.fold(Zero::zero(), <$res>::add)
+        }
+    };
+}
+
+macro_rules! impl_product_iter_type {
+    ($res:ty) => {
+        impl Product for $res {
+            impl_product_iter_type!($res, $res);
+        }
+
+        impl<'a> Product<&'a $res> for $res {
+            impl_product_iter_type!($res, &'a $res);
+        }
+    };
+
+    ($res:ty, $item:ty) => {
+        fn product<I>(iter: I) -> Self
+        where
+            I: Iterator<Item = $item>
+        {
+            iter.fold(One::one(), <$res>::mul)
+        }
+    };
+}

src/tests/bigint.rs

@@ -1217,3 +1217,35 @@ fn test_random_shr() {
         }
     }
 }
+#[test]
+fn test_iter_sum() {
+    let result: BigInt = FromPrimitive::from_isize(-1234567).unwrap();
+    let data: Vec<BigInt> = vec![
+        FromPrimitive::from_i32(-1000000).unwrap(),
+        FromPrimitive::from_i32(-200000).unwrap(),
+        FromPrimitive::from_i32(-30000).unwrap(),
+        FromPrimitive::from_i32(-4000).unwrap(),
+        FromPrimitive::from_i32(-500).unwrap(),
+        FromPrimitive::from_i32(-60).unwrap(),
+        FromPrimitive::from_i32(-7).unwrap(),
+    ];
+
+    assert_eq!(result, data.iter().sum());
+    assert_eq!(result, data.into_iter().sum());
+}
+
+#[test]
+fn test_iter_product() {
+    let data: Vec<BigInt> = vec![
+        FromPrimitive::from_i32(1001).unwrap(),
+        FromPrimitive::from_i32(-1002).unwrap(),
+        FromPrimitive::from_i32(1003).unwrap(),
+        FromPrimitive::from_i32(-1004).unwrap(),
+        FromPrimitive::from_i32(1005).unwrap(),
+    ];
+    let result = data.get(0).unwrap() * data.get(1).unwrap() * data.get(2).unwrap()
+        * data.get(3).unwrap() * data.get(4).unwrap();
+
+    assert_eq!(result, data.iter().product());
+    assert_eq!(result, data.into_iter().product());
+}

src/tests/biguint.rs

@@ -1676,3 +1676,36 @@ fn test_mul_divide_torture() {
 fn test_mul_divide_torture_long() {
     test_mul_divide_torture_count(1000000);
 }
+
+#[test]
+fn test_iter_sum() {
+    let result: BigUint = FromPrimitive::from_isize(1234567).unwrap();
+    let data: Vec<BigUint> = vec![
+        FromPrimitive::from_u32(1000000).unwrap(),
+        FromPrimitive::from_u32(200000).unwrap(),
+        FromPrimitive::from_u32(30000).unwrap(),
+        FromPrimitive::from_u32(4000).unwrap(),
+        FromPrimitive::from_u32(500).unwrap(),
+        FromPrimitive::from_u32(60).unwrap(),
+        FromPrimitive::from_u32(7).unwrap(),
+    ];
+
+    assert_eq!(result, data.iter().sum());
+    assert_eq!(result, data.into_iter().sum());
+}
+
+#[test]
+fn test_iter_product() {
+    let data: Vec<BigUint> = vec![
+        FromPrimitive::from_u32(1001).unwrap(),
+        FromPrimitive::from_u32(1002).unwrap(),
+        FromPrimitive::from_u32(1003).unwrap(),
+        FromPrimitive::from_u32(1004).unwrap(),
+        FromPrimitive::from_u32(1005).unwrap(),
+    ];
+    let result = data.get(0).unwrap() * data.get(1).unwrap() * data.get(2).unwrap()
+        * data.get(3).unwrap() * data.get(4).unwrap();
+
+    assert_eq!(result, data.iter().product());
+    assert_eq!(result, data.into_iter().product());
+}