Rewrite all tests

Author: termoshtt

src/generate.rs

@@ -19,6 +19,16 @@ pub fn conjugate<A, Si, So>(a: &ArrayBase<Si, Ix2>) -> ArrayBase<So, Ix2>
     a
 }
 
+pub fn random<A, S, Sh, D>(sh: Sh) -> ArrayBase<S, D>
+    where A: RandNormal,
+          S: DataOwned<Elem = A>,
+          D: Dimension,
+          Sh: ShapeBuilder<Dim = D>
+{
+    let mut rng = thread_rng();
+    ArrayBase::from_shape_fn(sh, |_| A::randn(&mut rng))
+}
+
 /// Random vector
 pub fn random_vector<A, S>(n: usize) -> ArrayBase<S, Ix1>
     where A: RandNormal,

tests/inv.rs

@@ -1,36 +1,33 @@
 
-macro_rules! impl_test{
-    ($modname:ident, $clone:ident) => {
-mod $modname {
-    use super::random_square;
-    use ndarray::*;
-    use ndarray_linalg::*;
-    #[test]
-    fn inv_random() {
-        let a = random_square(3);
-        let ai = a.$clone().inv().unwrap();
-        let id = Array::eye(3);
-        assert_close_l2!(&ai.dot(&a), &id, 1e-7);
-    }
+extern crate ndarray;
+#[macro_use]
+extern crate ndarray_linalg;
+extern crate num_traits;
 
-    #[test]
-    fn inv_random_t() {
-        let a = random_square(3).reversed_axes();
-        let ai = a.$clone().inv().unwrap();
-        let id = Array::eye(3);
-        assert_close_l2!(&ai.dot(&a), &id, 1e-7);
-    }
+use ndarray::*;
+use ndarray_linalg::*;
 
-    #[test]
-    #[should_panic]
-    fn inv_error() {
-        // do not have inverse
-        let a = Array::<f64, _>::zeros(9).into_shape((3, 3)).unwrap();
-        let a_inv = a.$clone().inv().unwrap();
-        println!("{:?}", a_inv);
-    }
+#[test]
+fn inv_random() {
+    let a: Array2<f64> = random((3, 3));
+    let ai: Array2<_> = (&a).inv().unwrap();
+    let id = Array::eye(3);
+    assert_close_l2!(&ai.dot(&a), &id, 1e-7);
 }
-}} // impl_test
 
-impl_test!(owned, clone);
-impl_test!(shared, to_shared);
+#[test]
+fn inv_random_t() {
+    let a: Array2<f64> = random((3, 3).f());
+    let ai: Array2<_> = (&a).inv().unwrap();
+    let id = Array::eye(3);
+    assert_close_l2!(&ai.dot(&a), &id, 1e-7);
+}
+
+#[test]
+#[should_panic]
+fn inv_error() {
+    // do not have inverse
+    let a = Array::<f64, _>::zeros(9).into_shape((3, 3)).unwrap();
+    let a_inv = a.inv().unwrap();
+    println!("{:?}", a_inv);
+}

tests/normalize.rs

@@ -1,14 +1,22 @@
 
+extern crate ndarray;
+#[macro_use]
+extern crate ndarray_linalg;
+extern crate num_traits;
+
+use ndarray::*;
+use ndarray_linalg::*;
+
 #[test]
 fn n_columns() {
-    let a = random_owned(3, 2, true);
+    let a: Array2<f64> = random((3, 2));
     let (n, v) = normalize(a.clone(), NormalizeAxis::Column);
     assert_close_l2!(&n.dot(&from_diag(&v)), &a, 1e-7);
 }
 
 #[test]
 fn n_rows() {
-    let a = random_owned(3, 2, true);
+    let a: Array2<f64> = random((3, 2));
     let (n, v) = normalize(a.clone(), NormalizeAxis::Row);
     assert_close_l2!(&from_diag(&v).dot(&n), &a, 1e-7);
 }

tests/opnorm.rs

@@ -1,40 +1,57 @@
 
-macro_rules! impl_test {
-    ($funcname:ident, $a:expr, $op1:expr, $opi:expr, $opf:expr) => {
-#[test]
-fn $funcname() {
-    let a = $a;
+extern crate ndarray;
+#[macro_use]
+extern crate ndarray_linalg;
+extern crate num_traits;
+
+use ndarray::*;
+use ndarray_linalg::*;
+use num_traits::Float;
+
+fn test(a: Array2<f64>, one: f64, inf: f64, fro: f64) {
     println!("ONE = {:?}", a.opnorm_one());
     println!("INF = {:?}", a.opnorm_inf());
     println!("FRO = {:?}", a.opnorm_fro());
-    assert_rclose!(a.opnorm_fro().unwrap(), $opf, 1e-7; "Frobenius norm");
-    assert_rclose!(a.opnorm_one().unwrap(), $op1, 1e-7; "One norm");
-    assert_rclose!(a.opnorm_inf().unwrap(), $opi, 1e-7; "Infinity norm");
-}
-}} // impl_test
-
-macro_rules! impl_test_opnorm {
-    ($modname:ident, $array:ty, $range:path) => {
-mod $modname {
-    use ndarray::*;
-    use ndarray_linalg::*;
-    use num_traits::Float;
-    fn gen(i: usize, j: usize, rev: bool) -> $array {
-        let n = (i * j + 1) as f64;
-        if rev {
-            $range(1., n, 1.).into_shape((j, i)).unwrap().reversed_axes()
-        } else {
-            $range(1., n, 1.).into_shape((i, j)).unwrap()
-        }
+    assert_rclose!(a.opnorm_one().unwrap(), one, 1e-7; "One norm");
+    assert_rclose!(a.opnorm_inf().unwrap(), inf, 1e-7; "Infinity norm");
+    assert_rclose!(a.opnorm_fro().unwrap(), fro, 1e-7; "Frobenius norm");
+}
+
+fn gen(i: usize, j: usize, rev: bool) -> Array2<f64> {
+    let n = (i * j + 1) as f64;
+    if rev {
+        Array::range(1., n, 1.).into_shape((j, i)).unwrap().reversed_axes()
+    } else {
+        Array::range(1., n, 1.).into_shape((i, j)).unwrap()
     }
-    impl_test!(opnorm_square, gen(3, 3, false), 18.0, 24.0, 285.0.sqrt());
-    impl_test!(opnorm_square_t, gen(3, 3, true), 24.0, 18.0, 285.0.sqrt());
-    impl_test!(opnorm_3x4, gen(3, 4, false), 24.0, 42.0, 650.0.sqrt());
-    impl_test!(opnorm_4x3_t, gen(4, 3, true), 42.0, 24.0, 650.0.sqrt());
-    impl_test!(opnorm_3x4_t, gen(3, 4, true), 33.0, 30.0, 650.0.sqrt());
-    impl_test!(opnorm_4x3, gen(4, 3, false), 30.0, 33.0, 650.0.sqrt());
 }
-}} // impl_test_opnorm
 
-impl_test_opnorm!(owned, Array<f64, Ix2>, Array::range);
-impl_test_opnorm!(shared, RcArray<f64, Ix2>, RcArray::range);
+#[test]
+fn opnorm_square() {
+    test(gen(3, 3, false), 18.0, 24.0, 285.0.sqrt());
+}
+
+#[test]
+fn opnorm_square_t() {
+    test(gen(3, 3, true), 24.0, 18.0, 285.0.sqrt());
+}
+
+#[test]
+fn opnorm_3x4() {
+    test(gen(3, 4, false), 24.0, 42.0, 650.0.sqrt());
+}
+
+#[test]
+fn opnorm_3x4_t() {
+    test(gen(3, 4, true), 33.0, 30.0, 650.0.sqrt());
+}
+
+#[test]
+fn opnorm_4x3() {
+    test(gen(4, 3, false), 30.0, 33.0, 650.0.sqrt());
+}
+
+#[test]
+fn opnorm_4x3_t() {
+    test(gen(4, 3, true), 42.0, 24.0, 650.0.sqrt());
+}

tests/qr.rs

@@ -1,34 +1,57 @@
 
-macro_rules! impl_test {
-    ($funcname:ident, $random:path, $n:expr, $m:expr, $t:expr) => {
-#[test]
-fn $funcname() {
-    use std::cmp::min;
-    use ndarray::*;
-    use ndarray_linalg::*;
-    let a = $random($n, $m, $t);
+extern crate ndarray;
+#[macro_use]
+extern crate ndarray_linalg;
+extern crate num_traits;
+
+use std::cmp::min;
+use ndarray::*;
+use ndarray_linalg::*;
+use num_traits::Float;
+
+fn test(a: Array2<f64>, n: usize, m: usize) {
     let ans = a.clone();
     println!("a = \n{:?}", &a);
-    let (q, r) : (Array2<_>, Array2<_>) = a.qr().unwrap();
+    let (q, r): (Array2<_>, Array2<_>) = a.qr().unwrap();
     println!("q = \n{:?}", &q);
     println!("r = \n{:?}", &r);
-    assert_close_l2!(&q.t().dot(&q), &Array::eye(min($n, $m)), 1e-7);
+    assert_close_l2!(&q.t().dot(&q), &Array::eye(min(n, m)), 1e-7);
     assert_close_l2!(&q.dot(&r), &ans, 1e-7);
     assert_close_l2!(&drop_lower(r.clone()), &r, 1e-7);
 }
-}} // impl_test
-
-macro_rules! impl_test_qr {
-    ($modname:ident, $random:path) => {
-mod $modname {
-    impl_test!(qr_square, $random, 3, 3, false);
-    impl_test!(qr_square_t, $random, 3, 3, true);
-    impl_test!(qr_3x4, $random, 3, 4, false);
-    impl_test!(qr_3x4_t, $random, 3, 4, true);
-    impl_test!(qr_4x3, $random, 4, 3, false);
-    impl_test!(qr_4x3_t, $random, 4, 3, true);
+
+#[test]
+fn qr_square() {
+    let a = random((3, 3));
+    test(a, 3, 3);
+}
+
+#[test]
+fn qr_square_t() {
+    let a = random((3, 3).f());
+    test(a, 3, 3);
 }
-}} // impl_test_qr
 
-impl_test_qr!(owned, super::random_owned);
-impl_test_qr!(shared, super::random_shared);
+#[test]
+fn qr_3x4() {
+    let a = random((3, 4));
+    test(a, 3, 4);
+}
+
+#[test]
+fn qr_3x4_t() {
+    let a = random((3, 4).f());
+    test(a, 3, 4);
+}
+
+#[test]
+fn qr_4x3() {
+    let a = random((4, 3));
+    test(a, 4, 3);
+}
+
+#[test]
+fn qr_4x3_t() {
+    let a = random((4, 3).f());
+    test(a, 4, 3);
+}

tests/svd.rs

@@ -1,12 +1,15 @@
 
-macro_rules! impl_test {
-    ($funcname:ident, $random:path, $n:expr, $m:expr, $t:expr) => {
-#[test]
-fn $funcname() {
-    use std::cmp::min;
-    use ndarray::*;
-    use ndarray_linalg::*;
-    let a = $random($n, $m, $t);
+extern crate ndarray;
+#[macro_use]
+extern crate ndarray_linalg;
+extern crate num_traits;
+
+use std::cmp::min;
+use ndarray::*;
+use ndarray_linalg::*;
+use num_traits::Float;
+
+fn test(a: Array2<f64>, n: usize, m: usize) {
     let answer = a.clone();
     println!("a = \n{:?}", &a);
     let (u, s, vt): (_, Array1<_>, _) = a.svd(true, true).unwrap();
@@ -15,25 +18,45 @@ fn $funcname() {
     println!("u = \n{:?}", &u);
     println!("s = \n{:?}", &s);
     println!("v = \n{:?}", &vt);
-    let mut sm = Array::zeros(($n, $m));
-    for i in 0..min($n, $m) {
+    let mut sm = Array::zeros((n, m));
+    for i in 0..min(n, m) {
         sm[(i, i)] = s[i];
     }
     assert_close_l2!(&u.dot(&sm).dot(&vt), &answer, 1e-7);
 }
-}} // impl_test
-
-macro_rules! impl_test_svd {
-    ($modname:ident, $random:path) => {
-mod $modname {
-    impl_test!(svd_square, $random, 3, 3, false);
-    impl_test!(svd_square_t, $random, 3, 3, true);
-    impl_test!(svd_4x3, $random, 4, 3, false);
-    impl_test!(svd_4x3_t, $random, 4, 3, true);
-    impl_test!(svd_3x4, $random, 3, 4, false);
-    impl_test!(svd_3x4_t, $random, 3, 4, true);
+
+#[test]
+fn svd_square() {
+    let a = random((3, 3));
+    test(a, 3, 3);
+}
+
+#[test]
+fn svd_square_t() {
+    let a = random((3, 3).f());
+    test(a, 3, 3);
 }
-}} // impl_test_svd
 
-impl_test_svd!(owned, super::random_owned);
-impl_test_svd!(shared, super::random_shared);
+#[test]
+fn svd_3x4() {
+    let a = random((3, 4));
+    test(a, 3, 4);
+}
+
+#[test]
+fn svd_3x4_t() {
+    let a = random((3, 4).f());
+    test(a, 3, 4);
+}
+
+#[test]
+fn svd_4x3() {
+    let a = random((4, 3));
+    test(a, 4, 3);
+}
+
+#[test]
+fn svd_4x3_t() {
+    let a = random((4, 3).f());
+    test(a, 4, 3);
+}

tests/trace.rs

@@ -1,7 +1,12 @@
 
+extern crate ndarray;
+extern crate ndarray_linalg;
+
+use ndarray::*;
+use ndarray_linalg::*;
+
 #[test]
 fn trace() {
-    let r_dist = RealNormal::new(0., 1.);
-    let a = Array::<f64, _>::random((3, 3), r_dist);
+    let a: Array2<f64> = random((3, 3));
     assert_rclose!(a.trace().unwrap(), a[(0, 0)] + a[(1, 1)] + a[(2, 2)], 1e-7);
 }

tests/vector.rs

@@ -1,4 +1,13 @@
 
+extern crate ndarray;
+#[macro_use]
+extern crate ndarray_linalg;
+extern crate num_traits;
+
+use ndarray::*;
+use ndarray_linalg::*;
+use num_traits::Float;
+
 #[test]
 fn vector_norm() {
     let a = Array::range(1., 10., 1.);