Merge pull request #31 from termoshtt/assert

termoshtt · web-flow · commit e0219a178fe6 · 2017-05-26T02:27:41.000+09:00
Assertion for tests
diff --git a/Cargo.toml b/Cargo.toml
@@ -15,11 +15,12 @@ openblas = ["blas/openblas", "lapack/openblas"]
 netlib   = ["blas/netlib", "lapack/netlib"]
 
 [dependencies]
-num-traits = "0.1"
+num-traits  = "0.1"
+num-complex = "0.1"
 ndarray = { version = "0.9",  default-features = false, features = ["blas"] }
 lapack  = { version = "0.11", default-features = false }
 blas    = { version = "0.15", default-features = false }
 
 [dev-dependencies]
-ndarray-rand    = "0.5"
-ndarray-numtest = "0.2"
+ndarray-rand = "0.5"
+rand-extra   = "0.1"
diff --git a/src/assert.rs b/src/assert.rs
@@ -0,0 +1,78 @@
+//! Assertions for array
+
+use std::iter::Sum;
+use num_traits::Float;
+use ndarray::*;
+
+use super::vector::*;
+
+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) }
+}
+
+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 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>,
+          S2: Data<Elem = A>,
+          D: Dimension
+{
+    let tol = (test - truth).norm_max();
+    if tol < atol { Ok(tol) } else { Err(tol) }
+}
+
+/// check two arrays are close in L1 norm
+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>,
+          S2: Data<Elem = A>,
+          D: Dimension
+{
+    let tol = (test - truth).norm_l1() / truth.norm_l1();
+    if tol < rtol { Ok(tol) } else { Err(tol) }
+}
+
+/// check two arrays are close in L2 norm
+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>,
+          S2: Data<Elem = A>,
+          D: Dimension
+{
+    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/src/lib.rs b/src/lib.rs
@@ -34,6 +34,7 @@
 extern crate blas;
 extern crate lapack;
 extern crate num_traits;
+extern crate num_complex;
 #[macro_use(s)]
 extern crate ndarray;
 
@@ -47,4 +48,5 @@ pub mod hermite;
 pub mod triangular;
 
 pub mod util;
+pub mod assert;
 pub mod prelude;
diff --git a/src/prelude.rs b/src/prelude.rs
@@ -4,3 +4,4 @@ pub use square::SquareMatrix;
 pub use hermite::HermiteMatrix;
 pub use triangular::*;
 pub use util::*;
+pub use assert::*;
diff --git a/src/util.rs b/src/util.rs
@@ -53,7 +53,7 @@ pub enum NormalizeAxis {
 
 /// normalize in L2 norm
 pub fn normalize<A, S, T>(mut m: ArrayBase<S, Ix2>, axis: NormalizeAxis) -> (ArrayBase<S, Ix2>, Vec<T>)
-    where A: LinalgScalar + NormedField<Output = T> + Div<T, Output = A>,
+    where A: LinalgScalar + Absolute<Output = T> + Div<T, Output = A>,
           S: DataMut<Elem = A>,
           T: Float + Sum
 {
@@ -65,42 +65,3 @@ pub fn normalize<A, S, T>(mut m: ArrayBase<S, Ix2>, axis: NormalizeAxis) -> (Arr
     }
     (m, ms)
 }
-
-/// 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>
-    where A: LinalgScalar + NormedField<Output = Tol>,
-          Tol: Float + Sum,
-          S1: Data<Elem = A>,
-          S2: Data<Elem = A>,
-          D: Dimension
-{
-    let tol = (test - truth).norm_max();
-    if tol < atol { Ok(tol) } else { Err(tol) }
-}
-
-/// 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>
-    where A: LinalgScalar + NormedField<Output = Tol>,
-          Tol: Float + Sum,
-          S1: Data<Elem = A>,
-          S2: Data<Elem = A>,
-          D: Dimension
-{
-    let tol = (test - truth).norm_l1() / truth.norm_l1();
-    if tol < rtol { Ok(tol) } else { Err(tol) }
-}
-
-/// 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>
-    where A: LinalgScalar + NormedField<Output = Tol>,
-          Tol: Float + Sum,
-          S1: Data<Elem = A>,
-          S2: Data<Elem = A>,
-          D: Dimension
-{
-    let tol = (test - truth).norm_l2() / truth.norm_l2();
-    if tol < rtol { Ok(tol) } else { Err(tol) }
-}
diff --git a/src/vector.rs b/src/vector.rs
@@ -21,42 +21,42 @@ pub trait Norm {
 }
 
 impl<A, S, D, T> Norm for ArrayBase<S, D>
-    where A: LinalgScalar + NormedField<Output = T>,
+    where A: LinalgScalar + Absolute<Output = T>,
           T: Float + Sum,
           S: Data<Elem = A>,
           D: Dimension
 {
     type Output = T;
     fn norm_l1(&self) -> Self::Output {
-        self.iter().map(|x| x.norm()).sum()
+        self.iter().map(|x| x.abs()).sum()
     }
     fn norm_l2(&self) -> Self::Output {
-        self.iter().map(|x| x.squared()).sum::<T>().sqrt()
+        self.iter().map(|x| x.sq_abs()).sum::<T>().sqrt()
     }
     fn norm_max(&self) -> Self::Output {
         self.iter().fold(T::zero(), |f, &val| {
-            let v = val.norm();
+            let v = val.abs();
             if f > v { f } else { v }
         })
     }
 }
 
 /// Field with norm
-pub trait NormedField {
+pub trait Absolute {
     type Output: Float;
-    fn squared(&self) -> Self::Output;
-    fn norm(&self) -> Self::Output {
-        self.squared().sqrt()
+    fn sq_abs(&self) -> Self::Output;
+    fn abs(&self) -> Self::Output {
+        self.sq_abs().sqrt()
     }
 }
 
-impl<A: Float> NormedField for A {
+impl<A: Float> Absolute for A {
     type Output = A;
-    fn squared(&self) -> A {
+    fn sq_abs(&self) -> A {
         *self * *self
     }
-    fn norm(&self) -> A {
-        self.abs()
+    fn abs(&self) -> A {
+        Float::abs(*self)
     }
 }
 
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/det.rs b/tests/det.rs
@@ -5,14 +5,13 @@ macro_rules! impl_test{
 mod $modname {
     use super::random_hermite;
     use ndarray_linalg::prelude::*;
-    use ndarray_numtest::prelude::*;
     #[test]
     fn deth() {
         let a = random_hermite(3);
         let (e, _) = a.$clone().eigh().unwrap();
         let deth = a.$clone().deth().unwrap();
         let det_eig = e.iter().fold(1.0, |x, y| x * y);
-        deth.assert_close(det_eig, 1.0e-7);
+        assert_rclose!(deth, det_eig, 1.0e-7);
     }
 }
 }} // impl_test
diff --git a/tests/eigh.rs b/tests/eigh.rs
@@ -5,16 +5,15 @@ macro_rules! impl_test {
 mod $modname {
     use ndarray::prelude::*;
     use ndarray_linalg::prelude::*;
-    use ndarray_numtest::prelude::*;
     #[test]
     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]
@@ -23,7 +22,7 @@ mod $modname {
         let (e, vecs) = a.$clone().eigh().unwrap();
         let s = vecs.t().dot(&a).dot(&vecs);
         for i in 0..3 {
-            e[i].assert_close(s[(i, i)], 1e-7);
+            assert_rclose!(e[i], s[(i, i)], 1e-7);
         }
     }
 }
diff --git a/tests/header.rs b/tests/header.rs
@@ -1,16 +1,18 @@
 
+extern crate rand_extra;
 extern crate ndarray;
 extern crate ndarray_rand;
+#[macro_use]
+#[allow(unused_imports)]
 extern crate ndarray_linalg;
-extern crate ndarray_numtest;
 extern crate num_traits;
 
 #[allow(unused_imports)]
 use ndarray::*;
 #[allow(unused_imports)]
 use ndarray_linalg::prelude::*;
 #[allow(unused_imports)]
-use ndarray_numtest::prelude::*;
+use rand_extra::*;
 #[allow(unused_imports)]
 use ndarray_rand::RandomExt;
 #[allow(unused_imports)]
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/opnorm.rs b/tests/opnorm.rs
@@ -5,9 +5,9 @@ macro_rules! impl_test {
 #[test]
 fn $funcname() {
     let a = $a;
-    a.opnorm_1().assert_close($op1, 1e-7);
-    a.opnorm_i().assert_close($opi, 1e-7);
-    a.opnorm_f().assert_close($opf, 1e-7);
+    assert_rclose!(a.opnorm_1(), $op1, 1e-7);
+    assert_rclose!(a.opnorm_i(), $opi, 1e-7);
+    assert_rclose!(a.opnorm_f(), $opf, 1e-7);
 }
 }} // impl_test
 
@@ -16,7 +16,6 @@ macro_rules! impl_test_opnorm {
 mod $modname {
     use ndarray::prelude::*;
     use ndarray_linalg::prelude::*;
-    use ndarray_numtest::prelude::*;
     use num_traits::Float;
     fn gen(i: usize, j: usize, rev: bool) -> $array {
         let n = (i * j + 1) as f64;
diff --git a/tests/outer.rs b/tests/outer.rs
@@ -14,7 +14,7 @@ fn outer_3x4() {
     println!("ab = \n{:?}", &ab);
     for i in 0..m {
         for j in 0..n {
-            ab[(i, j)].assert_close(a[i] * b[j], 1e-7);
+            assert_rclose!(ab[(i, j)], a[i] * b[j], 1e-7);
         }
     }
 }
@@ -32,7 +32,7 @@ fn outer_4x3() {
     println!("ab = \n{:?}", &ab);
     for i in 0..m {
         for j in 0..n {
-            ab[(i, j)].assert_close(a[i] * b[j], 1e-7);
+            assert_rclose!(ab[(i, j)], a[i] * b[j], 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
diff --git a/tests/ssqrt.rs b/tests/ssqrt.rs
diff --git a/tests/svd.rs b/tests/svd.rs
diff --git a/tests/trace.rs b/tests/trace.rs
diff --git a/tests/triangular.rs b/tests/triangular.rs
diff --git a/tests/vector.rs b/tests/vector.rs

Original file line number	Diff line number	Diff line change
`@@ -21,42 +21,42 @@ pub trait Norm {`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`impl<A, S, D, T> Norm for ArrayBase<S, D>`
`24`		`- where A: LinalgScalar + NormedField<Output = T>,`
	`24`	`+ where A: LinalgScalar + Absolute<Output = T>,`
`25`	`25`	`T: Float + Sum,`
`26`	`26`	`S: Data<Elem = A>,`
`27`	`27`	`D: Dimension`
`28`	`28`	`{`
`29`	`29`	`type Output = T;`
`30`	`30`	`fn norm_l1(&self) -> Self::Output {`
`31`		`- self.iter().map(\|x\| x.norm()).sum()`
	`31`	`+ self.iter().map(\|x\| x.abs()).sum()`
`32`	`32`	`}`
`33`	`33`	`fn norm_l2(&self) -> Self::Output {`
`34`		`- self.iter().map(\|x\| x.squared()).sum::<T>().sqrt()`
	`34`	`+ self.iter().map(\|x\| x.sq_abs()).sum::<T>().sqrt()`
`35`	`35`	`}`
`36`	`36`	`fn norm_max(&self) -> Self::Output {`
`37`	`37`	`self.iter().fold(T::zero(), \|f, &val\| {`
`38`		`- let v = val.norm();`
	`38`	`+ let v = val.abs();`
`39`	`39`	`if f > v { f } else { v }`
`40`	`40`	`})`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`/// Field with norm`
`45`		`-pub trait NormedField {`
	`45`	`+pub trait Absolute {`
`46`	`46`	`type Output: Float;`
`47`		`- fn squared(&self) -> Self::Output;`
`48`		`- fn norm(&self) -> Self::Output {`
`49`		`- self.squared().sqrt()`
	`47`	`+ fn sq_abs(&self) -> Self::Output;`
	`48`	`+ fn abs(&self) -> Self::Output {`
	`49`	`+ self.sq_abs().sqrt()`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`
`53`		`-impl<A: Float> NormedField for A {`
	`53`	`+impl<A: Float> Absolute for A {`
`54`	`54`	`type Output = A;`
`55`		`- fn squared(&self) -> A {`
	`55`	`+ fn sq_abs(&self) -> A {`
`56`	`56`	`self *self`
`57`	`57`	`}`
`58`		`- fn norm(&self) -> A {`
`59`		`- self.abs()`
	`58`	`+ fn abs(&self) -> A {`
	`59`	`+ Float::abs(*self)`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`
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
`@@ -5,16 +5,15 @@ macro_rules! impl_test {`
`5`	`5`	`mod $modname {`
`6`	`6`	`use ndarray::prelude::*;`
`7`	`7`	`use ndarray_linalg::prelude::*;`
`8`		`- use ndarray_numtest::prelude::*;`
`9`	`8`	`#[test]`
`10`	`9`	`fn eigen_vector_manual() {`
`11`	`10`	`let a = arr2(&[[3.0, 1.0, 1.0], [1.0, 3.0, 1.0], [1.0, 1.0, 3.0]]);`
`12`	`11`	`let (e, vecs) = a.$clone().eigh().unwrap();`
`13`		`- 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);`
`14`	`13`	`for (i, v) in vecs.axis_iter(Axis(1)).enumerate() {`
`15`	`14`	`let av = a.dot(&v);`
`16`	`15`	`let ev = v.mapv(\|x\| e[i] * x);`
`17`		`- all_close_l2(&av, &ev, 1.0e-7).unwrap();`
	`16`	`+ assert_close_l2!(&av, &ev, 1.0e-7);`
`18`	`17`	`}`
`19`	`18`	`}`
`20`	`19`	`#[test]`
`@@ -23,7 +22,7 @@ mod $modname {`
`23`	`22`	`let (e, vecs) = a.$clone().eigh().unwrap();`
`24`	`23`	`let s = vecs.t().dot(&a).dot(&vecs);`
`25`	`24`	`for i in 0..3 {`
`26`		`- e[i].assert_close(s[(i, i)], 1e-7);`
	`25`	`+ assert_rclose!(e[i], s[(i, i)], 1e-7);`
`27`	`26`	`}`
`28`	`27`	`}`
`29`	`28`	`}`