From 984cf2213d1012ad6c1b29190de6561792c2a34b Mon Sep 17 00:00:00 2001 From: Jim Turner Date: Fri, 11 Jan 2019 16:39:11 -0500 Subject: [PATCH 01/22] Implement approx traits for ArrayBase --- Cargo.toml | 1 + src/arraytraits.rs | 86 ++++++++++++++++++++++++++++++++++++++++++++++ src/lib.rs | 1 + tests/array.rs | 59 +++++++++++++++++++++++++++++++ 4 files changed, 147 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index 2f4f8bb0a..ccf4faf04 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -28,6 +28,7 @@ bench = false test = true [dependencies] +approx = "0.3" num-integer = "0.1.39" num-traits = "0.2" num-complex = "0.2" diff --git a/src/arraytraits.rs b/src/arraytraits.rs index 13b5ce6c8..91b163ad4 100644 --- a/src/arraytraits.rs +++ b/src/arraytraits.rs @@ -113,6 +113,92 @@ impl Eq for ArrayBase S::Elem: Eq, { } +impl approx::AbsDiffEq for ArrayBase +where + A: approx::AbsDiffEq, + A::Epsilon: Clone, + S: Data, + D: Dimension, +{ + type Epsilon = A::Epsilon; + + fn default_epsilon() -> A::Epsilon { + A::default_epsilon() + } + + fn abs_diff_eq(&self, other: &ArrayBase, epsilon: A::Epsilon) -> bool { + if self.shape() != other.shape() { + return false; + } + Zip::from(self) + .and(other) + .fold_while(true, |_, a, b| { + if A::abs_diff_ne(a, b, epsilon.clone()) { + FoldWhile::Done(false) + } else { + FoldWhile::Continue(true) + } + }) + .into_inner() + } +} + +impl approx::RelativeEq for ArrayBase +where + A: approx::RelativeEq, + A::Epsilon: Clone, + S: Data, + D: Dimension, +{ + fn default_max_relative() -> A::Epsilon { + A::default_max_relative() + } + + fn relative_eq(&self, other: &ArrayBase, epsilon: A::Epsilon, max_relative: A::Epsilon) -> bool { + if self.shape() != other.shape() { + return false; + } + Zip::from(self) + .and(other) + .fold_while(true, |_, a, b| { + if A::relative_ne(a, b, epsilon.clone(), max_relative.clone()) { + FoldWhile::Done(false) + } else { + FoldWhile::Continue(true) + } + }) + .into_inner() + } +} + +impl approx::UlpsEq for ArrayBase +where + A: approx::UlpsEq, + A::Epsilon: Clone, + S: Data, + D: Dimension, +{ + fn default_max_ulps() -> u32 { + A::default_max_ulps() + } + + fn ulps_eq(&self, other: &ArrayBase, epsilon: A::Epsilon, max_ulps: u32) -> bool { + if self.shape() != other.shape() { + return false; + } + Zip::from(self) + .and(other) + .fold_while(true, |_, a, b| { + if A::ulps_ne(a, b, epsilon.clone(), max_ulps) { + FoldWhile::Done(false) + } else { + FoldWhile::Continue(true) + } + }) + .into_inner() + } +} + impl FromIterator for ArrayBase where S: DataOwned { diff --git a/src/lib.rs b/src/lib.rs index d998be49f..5ab2656b4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -97,6 +97,7 @@ extern crate blas_src; extern crate matrixmultiply; +extern crate approx; extern crate itertools; extern crate num_traits; extern crate num_complex; diff --git a/tests/array.rs b/tests/array.rs index 28e2e7fbc..60f28f132 100644 --- a/tests/array.rs +++ b/tests/array.rs @@ -1,5 +1,6 @@ #![allow(non_snake_case)] +extern crate approx; extern crate ndarray; extern crate defmac; extern crate itertools; @@ -12,6 +13,10 @@ use ndarray::{ multislice, }; use ndarray::indices; +use approx::{ + assert_abs_diff_eq, assert_abs_diff_ne, assert_relative_eq, assert_relative_ne, assert_ulps_eq, + assert_ulps_ne, +}; use defmac::defmac; use itertools::{enumerate, zip}; @@ -1163,6 +1168,60 @@ fn equality() assert!(a != c); } +#[test] +fn abs_diff_eq() +{ + let a: Array2 = array![[0., 2.], [-0.000010001, 100000000.]]; + let mut b: Array2 = array![[0., 1.], [-0.000010002, 100000001.]]; + assert_abs_diff_ne!(a, b); + b[(0, 1)] = 2.; + assert_abs_diff_eq!(a, b); + + // Check epsilon. + assert_abs_diff_eq!(array![0.0f32], array![1e-40f32], epsilon = 1e-40f32); + assert_abs_diff_ne!(array![0.0f32], array![1e-40f32], epsilon = 1e-41f32); + + // Make sure we can compare different shapes without failure. + let c = array![[1., 2.]]; + assert_abs_diff_ne!(a, c); +} + +#[test] +fn relative_eq() +{ + let a: Array2 = array![[1., 2.], [-0.000010001, 100000000.]]; + let mut b: Array2 = array![[1., 1.], [-0.000010002, 100000001.]]; + assert_relative_ne!(a, b); + b[(0, 1)] = 2.; + assert_relative_eq!(a, b); + + // Check epsilon. + assert_relative_eq!(array![0.0f32], array![1e-40f32], epsilon = 1e-40f32); + assert_relative_ne!(array![0.0f32], array![1e-40f32], epsilon = 1e-41f32); + + // Make sure we can compare different shapes without failure. + let c = array![[1., 2.]]; + assert_relative_ne!(a, c); +} + +#[test] +fn ulps_eq() +{ + let a: Array2 = array![[1., 2.], [-0.000010001, 100000000.]]; + let mut b: Array2 = array![[1., 1.], [-0.000010002, 100000001.]]; + assert_ulps_ne!(a, b); + b[(0, 1)] = 2.; + assert_ulps_eq!(a, b); + + // Check epsilon. + assert_ulps_eq!(array![0.0f32], array![1e-40f32], epsilon = 1e-40f32); + assert_ulps_ne!(array![0.0f32], array![1e-40f32], epsilon = 1e-41f32); + + // Make sure we can compare different shapes without failure. + let c = array![[1., 2.]]; + assert_ulps_ne!(a, c); +} + #[test] fn map1() { From d06b9359f62afd666e28bdc0ceb5ddbf679db2db Mon Sep 17 00:00:00 2001 From: Jim Turner Date: Mon, 14 Jan 2019 15:07:45 -0500 Subject: [PATCH 02/22] Feature-gate approx trait implementations --- Cargo.toml | 5 +- src/array_approx.rs | 157 ++++++++++++++++++++++++++++++++++++++++++++ src/arraytraits.rs | 86 ------------------------ src/lib.rs | 9 ++- tests/array.rs | 59 ----------------- 5 files changed, 168 insertions(+), 148 deletions(-) create mode 100644 src/array_approx.rs diff --git a/Cargo.toml b/Cargo.toml index ccf4faf04..b1394aa75 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -28,7 +28,6 @@ bench = false test = true [dependencies] -approx = "0.3" num-integer = "0.1.39" num-traits = "0.2" num-complex = "0.2" @@ -36,6 +35,8 @@ itertools = { version = "0.7.0", default-features = false } rayon = { version = "1.0.3", optional = true } +approx = { version = "0.3", optional = true } + # Use via the `blas` crate feature! cblas-sys = { version = "0.1.4", optional = true, default-features = false } blas-src = { version = "0.2.0", optional = true, default-features = false } @@ -62,7 +63,7 @@ test-blas-openblas-sys = ["blas"] test = ["test-blas-openblas-sys"] # This feature is used for docs -docs = ["serde-1", "rayon"] +docs = ["approx", "serde-1", "rayon"] [profile.release] [profile.bench] diff --git a/src/array_approx.rs b/src/array_approx.rs new file mode 100644 index 000000000..f8adeb09e --- /dev/null +++ b/src/array_approx.rs @@ -0,0 +1,157 @@ +use crate::imp_prelude::*; +use crate::{FoldWhile, Zip}; +use approx::{AbsDiffEq, RelativeEq, UlpsEq}; + +/// **Requires crate feature `"approx"`** +impl AbsDiffEq for ArrayBase +where + A: AbsDiffEq, + A::Epsilon: Clone, + S: Data, + D: Dimension, +{ + type Epsilon = A::Epsilon; + + fn default_epsilon() -> A::Epsilon { + A::default_epsilon() + } + + fn abs_diff_eq(&self, other: &ArrayBase, epsilon: A::Epsilon) -> bool { + if self.shape() != other.shape() { + return false; + } + Zip::from(self) + .and(other) + .fold_while(true, |_, a, b| { + if A::abs_diff_ne(a, b, epsilon.clone()) { + FoldWhile::Done(false) + } else { + FoldWhile::Continue(true) + } + }) + .into_inner() + } +} + +/// **Requires crate feature `"approx"`** +impl RelativeEq for ArrayBase +where + A: RelativeEq, + A::Epsilon: Clone, + S: Data, + D: Dimension, +{ + fn default_max_relative() -> A::Epsilon { + A::default_max_relative() + } + + fn relative_eq( + &self, + other: &ArrayBase, + epsilon: A::Epsilon, + max_relative: A::Epsilon, + ) -> bool { + if self.shape() != other.shape() { + return false; + } + Zip::from(self) + .and(other) + .fold_while(true, |_, a, b| { + if A::relative_ne(a, b, epsilon.clone(), max_relative.clone()) { + FoldWhile::Done(false) + } else { + FoldWhile::Continue(true) + } + }) + .into_inner() + } +} + +/// **Requires crate feature `"approx"`** +impl UlpsEq for ArrayBase +where + A: UlpsEq, + A::Epsilon: Clone, + S: Data, + D: Dimension, +{ + fn default_max_ulps() -> u32 { + A::default_max_ulps() + } + + fn ulps_eq(&self, other: &ArrayBase, epsilon: A::Epsilon, max_ulps: u32) -> bool { + if self.shape() != other.shape() { + return false; + } + Zip::from(self) + .and(other) + .fold_while(true, |_, a, b| { + if A::ulps_ne(a, b, epsilon.clone(), max_ulps) { + FoldWhile::Done(false) + } else { + FoldWhile::Continue(true) + } + }) + .into_inner() + } +} + +#[cfg(test)] +mod tests { + use crate::prelude::*; + use approx::{ + assert_abs_diff_eq, assert_abs_diff_ne, assert_relative_eq, assert_relative_ne, + assert_ulps_eq, assert_ulps_ne, + }; + + #[test] + fn abs_diff_eq() { + let a: Array2 = array![[0., 2.], [-0.000010001, 100000000.]]; + let mut b: Array2 = array![[0., 1.], [-0.000010002, 100000001.]]; + assert_abs_diff_ne!(a, b); + b[(0, 1)] = 2.; + assert_abs_diff_eq!(a, b); + + // Check epsilon. + assert_abs_diff_eq!(array![0.0f32], array![1e-40f32], epsilon = 1e-40f32); + assert_abs_diff_ne!(array![0.0f32], array![1e-40f32], epsilon = 1e-41f32); + + // Make sure we can compare different shapes without failure. + let c = array![[1., 2.]]; + assert_abs_diff_ne!(a, c); + } + + #[test] + fn relative_eq() { + let a: Array2 = array![[1., 2.], [-0.000010001, 100000000.]]; + let mut b: Array2 = array![[1., 1.], [-0.000010002, 100000001.]]; + assert_relative_ne!(a, b); + b[(0, 1)] = 2.; + assert_relative_eq!(a, b); + + // Check epsilon. + assert_relative_eq!(array![0.0f32], array![1e-40f32], epsilon = 1e-40f32); + assert_relative_ne!(array![0.0f32], array![1e-40f32], epsilon = 1e-41f32); + + // Make sure we can compare different shapes without failure. + let c = array![[1., 2.]]; + assert_relative_ne!(a, c); + } + + #[test] + fn ulps_eq() { + let a: Array2 = array![[1., 2.], [-0.000010001, 100000000.]]; + let mut b: Array2 = array![[1., 1.], [-0.000010002, 100000001.]]; + assert_ulps_ne!(a, b); + b[(0, 1)] = 2.; + assert_ulps_eq!(a, b); + + // Check epsilon. + assert_ulps_eq!(array![0.0f32], array![1e-40f32], epsilon = 1e-40f32); + assert_ulps_ne!(array![0.0f32], array![1e-40f32], epsilon = 1e-41f32); + + // Make sure we can compare different shapes without failure. + let c = array![[1., 2.]]; + assert_ulps_ne!(a, c); + } +} diff --git a/src/arraytraits.rs b/src/arraytraits.rs index 91b163ad4..13b5ce6c8 100644 --- a/src/arraytraits.rs +++ b/src/arraytraits.rs @@ -113,92 +113,6 @@ impl Eq for ArrayBase S::Elem: Eq, { } -impl approx::AbsDiffEq for ArrayBase -where - A: approx::AbsDiffEq, - A::Epsilon: Clone, - S: Data, - D: Dimension, -{ - type Epsilon = A::Epsilon; - - fn default_epsilon() -> A::Epsilon { - A::default_epsilon() - } - - fn abs_diff_eq(&self, other: &ArrayBase, epsilon: A::Epsilon) -> bool { - if self.shape() != other.shape() { - return false; - } - Zip::from(self) - .and(other) - .fold_while(true, |_, a, b| { - if A::abs_diff_ne(a, b, epsilon.clone()) { - FoldWhile::Done(false) - } else { - FoldWhile::Continue(true) - } - }) - .into_inner() - } -} - -impl approx::RelativeEq for ArrayBase -where - A: approx::RelativeEq, - A::Epsilon: Clone, - S: Data, - D: Dimension, -{ - fn default_max_relative() -> A::Epsilon { - A::default_max_relative() - } - - fn relative_eq(&self, other: &ArrayBase, epsilon: A::Epsilon, max_relative: A::Epsilon) -> bool { - if self.shape() != other.shape() { - return false; - } - Zip::from(self) - .and(other) - .fold_while(true, |_, a, b| { - if A::relative_ne(a, b, epsilon.clone(), max_relative.clone()) { - FoldWhile::Done(false) - } else { - FoldWhile::Continue(true) - } - }) - .into_inner() - } -} - -impl approx::UlpsEq for ArrayBase -where - A: approx::UlpsEq, - A::Epsilon: Clone, - S: Data, - D: Dimension, -{ - fn default_max_ulps() -> u32 { - A::default_max_ulps() - } - - fn ulps_eq(&self, other: &ArrayBase, epsilon: A::Epsilon, max_ulps: u32) -> bool { - if self.shape() != other.shape() { - return false; - } - Zip::from(self) - .and(other) - .fold_while(true, |_, a, b| { - if A::ulps_ne(a, b, epsilon.clone(), max_ulps) { - FoldWhile::Done(false) - } else { - FoldWhile::Continue(true) - } - }) - .into_inner() - } -} - impl FromIterator for ArrayBase where S: DataOwned { diff --git a/src/lib.rs b/src/lib.rs index 5ab2656b4..9ffab0665 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -68,6 +68,9 @@ //! - `rayon` //! - Optional, compatible with Rust stable //! - Enables parallel iterators, parallelized methods and [`par_azip!`]. +//! - `approx` +//! - Optional, compatible with Rust stable +//! - Enables implementations of traits from the [`approx`] crate. //! - `blas` //! - Optional and experimental, compatible with Rust stable //! - Enable transparent BLAS support for matrix multiplication. @@ -90,6 +93,9 @@ extern crate serde; #[cfg(feature="rayon")] extern crate rayon; +#[cfg(feature="approx")] +extern crate approx; + #[cfg(feature="blas")] extern crate cblas_sys; #[cfg(feature="blas")] @@ -97,7 +103,6 @@ extern crate blas_src; extern crate matrixmultiply; -extern crate approx; extern crate itertools; extern crate num_traits; extern crate num_complex; @@ -147,6 +152,8 @@ mod aliases; mod arraytraits; #[cfg(feature = "serde-1")] mod array_serde; +#[cfg(feature = "approx")] +mod array_approx; mod arrayformat; mod data_traits; diff --git a/tests/array.rs b/tests/array.rs index 60f28f132..28e2e7fbc 100644 --- a/tests/array.rs +++ b/tests/array.rs @@ -1,6 +1,5 @@ #![allow(non_snake_case)] -extern crate approx; extern crate ndarray; extern crate defmac; extern crate itertools; @@ -13,10 +12,6 @@ use ndarray::{ multislice, }; use ndarray::indices; -use approx::{ - assert_abs_diff_eq, assert_abs_diff_ne, assert_relative_eq, assert_relative_ne, assert_ulps_eq, - assert_ulps_ne, -}; use defmac::defmac; use itertools::{enumerate, zip}; @@ -1168,60 +1163,6 @@ fn equality() assert!(a != c); } -#[test] -fn abs_diff_eq() -{ - let a: Array2 = array![[0., 2.], [-0.000010001, 100000000.]]; - let mut b: Array2 = array![[0., 1.], [-0.000010002, 100000001.]]; - assert_abs_diff_ne!(a, b); - b[(0, 1)] = 2.; - assert_abs_diff_eq!(a, b); - - // Check epsilon. - assert_abs_diff_eq!(array![0.0f32], array![1e-40f32], epsilon = 1e-40f32); - assert_abs_diff_ne!(array![0.0f32], array![1e-40f32], epsilon = 1e-41f32); - - // Make sure we can compare different shapes without failure. - let c = array![[1., 2.]]; - assert_abs_diff_ne!(a, c); -} - -#[test] -fn relative_eq() -{ - let a: Array2 = array![[1., 2.], [-0.000010001, 100000000.]]; - let mut b: Array2 = array![[1., 1.], [-0.000010002, 100000001.]]; - assert_relative_ne!(a, b); - b[(0, 1)] = 2.; - assert_relative_eq!(a, b); - - // Check epsilon. - assert_relative_eq!(array![0.0f32], array![1e-40f32], epsilon = 1e-40f32); - assert_relative_ne!(array![0.0f32], array![1e-40f32], epsilon = 1e-41f32); - - // Make sure we can compare different shapes without failure. - let c = array![[1., 2.]]; - assert_relative_ne!(a, c); -} - -#[test] -fn ulps_eq() -{ - let a: Array2 = array![[1., 2.], [-0.000010001, 100000000.]]; - let mut b: Array2 = array![[1., 1.], [-0.000010002, 100000001.]]; - assert_ulps_ne!(a, b); - b[(0, 1)] = 2.; - assert_ulps_eq!(a, b); - - // Check epsilon. - assert_ulps_eq!(array![0.0f32], array![1e-40f32], epsilon = 1e-40f32); - assert_ulps_ne!(array![0.0f32], array![1e-40f32], epsilon = 1e-41f32); - - // Make sure we can compare different shapes without failure. - let c = array![[1., 2.]]; - assert_ulps_ne!(a, c); -} - #[test] fn map1() { From cbb07a46454ee1b73d80b6bbae08b8e4b7ff911a Mon Sep 17 00:00:00 2001 From: LukeMathWalker Date: Sat, 4 May 2019 17:09:24 +0100 Subject: [PATCH 03/22] Use Zip::all where possible --- src/array_approx.rs | 27 +++------------------------ 1 file changed, 3 insertions(+), 24 deletions(-) diff --git a/src/array_approx.rs b/src/array_approx.rs index f8adeb09e..75f48600d 100644 --- a/src/array_approx.rs +++ b/src/array_approx.rs @@ -22,14 +22,7 @@ where } Zip::from(self) .and(other) - .fold_while(true, |_, a, b| { - if A::abs_diff_ne(a, b, epsilon.clone()) { - FoldWhile::Done(false) - } else { - FoldWhile::Continue(true) - } - }) - .into_inner() + .all(A::abs_diff_ne(a, b, epsilon.clone())) } } @@ -56,14 +49,7 @@ where } Zip::from(self) .and(other) - .fold_while(true, |_, a, b| { - if A::relative_ne(a, b, epsilon.clone(), max_relative.clone()) { - FoldWhile::Done(false) - } else { - FoldWhile::Continue(true) - } - }) - .into_inner() + .all(A::relative_ne(a, b, epsilon.clone(), max_relative.clone())) } } @@ -85,14 +71,7 @@ where } Zip::from(self) .and(other) - .fold_while(true, |_, a, b| { - if A::ulps_ne(a, b, epsilon.clone(), max_ulps) { - FoldWhile::Done(false) - } else { - FoldWhile::Continue(true) - } - }) - .into_inner() + .all(A::ulps_ne(a, b, epsilon.clone(), max_ulps)) } } From d21fe5cdf3af32e9703b9cd920b51d1cab4fb5ec Mon Sep 17 00:00:00 2001 From: LukeMathWalker Date: Sat, 4 May 2019 17:14:37 +0100 Subject: [PATCH 04/22] Mark `all_close` as deprecated --- src/numeric/impl_numeric.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/numeric/impl_numeric.rs b/src/numeric/impl_numeric.rs index 87e7be590..849bd2b65 100644 --- a/src/numeric/impl_numeric.rs +++ b/src/numeric/impl_numeric.rs @@ -306,6 +306,7 @@ impl ArrayBase /// If their shapes disagree, `rhs` is broadcast to the shape of `self`. /// /// **Panics** if broadcasting to the same shape isn’t possible. + #[deprecated(note="Use `abs_diff_eq` - it requires the `approx` crate feature", since="0.13")] pub fn all_close(&self, rhs: &ArrayBase, tol: A) -> bool where A: Float, S2: Data, From 5e309240d3db1a2d0d8c045cbc534b0fa80b1f34 Mon Sep 17 00:00:00 2001 From: LukeMathWalker Date: Sat, 4 May 2019 17:25:02 +0100 Subject: [PATCH 05/22] Fix implementation. --- src/array_approx.rs | 8 ++++---- src/logspace.rs | 3 ++- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/array_approx.rs b/src/array_approx.rs index 75f48600d..100a7aa38 100644 --- a/src/array_approx.rs +++ b/src/array_approx.rs @@ -1,5 +1,5 @@ use crate::imp_prelude::*; -use crate::{FoldWhile, Zip}; +use crate::Zip; use approx::{AbsDiffEq, RelativeEq, UlpsEq}; /// **Requires crate feature `"approx"`** @@ -22,7 +22,7 @@ where } Zip::from(self) .and(other) - .all(A::abs_diff_ne(a, b, epsilon.clone())) + .all(|a, b| A::abs_diff_eq(a, b, epsilon.clone())) } } @@ -49,7 +49,7 @@ where } Zip::from(self) .and(other) - .all(A::relative_ne(a, b, epsilon.clone(), max_relative.clone())) + .all(|a, b| A::relative_eq(a, b, epsilon.clone(), max_relative.clone())) } } @@ -71,7 +71,7 @@ where } Zip::from(self) .and(other) - .all(A::ulps_ne(a, b, epsilon.clone(), max_ulps)) + .all(|a, b| A::ulps_eq(a, b, epsilon.clone(), max_ulps)) } } diff --git a/src/logspace.rs b/src/logspace.rs index fe62e9990..d27b8170b 100644 --- a/src/logspace.rs +++ b/src/logspace.rs @@ -97,11 +97,12 @@ where mod tests { use super::logspace; use crate::{arr1, Array1}; + use approx::AbsDiffEq; #[test] fn valid() { let array: Array1<_> = logspace(10.0, 0.0, 3.0, 4).collect(); - assert!(array.all_close(&arr1(&[1e0, 1e1, 1e2, 1e3]), 1e-5)); + assert!(array.abs_diff_eq(&arr1(&[1e0, 1e1, 1e2, 1e3]), 1e-5)); let array: Array1<_> = logspace(10.0, 3.0, 0.0, 4).collect(); assert!(array.all_close(&arr1(&[1e3, 1e2, 1e1, 1e0]), 1e-5)); From fa603767f0b77890301bb94935d2b2de7aadc055 Mon Sep 17 00:00:00 2001 From: LukeMathWalker Date: Sat, 4 May 2019 17:41:30 +0100 Subject: [PATCH 06/22] Fix issues with conditional execution based on activated features --- src/geomspace.rs | 9 +++++---- src/impl_constructors.rs | 7 +++++-- src/logspace.rs | 8 ++++---- 3 files changed, 14 insertions(+), 10 deletions(-) diff --git a/src/geomspace.rs b/src/geomspace.rs index f04d44889..93b73329b 100644 --- a/src/geomspace.rs +++ b/src/geomspace.rs @@ -109,18 +109,19 @@ mod tests { use crate::{arr1, Array1}; #[test] + #[cfg(approx)] fn valid() { let array: Array1<_> = geomspace(1e0, 1e3, 4).collect(); - assert!(array.all_close(&arr1(&[1e0, 1e1, 1e2, 1e3]), 1e-5)); + assert!(array.abs_diff_eq(&arr1(&[1e0, 1e1, 1e2, 1e3]), 1e-5)); let array: Array1<_> = geomspace(1e3, 1e0, 4).collect(); - assert!(array.all_close(&arr1(&[1e3, 1e2, 1e1, 1e0]), 1e-5)); + assert!(array.abs_diff_eq(&arr1(&[1e3, 1e2, 1e1, 1e0]), 1e-5)); let array: Array1<_> = geomspace(-1e3, -1e0, 4).collect(); - assert!(array.all_close(&arr1(&[-1e3, -1e2, -1e1, -1e0]), 1e-5)); + assert!(array.abs_diff_eq(&arr1(&[-1e3, -1e2, -1e1, -1e0]), 1e-5)); let array: Array1<_> = geomspace(-1e0, -1e3, 4).collect(); - assert!(array.all_close(&arr1(&[-1e0, -1e1, -1e2, -1e3]), 1e-5)); + assert!(array.abs_diff_eq(&arr1(&[-1e0, -1e1, -1e2, -1e3]), 1e-5)); } #[test] diff --git a/src/impl_constructors.rs b/src/impl_constructors.rs index a57dcfff8..66a70cf3f 100644 --- a/src/impl_constructors.rs +++ b/src/impl_constructors.rs @@ -112,12 +112,15 @@ impl ArrayBase /// /// ```rust /// use ndarray::{Array, arr1}; + /// use approx::AbsDiffEq; /// + /// # #[cfg(feature = "approx")] { /// let array = Array::logspace(10.0, 0.0, 3.0, 4); - /// assert!(array.all_close(&arr1(&[1e0, 1e1, 1e2, 1e3]), 1e-5)); + /// assert!(array.abs_diff_eq(&arr1(&[1e0, 1e1, 1e2, 1e3]), 1e-5)); /// /// let array = Array::logspace(-10.0, 3.0, 0.0, 4); - /// assert!(array.all_close(&arr1(&[-1e3, -1e2, -1e1, -1e0]), 1e-5)); + /// assert!(array.abs_diff_eq(&arr1(&[-1e3, -1e2, -1e1, -1e0]), 1e-5)); + /// # } /// ``` pub fn logspace(base: A, start: A, end: A, n: usize) -> Self where diff --git a/src/logspace.rs b/src/logspace.rs index d27b8170b..7aa6d11e2 100644 --- a/src/logspace.rs +++ b/src/logspace.rs @@ -97,21 +97,21 @@ where mod tests { use super::logspace; use crate::{arr1, Array1}; - use approx::AbsDiffEq; #[test] + #[cfg(approx)] fn valid() { let array: Array1<_> = logspace(10.0, 0.0, 3.0, 4).collect(); assert!(array.abs_diff_eq(&arr1(&[1e0, 1e1, 1e2, 1e3]), 1e-5)); let array: Array1<_> = logspace(10.0, 3.0, 0.0, 4).collect(); - assert!(array.all_close(&arr1(&[1e3, 1e2, 1e1, 1e0]), 1e-5)); + assert!(array.abs_diff_eq(&arr1(&[1e3, 1e2, 1e1, 1e0]), 1e-5)); let array: Array1<_> = logspace(-10.0, 3.0, 0.0, 4).collect(); - assert!(array.all_close(&arr1(&[-1e3, -1e2, -1e1, -1e0]), 1e-5)); + assert!(array.abs_diff_eq(&arr1(&[-1e3, -1e2, -1e1, -1e0]), 1e-5)); let array: Array1<_> = logspace(-10.0, 0.0, 3.0, 4).collect(); - assert!(array.all_close(&arr1(&[-1e0, -1e1, -1e2, -1e3]), 1e-5)); + assert!(array.abs_diff_eq(&arr1(&[-1e0, -1e1, -1e2, -1e3]), 1e-5)); } #[test] From 8fb8aa4edf9391efcf9cd243c446533771717afe Mon Sep 17 00:00:00 2001 From: LukeMathWalker Date: Sat, 4 May 2019 17:43:47 +0100 Subject: [PATCH 07/22] Remove all_close from all doc tests --- src/impl_constructors.rs | 7 +++++-- src/impl_methods.rs | 7 +++++-- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/src/impl_constructors.rs b/src/impl_constructors.rs index 66a70cf3f..fca687a0c 100644 --- a/src/impl_constructors.rs +++ b/src/impl_constructors.rs @@ -140,12 +140,15 @@ impl ArrayBase /// /// ```rust /// use ndarray::{Array, arr1}; + /// use approx::AbsDiffEq; /// + /// # #[cfg(feature = "approx")] { /// let array = Array::geomspace(1e0, 1e3, 4); - /// assert!(array.all_close(&arr1(&[1e0, 1e1, 1e2, 1e3]), 1e-5)); + /// assert!(array.abs_diff_eq(&arr1(&[1e0, 1e1, 1e2, 1e3]), 1e-5)); /// /// let array = Array::geomspace(-1e3, -1e0, 4); - /// assert!(array.all_close(&arr1(&[-1e3, -1e2, -1e1, -1e0]), 1e-5)); + /// assert!(array.abs_diff_eq(&arr1(&[-1e3, -1e2, -1e1, -1e0]), 1e-5)); + /// # } /// ``` pub fn geomspace(start: A, end: A, n: usize) -> Self where diff --git a/src/impl_methods.rs b/src/impl_methods.rs index 6192c54ef..5887bebcb 100644 --- a/src/impl_methods.rs +++ b/src/impl_methods.rs @@ -2040,14 +2040,17 @@ where /// /// ``` /// use ndarray::arr2; + /// use approx::AbsDiffEq; /// + /// # #[cfg(feature = "approx")] { /// let mut a = arr2(&[[ 0., 1.], /// [-1., 2.]]); /// a.mapv_inplace(f32::exp); /// assert!( - /// a.all_close(&arr2(&[[1.00000, 2.71828], - /// [0.36788, 7.38906]]), 1e-5) + /// a.abs_diff_eq(&arr2(&[[1.00000, 2.71828], + /// [0.36788, 7.38906]]), 1e-5) /// ); + /// # } /// ``` pub fn mapv_inplace(&mut self, mut f: F) where S: DataMut, From 3e47c5ca08c06964ea05be1ae6759428f825c0f3 Mon Sep 17 00:00:00 2001 From: LukeMathWalker Date: Sat, 4 May 2019 17:48:03 +0100 Subject: [PATCH 08/22] Update guide for NumPy users --- src/doc/ndarray_for_numpy_users/mod.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/doc/ndarray_for_numpy_users/mod.rs b/src/doc/ndarray_for_numpy_users/mod.rs index b268c9b24..79acad788 100644 --- a/src/doc/ndarray_for_numpy_users/mod.rs +++ b/src/doc/ndarray_for_numpy_users/mod.rs @@ -473,7 +473,7 @@ //! //! //! -//! [`a.all_close(&b, 1e-8)`][.all_close()] +//! [`a.abs_diff_eq(&b, 1e-8)`][.abs_diff_eq()] //! //! //! @@ -557,7 +557,7 @@ //! `a[:,4]` | [`a.column(4)`][.column()] or [`a.column_mut(4)`][.column_mut()] | view (or mutable view) of column 4 in a 2-D array //! `a.shape[0] == a.shape[1]` | [`a.is_square()`][.is_square()] | check if the array is square //! -//! [.all_close()]: ../../struct.ArrayBase.html#method.all_close +//! [.abs_diff_eq()]: ../../struct.ArrayBase.html#impl-AbsDiffEq> //! [ArcArray]: ../../type.ArcArray.html //! [arr2()]: ../../fn.arr2.html //! [array!]: ../../macro.array.html From 9b831753a74f3bef35cca07789e1749e47e71ccd Mon Sep 17 00:00:00 2001 From: LukeMathWalker Date: Sat, 4 May 2019 17:52:06 +0100 Subject: [PATCH 09/22] Replace all_close with abs_diff_eq in tests (currently failing) --- tests/array.rs | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/tests/array.rs b/tests/array.rs index ef5b1058d..2c0f0be27 100644 --- a/tests/array.rs +++ b/tests/array.rs @@ -12,6 +12,7 @@ use ndarray::{ multislice, }; use ndarray::indices; +use approx::AbsDiffEq; use defmac::defmac; use itertools::{enumerate, zip, Itertools}; @@ -680,6 +681,7 @@ fn test_sub_oob_1() { #[test] +#[cfg(feature = "approx")] fn test_select(){ // test for 2-d array let x = arr2(&[[0., 1.], [1.,0.],[1.,0.],[1.,0.],[1.,0.],[0., 1.],[0., 1.]]); @@ -687,8 +689,8 @@ fn test_select(){ let c = x.select(Axis(1),&[1]); let r_target = arr2(&[[1.,0.],[1.,0.],[0., 1.]]); let c_target = arr2(&[[1.,0.,0.,0.,0., 1., 1.]]); - assert!(r.all_close(&r_target,1e-8)); - assert!(c.all_close(&c_target.t(),1e-8)); + assert!(r.abs_diff_eq(&r_target,1e-8)); + assert!(c.abs_diff_eq(&c_target.t(),1e-8)); // test for 3-d array let y = arr3(&[[[1., 2., 3.], @@ -699,8 +701,8 @@ fn test_select(){ let c = y.select(Axis(2),&[1]); let r_target = arr3(&[[[1.5, 1.5, 3.]], [[1., 2.5, 3.]]]); let c_target = arr3(&[[[2.],[1.5]],[[2.],[2.5]]]); - assert!(r.all_close(&r_target,1e-8)); - assert!(c.all_close(&c_target,1e-8)); + assert!(r.abs_diff_eq(&r_target,1e-8)); + assert!(c.abs_diff_eq(&c_target,1e-8)); } @@ -1733,13 +1735,14 @@ fn test_contiguous() { } #[test] +#[cfg(feature = "approx")] fn test_all_close() { let c = arr3(&[[[1., 2., 3.], [1.5, 1.5, 3.]], [[1., 2., 3.], [1., 2.5, 3.]]]); - assert!(c.all_close(&aview1(&[1., 2., 3.]), 1.)); - assert!(!c.all_close(&aview1(&[1., 2., 3.]), 0.1)); + assert!(c.abs_diff_eq(&aview1(&[1., 2., 3.]), 1.)); + assert!(c.abs_diff_neq(&aview1(&[1., 2., 3.]), 0.1)); } #[test] From e0f390d9d82445ce415bb006e87d9fe0549c563c Mon Sep 17 00:00:00 2001 From: LukeMathWalker Date: Sat, 4 May 2019 17:54:52 +0100 Subject: [PATCH 10/22] Fix typo, pin 0.3.2 to get latest changes --- Cargo.toml | 4 ++-- tests/array.rs | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index c75dc92d6..cd6939a33 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -35,7 +35,7 @@ itertools = { version = "0.7.0", default-features = false } rayon = { version = "1.0.3", optional = true } -approx = { version = "0.3", optional = true } +approx = { version = "0.3.2", optional = true } # Use via the `blas` crate feature! cblas-sys = { version = "0.1.4", optional = true, default-features = false } @@ -50,7 +50,7 @@ defmac = "0.2" quickcheck = { version = "0.7.2", default-features = false } rawpointer = "0.1" itertools = { version = "0.7.0", default-features = false, features = ["use_std"] } -approx = "0.3" +approx = "0.3.2" [features] # Enable blas usage diff --git a/tests/array.rs b/tests/array.rs index 2c0f0be27..73eb08754 100644 --- a/tests/array.rs +++ b/tests/array.rs @@ -1742,7 +1742,7 @@ fn test_all_close() { [[1., 2., 3.], [1., 2.5, 3.]]]); assert!(c.abs_diff_eq(&aview1(&[1., 2., 3.]), 1.)); - assert!(c.abs_diff_neq(&aview1(&[1., 2., 3.]), 0.1)); + assert!(c.abs_diff_ne(&aview1(&[1., 2., 3.]), 0.1)); } #[test] From ac67ea5e9248afbf72b2e21270e3719ea16a3d68 Mon Sep 17 00:00:00 2001 From: LukeMathWalker Date: Sun, 5 May 2019 10:18:58 +0100 Subject: [PATCH 11/22] Allow comparison between arrays with different ownership properties --- src/array_approx.rs | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/src/array_approx.rs b/src/array_approx.rs index 100a7aa38..eb0a32fde 100644 --- a/src/array_approx.rs +++ b/src/array_approx.rs @@ -3,11 +3,12 @@ use crate::Zip; use approx::{AbsDiffEq, RelativeEq, UlpsEq}; /// **Requires crate feature `"approx"`** -impl AbsDiffEq for ArrayBase +impl AbsDiffEq> for ArrayBase where A: AbsDiffEq, A::Epsilon: Clone, S: Data, + T: Data, D: Dimension, { type Epsilon = A::Epsilon; @@ -16,7 +17,7 @@ where A::default_epsilon() } - fn abs_diff_eq(&self, other: &ArrayBase, epsilon: A::Epsilon) -> bool { + fn abs_diff_eq(&self, other: &ArrayBase, epsilon: A::Epsilon) -> bool { if self.shape() != other.shape() { return false; } @@ -27,11 +28,12 @@ where } /// **Requires crate feature `"approx"`** -impl RelativeEq for ArrayBase +impl RelativeEq> for ArrayBase where A: RelativeEq, A::Epsilon: Clone, S: Data, + T: Data, D: Dimension, { fn default_max_relative() -> A::Epsilon { @@ -40,7 +42,7 @@ where fn relative_eq( &self, - other: &ArrayBase, + other: &ArrayBase, epsilon: A::Epsilon, max_relative: A::Epsilon, ) -> bool { @@ -54,18 +56,19 @@ where } /// **Requires crate feature `"approx"`** -impl UlpsEq for ArrayBase +impl UlpsEq> for ArrayBase where A: UlpsEq, A::Epsilon: Clone, S: Data, + T: Data, D: Dimension, { fn default_max_ulps() -> u32 { A::default_max_ulps() } - fn ulps_eq(&self, other: &ArrayBase, epsilon: A::Epsilon, max_ulps: u32) -> bool { + fn ulps_eq(&self, other: &ArrayBase, epsilon: A::Epsilon, max_ulps: u32) -> bool { if self.shape() != other.shape() { return false; } From 35915b86588968dba84ce4dafe39e618153649a1 Mon Sep 17 00:00:00 2001 From: LukeMathWalker Date: Sun, 5 May 2019 10:23:05 +0100 Subject: [PATCH 12/22] Fix assertions --- tests/array.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/tests/array.rs b/tests/array.rs index 73eb08754..f9d42638d 100644 --- a/tests/array.rs +++ b/tests/array.rs @@ -1741,8 +1741,12 @@ fn test_all_close() { [1.5, 1.5, 3.]], [[1., 2., 3.], [1., 2.5, 3.]]]); - assert!(c.abs_diff_eq(&aview1(&[1., 2., 3.]), 1.)); - assert!(c.abs_diff_ne(&aview1(&[1., 2., 3.]), 0.1)); + assert!( + c.abs_diff_eq(&aview1(&[1., 2., 3.]).broadcast(c.raw_dim()).unwrap(), 1.) + ); + assert!( + c.abs_diff_ne(&aview1(&[1., 2., 3.]).broadcast(c.raw_dim()).unwrap(), 0.1) + ); } #[test] From 3d8196735616dfea5aeaf9864ad1c176ae0bb34d Mon Sep 17 00:00:00 2001 From: LukeMathWalker Date: Sun, 5 May 2019 10:24:39 +0100 Subject: [PATCH 13/22] Fix test --- tests/par_rayon.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/par_rayon.rs b/tests/par_rayon.rs index 70b69e0eb..6dda0a1d1 100644 --- a/tests/par_rayon.rs +++ b/tests/par_rayon.rs @@ -24,12 +24,13 @@ fn test_axis_iter() { } #[test] +#[cfg(features = "approx")] fn test_axis_iter_mut() { let mut a = Array::linspace(0., 1.0f64, M * N).into_shape((M, N)).unwrap(); let b = a.mapv(|x| x.exp()); a.axis_iter_mut(Axis(0)).into_par_iter().for_each(|mut v| v.mapv_inplace(|x| x.exp())); println!("{:?}", a.slice(s![..10, ..5])); - assert!(a.all_close(&b, 0.001)); + assert_abs_diff_eq!(a, &b, 0.001); } #[test] From cf646e2f2e78a3e547dc3548f01297510f9267ef Mon Sep 17 00:00:00 2001 From: LukeMathWalker Date: Sun, 5 May 2019 10:30:04 +0100 Subject: [PATCH 14/22] Move tests from all_close to approx --- tests/array-construct.rs | 3 ++- tests/azip.rs | 9 ++++++--- tests/numeric.rs | 20 +++++++++++--------- tests/par_azip.rs | 3 ++- 4 files changed, 21 insertions(+), 14 deletions(-) diff --git a/tests/array-construct.rs b/tests/array-construct.rs index 7e320c314..e14b9f9fd 100644 --- a/tests/array-construct.rs +++ b/tests/array-construct.rs @@ -21,6 +21,7 @@ fn test_dimension_zero() { } #[test] +#[cfg(features = "approx")] fn test_arc_into_owned() { let a = Array2::from_elem((5, 5), 1.).into_shared(); let mut b = a.clone(); @@ -28,7 +29,7 @@ fn test_arc_into_owned() { let mut c = b.into_owned(); c.fill(2.); // test that they are unshared - assert!(!a.all_close(&c, 0.01)); + assert_abs_diff_ne!(a, &c, 0.01); } #[test] diff --git a/tests/azip.rs b/tests/azip.rs index 39a5d2991..2d9166e2a 100644 --- a/tests/azip.rs +++ b/tests/azip.rs @@ -45,17 +45,19 @@ fn test_azip2_3() { } #[test] +#[cfg(features = "approx")] fn test_azip2_sum() { let c = Array::from_shape_fn((5, 10), |(i, j)| f32::exp((i + j) as f32)); for i in 0..2 { let ax = Axis(i); let mut b = Array::zeros(c.len_of(ax)); azip!(mut b, ref c (c.axis_iter(ax)) in { *b = c.sum() }); - assert!(b.all_close(&c.sum_axis(Axis(1 - i)), 1e-6)); + assert_abs_diff_eq!(b, c.sum_axis(Axis(1 - i)), 1e-6); } } #[test] +#[cfg(features = "approx")] fn test_azip3_slices() { let mut a = [0.; 32]; let mut b = [0.; 32]; @@ -69,10 +71,11 @@ fn test_azip3_slices() { *c = a.sin(); }); let res = Array::linspace(0., 3.1, 32).mapv_into(f32::sin); - assert!(res.all_close(&ArrayView::from(&c), 1e-4)); + assert_abs_diff_eq!(res, &ArrayView::from(&c), 1e-4); } #[test] +#[cfg(features = "approx")] fn test_broadcast() { let n = 16; let mut a = Array::::zeros((n, n)); @@ -90,7 +93,7 @@ fn test_broadcast() { .and_broadcast(&e); z.apply(|x, &y, &z, &w| *x = y + z + w); } - assert!(a.all_close(&(&b + &d + &e), 1e-4)); + assert_abs_diff_eq!(a, &(&b + &d + &e), 1e-4); } #[should_panic] diff --git a/tests/numeric.rs b/tests/numeric.rs index e73da4904..16ad9f707 100644 --- a/tests/numeric.rs +++ b/tests/numeric.rs @@ -62,6 +62,7 @@ fn sum_mean_empty() { } #[test] +#[cfg(features = "approx")] fn var_axis() { let a = array![ [ @@ -75,38 +76,39 @@ fn var_axis() { [-1.08, 4.66, 8.34, -0.73], ], ]; - assert!(a.var_axis(Axis(0), 1.5).all_close( + assert_abs_diff_eq!( + a.var_axis(Axis(0), 1.5), &aview2(&[ [3.236401e+02, 8.556250e+01, 4.708900e+00, 9.428410e+01], [9.672100e+00, 2.289169e+02, 7.344490e+01, 2.171560e+01], [7.157160e+01, 1.849000e-01, 2.631690e+01, 5.314410e+01] ]), 1e-4, - )); - assert!(a.var_axis(Axis(1), 1.7).all_close( + ); + assert_abs_diff_eq!(a.var_axis(Axis(1), 1.7), &aview2(&[ [0.61676923, 80.81092308, 6.79892308, 0.11789744], [75.19912821, 114.25235897, 48.32405128, 9.03020513], ]), 1e-8, - )); - assert!(a.var_axis(Axis(2), 2.3).all_close( + ); + assert_abs_diff_eq!(a.var_axis(Axis(2), 2.3), &aview2(&[ [ 79.64552941, 129.09663235, 95.98929412], [109.64952941, 43.28758824, 36.27439706], ]), 1e-8, - )); + ); let b = array![[1.1, 2.3, 4.7]]; - assert!(b.var_axis(Axis(0), 0.).all_close(&aview1(&[0., 0., 0.]), 1e-12)); - assert!(b.var_axis(Axis(1), 0.).all_close(&aview1(&[2.24]), 1e-12)); + assert_abs_diff_eq!(b.var_axis(Axis(0), 0.), &aview1(&[0., 0., 0.]), 1e-12); + assert_abs_diff_eq!(b.var_axis(Axis(1), 0.).all_close(&aview1(&[2.24]), 1e-12)); let c = array![[], []]; assert_eq!(c.var_axis(Axis(0), 0.), aview1(&[])); let d = array![1.1, 2.7, 3.5, 4.9]; - assert!(d.var_axis(Axis(0), 0.).all_close(&aview0(&1.8875), 1e-12)); + assert_abs_diff_eq!(d.var_axis(Axis(0), 0.), &aview0(&1.8875), 1e-12); } #[test] diff --git a/tests/par_azip.rs b/tests/par_azip.rs index 4ffe5b347..d373345e4 100644 --- a/tests/par_azip.rs +++ b/tests/par_azip.rs @@ -25,6 +25,7 @@ fn test_par_azip2() { } #[test] +#[cfg(features = "approx")] fn test_par_azip3() { let mut a = [0.; 32]; let mut b = [0.; 32]; @@ -38,7 +39,7 @@ fn test_par_azip3() { *c = a.sin(); }); let res = Array::linspace(0., 3.1, 32).mapv_into(f32::sin); - assert!(res.all_close(&ArrayView::from(&c), 1e-4)); + assert_abs_diff_eq!(res, &ArrayView::from(&c), 1e-4); } #[should_panic] From e6c6ff100924947fedde5f0f9a31a4773ac43b7b Mon Sep 17 00:00:00 2001 From: LukeMathWalker Date: Sun, 5 May 2019 10:33:33 +0100 Subject: [PATCH 15/22] Move tests from all_close to approx --- tests/azip.rs | 2 +- tests/numeric.rs | 23 ++++++++++++----------- 2 files changed, 13 insertions(+), 12 deletions(-) diff --git a/tests/azip.rs b/tests/azip.rs index 2d9166e2a..9e4efabce 100644 --- a/tests/azip.rs +++ b/tests/azip.rs @@ -4,7 +4,7 @@ extern crate itertools; use ndarray::prelude::*; use ndarray::Zip; -use itertools::{assert_equal, cloned, enumerate}; +use itertools::{assert_equal, cloned}; use std::mem::swap; diff --git a/tests/numeric.rs b/tests/numeric.rs index 16ad9f707..a9aaf7c91 100644 --- a/tests/numeric.rs +++ b/tests/numeric.rs @@ -1,6 +1,6 @@ extern crate approx; use std::f64; -use ndarray::{array, Axis, aview1, aview2, aview0, arr0, arr1, arr2, Array, Array1, Array2, Array3}; +use ndarray::{array, Axis, aview1, arr0, arr1, arr2, Array, Array1, Array2, Array3}; use approx::abs_diff_eq; #[test] @@ -102,7 +102,7 @@ fn var_axis() { let b = array![[1.1, 2.3, 4.7]]; assert_abs_diff_eq!(b.var_axis(Axis(0), 0.), &aview1(&[0., 0., 0.]), 1e-12); - assert_abs_diff_eq!(b.var_axis(Axis(1), 0.).all_close(&aview1(&[2.24]), 1e-12)); + assert_abs_diff_eq!(b.var_axis(Axis(1), 0.), &aview1(&[2.24]), 1e-12); let c = array![[], []]; assert_eq!(c.var_axis(Axis(0), 0.), aview1(&[])); @@ -112,6 +112,7 @@ fn var_axis() { } #[test] +#[cfg(features = "approx")] fn std_axis() { let a = array![ [ @@ -125,33 +126,33 @@ fn std_axis() { [ 0.51529756, 0.70111616, 0.20799415, 0.91851457] ], ]; - assert!(a.std_axis(Axis(0), 1.5).all_close( + assert_abs_diff_eq!(a.std_axis(Axis(0), 1.5), &aview2(&[ [ 0.05989184, 0.36051836, 0.00989781, 0.32669847], [ 0.81957535, 0.39599997, 0.49731472, 0.17084346], [ 0.07044443, 0.06795249, 0.09794304, 0.83195211], ]), 1e-4, - )); - assert!(a.std_axis(Axis(1), 1.7).all_close( + ); + assert_abs_diff_eq!(a.std_axis(Axis(1), 1.7), &aview2(&[ [ 0.42698655, 0.48139215, 0.36874991, 0.41458724], [ 0.26769097, 0.18941435, 0.30555015, 0.35118674], ]), 1e-8, - )); - assert!(a.std_axis(Axis(2), 2.3).all_close( + ); + assert_abs_diff_eq!(a.std_axis(Axis(2), 2.3), &aview2(&[ [ 0.41117907, 0.37130425, 0.35332388], [ 0.16905862, 0.25304841, 0.39978276], ]), 1e-8, - )); + ); let b = array![[100000., 1., 0.01]]; - assert!(b.std_axis(Axis(0), 0.).all_close(&aview1(&[0., 0., 0.]), 1e-12)); - assert!( - b.std_axis(Axis(1), 0.).all_close(&aview1(&[47140.214021552769]), 1e-6), + assert_abs_diff_eq!(b.std_axis(Axis(0), 0.), &aview1(&[0., 0., 0.]), 1e-12); + assert_abs_diff_eq!( + b.std_axis(Axis(1), 0.), &aview1(&[47140.214021552769]), 1e-6, ); let c = array![[], []]; From 9f9aeba68d880730ed52ae73f6551e8888caaa69 Mon Sep 17 00:00:00 2001 From: Jim Turner Date: Sun, 5 May 2019 11:56:32 -0400 Subject: [PATCH 16/22] Impl approx traits for differing element types --- src/array_approx.rs | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/src/array_approx.rs b/src/array_approx.rs index eb0a32fde..0d6a6cd9c 100644 --- a/src/array_approx.rs +++ b/src/array_approx.rs @@ -3,12 +3,12 @@ use crate::Zip; use approx::{AbsDiffEq, RelativeEq, UlpsEq}; /// **Requires crate feature `"approx"`** -impl AbsDiffEq> for ArrayBase +impl AbsDiffEq> for ArrayBase where - A: AbsDiffEq, + A: AbsDiffEq, A::Epsilon: Clone, S: Data, - T: Data, + S2: Data, D: Dimension, { type Epsilon = A::Epsilon; @@ -17,7 +17,7 @@ where A::default_epsilon() } - fn abs_diff_eq(&self, other: &ArrayBase, epsilon: A::Epsilon) -> bool { + fn abs_diff_eq(&self, other: &ArrayBase, epsilon: A::Epsilon) -> bool { if self.shape() != other.shape() { return false; } @@ -28,12 +28,12 @@ where } /// **Requires crate feature `"approx"`** -impl RelativeEq> for ArrayBase +impl RelativeEq> for ArrayBase where - A: RelativeEq, + A: RelativeEq, A::Epsilon: Clone, S: Data, - T: Data, + S2: Data, D: Dimension, { fn default_max_relative() -> A::Epsilon { @@ -42,7 +42,7 @@ where fn relative_eq( &self, - other: &ArrayBase, + other: &ArrayBase, epsilon: A::Epsilon, max_relative: A::Epsilon, ) -> bool { @@ -56,19 +56,19 @@ where } /// **Requires crate feature `"approx"`** -impl UlpsEq> for ArrayBase +impl UlpsEq> for ArrayBase where - A: UlpsEq, + A: UlpsEq, A::Epsilon: Clone, S: Data, - T: Data, + S2: Data, D: Dimension, { fn default_max_ulps() -> u32 { A::default_max_ulps() } - fn ulps_eq(&self, other: &ArrayBase, epsilon: A::Epsilon, max_ulps: u32) -> bool { + fn ulps_eq(&self, other: &ArrayBase, epsilon: A::Epsilon, max_ulps: u32) -> bool { if self.shape() != other.shape() { return false; } From 54a68951bfc4325513752af3e6dd45ef196fa312 Mon Sep 17 00:00:00 2001 From: Jim Turner Date: Sun, 5 May 2019 12:03:52 -0400 Subject: [PATCH 17/22] Fix unused import warning --- tests/array.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tests/array.rs b/tests/array.rs index f9d42638d..bca8bf47c 100644 --- a/tests/array.rs +++ b/tests/array.rs @@ -12,7 +12,6 @@ use ndarray::{ multislice, }; use ndarray::indices; -use approx::AbsDiffEq; use defmac::defmac; use itertools::{enumerate, zip, Itertools}; @@ -683,6 +682,8 @@ fn test_sub_oob_1() { #[test] #[cfg(feature = "approx")] fn test_select(){ + use approx::AbsDiffEq; + // test for 2-d array let x = arr2(&[[0., 1.], [1.,0.],[1.,0.],[1.,0.],[1.,0.],[0., 1.],[0., 1.]]); let r = x.select(Axis(0),&[1,3,5]); @@ -1737,6 +1738,7 @@ fn test_contiguous() { #[test] #[cfg(feature = "approx")] fn test_all_close() { + use approx::AbsDiffEq; let c = arr3(&[[[1., 2., 3.], [1.5, 1.5, 3.]], [[1., 2., 3.], From bdb2b867e0c3306a6fd6b6e6bf25a1460983a705 Mon Sep 17 00:00:00 2001 From: Jim Turner Date: Sun, 5 May 2019 12:10:27 -0400 Subject: [PATCH 18/22] Remove duplicate type parameter --- src/array_approx.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/array_approx.rs b/src/array_approx.rs index 0d6a6cd9c..82c95a224 100644 --- a/src/array_approx.rs +++ b/src/array_approx.rs @@ -56,7 +56,7 @@ where } /// **Requires crate feature `"approx"`** -impl UlpsEq> for ArrayBase +impl UlpsEq> for ArrayBase where A: UlpsEq, A::Epsilon: Clone, From a2070aa6e5655626db2f09131a0316a0d9f9dfa1 Mon Sep 17 00:00:00 2001 From: Jim Turner Date: Sun, 5 May 2019 13:06:38 -0400 Subject: [PATCH 19/22] Fix link in docs --- src/doc/ndarray_for_numpy_users/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/doc/ndarray_for_numpy_users/mod.rs b/src/doc/ndarray_for_numpy_users/mod.rs index 79acad788..c8274b45d 100644 --- a/src/doc/ndarray_for_numpy_users/mod.rs +++ b/src/doc/ndarray_for_numpy_users/mod.rs @@ -557,7 +557,7 @@ //! `a[:,4]` | [`a.column(4)`][.column()] or [`a.column_mut(4)`][.column_mut()] | view (or mutable view) of column 4 in a 2-D array //! `a.shape[0] == a.shape[1]` | [`a.is_square()`][.is_square()] | check if the array is square //! -//! [.abs_diff_eq()]: ../../struct.ArrayBase.html#impl-AbsDiffEq> +//! [.abs_diff_eq()]: ../../struct.ArrayBase.html#impl-AbsDiffEq> //! [ArcArray]: ../../type.ArcArray.html //! [arr2()]: ../../fn.arr2.html //! [array!]: ../../macro.array.html From 3219842153cba7c2cd72ba7a30de09ed8aa39291 Mon Sep 17 00:00:00 2001 From: Jim Turner Date: Sun, 5 May 2019 14:34:36 -0400 Subject: [PATCH 20/22] Fix tests --- src/geomspace.rs | 14 +++++----- src/impl_constructors.rs | 12 ++++----- src/impl_methods.rs | 10 ++++--- src/logspace.rs | 14 +++++----- tests/array-construct.rs | 6 +++-- tests/array.rs | 21 ++++++--------- tests/azip.rs | 21 ++++++++++----- tests/numeric.rs | 58 ++++++++++++++++++++++++---------------- tests/par_azip.rs | 6 +++-- tests/par_rayon.rs | 5 ++-- 10 files changed, 96 insertions(+), 71 deletions(-) diff --git a/src/geomspace.rs b/src/geomspace.rs index 93b73329b..63136190f 100644 --- a/src/geomspace.rs +++ b/src/geomspace.rs @@ -106,22 +106,24 @@ where #[cfg(test)] mod tests { use super::geomspace; - use crate::{arr1, Array1}; #[test] - #[cfg(approx)] + #[cfg(feature = "approx")] fn valid() { + use approx::assert_abs_diff_eq; + use crate::{arr1, Array1}; + let array: Array1<_> = geomspace(1e0, 1e3, 4).collect(); - assert!(array.abs_diff_eq(&arr1(&[1e0, 1e1, 1e2, 1e3]), 1e-5)); + assert_abs_diff_eq!(array, arr1(&[1e0, 1e1, 1e2, 1e3]), epsilon = 1e-12); let array: Array1<_> = geomspace(1e3, 1e0, 4).collect(); - assert!(array.abs_diff_eq(&arr1(&[1e3, 1e2, 1e1, 1e0]), 1e-5)); + assert_abs_diff_eq!(array, arr1(&[1e3, 1e2, 1e1, 1e0]), epsilon = 1e-12); let array: Array1<_> = geomspace(-1e3, -1e0, 4).collect(); - assert!(array.abs_diff_eq(&arr1(&[-1e3, -1e2, -1e1, -1e0]), 1e-5)); + assert_abs_diff_eq!(array, arr1(&[-1e3, -1e2, -1e1, -1e0]), epsilon = 1e-12); let array: Array1<_> = geomspace(-1e0, -1e3, 4).collect(); - assert!(array.abs_diff_eq(&arr1(&[-1e0, -1e1, -1e2, -1e3]), 1e-5)); + assert_abs_diff_eq!(array, arr1(&[-1e0, -1e1, -1e2, -1e3]), epsilon = 1e-12); } #[test] diff --git a/src/impl_constructors.rs b/src/impl_constructors.rs index fca687a0c..72dbfd310 100644 --- a/src/impl_constructors.rs +++ b/src/impl_constructors.rs @@ -111,15 +111,15 @@ impl ArrayBase /// **Panics** if the length is greater than `isize::MAX`. /// /// ```rust + /// use approx::assert_abs_diff_eq; /// use ndarray::{Array, arr1}; - /// use approx::AbsDiffEq; /// /// # #[cfg(feature = "approx")] { /// let array = Array::logspace(10.0, 0.0, 3.0, 4); - /// assert!(array.abs_diff_eq(&arr1(&[1e0, 1e1, 1e2, 1e3]), 1e-5)); + /// assert_abs_diff_eq!(array, arr1(&[1e0, 1e1, 1e2, 1e3])); /// /// let array = Array::logspace(-10.0, 3.0, 0.0, 4); - /// assert!(array.abs_diff_eq(&arr1(&[-1e3, -1e2, -1e1, -1e0]), 1e-5)); + /// assert_abs_diff_eq!(array, arr1(&[-1e3, -1e2, -1e1, -1e0])); /// # } /// ``` pub fn logspace(base: A, start: A, end: A, n: usize) -> Self @@ -139,15 +139,15 @@ impl ArrayBase /// **Panics** if `n` is greater than `isize::MAX`. /// /// ```rust + /// use approx::assert_abs_diff_eq; /// use ndarray::{Array, arr1}; - /// use approx::AbsDiffEq; /// /// # #[cfg(feature = "approx")] { /// let array = Array::geomspace(1e0, 1e3, 4); - /// assert!(array.abs_diff_eq(&arr1(&[1e0, 1e1, 1e2, 1e3]), 1e-5)); + /// assert_abs_diff_eq!(array, arr1(&[1e0, 1e1, 1e2, 1e3]), epsilon = 1e-12); /// /// let array = Array::geomspace(-1e3, -1e0, 4); - /// assert!(array.abs_diff_eq(&arr1(&[-1e3, -1e2, -1e1, -1e0]), 1e-5)); + /// assert_abs_diff_eq!(array, arr1(&[-1e3, -1e2, -1e1, -1e0]), epsilon = 1e-12); /// # } /// ``` pub fn geomspace(start: A, end: A, n: usize) -> Self diff --git a/src/impl_methods.rs b/src/impl_methods.rs index 5887bebcb..21a5ac013 100644 --- a/src/impl_methods.rs +++ b/src/impl_methods.rs @@ -2039,16 +2039,18 @@ where /// Elements are visited in arbitrary order. /// /// ``` + /// use approx::assert_abs_diff_eq; /// use ndarray::arr2; - /// use approx::AbsDiffEq; /// /// # #[cfg(feature = "approx")] { /// let mut a = arr2(&[[ 0., 1.], /// [-1., 2.]]); /// a.mapv_inplace(f32::exp); - /// assert!( - /// a.abs_diff_eq(&arr2(&[[1.00000, 2.71828], - /// [0.36788, 7.38906]]), 1e-5) + /// assert_abs_diff_eq!( + /// a, + /// arr2(&[[1.00000, 2.71828], + /// [0.36788, 7.38906]]), + /// epsilon = 1e-5, /// ); /// # } /// ``` diff --git a/src/logspace.rs b/src/logspace.rs index 7aa6d11e2..7a32f3795 100644 --- a/src/logspace.rs +++ b/src/logspace.rs @@ -96,22 +96,24 @@ where #[cfg(test)] mod tests { use super::logspace; - use crate::{arr1, Array1}; #[test] - #[cfg(approx)] + #[cfg(feature = "approx")] fn valid() { + use approx::assert_abs_diff_eq; + use crate::{arr1, Array1}; + let array: Array1<_> = logspace(10.0, 0.0, 3.0, 4).collect(); - assert!(array.abs_diff_eq(&arr1(&[1e0, 1e1, 1e2, 1e3]), 1e-5)); + assert_abs_diff_eq!(array, arr1(&[1e0, 1e1, 1e2, 1e3])); let array: Array1<_> = logspace(10.0, 3.0, 0.0, 4).collect(); - assert!(array.abs_diff_eq(&arr1(&[1e3, 1e2, 1e1, 1e0]), 1e-5)); + assert_abs_diff_eq!(array, arr1(&[1e3, 1e2, 1e1, 1e0])); let array: Array1<_> = logspace(-10.0, 3.0, 0.0, 4).collect(); - assert!(array.abs_diff_eq(&arr1(&[-1e3, -1e2, -1e1, -1e0]), 1e-5)); + assert_abs_diff_eq!(array, arr1(&[-1e3, -1e2, -1e1, -1e0])); let array: Array1<_> = logspace(-10.0, 0.0, 3.0, 4).collect(); - assert!(array.abs_diff_eq(&arr1(&[-1e0, -1e1, -1e2, -1e3]), 1e-5)); + assert_abs_diff_eq!(array, arr1(&[-1e0, -1e1, -1e2, -1e3])); } #[test] diff --git a/tests/array-construct.rs b/tests/array-construct.rs index e14b9f9fd..726892052 100644 --- a/tests/array-construct.rs +++ b/tests/array-construct.rs @@ -21,15 +21,17 @@ fn test_dimension_zero() { } #[test] -#[cfg(features = "approx")] +#[cfg(feature = "approx")] fn test_arc_into_owned() { + use approx::assert_abs_diff_ne; + let a = Array2::from_elem((5, 5), 1.).into_shared(); let mut b = a.clone(); b.fill(0.); let mut c = b.into_owned(); c.fill(2.); // test that they are unshared - assert_abs_diff_ne!(a, &c, 0.01); + assert_abs_diff_ne!(a, c, epsilon = 0.01); } #[test] diff --git a/tests/array.rs b/tests/array.rs index bca8bf47c..2739dd582 100644 --- a/tests/array.rs +++ b/tests/array.rs @@ -682,7 +682,7 @@ fn test_sub_oob_1() { #[test] #[cfg(feature = "approx")] fn test_select(){ - use approx::AbsDiffEq; + use approx::assert_abs_diff_eq; // test for 2-d array let x = arr2(&[[0., 1.], [1.,0.],[1.,0.],[1.,0.],[1.,0.],[0., 1.],[0., 1.]]); @@ -690,8 +690,8 @@ fn test_select(){ let c = x.select(Axis(1),&[1]); let r_target = arr2(&[[1.,0.],[1.,0.],[0., 1.]]); let c_target = arr2(&[[1.,0.,0.,0.,0., 1., 1.]]); - assert!(r.abs_diff_eq(&r_target,1e-8)); - assert!(c.abs_diff_eq(&c_target.t(),1e-8)); + assert_abs_diff_eq!(r, r_target); + assert_abs_diff_eq!(c, c_target.t()); // test for 3-d array let y = arr3(&[[[1., 2., 3.], @@ -702,8 +702,8 @@ fn test_select(){ let c = y.select(Axis(2),&[1]); let r_target = arr3(&[[[1.5, 1.5, 3.]], [[1., 2.5, 3.]]]); let c_target = arr3(&[[[2.],[1.5]],[[2.],[2.5]]]); - assert!(r.abs_diff_eq(&r_target,1e-8)); - assert!(c.abs_diff_eq(&c_target,1e-8)); + assert_abs_diff_eq!(r, r_target); + assert_abs_diff_eq!(c, c_target); } @@ -1736,19 +1736,14 @@ fn test_contiguous() { } #[test] -#[cfg(feature = "approx")] +#[allow(deprecated)] fn test_all_close() { - use approx::AbsDiffEq; let c = arr3(&[[[1., 2., 3.], [1.5, 1.5, 3.]], [[1., 2., 3.], [1., 2.5, 3.]]]); - assert!( - c.abs_diff_eq(&aview1(&[1., 2., 3.]).broadcast(c.raw_dim()).unwrap(), 1.) - ); - assert!( - c.abs_diff_ne(&aview1(&[1., 2., 3.]).broadcast(c.raw_dim()).unwrap(), 0.1) - ); + assert!(c.all_close(&aview1(&[1., 2., 3.]), 1.)); + assert!(!c.all_close(&aview1(&[1., 2., 3.]), 0.1)); } #[test] diff --git a/tests/azip.rs b/tests/azip.rs index 9e4efabce..771797706 100644 --- a/tests/azip.rs +++ b/tests/azip.rs @@ -45,24 +45,28 @@ fn test_azip2_3() { } #[test] -#[cfg(features = "approx")] +#[cfg(feature = "approx")] fn test_azip2_sum() { + use approx::assert_abs_diff_eq; + let c = Array::from_shape_fn((5, 10), |(i, j)| f32::exp((i + j) as f32)); for i in 0..2 { let ax = Axis(i); let mut b = Array::zeros(c.len_of(ax)); azip!(mut b, ref c (c.axis_iter(ax)) in { *b = c.sum() }); - assert_abs_diff_eq!(b, c.sum_axis(Axis(1 - i)), 1e-6); + assert_abs_diff_eq!(b, c.sum_axis(Axis(1 - i)), epsilon = 1e-6); } } #[test] -#[cfg(features = "approx")] +#[cfg(feature = "approx")] fn test_azip3_slices() { + use approx::assert_abs_diff_eq; + let mut a = [0.; 32]; let mut b = [0.; 32]; let mut c = [0.; 32]; - for (i, elt) in enumerate(&mut b) { + for (i, elt) in b.iter_mut().enumerate() { *elt = i as f32; } @@ -71,12 +75,14 @@ fn test_azip3_slices() { *c = a.sin(); }); let res = Array::linspace(0., 3.1, 32).mapv_into(f32::sin); - assert_abs_diff_eq!(res, &ArrayView::from(&c), 1e-4); + assert_abs_diff_eq!(res, ArrayView::from(&c), epsilon = 1e-4); } #[test] -#[cfg(features = "approx")] +#[cfg(feature = "approx")] fn test_broadcast() { + use approx::assert_abs_diff_eq; + let n = 16; let mut a = Array::::zeros((n, n)); let mut b = Array::::from_elem((1, n), 1.); @@ -93,7 +99,8 @@ fn test_broadcast() { .and_broadcast(&e); z.apply(|x, &y, &z, &w| *x = y + z + w); } - assert_abs_diff_eq!(a, &(&b + &d + &e), 1e-4); + let sum = &b + &d + &e; + assert_abs_diff_eq!(a, sum.broadcast((n, n)).unwrap(), epsilon = 1e-4); } #[should_panic] diff --git a/tests/numeric.rs b/tests/numeric.rs index a9aaf7c91..5fe911248 100644 --- a/tests/numeric.rs +++ b/tests/numeric.rs @@ -1,7 +1,7 @@ extern crate approx; use std::f64; use ndarray::{array, Axis, aview1, arr0, arr1, arr2, Array, Array1, Array2, Array3}; -use approx::abs_diff_eq; +use approx::assert_abs_diff_eq; #[test] fn test_mean_with_nan_values() { @@ -29,9 +29,8 @@ fn test_mean_with_array_of_floats() { 0.63608897, 0.84959691, 0.43599069, 0.77867775, 0.88267754, 0.83003623, 0.67016118, 0.67547638, 0.65220036, 0.68043427 ]; - // Computed using NumPy - let expected_mean = 0.5475494059146699; - abs_diff_eq!(a.mean().unwrap(), expected_mean, epsilon = f64::EPSILON); + let exact_mean = 0.5475494054; + assert_abs_diff_eq!(a.mean().unwrap(), exact_mean); } #[test] @@ -62,8 +61,10 @@ fn sum_mean_empty() { } #[test] -#[cfg(features = "approx")] +#[cfg(feature = "approx")] fn var_axis() { + use ndarray::{aview0, aview2}; + let a = array![ [ [-9.76, -0.38, 1.59, 6.23], @@ -83,37 +84,39 @@ fn var_axis() { [9.672100e+00, 2.289169e+02, 7.344490e+01, 2.171560e+01], [7.157160e+01, 1.849000e-01, 2.631690e+01, 5.314410e+01] ]), - 1e-4, + epsilon = 1e-4, ); assert_abs_diff_eq!(a.var_axis(Axis(1), 1.7), &aview2(&[ [0.61676923, 80.81092308, 6.79892308, 0.11789744], [75.19912821, 114.25235897, 48.32405128, 9.03020513], ]), - 1e-8, + epsilon = 1e-8, ); assert_abs_diff_eq!(a.var_axis(Axis(2), 2.3), &aview2(&[ [ 79.64552941, 129.09663235, 95.98929412], [109.64952941, 43.28758824, 36.27439706], ]), - 1e-8, + epsilon = 1e-8, ); let b = array![[1.1, 2.3, 4.7]]; - assert_abs_diff_eq!(b.var_axis(Axis(0), 0.), &aview1(&[0., 0., 0.]), 1e-12); - assert_abs_diff_eq!(b.var_axis(Axis(1), 0.), &aview1(&[2.24]), 1e-12); + assert_abs_diff_eq!(b.var_axis(Axis(0), 0.), &aview1(&[0., 0., 0.]), epsilon = 1e-12); + assert_abs_diff_eq!(b.var_axis(Axis(1), 0.), &aview1(&[2.24]), epsilon = 1e-12); let c = array![[], []]; assert_eq!(c.var_axis(Axis(0), 0.), aview1(&[])); let d = array![1.1, 2.7, 3.5, 4.9]; - assert_abs_diff_eq!(d.var_axis(Axis(0), 0.), &aview0(&1.8875), 1e-12); + assert_abs_diff_eq!(d.var_axis(Axis(0), 0.), &aview0(&1.8875), epsilon = 1e-12); } #[test] -#[cfg(features = "approx")] +#[cfg(feature = "approx")] fn std_axis() { + use ndarray::aview2; + let a = array![ [ [ 0.22935481, 0.08030619, 0.60827517, 0.73684379], @@ -126,33 +129,42 @@ fn std_axis() { [ 0.51529756, 0.70111616, 0.20799415, 0.91851457] ], ]; - assert_abs_diff_eq!(a.std_axis(Axis(0), 1.5), - &aview2(&[ + assert_abs_diff_eq!( + a.std_axis(Axis(0), 1.5), + aview2(&[ [ 0.05989184, 0.36051836, 0.00989781, 0.32669847], [ 0.81957535, 0.39599997, 0.49731472, 0.17084346], [ 0.07044443, 0.06795249, 0.09794304, 0.83195211], ]), - 1e-4, + epsilon = 1e-4, ); - assert_abs_diff_eq!(a.std_axis(Axis(1), 1.7), - &aview2(&[ + assert_abs_diff_eq!( + a.std_axis(Axis(1), 1.7), + aview2(&[ [ 0.42698655, 0.48139215, 0.36874991, 0.41458724], [ 0.26769097, 0.18941435, 0.30555015, 0.35118674], ]), - 1e-8, + epsilon = 1e-8, ); - assert_abs_diff_eq!(a.std_axis(Axis(2), 2.3), - &aview2(&[ + assert_abs_diff_eq!( + a.std_axis(Axis(2), 2.3), + aview2(&[ [ 0.41117907, 0.37130425, 0.35332388], [ 0.16905862, 0.25304841, 0.39978276], ]), - 1e-8, + epsilon = 1e-8, ); let b = array![[100000., 1., 0.01]]; - assert_abs_diff_eq!(b.std_axis(Axis(0), 0.), &aview1(&[0., 0., 0.]), 1e-12); assert_abs_diff_eq!( - b.std_axis(Axis(1), 0.), &aview1(&[47140.214021552769]), 1e-6, + b.std_axis(Axis(0), 0.), + aview1(&[0., 0., 0.]), + epsilon = 1e-12, + ); + assert_abs_diff_eq!( + b.std_axis(Axis(1), 0.), + aview1(&[47140.214021552769]), + epsilon = 1e-6, ); let c = array![[], []]; diff --git a/tests/par_azip.rs b/tests/par_azip.rs index d373345e4..153c81f10 100644 --- a/tests/par_azip.rs +++ b/tests/par_azip.rs @@ -25,8 +25,10 @@ fn test_par_azip2() { } #[test] -#[cfg(features = "approx")] +#[cfg(feature = "approx")] fn test_par_azip3() { + use approx::assert_abs_diff_eq; + let mut a = [0.; 32]; let mut b = [0.; 32]; let mut c = [0.; 32]; @@ -39,7 +41,7 @@ fn test_par_azip3() { *c = a.sin(); }); let res = Array::linspace(0., 3.1, 32).mapv_into(f32::sin); - assert_abs_diff_eq!(res, &ArrayView::from(&c), 1e-4); + assert_abs_diff_eq!(res, ArrayView::from(&c), epsilon = 1e-4); } #[should_panic] diff --git a/tests/par_rayon.rs b/tests/par_rayon.rs index 6dda0a1d1..9407daeb6 100644 --- a/tests/par_rayon.rs +++ b/tests/par_rayon.rs @@ -24,13 +24,14 @@ fn test_axis_iter() { } #[test] -#[cfg(features = "approx")] +#[cfg(feature = "approx")] fn test_axis_iter_mut() { + use approx::assert_abs_diff_eq; let mut a = Array::linspace(0., 1.0f64, M * N).into_shape((M, N)).unwrap(); let b = a.mapv(|x| x.exp()); a.axis_iter_mut(Axis(0)).into_par_iter().for_each(|mut v| v.mapv_inplace(|x| x.exp())); println!("{:?}", a.slice(s![..10, ..5])); - assert_abs_diff_eq!(a, &b, 0.001); + assert_abs_diff_eq!(a, b, epsilon = 0.001); } #[test] From 3d89f7dd526799d64693c82ba2640d6a062dead7 Mon Sep 17 00:00:00 2001 From: Jim Turner Date: Sun, 5 May 2019 14:41:18 -0400 Subject: [PATCH 21/22] Fix formatting --- tests/numeric.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tests/numeric.rs b/tests/numeric.rs index 5fe911248..06d2f50a4 100644 --- a/tests/numeric.rs +++ b/tests/numeric.rs @@ -86,14 +86,16 @@ fn var_axis() { ]), epsilon = 1e-4, ); - assert_abs_diff_eq!(a.var_axis(Axis(1), 1.7), + assert_abs_diff_eq!( + a.var_axis(Axis(1), 1.7), &aview2(&[ [0.61676923, 80.81092308, 6.79892308, 0.11789744], [75.19912821, 114.25235897, 48.32405128, 9.03020513], ]), epsilon = 1e-8, ); - assert_abs_diff_eq!(a.var_axis(Axis(2), 2.3), + assert_abs_diff_eq!( + a.var_axis(Axis(2), 2.3), &aview2(&[ [ 79.64552941, 129.09663235, 95.98929412], [109.64952941, 43.28758824, 36.27439706], From e7ea7f37e16c6bccd06acf73a77f58ca5d42f282 Mon Sep 17 00:00:00 2001 From: Jim Turner Date: Sun, 5 May 2019 14:43:57 -0400 Subject: [PATCH 22/22] Remove unnecessary & --- tests/numeric.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/numeric.rs b/tests/numeric.rs index 06d2f50a4..403524413 100644 --- a/tests/numeric.rs +++ b/tests/numeric.rs @@ -79,7 +79,7 @@ fn var_axis() { ]; assert_abs_diff_eq!( a.var_axis(Axis(0), 1.5), - &aview2(&[ + aview2(&[ [3.236401e+02, 8.556250e+01, 4.708900e+00, 9.428410e+01], [9.672100e+00, 2.289169e+02, 7.344490e+01, 2.171560e+01], [7.157160e+01, 1.849000e-01, 2.631690e+01, 5.314410e+01] @@ -88,7 +88,7 @@ fn var_axis() { ); assert_abs_diff_eq!( a.var_axis(Axis(1), 1.7), - &aview2(&[ + aview2(&[ [0.61676923, 80.81092308, 6.79892308, 0.11789744], [75.19912821, 114.25235897, 48.32405128, 9.03020513], ]), @@ -96,7 +96,7 @@ fn var_axis() { ); assert_abs_diff_eq!( a.var_axis(Axis(2), 2.3), - &aview2(&[ + aview2(&[ [ 79.64552941, 129.09663235, 95.98929412], [109.64952941, 43.28758824, 36.27439706], ]), @@ -104,14 +104,14 @@ fn var_axis() { ); let b = array![[1.1, 2.3, 4.7]]; - assert_abs_diff_eq!(b.var_axis(Axis(0), 0.), &aview1(&[0., 0., 0.]), epsilon = 1e-12); - assert_abs_diff_eq!(b.var_axis(Axis(1), 0.), &aview1(&[2.24]), epsilon = 1e-12); + assert_abs_diff_eq!(b.var_axis(Axis(0), 0.), aview1(&[0., 0., 0.]), epsilon = 1e-12); + assert_abs_diff_eq!(b.var_axis(Axis(1), 0.), aview1(&[2.24]), epsilon = 1e-12); let c = array![[], []]; assert_eq!(c.var_axis(Axis(0), 0.), aview1(&[])); let d = array![1.1, 2.7, 3.5, 4.9]; - assert_abs_diff_eq!(d.var_axis(Axis(0), 0.), &aview0(&1.8875), epsilon = 1e-12); + assert_abs_diff_eq!(d.var_axis(Axis(0), 0.), aview0(&1.8875), epsilon = 1e-12); } #[test]