diff --git a/Cargo.toml b/Cargo.toml
index 395f35e31..e9ea56d8c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,6 +35,8 @@ itertools = { version = "0.8.0", default-features = false }
 
 rayon = { version = "1.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 }
 blas-src = { version = "0.2.0", optional = true, default-features = false }
@@ -47,8 +49,8 @@ serde = { version = "1.0", optional = true }
 defmac = "0.2"
 quickcheck = { version = "0.8", default-features = false }
 rawpointer = "0.1"
+approx = "0.3.2"
 itertools = { version = "0.8.0", default-features = false, features = ["use_std"] }
-approx = "0.3"
 
 [features]
 # Enable blas usage
@@ -63,7 +65,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..82c95a224
--- /dev/null
+++ b/src/array_approx.rs
@@ -0,0 +1,139 @@
+use crate::imp_prelude::*;
+use crate::Zip;
+use approx::{AbsDiffEq, RelativeEq, UlpsEq};
+
+/// **Requires crate feature `"approx"`**
+impl<A, B, S, S2, D> AbsDiffEq<ArrayBase<S2, D>> for ArrayBase<S, D>
+where
+    A: AbsDiffEq<B>,
+    A::Epsilon: Clone,
+    S: Data<Elem = A>,
+    S2: Data<Elem = B>,
+    D: Dimension,
+{
+    type Epsilon = A::Epsilon;
+
+    fn default_epsilon() -> A::Epsilon {
+        A::default_epsilon()
+    }
+
+    fn abs_diff_eq(&self, other: &ArrayBase<S2, D>, epsilon: A::Epsilon) -> bool {
+        if self.shape() != other.shape() {
+            return false;
+        }
+        Zip::from(self)
+            .and(other)
+            .all(|a, b| A::abs_diff_eq(a, b, epsilon.clone()))
+    }
+}
+
+/// **Requires crate feature `"approx"`**
+impl<A, B, S, S2, D> RelativeEq<ArrayBase<S2, D>> for ArrayBase<S, D>
+where
+    A: RelativeEq<B>,
+    A::Epsilon: Clone,
+    S: Data<Elem = A>,
+    S2: Data<Elem = B>,
+    D: Dimension,
+{
+    fn default_max_relative() -> A::Epsilon {
+        A::default_max_relative()
+    }
+
+    fn relative_eq(
+        &self,
+        other: &ArrayBase<S2, D>,
+        epsilon: A::Epsilon,
+        max_relative: A::Epsilon,
+    ) -> bool {
+        if self.shape() != other.shape() {
+            return false;
+        }
+        Zip::from(self)
+            .and(other)
+            .all(|a, b| A::relative_eq(a, b, epsilon.clone(), max_relative.clone()))
+    }
+}
+
+/// **Requires crate feature `"approx"`**
+impl<A, B, S, S2, D> UlpsEq<ArrayBase<S2, D>> for ArrayBase<S, D>
+where
+    A: UlpsEq<B>,
+    A::Epsilon: Clone,
+    S: Data<Elem = A>,
+    S2: Data<Elem = B>,
+    D: Dimension,
+{
+    fn default_max_ulps() -> u32 {
+        A::default_max_ulps()
+    }
+
+    fn ulps_eq(&self, other: &ArrayBase<S2, D>, epsilon: A::Epsilon, max_ulps: u32) -> bool {
+        if self.shape() != other.shape() {
+            return false;
+        }
+        Zip::from(self)
+            .and(other)
+            .all(|a, b| A::ulps_eq(a, b, epsilon.clone(), max_ulps))
+    }
+}
+
+#[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<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);
+    }
+}
diff --git a/src/doc/ndarray_for_numpy_users/mod.rs b/src/doc/ndarray_for_numpy_users/mod.rs
index b268c9b24..c8274b45d 100644
--- a/src/doc/ndarray_for_numpy_users/mod.rs
+++ b/src/doc/ndarray_for_numpy_users/mod.rs
@@ -473,7 +473,7 @@
 //!
 //! </td><td>
 //!
-//! [`a.all_close(&b, 1e-8)`][.all_close()]
+//! [`a.abs_diff_eq(&b, 1e-8)`][.abs_diff_eq()]
 //!
 //! </td><td>
 //!
@@ -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<ArrayBase<S2%2C%20D>>
 //! [ArcArray]: ../../type.ArcArray.html
 //! [arr2()]: ../../fn.arr2.html
 //! [array!]: ../../macro.array.html
diff --git a/src/geomspace.rs b/src/geomspace.rs
index f04d44889..63136190f 100644
--- a/src/geomspace.rs
+++ b/src/geomspace.rs
@@ -106,21 +106,24 @@ where
 #[cfg(test)]
 mod tests {
     use super::geomspace;
-    use crate::{arr1, Array1};
 
     #[test]
+    #[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.all_close(&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.all_close(&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.all_close(&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.all_close(&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 a57dcfff8..72dbfd310 100644
--- a/src/impl_constructors.rs
+++ b/src/impl_constructors.rs
@@ -111,13 +111,16 @@ impl<S, A> ArrayBase<S, Ix1>
     /// **Panics** if the length is greater than `isize::MAX`.
     ///
     /// ```rust
+    /// use approx::assert_abs_diff_eq;
     /// use ndarray::{Array, arr1};
     ///
+    /// # #[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_abs_diff_eq!(array, arr1(&[1e0, 1e1, 1e2, 1e3]));
     ///
     /// let array = Array::logspace(-10.0, 3.0, 0.0, 4);
-    /// assert!(array.all_close(&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
     where
@@ -136,13 +139,16 @@ impl<S, A> ArrayBase<S, Ix1>
     /// **Panics** if `n` is greater than `isize::MAX`.
     ///
     /// ```rust
+    /// use approx::assert_abs_diff_eq;
     /// use ndarray::{Array, arr1};
     ///
+    /// # #[cfg(feature = "approx")] {
     /// let array = Array::geomspace(1e0, 1e3, 4);
-    /// assert!(array.all_close(&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.all_close(&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
     where
diff --git a/src/impl_methods.rs b/src/impl_methods.rs
index 6192c54ef..21a5ac013 100644
--- a/src/impl_methods.rs
+++ b/src/impl_methods.rs
@@ -2039,15 +2039,20 @@ where
     /// Elements are visited in arbitrary order.
     ///
     /// ```
+    /// use approx::assert_abs_diff_eq;
     /// use ndarray::arr2;
     ///
+    /// # #[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)
+    /// assert_abs_diff_eq!(
+    ///     a,
+    ///     arr2(&[[1.00000, 2.71828],
+    ///            [0.36788, 7.38906]]),
+    ///     epsilon = 1e-5,
     /// );
+    /// # }
     /// ```
     pub fn mapv_inplace<F>(&mut self, mut f: F)
         where S: DataMut,
diff --git a/src/lib.rs b/src/lib.rs
index 5cb59ae5a..297b37af7 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")]
@@ -146,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/src/logspace.rs b/src/logspace.rs
index fe62e9990..7a32f3795 100644
--- a/src/logspace.rs
+++ b/src/logspace.rs
@@ -96,21 +96,24 @@ where
 #[cfg(test)]
 mod tests {
     use super::logspace;
-    use crate::{arr1, Array1};
 
     #[test]
+    #[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.all_close(&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.all_close(&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.all_close(&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.all_close(&arr1(&[-1e0, -1e1, -1e2, -1e3]), 1e-5));
+        assert_abs_diff_eq!(array, arr1(&[-1e0, -1e1, -1e2, -1e3]));
     }
 
     #[test]
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<A, S, D> ArrayBase<S, D>
     /// 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<S2, E>(&self, rhs: &ArrayBase<S2, E>, tol: A) -> bool
         where A: Float,
               S2: Data<Elem=A>,
diff --git a/tests/array-construct.rs b/tests/array-construct.rs
index 7e320c314..726892052 100644
--- a/tests/array-construct.rs
+++ b/tests/array-construct.rs
@@ -21,14 +21,17 @@ fn test_dimension_zero() {
 }
 
 #[test]
+#[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!(!a.all_close(&c, 0.01));
+    assert_abs_diff_ne!(a, c, epsilon = 0.01);
 }
 
 #[test]
diff --git a/tests/array.rs b/tests/array.rs
index ef5b1058d..2739dd582 100644
--- a/tests/array.rs
+++ b/tests/array.rs
@@ -680,15 +680,18 @@ fn test_sub_oob_1() {
 
 
 #[test]
+#[cfg(feature = "approx")]
 fn test_select(){
+    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.]]);
     let r = x.select(Axis(0),&[1,3,5]);
     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_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.],
@@ -699,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.all_close(&r_target,1e-8));
-    assert!(c.all_close(&c_target,1e-8));
+    assert_abs_diff_eq!(r, r_target);
+    assert_abs_diff_eq!(c, c_target);
 
 }
 
@@ -1733,6 +1736,7 @@ fn test_contiguous() {
 }
 
 #[test]
+#[allow(deprecated)]
 fn test_all_close() {
     let c = arr3(&[[[1., 2., 3.],
                     [1.5, 1.5, 3.]],
diff --git a/tests/azip.rs b/tests/azip.rs
index 39a5d2991..771797706 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;
 
@@ -45,22 +45,28 @@ fn test_azip2_3() {
 }
 
 #[test]
+#[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!(b.all_close(&c.sum_axis(Axis(1 - i)), 1e-6));
+        assert_abs_diff_eq!(b, c.sum_axis(Axis(1 - i)), epsilon = 1e-6);
     }
 }
 
 #[test]
+#[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;
     }
 
@@ -69,11 +75,14 @@ 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), epsilon = 1e-4);
 }
 
 #[test]
+#[cfg(feature = "approx")]
 fn test_broadcast() {
+    use approx::assert_abs_diff_eq;
+
     let n = 16;
     let mut a = Array::<f32, _>::zeros((n, n));
     let mut b = Array::<f32, _>::from_elem((1, n), 1.);
@@ -90,7 +99,8 @@ 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));
+    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 e73da4904..403524413 100644
--- a/tests/numeric.rs
+++ b/tests/numeric.rs
@@ -1,7 +1,7 @@
 extern crate approx;
 use std::f64;
-use ndarray::{array, Axis, aview1, aview2, aview0, arr0, arr1, arr2, Array, Array1, Array2, Array3};
-use approx::abs_diff_eq;
+use ndarray::{array, Axis, aview1, arr0, arr1, arr2, Array, Array1, Array2, Array3};
+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,7 +61,10 @@ fn sum_mean_empty() {
 }
 
 #[test]
+#[cfg(feature = "approx")]
 fn var_axis() {
+    use ndarray::{aview0, aview2};
+
     let a = array![
         [
             [-9.76, -0.38, 1.59, 6.23],
@@ -75,42 +77,48 @@ fn var_axis() {
             [-1.08, 4.66, 8.34, -0.73],
         ],
     ];
-    assert!(a.var_axis(Axis(0), 1.5).all_close(
-        &aview2(&[
+    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(
-        &aview2(&[
+        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,
-    ));
-    assert!(a.var_axis(Axis(2), 2.3).all_close(
-        &aview2(&[
+        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!(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.]), 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!(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), epsilon = 1e-12);
 }
 
 #[test]
+#[cfg(feature = "approx")]
 fn std_axis() {
+    use ndarray::aview2;
+
     let a = array![
        [
             [ 0.22935481,  0.08030619,  0.60827517,  0.73684379],
@@ -123,33 +131,42 @@ fn std_axis() {
             [ 0.51529756,  0.70111616,  0.20799415,  0.91851457]
        ],
     ];
-    assert!(a.std_axis(Axis(0), 1.5).all_close(
-        &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,
-    ));
-    assert!(a.std_axis(Axis(1), 1.7).all_close(
-        &aview2(&[
+        epsilon = 1e-4,
+    );
+    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(
-        &aview2(&[
+        epsilon = 1e-8,
+    );
+    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!(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.]),
+        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 4ffe5b347..153c81f10 100644
--- a/tests/par_azip.rs
+++ b/tests/par_azip.rs
@@ -25,7 +25,10 @@ fn test_par_azip2() {
 }
 
 #[test]
+#[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];
@@ -38,7 +41,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), epsilon = 1e-4);
 }
 
 #[should_panic]
diff --git a/tests/par_rayon.rs b/tests/par_rayon.rs
index 70b69e0eb..9407daeb6 100644
--- a/tests/par_rayon.rs
+++ b/tests/par_rayon.rs
@@ -24,12 +24,14 @@ fn test_axis_iter() {
 }
 
 #[test]
+#[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!(a.all_close(&b, 0.001));
+    assert_abs_diff_eq!(a, b, epsilon = 0.001);
 }
 
 #[test]