fix #82

Cargo.toml

@@ -19,7 +19,7 @@ keywords = [
 ]
 
 [package.metadata.docs.rs]
-features = ["std", "num-complex"]
+features = ["std", "num-complex", "ordered-float"]
 
 [lib]
 name = "approx"
@@ -29,5 +29,6 @@ default = ["std"]
 std = []
 
 [dependencies]
-num-traits = { version = "0.2.0", default_features = false }
-num-complex = { version = "0.4.0", optional = true }
+num-traits = { version = "0.2.16", default_features = false }
+num-complex = { version = "0.4.3", optional = true }
+ordered-float = { version = "3.7.0", optional = true }

src/abs_diff_eq.rs

@@ -1,8 +1,28 @@
 use core::cell;
 #[cfg(feature = "num-complex")]
 use num_complex::Complex;
+#[cfg(feature = "ordered-float")]
+use num_traits::Float;
+#[cfg(feature = "ordered-float")]
+use ordered_float::{NotNan, OrderedFloat};
 
 /// Equality that is defined using the absolute difference of two numbers.
+/// 
+/// For two numbers `a` and `b`, if `|a - b| < epsilon`, then the two numbers are considered
+/// to be equal under the absolute difference equality.
+/// 
+/// `abs_diff_eq`, `abs_diff_ne`, `assert_abs_diff_eq`, and `assert_abs_diff_ne` macros
+/// are all wrappers of the `abs_diff_eq` function in this trait.
+/// 
+/// # Examples
+/// 
+/// ```
+/// #[macro_use] extern crate approx;
+/// # fn main() {
+/// assert_abs_diff_eq!(1.0f32, 1.00000001f32, epsilon = 1e-8);
+/// assert_abs_diff_ne!(1.0f32, 1.0000001f32, epsilon = 1e-8);
+/// # }
+/// ```
 pub trait AbsDiffEq<Rhs = Self>: PartialEq<Rhs>
 where
     Rhs: ?Sized,
@@ -183,3 +203,63 @@ where
             && T::abs_diff_eq(&self.im, &other.im, epsilon)
     }
 }
+
+#[cfg(feature = "ordered-float")]
+impl<T: AbsDiffEq + Copy> AbsDiffEq for NotNan<T> {
+    type Epsilon = T::Epsilon;
+
+    #[inline]
+    fn default_epsilon() -> Self::Epsilon {
+        T::default_epsilon()
+    }
+
+    #[inline]
+    fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool {
+        T::abs_diff_eq(&self.into_inner(), &other.into_inner(), epsilon)
+    }
+}
+
+#[cfg(feature = "ordered-float")]
+impl<T: AbsDiffEq + Float> AbsDiffEq<T> for NotNan<T> {
+    type Epsilon = T::Epsilon;
+
+    #[inline]
+    fn default_epsilon() -> Self::Epsilon {
+        T::default_epsilon()
+    }
+
+    #[inline]
+    fn abs_diff_eq(&self, other: &T, epsilon: Self::Epsilon) -> bool {
+        T::abs_diff_eq(&self.into_inner(), other, epsilon)
+    }
+}
+
+#[cfg(feature = "ordered-float")]
+impl<T: AbsDiffEq + Float> AbsDiffEq for OrderedFloat<T> {
+    type Epsilon = T::Epsilon;
+
+    #[inline]
+    fn default_epsilon() -> Self::Epsilon {
+        T::default_epsilon()
+    }
+
+    #[inline]
+    fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool {
+        T::abs_diff_eq(&self.into_inner(), &other.into_inner(), epsilon)
+    }
+}
+
+#[cfg(feature = "ordered-float")]
+impl<T: AbsDiffEq + Float> AbsDiffEq<T> for OrderedFloat<T> {
+    type Epsilon = T::Epsilon;
+
+    #[inline]
+    fn default_epsilon() -> Self::Epsilon {
+        T::default_epsilon()
+    }
+
+    #[inline]
+    fn abs_diff_eq(&self, other: &T, epsilon: Self::Epsilon) -> bool {
+        T::abs_diff_eq(&self.into_inner(), other, epsilon)
+    }
+}

src/lib.rs

@@ -160,6 +160,8 @@
 #[cfg(feature = "num-complex")]
 extern crate num_complex;
 extern crate num_traits;
+#[cfg(feature = "ordered-float")]
+extern crate ordered_float;
 
 mod abs_diff_eq;
 mod relative_eq;

src/relative_eq.rs

@@ -1,10 +1,31 @@
 use core::{cell, f32, f64};
 #[cfg(feature = "num-complex")]
 use num_complex::Complex;
+#[cfg(feature = "ordered-float")]
+use num_traits::Float;
+#[cfg(feature = "ordered-float")]
+use ordered_float::{NotNan, OrderedFloat};
 use AbsDiffEq;
 
 /// Equality comparisons between two numbers using both the absolute difference and
 /// relative based comparisons.
+/// 
+/// For two number `a` and `b`, if `a` and `b` are epsilon equal under [AbsDiffEq] or if
+/// `|a - b| <= max_relative * max(|a|, |b|)`, then the two numbers are considered to be
+/// relative equal.
+/// 
+/// `relative_eq`, `relative_ne`, `assert_relative_eq`, and `assert_relative_ne` macros
+/// are all wrappers of the `relative_eq` function in this trait.
+/// 
+/// # Examples
+/// 
+/// ```
+/// #[macro_use] extern crate approx;
+/// # fn main() {
+/// assert_relative_eq!(1.0f32, 1.5f32, max_relative = 0.34);
+/// assert_relative_ne!(1.0f32, 1.5f32, max_relative = 0.33);
+/// # }
+/// ```
 pub trait RelativeEq<Rhs = Self>: AbsDiffEq<Rhs>
 where
     Rhs: ?Sized,
@@ -189,3 +210,75 @@ where
             && T::relative_eq(&self.im, &other.im, epsilon, max_relative)
     }
 }
+
+#[cfg(feature = "ordered-float")]
+impl<T: RelativeEq + Copy> RelativeEq for NotNan<T> {
+    #[inline]
+    fn default_max_relative() -> Self::Epsilon {
+        T::default_max_relative()
+    }
+
+    #[inline]
+    fn relative_eq(
+        &self,
+        other: &Self,
+        epsilon: Self::Epsilon,
+        max_relative: Self::Epsilon,
+    ) -> bool {
+        T::relative_eq(
+            &self.into_inner(),
+            &other.into_inner(),
+            epsilon,
+            max_relative,
+        )
+    }
+}
+
+#[cfg(feature = "ordered-float")]
+impl<T: RelativeEq + Float> RelativeEq<T> for NotNan<T> {
+    #[inline]
+    fn default_max_relative() -> Self::Epsilon {
+        T::default_max_relative()
+    }
+
+    #[inline]
+    fn relative_eq(&self, other: &T, epsilon: Self::Epsilon, max_relative: Self::Epsilon) -> bool {
+        T::relative_eq(&self.into_inner(), other, epsilon, max_relative)
+    }
+}
+
+#[cfg(feature = "ordered-float")]
+impl<T: RelativeEq + Float> RelativeEq for OrderedFloat<T> {
+    #[inline]
+    fn default_max_relative() -> Self::Epsilon {
+        T::default_max_relative()
+    }
+
+    #[inline]
+    fn relative_eq(
+        &self,
+        other: &Self,
+        epsilon: Self::Epsilon,
+        max_relative: Self::Epsilon,
+    ) -> bool {
+        T::relative_eq(
+            &self.into_inner(),
+            &other.into_inner(),
+            epsilon,
+            max_relative,
+        )
+    }
+}
+
+#[cfg(feature = "ordered-float")]
+impl<T: RelativeEq + Float> RelativeEq<T> for OrderedFloat<T> {
+    #[inline]
+    fn default_max_relative() -> Self::Epsilon {
+        T::default_max_relative()
+    }
+
+    #[inline]
+    fn relative_eq(&self, other: &T, epsilon: Self::Epsilon, max_relative: Self::Epsilon) -> bool {
+        T::relative_eq(&self.into_inner(), other, epsilon, max_relative)
+    }
+}

src/ulps_eq.rs

@@ -1,7 +1,11 @@
 use core::cell;
 #[cfg(feature = "num-complex")]
 use num_complex::Complex;
+#[cfg(feature = "ordered-float")]
+use num_traits::Float;
 use num_traits::Signed;
+#[cfg(feature = "ordered-float")]
+use ordered_float::{NotNan, OrderedFloat};
 
 use AbsDiffEq;
 
@@ -156,3 +160,55 @@ where
             && T::ulps_eq(&self.im, &other.im, epsilon, max_ulps)
     }
 }
+
+#[cfg(feature = "ordered-float")]
+impl<T: UlpsEq + Copy> UlpsEq for NotNan<T> {
+    #[inline]
+    fn default_max_ulps() -> u32 {
+        T::default_max_ulps()
+    }
+
+    #[inline]
+    fn ulps_eq(&self, other: &NotNan<T>, epsilon: T::Epsilon, max_ulps: u32) -> bool {
+        T::ulps_eq(&self.into_inner(), &other.into_inner(), epsilon, max_ulps)
+    }
+}
+
+#[cfg(feature = "ordered-float")]
+impl<T: UlpsEq + Float> UlpsEq<T> for NotNan<T> {
+    #[inline]
+    fn default_max_ulps() -> u32 {
+        T::default_max_ulps()
+    }
+
+    #[inline]
+    fn ulps_eq(&self, other: &T, epsilon: T::Epsilon, max_ulps: u32) -> bool {
+        T::ulps_eq(&self.into_inner(), other, epsilon, max_ulps)
+    }
+}
+
+#[cfg(feature = "ordered-float")]
+impl<T: UlpsEq + Float> UlpsEq for OrderedFloat<T> {
+    #[inline]
+    fn default_max_ulps() -> u32 {
+        T::default_max_ulps()
+    }
+
+    #[inline]
+    fn ulps_eq(&self, other: &OrderedFloat<T>, epsilon: T::Epsilon, max_ulps: u32) -> bool {
+        T::ulps_eq(&self.into_inner(), &other.into_inner(), epsilon, max_ulps)
+    }
+}
+
+#[cfg(feature = "ordered-float")]
+impl<T: UlpsEq + Float> UlpsEq<T> for OrderedFloat<T> {
+    #[inline]
+    fn default_max_ulps() -> u32 {
+        T::default_max_ulps()
+    }
+
+    #[inline]
+    fn ulps_eq(&self, other: &T, epsilon: T::Epsilon, max_ulps: u32) -> bool {
+        T::ulps_eq(&self.into_inner(), other, epsilon, max_ulps)
+    }
+}

tests/abs_diff_eq.rs

@@ -441,3 +441,61 @@ mod test_complex {
         }
     }
 }
+
+#[cfg(feature = "ordered-float")]
+mod test_ordered_float {
+    extern crate ordered_float;
+    pub use self::ordered_float::{NotNan, OrderedFloat};
+
+    mod test_f32 {
+        use super::OrderedFloat;
+
+        #[test]
+        fn test_basic() {
+            assert_abs_diff_eq!(OrderedFloat(1.0f32), OrderedFloat(1.0f32));
+            assert_abs_diff_ne!(OrderedFloat(1.0f32), OrderedFloat(2.0f32));
+            assert_abs_diff_eq!(OrderedFloat(1.0f32), 1.0f32);
+            assert_abs_diff_ne!(OrderedFloat(1.0f32), 2.0f32);
+            assert_abs_diff_eq!(1.0f32, OrderedFloat(1.0f32));
+            assert_abs_diff_ne!(1.0f32, OrderedFloat(2.0f32));
+        }
+
+        #[test]
+        #[should_panic]
+        fn test_basic_panic_eq() {
+            assert_abs_diff_eq!(OrderedFloat(1.0f32), OrderedFloat(2.0f32));
+        }
+
+        #[test]
+        #[should_panic]
+        fn test_basic_panic_ne() {
+            assert_abs_diff_ne!(OrderedFloat(1.0f32), OrderedFloat(1.0f32));
+        }
+    }
+
+    mod test_f64 {
+        use super::OrderedFloat;
+
+        #[test]
+        fn test_basic() {
+            assert_abs_diff_eq!(OrderedFloat(1.0f64), OrderedFloat(1.0f64));
+            assert_abs_diff_ne!(OrderedFloat(1.0f64), OrderedFloat(2.0f64));
+            assert_abs_diff_eq!(OrderedFloat(1.0f64), 1.0f64);
+            assert_abs_diff_ne!(OrderedFloat(1.0f64), 2.0f64);
+            assert_abs_diff_eq!(1.0f64, OrderedFloat(1.0f64));
+            assert_abs_diff_ne!(1.0f64, OrderedFloat(2.0f64));
+        }
+
+        #[test]
+        #[should_panic]
+        fn test_basic_panic_eq() {
+            assert_abs_diff_eq!(OrderedFloat(1.0f64), OrderedFloat(2.0f64));
+        }
+
+        #[test]
+        #[should_panic]
+        fn test_basic_panic_ne() {
+            assert_abs_diff_ne!(OrderedFloat(1.0f64), OrderedFloat(1.0f64));
+        }
+    }
+}