Improve doc examples withassert_relative_eq

Signed-off-by: Tom Delmas <[email protected]>

typed_floats/src/lib.rs

@@ -93,6 +93,49 @@
 #![warn(clippy::indexing_slicing)]
 #![warn(missing_docs)]
 
+/// This macros assert that two values are close to each other.
+/// 
+/// # Examples
+/// 
+/// ```
+/// # use typed_floats::*;
+/// assert_relative_eq!(1.0_f64, 1.0);
+/// assert_relative_eq!(1.0_f64, 1.000000001, 1e-7);
+/// ```
+/// 
+/// ```should_panic
+/// # use typed_floats::*;
+/// assert_relative_eq!(2.0_f64, 1.0);
+/// ```
+/// 
+/// ```should_panic
+/// # use typed_floats::*;
+/// assert_relative_eq!(1.0_f64, 1.000001, 1e-7);
+/// ```
+#[macro_export]
+macro_rules! assert_relative_eq {
+    ($left:expr, $right:expr) => {{
+        let epsilon = 1e-7;
+
+        assert_relative_eq!($left, $right, epsilon);
+    }};
+    ($left:expr, $right:expr, $epsilon:expr) => {{
+        let left_val = $left;
+        let right_val = $right;
+        let diff = (left_val - right_val).abs();
+
+        assert!(
+            diff <= $epsilon,
+            "assertion failed: `(left ~= right)` \
+             (left: `{:?}`, right: `{:?}`, (left - right): `{:?}`, epsilon: `{:?}`)",
+            left_val,
+            right_val,
+            diff,
+            $epsilon
+        );
+    }};
+}
+
 /// This trait is used to specify the return type of the [`Hypot::hypot()`] function.
 pub trait Hypot<T> {
     /// The resulting type after applying [`Hypot::hypot()`].

typed_floats_macros/src/impl_self.rs

@@ -631,12 +631,12 @@ pub(crate) fn get_impl_self() -> Vec<Op> {
                 /// let e: NonNaNFinite = core::f64::consts::FRAC_PI_2.try_into().unwrap();
                 /// let f: NonNaNFinite = (-core::f64::consts::FRAC_PI_2).try_into().unwrap();
                 ///
-                /// assert!(a.sin().get().abs() < 1.0e-10);
-                /// assert!(b.sin().get().abs() < 1.0e-10);
-                /// assert!(c.sin().get().abs() < 1.0e-10);
-                /// assert!(d.sin().get().abs() < 1.0e-10);
-                /// assert!((e.sin().get() - 1.0).abs() < 1.0e-10);
-                /// assert!((f.sin().get() + 1.0).abs() < 1.0e-10);
+                /// assert_relative_eq!(a.sin().get(), 0.0);
+                /// assert_relative_eq!(b.sin().get(), 0.0);
+                /// assert_relative_eq!(c.sin().get(), 0.0);
+                /// assert_relative_eq!(d.sin().get(), 0.0);
+                /// assert_relative_eq!(e.sin().get(), 1.0);
+                /// assert_relative_eq!(f.sin().get(), -1.0);
                 ///
                 /// assert!(tf64::INFINITY.sin().is_nan());
                 /// assert!(tf64::NEG_INFINITY.sin().is_nan());
@@ -678,12 +678,12 @@ pub(crate) fn get_impl_self() -> Vec<Op> {
                 /// let e: NonNaNFinite = core::f64::consts::FRAC_PI_2.try_into().unwrap();
                 /// let f: NonNaNFinite = (-core::f64::consts::FRAC_PI_2).try_into().unwrap();
                 ///
-                /// assert!((a.cos().get() + 1.0).abs() < 1.0e-10);
-                /// assert!((b.cos().get() - 1.0).abs() < 1.0e-10);
-                /// assert!((c.cos().get() - 1.0).abs() < 1.0e-10);
-                /// assert!((d.cos().get() + 1.0).abs() < 1.0e-10);
-                /// assert!(e.cos().get().abs() < 1.0e-10);
-                /// assert!(f.cos().get().abs() < 1.0e-10);
+                /// assert_relative_eq!(a.cos().get(), -1.0);
+                /// assert_relative_eq!(b.cos().get(), 1.0);
+                /// assert_relative_eq!(c.cos().get(), 1.0);
+                /// assert_relative_eq!(d.cos().get(), -1.0);
+                /// assert_relative_eq!(e.cos().get(), 0.0);
+                /// assert_relative_eq!(f.cos().get(), 0.0);
                 ///
                 /// assert!(tf64::INFINITY.cos().is_nan());
                 /// assert!(tf64::NEG_INFINITY.cos().is_nan());
@@ -718,7 +718,7 @@ pub(crate) fn get_impl_self() -> Vec<Op> {
                 /// # use typed_floats::*;
                 ///
                 /// assert_eq!(tf64::ZERO.tan(), 0.0);
-                /// assert!((tf64::consts::FRAC_PI_4.tan().get() - 1.0).abs() < 1.0e-10);
+                /// assert_relative_eq!(tf64::consts::FRAC_PI_4.tan().get(), 1.0);
                 ///
                 /// assert!(tf64::INFINITY.tan().is_nan());
                 /// assert!(tf64::NEG_INFINITY.tan().is_nan());