Polish approx

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 }
@@ -49,6 +49,8 @@ serde = { version = "1.0", optional = true }
 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.2"
 
 [features]
 # Enable blas usage

examples/column_standardize.rs

@@ -23,9 +23,9 @@ fn main() {
                           [ 2.,  2.,  2.]];
 
     println!("{:8.4}", data);
-    println!("{:8.4} (Mean axis=0)", data.mean_axis(Axis(0)));
+    println!("{:8.4} (Mean axis=0)", data.mean_axis(Axis(0)).unwrap());
 
-    data -= &data.mean_axis(Axis(0));
+    data -= &data.mean_axis(Axis(0)).unwrap();
     println!("{:8.4}", data);
 
     data /= &std(&data, Axis(0));

src/array_approx.rs

@@ -1,13 +1,14 @@
 use crate::imp_prelude::*;
-use crate::{FoldWhile, Zip};
+use crate::Zip;
 use approx::{AbsDiffEq, RelativeEq, UlpsEq};
 
 /// **Requires crate feature `"approx"`**
-impl<A, S, D> AbsDiffEq for ArrayBase<S, D>
+impl<A, S, T, D> AbsDiffEq<ArrayBase<T, D>> for ArrayBase<S, D>
 where
     A: AbsDiffEq,
     A::Epsilon: Clone,
     S: Data<Elem = A>,
+    T: Data<Elem = A>,
     D: Dimension,
 {
     type Epsilon = A::Epsilon;
@@ -16,29 +17,23 @@ where
         A::default_epsilon()
     }
 
-    fn abs_diff_eq(&self, other: &ArrayBase<S, D>, epsilon: A::Epsilon) -> bool {
+    fn abs_diff_eq(&self, other: &ArrayBase<T, 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()
+            .all(|a, b| A::abs_diff_eq(a, b, epsilon.clone()))
     }
 }
 
 /// **Requires crate feature `"approx"`**
-impl<A, S, D> RelativeEq for ArrayBase<S, D>
+impl<A, S, T, D> RelativeEq<ArrayBase<T, D>> for ArrayBase<S, D>
 where
     A: RelativeEq,
     A::Epsilon: Clone,
     S: Data<Elem = A>,
+    T: Data<Elem = A>,
     D: Dimension,
 {
     fn default_max_relative() -> A::Epsilon {
@@ -47,7 +42,7 @@ where
 
     fn relative_eq(
         &self,
-        other: &ArrayBase<S, D>,
+        other: &ArrayBase<T, D>,
         epsilon: A::Epsilon,
         max_relative: A::Epsilon,
     ) -> bool {
@@ -56,43 +51,30 @@ 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, b| A::relative_eq(a, b, epsilon.clone(), max_relative.clone()))
     }
 }
 
 /// **Requires crate feature `"approx"`**
-impl<A, S, D> UlpsEq for ArrayBase<S, D>
+impl<A, S, D, T> UlpsEq<ArrayBase<T, D>> for ArrayBase<S, D>
 where
     A: UlpsEq,
     A::Epsilon: Clone,
     S: Data<Elem = A>,
+    T: 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 {
+    fn ulps_eq(&self, other: &ArrayBase<T, 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()
+            .all(|a, b| A::ulps_eq(a, b, epsilon.clone(), max_ulps))
     }
 }