Add assert_close_{l1,l2,max}

termoshtt · termoshtt · commit 69c94ff9d7c2 · 2017-05-26T02:21:58.000+09:00
diff --git a/src/assert.rs b/src/assert.rs
@@ -6,61 +6,24 @@ use ndarray::*;
 
 use super::vector::*;
 
-pub trait Close: Absolute {
-    fn rclose(self, truth: Self, relative_tol: Self::Output) -> Result<Self::Output, Self::Output>;
-    fn aclose(self, truth: Self, absolute_tol: Self::Output) -> Result<Self::Output, Self::Output>;
-}
-
-macro_rules! impl_AssertClose {
-    ($scalar:ty) => {
-impl Close for $scalar {
-    fn rclose(self, truth: Self, rtol: Self::Output) -> Result<Self::Output, Self::Output> {
-        let dev = (self - truth).abs() / truth.abs();
-        if dev < rtol {
-            Ok(dev)
-        } else {
-            Err(dev)
-        }
-    }
-
-    fn aclose(self, truth: Self, atol: Self::Output) -> Result<Self::Output, Self::Output> {
-        let dev = (self - truth).abs();
-        if dev < atol {
-            Ok(dev)
-        } else {
-            Err(dev)
-        }
-    }
-}
-}} // impl_AssertClose
-impl_AssertClose!(f64);
-impl_AssertClose!(f32);
-
-#[macro_export]
-macro_rules! assert_rclose {
-    ($test:expr, $truth:expr, $tol:expr) => {
-        $test.rclose($truth, $tol).unwrap();
-    };
-    ($test:expr, $truth:expr, $tol:expr; $comment:expr) => {
-        $test.rclose($truth, $tol).expect($comment);
-    };
+pub fn rclose<A, Tol>(test: A, truth: A, rtol: Tol) -> Result<Tol, Tol>
+    where A: LinalgScalar + Absolute<Output = Tol>,
+          Tol: Float
+{
+    let dev = (test - truth).abs() / truth.abs();
+    if dev < rtol { Ok(dev) } else { Err(dev) }
 }
 
-#[macro_export]
-macro_rules! assert_aclose {
-    ($test:expr, $truth:expr, $tol:expr) => {
-        $test.aclose($truth, $tol).unwrap();
-    };
-    ($test:expr, $truth:expr, $tol:expr; $comment:expr) => {
-        $test.aclose($truth, $tol).expect($comment);
-    };
+pub fn aclose<A, Tol>(test: A, truth: A, atol: Tol) -> Result<Tol, Tol>
+    where A: LinalgScalar + Absolute<Output = Tol>,
+          Tol: Float
+{
+    let dev = (test - truth).abs();
+    if dev < atol { Ok(dev) } else { Err(dev) }
 }
 
 /// check two arrays are close in maximum norm
-pub fn all_close_max<A, Tol, S1, S2, D>(test: &ArrayBase<S1, D>,
-                                        truth: &ArrayBase<S2, D>,
-                                        atol: Tol)
-                                        -> Result<Tol, Tol>
+pub fn close_max<A, Tol, S1, S2, D>(test: &ArrayBase<S1, D>, truth: &ArrayBase<S2, D>, atol: Tol) -> Result<Tol, Tol>
     where A: LinalgScalar + Absolute<Output = Tol>,
           Tol: Float + Sum,
           S1: Data<Elem = A>,
@@ -72,7 +35,7 @@ pub fn all_close_max<A, Tol, S1, S2, D>(test: &ArrayBase<S1, D>,
 }
 
 /// check two arrays are close in L1 norm
-pub fn all_close_l1<A, Tol, S1, S2, D>(test: &ArrayBase<S1, D>, truth: &ArrayBase<S2, D>, rtol: Tol) -> Result<Tol, Tol>
+pub fn close_l1<A, Tol, S1, S2, D>(test: &ArrayBase<S1, D>, truth: &ArrayBase<S2, D>, rtol: Tol) -> Result<Tol, Tol>
     where A: LinalgScalar + Absolute<Output = Tol>,
           Tol: Float + Sum,
           S1: Data<Elem = A>,
@@ -84,7 +47,7 @@ pub fn all_close_l1<A, Tol, S1, S2, D>(test: &ArrayBase<S1, D>, truth: &ArrayBas
 }
 
 /// check two arrays are close in L2 norm
-pub fn all_close_l2<A, Tol, S1, S2, D>(test: &ArrayBase<S1, D>, truth: &ArrayBase<S2, D>, rtol: Tol) -> Result<Tol, Tol>
+pub fn close_l2<A, Tol, S1, S2, D>(test: &ArrayBase<S1, D>, truth: &ArrayBase<S2, D>, rtol: Tol) -> Result<Tol, Tol>
     where A: LinalgScalar + Absolute<Output = Tol>,
           Tol: Float + Sum,
           S1: Data<Elem = A>,
@@ -94,3 +57,22 @@ pub fn all_close_l2<A, Tol, S1, S2, D>(test: &ArrayBase<S1, D>, truth: &ArrayBas
     let tol = (test - truth).norm_l2() / truth.norm_l2();
     if tol < rtol { Ok(tol) } else { Err(tol) }
 }
+
+macro_rules! generate_assert {
+    ($assert:ident, $close:path) => {
+#[macro_export]
+macro_rules! $assert {
+    ($test:expr, $truth:expr, $tol:expr) => {
+        $close($test, $truth, $tol).unwrap();
+    };
+    ($test:expr, $truth:expr, $tol:expr; $comment:expr) => {
+        $close($test, $truth, $tol).expect($comment);
+    };
+}
+}} // generate_assert!
+
+generate_assert!(assert_rclose, rclose);
+generate_assert!(assert_aclose, aclose);
+generate_assert!(assert_close_max, close_max);
+generate_assert!(assert_close_l1, close_l1);
+generate_assert!(assert_close_l2, close_l2);
diff --git a/tests/cholesky.rs b/tests/cholesky.rs
@@ -12,7 +12,7 @@ mod $modname {
         let c = a.$clone().cholesky().unwrap();
         println!("c = \n{:?}", c);
         println!("cc = \n{:?}", c.t().dot(&c));
-        all_close_l2(&c.t().dot(&c), &a, 1e-7).unwrap();
+        assert_close_l2!(&c.t().dot(&c), &a, 1e-7);
     }
     #[test]
     fn cholesky_t() {
@@ -21,7 +21,7 @@ mod $modname {
         let c = a.$clone().cholesky().unwrap();
         println!("c = \n{:?}", c);
         println!("cc = \n{:?}", c.t().dot(&c));
-        all_close_l2(&c.t().dot(&c), &a, 1e-7).unwrap();
+        assert_close_l2!(&c.t().dot(&c), &a, 1e-7);
     }
 }
 }} // impl_test
diff --git a/tests/eigh.rs b/tests/eigh.rs
@@ -9,11 +9,11 @@ mod $modname {
     fn eigen_vector_manual() {
         let a = arr2(&[[3.0, 1.0, 1.0], [1.0, 3.0, 1.0], [1.0, 1.0, 3.0]]);
         let (e, vecs) = a.$clone().eigh().unwrap();
-        all_close_l2(&e, &arr1(&[2.0, 2.0, 5.0]), 1.0e-7).unwrap();
+        assert_close_l2!(&e, &arr1(&[2.0, 2.0, 5.0]), 1.0e-7);
         for (i, v) in vecs.axis_iter(Axis(1)).enumerate() {
             let av = a.dot(&v);
             let ev = v.mapv(|x| e[i] * x);
-            all_close_l2(&av, &ev, 1.0e-7).unwrap();
+            assert_close_l2!(&av, &ev, 1.0e-7);
         }
     }
     #[test]
diff --git a/tests/inv.rs b/tests/inv.rs
@@ -11,15 +11,15 @@ mod $modname {
         let a = random_square(3);
         let ai = a.$clone().inv().unwrap();
         let id = Array::eye(3);
-        all_close_l2(&ai.dot(&a), &id, 1e-7).unwrap();
+        assert_close_l2!(&ai.dot(&a), &id, 1e-7);
     }
 
     #[test]
     fn inv_random_t() {
         let a = random_square(3).reversed_axes();
         let ai = a.$clone().inv().unwrap();
         let id = Array::eye(3);
-        all_close_l2(&ai.dot(&a), &id, 1e-7).unwrap();
+        assert_close_l2!(&ai.dot(&a), &id, 1e-7);
     }
 
     #[test]
diff --git a/tests/lu.rs b/tests/lu.rs
@@ -12,7 +12,7 @@ fn $funcname() {
     println!("L = \n{:?}", &l);
     println!("U = \n{:?}", &u);
     println!("LU = \n{:?}", l.dot(&u));
-    all_close_l2(&l.dot(&u).permutated(&p), &ans, 1e-7).unwrap();
+    assert_close_l2!(&l.dot(&u).permutated(&p), &ans, 1e-7);
 }
 }} // impl_test
 
diff --git a/tests/normalize.rs b/tests/normalize.rs
@@ -4,12 +4,12 @@ include!("header.rs");
 fn n_columns() {
     let a = random_owned(3, 2, true);
     let (n, v) = normalize(a.clone(), NormalizeAxis::Column);
-    all_close_l2(&n.dot(&from_diag(&v)), &a, 1e-7).unwrap();
+    assert_close_l2!(&n.dot(&from_diag(&v)), &a, 1e-7);
 }
 
 #[test]
 fn n_rows() {
     let a = random_owned(3, 2, true);
     let (n, v) = normalize(a.clone(), NormalizeAxis::Row);
-    all_close_l2(&from_diag(&v).dot(&n), &a, 1e-7).unwrap();
+    assert_close_l2!(&from_diag(&v).dot(&n), &a, 1e-7);
 }
diff --git a/tests/permutate.rs b/tests/permutate.rs
@@ -10,7 +10,7 @@ fn $testname() {
     let p = $permutate; // replace 1-2
     let pa = a.permutated(&p);
     println!("permutated = \n{:?}", &pa);
-    all_close_l2(&pa, &$answer, 1e-7).unwrap();
+    assert_close_l2!(&pa, &$answer, 1e-7);
 }
 }} // impl_test
 
diff --git a/tests/qr.rs b/tests/qr.rs
@@ -13,9 +13,9 @@ fn $funcname() {
     let (q, r) = a.qr().unwrap();
     println!("q = \n{:?}", &q);
     println!("r = \n{:?}", &r);
-    all_close_l2(&q.t().dot(&q), &Array::eye(min($n, $m)), 1e-7).unwrap();
-    all_close_l2(&q.dot(&r), &ans, 1e-7).unwrap();
-    all_close_l2(&drop_lower(r.clone()), &r, 1e-7).unwrap();
+    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
 
diff --git a/tests/ssqrt.rs b/tests/ssqrt.rs
@@ -9,15 +9,15 @@ mod $modname {
     fn ssqrt() {
         let a = random_hermite(3);
         let ar = a.$clone().ssqrt().unwrap();
-        all_close_l2(&ar.clone().t(), &ar, 1e-7).expect("not symmetric");
-        all_close_l2(&ar.dot(&ar), &a, 1e-7).expect("not sqrt");
+        assert_close_l2!(&ar.clone().t(), &ar, 1e-7; "not symmetric");
+        assert_close_l2!(&ar.dot(&ar), &a, 1e-7; "not sqrt");
     }
     #[test]
     fn ssqrt_t() {
         let a = random_hermite(3).reversed_axes();
         let ar = a.$clone().ssqrt().unwrap();
-        all_close_l2(&ar.clone().t(), &ar, 1e-7).expect("not symmetric");
-        all_close_l2(&ar.dot(&ar), &a, 1e-7).expect("not sqrt");
+        assert_close_l2!(&ar.clone().t(), &ar, 1e-7; "not symmetric");
+        assert_close_l2!(&ar.dot(&ar), &a, 1e-7; "not sqrt");
     }
 }
 }} // impl_test
diff --git a/tests/svd.rs b/tests/svd.rs
@@ -18,7 +18,7 @@ fn $funcname() {
     for i in 0..min($n, $m) {
         sm[(i, i)] = s[i];
     }
-    all_close_l2(&u.dot(&sm).dot(&vt), &answer, 1e-7).unwrap();
+    assert_close_l2!(&u.dot(&sm).dot(&vt), &answer, 1e-7);
 }
 }} // impl_test
 
diff --git a/tests/triangular.rs b/tests/triangular.rs
@@ -17,7 +17,7 @@ mod $modname {
         let x = a.solve_upper(b.clone()).unwrap();
         println!("x = \n{:?}", &x);
         println!("Ax = \n{:?}", a.dot(&x));
-        all_close_l2(&a.dot(&x), &b, 1e-7).unwrap();
+        assert_close_l2!(&a.dot(&x), &b, 1e-7);
     }
 
     #[test]
@@ -30,7 +30,7 @@ mod $modname {
         let x = a.solve_upper(b.clone()).unwrap();
         println!("x = \n{:?}", &x);
         println!("Ax = \n{:?}", a.dot(&x));
-        all_close_l2(&a.dot(&x), &b, 1e-7).unwrap();
+        assert_close_l2!(&a.dot(&x), &b, 1e-7);
     }
 
     #[test]
@@ -43,7 +43,7 @@ mod $modname {
         let x = a.solve_lower(b.clone()).unwrap();
         println!("x = \n{:?}", &x);
         println!("Ax = \n{:?}", a.dot(&x));
-        all_close_l2(&a.dot(&x), &b, 1e-7).unwrap();
+        assert_close_l2!(&a.dot(&x), &b, 1e-7);
     }
 
     #[test]
@@ -56,7 +56,7 @@ mod $modname {
         let x = a.solve_lower(b.clone()).unwrap();
         println!("x = \n{:?}", &x);
         println!("Ax = \n{:?}", a.dot(&x));
-        all_close_l2(&a.dot(&x), &b, 1e-7).unwrap();
+        assert_close_l2!(&a.dot(&x), &b, 1e-7);
     }
 }
 }} // impl_test_opnorm
@@ -78,7 +78,7 @@ mod $modname {
         let x = a.$solve(&b).unwrap();
         println!("x = \n{:?}", &x);
         println!("Ax = \n{:?}", a.dot(&x));
-        all_close_l2(&a.dot(&x), &b, 1e-7).unwrap();
+        assert_close_l2!(&a.dot(&x), &b, 1e-7);
     }
     #[test]
     fn solve_tf() {
@@ -89,7 +89,7 @@ mod $modname {
         let x = a.$solve(&b).unwrap();
         println!("x = \n{:?}", &x);
         println!("Ax = \n{:?}", a.dot(&x));
-        all_close_l2(&a.dot(&x), &b, 1e-7).unwrap();
+        assert_close_l2!(&a.dot(&x), &b, 1e-7);
     }
     #[test]
     fn solve_ft() {
@@ -100,7 +100,7 @@ mod $modname {
         let x = a.$solve(&b).unwrap();
         println!("x = \n{:?}", &x);
         println!("Ax = \n{:?}", a.dot(&x));
-        all_close_l2(&a.dot(&x), &b, 1e-7).unwrap();
+        assert_close_l2!(&a.dot(&x), &b, 1e-7);
     }
     #[test]
     fn solve_ff() {
@@ -111,7 +111,7 @@ mod $modname {
         let x = a.$solve(&b).unwrap();
         println!("x = \n{:?}", &x);
         println!("Ax = \n{:?}", a.dot(&x));
-        all_close_l2(&a.dot(&x), &b, 1e-7).unwrap();
+        assert_close_l2!(&a.dot(&x), &b, 1e-7);
     }
 }
 }} // impl_test_2d

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ mod $modname {`
`12`	`12`	`let c = a.$clone().cholesky().unwrap();`
`13`	`13`	`println!("c = \n{:?}", c);`
`14`	`14`	`println!("cc = \n{:?}", c.t().dot(&c));`
`15`		`- all_close_l2(&c.t().dot(&c), &a, 1e-7).unwrap();`
	`15`	`+ assert_close_l2!(&c.t().dot(&c), &a, 1e-7);`
`16`	`16`	`}`
`17`	`17`	`#[test]`
`18`	`18`	`fn cholesky_t() {`
`@@ -21,7 +21,7 @@ mod $modname {`
`21`	`21`	`let c = a.$clone().cholesky().unwrap();`
`22`	`22`	`println!("c = \n{:?}", c);`
`23`	`23`	`println!("cc = \n{:?}", c.t().dot(&c));`
`24`		`- all_close_l2(&c.t().dot(&c), &a, 1e-7).unwrap();`
	`24`	`+ assert_close_l2!(&c.t().dot(&c), &a, 1e-7);`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`	`}} // impl_test`
Original file line number	Diff line number	Diff line change
`@@ -9,11 +9,11 @@ mod $modname {`
`9`	`9`	`fn eigen_vector_manual() {`
`10`	`10`	`let a = arr2(&[[3.0, 1.0, 1.0], [1.0, 3.0, 1.0], [1.0, 1.0, 3.0]]);`
`11`	`11`	`let (e, vecs) = a.$clone().eigh().unwrap();`
`12`		`- all_close_l2(&e, &arr1(&[2.0, 2.0, 5.0]), 1.0e-7).unwrap();`
	`12`	`+ assert_close_l2!(&e, &arr1(&[2.0, 2.0, 5.0]), 1.0e-7);`
`13`	`13`	`for (i, v) in vecs.axis_iter(Axis(1)).enumerate() {`
`14`	`14`	`let av = a.dot(&v);`
`15`	`15`	`let ev = v.mapv(\|x\| e[i] * x);`
`16`		`- all_close_l2(&av, &ev, 1.0e-7).unwrap();`
	`16`	`+ assert_close_l2!(&av, &ev, 1.0e-7);`
`17`	`17`	`}`
`18`	`18`	`}`
`19`	`19`	`#[test]`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ fn $funcname() {`
`12`	`12`	`println!("L = \n{:?}", &l);`
`13`	`13`	`println!("U = \n{:?}", &u);`
`14`	`14`	`println!("LU = \n{:?}", l.dot(&u));`
`15`		`- all_close_l2(&l.dot(&u).permutated(&p), &ans, 1e-7).unwrap();`
	`15`	`+ assert_close_l2!(&l.dot(&u).permutated(&p), &ans, 1e-7);`
`16`	`16`	`}`
`17`	`17`	`}} // impl_test`
`18`	`18`
Original file line number	Diff line number	Diff line change
`@@ -4,12 +4,12 @@ include!("header.rs");`
`4`	`4`	`fn n_columns() {`
`5`	`5`	`let a = random_owned(3, 2, true);`
`6`	`6`	`let (n, v) = normalize(a.clone(), NormalizeAxis::Column);`
`7`		`- all_close_l2(&n.dot(&from_diag(&v)), &a, 1e-7).unwrap();`
	`7`	`+ assert_close_l2!(&n.dot(&from_diag(&v)), &a, 1e-7);`
`8`	`8`	`}`
`9`	`9`
`10`	`10`	`#[test]`
`11`	`11`	`fn n_rows() {`
`12`	`12`	`let a = random_owned(3, 2, true);`
`13`	`13`	`let (n, v) = normalize(a.clone(), NormalizeAxis::Row);`
`14`		`- all_close_l2(&from_diag(&v).dot(&n), &a, 1e-7).unwrap();`
	`14`	`+ assert_close_l2!(&from_diag(&v).dot(&n), &a, 1e-7);`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ fn $testname() {`
`10`	`10`	`let p = $permutate; // replace 1-2`
`11`	`11`	`let pa = a.permutated(&p);`
`12`	`12`	`println!("permutated = \n{:?}", &pa);`
`13`		`- all_close_l2(&pa, &$answer, 1e-7).unwrap();`
	`13`	`+ assert_close_l2!(&pa, &$answer, 1e-7);`
`14`	`14`	`}`
`15`	`15`	`}} // impl_test`
`16`	`16`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ fn $funcname() {`
`18`	`18`	`for i in 0..min($n, $m) {`
`19`	`19`	`sm[(i, i)] = s[i];`
`20`	`20`	`}`
`21`		`- all_close_l2(&u.dot(&sm).dot(&vt), &answer, 1e-7).unwrap();`
	`21`	`+ assert_close_l2!(&u.dot(&sm).dot(&vt), &answer, 1e-7);`
`22`	`22`	`}`
`23`	`23`	`}} // impl_test`
`24`	`24`