Implement approx traits for ArrayBase

Author: jturner314

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"

src/arraytraits.rs

@@ -113,6 +113,92 @@ impl<S, D> Eq for ArrayBase<S, D>
           S::Elem: Eq,
 { }
 
+impl<A, S, D> approx::AbsDiffEq for ArrayBase<S, D>
+where
+    A: approx::AbsDiffEq,
+    A::Epsilon: Clone,
+    S: Data<Elem = A>,
+    D: Dimension,
+{
+    type Epsilon = A::Epsilon;
+
+    fn default_epsilon() -> A::Epsilon {
+        A::default_epsilon()
+    }
+
+    fn abs_diff_eq(&self, other: &ArrayBase<S, D>, 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<A, S, D> approx::RelativeEq for ArrayBase<S, D>
+where
+    A: approx::RelativeEq,
+    A::Epsilon: Clone,
+    S: Data<Elem = A>,
+    D: Dimension,
+{
+    fn default_max_relative() -> A::Epsilon {
+        A::default_max_relative()
+    }
+
+    fn relative_eq(&self, other: &ArrayBase<S, D>, 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<A, S, D> approx::UlpsEq for ArrayBase<S, D>
+where
+    A: approx::UlpsEq,
+    A::Epsilon: Clone,
+    S: Data<Elem = A>,
+    D: Dimension,
+{
+    fn default_max_ulps() -> u32 {
+        A::default_max_ulps()
+    }
+
+    fn ulps_eq(&self, other: &ArrayBase<S, D>, 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<A, S> FromIterator<A> for ArrayBase<S, Ix1>
     where S: DataOwned<Elem=A>
 {

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;

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<f32> = array![[0., 2.], [-0.000010001, 100000000.]];
+    let mut b: Array2<f32> = 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<f32> = array![[1., 2.], [-0.000010001, 100000000.]];
+    let mut b: Array2<f32> = 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<f32> = array![[1., 2.], [-0.000010001, 100000000.]];
+    let mut b: Array2<f32> = 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()
 {