diff --git a/src/array_approx.rs b/src/array_approx.rs
index a2e9c2327..bb6804a27 100644
--- a/src/array_approx.rs
+++ b/src/array_approx.rs
@@ -21,9 +21,10 @@ where
         if self.shape() != other.shape() {
             return false;
         }
+
         Zip::from(self)
             .and(other)
-            .all(|a, b| A::abs_diff_eq(a, b, epsilon.clone()))
+            .all(move |a, b| A::abs_diff_eq(a, b, epsilon.clone()))
     }
 }
 
@@ -49,9 +50,10 @@ where
         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()))
+            .all(move |a, b| A::relative_eq(a, b, epsilon.clone(), max_relative.clone()))
     }
 }
 
@@ -72,12 +74,51 @@ where
         if self.shape() != other.shape() {
             return false;
         }
+
         Zip::from(self)
             .and(other)
-            .all(|a, b| A::ulps_eq(a, b, epsilon.clone(), max_ulps))
+            .all(move |a, b| A::ulps_eq(a, b, epsilon.clone(), max_ulps))
     }
 }
 
+impl<A, S, D> ArrayBase<S, D>
+where
+    S: Data<Elem = A>,
+    D: Dimension,
+{
+    /// A test for equality that uses the elementwise absolute difference to compute the
+    /// approximate equality of two arrays.
+    ///
+    /// **Requires crate feature `"approx"`**
+    pub fn abs_diff_eq<S2>(&self, other: &ArrayBase<S2, D>, epsilon: A::Epsilon) -> bool
+    where
+        A: AbsDiffEq<S2::Elem>,
+        A::Epsilon: Clone,
+        S2: Data,
+    {
+        <Self as AbsDiffEq<_>>::abs_diff_eq(self, other, epsilon)
+    }
+
+    /// A test for equality that uses an elementwise relative comparison if the values are far
+    /// apart; and the absolute difference otherwise.
+    ///
+    /// **Requires crate feature `"approx"`**
+    pub fn relative_eq<S2>(
+        &self,
+        other: &ArrayBase<S2, D>,
+        epsilon: A::Epsilon,
+        max_relative: A::Epsilon,
+    ) -> bool
+    where
+        A: RelativeEq<S2::Elem>,
+        A::Epsilon: Clone,
+        S2: Data
+    {
+        <Self as RelativeEq<_>>::relative_eq(self, other, epsilon, max_relative)
+    }
+}
+
+
 #[cfg(test)]
 mod tests {
     use crate::prelude::*;
diff --git a/src/lib.rs b/src/lib.rs
index f48da4b32..7a7a201ab 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -168,8 +168,6 @@ mod aliases;
 #[macro_use]
 mod itertools;
 mod argument_traits;
-#[cfg(feature = "approx")]
-mod array_approx;
 #[cfg(feature = "serde")]
 mod array_serde;
 mod arrayformat;
@@ -1520,6 +1518,9 @@ impl<'a, A> CowRepr<'a, A> {
     }
 }
 
+// NOTE: The order of modules decides in which order methods on the type ArrayBase
+// (mainly mentioning that as the most relevant type) show up in the documentation.
+// Consider the doc effect of ordering modules here.
 mod impl_clone;
 
 mod impl_internal_constructors;
@@ -1613,6 +1614,9 @@ pub mod linalg;
 mod impl_ops;
 pub use crate::impl_ops::ScalarOperand;
 
+#[cfg(feature = "approx")]
+mod array_approx;
+
 // Array view methods
 mod impl_views;