From ba50f5000e7cdb156cc655c946ee71e5975b37ef Mon Sep 17 00:00:00 2001 From: MqCreaple Date: Sun, 23 Jul 2023 23:00:51 +0800 Subject: [PATCH 1/3] add feature of ordered-float --- Cargo.toml | 3 ++- src/abs_diff_eq.rs | 34 ++++++++++++++++++++++++++++++++++ src/lib.rs | 2 ++ src/relative_eq.rs | 32 ++++++++++++++++++++++++++++++++ src/ulps_eq.rs | 30 ++++++++++++++++++++++++++++++ 5 files changed, 100 insertions(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index d4ff24d..aac50e9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -19,7 +19,7 @@ keywords = [ ] [package.metadata.docs.rs] -features = ["std", "num-complex"] +features = ["std", "num-complex", "ordered-float"] [lib] name = "approx" @@ -31,3 +31,4 @@ std = [] [dependencies] num-traits = { version = "0.2.0", default_features = false } num-complex = { version = "0.4.0", optional = true } +ordered-float = { version = "3.7.0", optional = true } \ No newline at end of file diff --git a/src/abs_diff_eq.rs b/src/abs_diff_eq.rs index b3b3974..67b520f 100644 --- a/src/abs_diff_eq.rs +++ b/src/abs_diff_eq.rs @@ -1,6 +1,10 @@ use core::cell; #[cfg(feature = "num-complex")] use num_complex::Complex; +#[cfg(feature = "ordered-float")] +use ordered_float::{NotNan, OrderedFloat}; +#[cfg(feature = "ordered-float")] +use num_traits::Float; /// Equality that is defined using the absolute difference of two numbers. pub trait AbsDiffEq: PartialEq @@ -183,3 +187,33 @@ where && T::abs_diff_eq(&self.im, &other.im, epsilon) } } + +#[cfg(feature = "ordered-float")] +impl AbsDiffEq for NotNan { + 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 AbsDiffEq for OrderedFloat { + 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) + } +} diff --git a/src/lib.rs b/src/lib.rs index 4730864..02c0ffb 100644 --- a/src/lib.rs +++ b/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; diff --git a/src/relative_eq.rs b/src/relative_eq.rs index 2919044..9871427 100644 --- a/src/relative_eq.rs +++ b/src/relative_eq.rs @@ -1,6 +1,10 @@ use core::{cell, f32, f64}; #[cfg(feature = "num-complex")] use num_complex::Complex; +#[cfg(feature = "ordered-float")] +use ordered_float::{NotNan, OrderedFloat}; +#[cfg(feature = "ordered-float")] +use num_traits::Float; use AbsDiffEq; /// Equality comparisons between two numbers using both the absolute difference and @@ -189,3 +193,31 @@ where && T::relative_eq(&self.im, &other.im, epsilon, max_relative) } } + +#[cfg(feature = "ordered-float")] +impl RelativeEq for NotNan { + #[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 RelativeEq for OrderedFloat { + #[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) + } +} diff --git a/src/ulps_eq.rs b/src/ulps_eq.rs index 6e58dfa..6375e07 100644 --- a/src/ulps_eq.rs +++ b/src/ulps_eq.rs @@ -1,6 +1,10 @@ use core::cell; #[cfg(feature = "num-complex")] use num_complex::Complex; +#[cfg(feature = "ordered-float")] +use ordered_float::{NotNan, OrderedFloat}; +#[cfg(feature = "ordered-float")] +use num_traits::Float; use num_traits::Signed; use AbsDiffEq; @@ -156,3 +160,29 @@ where && T::ulps_eq(&self.im, &other.im, epsilon, max_ulps) } } + +#[cfg(feature = "ordered-float")] +impl UlpsEq for NotNan { + #[inline] + fn default_max_ulps() -> u32 { + T::default_max_ulps() + } + + #[inline] + fn ulps_eq(&self, other: &NotNan, epsilon: T::Epsilon, max_ulps: u32) -> bool { + T::ulps_eq(&self.into_inner(), &other.into_inner(), epsilon, max_ulps) + } +} + +#[cfg(feature = "ordered-float")] +impl UlpsEq for OrderedFloat { + #[inline] + fn default_max_ulps() -> u32 { + T::default_max_ulps() + } + + #[inline] + fn ulps_eq(&self, other: &OrderedFloat, epsilon: T::Epsilon, max_ulps: u32) -> bool { + T::ulps_eq(&self.into_inner(), &other.into_inner(), epsilon, max_ulps) + } +} \ No newline at end of file From 2f25a2a4cfb3d0724e3bd6e99724667b01936344 Mon Sep 17 00:00:00 2001 From: MqCreaple Date: Sun, 23 Jul 2023 23:22:29 +0800 Subject: [PATCH 2/3] add more impl for ordered-float and tests --- src/abs_diff_eq.rs | 34 +++++++++++++++++++++++-- src/relative_eq.rs | 60 ++++++++++++++++++++++++++++++++++++++------ src/ulps_eq.rs | 32 ++++++++++++++++++++--- tests/abs_diff_eq.rs | 58 ++++++++++++++++++++++++++++++++++++++++++ tests/relative_eq.rs | 58 ++++++++++++++++++++++++++++++++++++++++++ tests/ulps_eq.rs | 58 ++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 287 insertions(+), 13 deletions(-) diff --git a/src/abs_diff_eq.rs b/src/abs_diff_eq.rs index 67b520f..117e858 100644 --- a/src/abs_diff_eq.rs +++ b/src/abs_diff_eq.rs @@ -2,9 +2,9 @@ use core::cell; #[cfg(feature = "num-complex")] use num_complex::Complex; #[cfg(feature = "ordered-float")] -use ordered_float::{NotNan, OrderedFloat}; -#[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. pub trait AbsDiffEq: PartialEq @@ -203,6 +203,21 @@ impl AbsDiffEq for NotNan { } } +#[cfg(feature = "ordered-float")] +impl AbsDiffEq for NotNan { + 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 AbsDiffEq for OrderedFloat { type Epsilon = T::Epsilon; @@ -217,3 +232,18 @@ impl AbsDiffEq for OrderedFloat { T::abs_diff_eq(&self.into_inner(), &other.into_inner(), epsilon) } } + +#[cfg(feature = "ordered-float")] +impl AbsDiffEq for OrderedFloat { + 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) + } +} diff --git a/src/relative_eq.rs b/src/relative_eq.rs index 9871427..a8ff556 100644 --- a/src/relative_eq.rs +++ b/src/relative_eq.rs @@ -2,9 +2,9 @@ use core::{cell, f32, f64}; #[cfg(feature = "num-complex")] use num_complex::Complex; #[cfg(feature = "ordered-float")] -use ordered_float::{NotNan, OrderedFloat}; -#[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 @@ -202,9 +202,31 @@ impl RelativeEq for NotNan { } #[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) + 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 RelativeEq for NotNan { + #[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) } } @@ -216,8 +238,30 @@ impl RelativeEq for OrderedFloat { } #[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) + 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 RelativeEq for OrderedFloat { + #[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) } } diff --git a/src/ulps_eq.rs b/src/ulps_eq.rs index 6375e07..94b36cf 100644 --- a/src/ulps_eq.rs +++ b/src/ulps_eq.rs @@ -2,10 +2,10 @@ use core::cell; #[cfg(feature = "num-complex")] use num_complex::Complex; #[cfg(feature = "ordered-float")] -use ordered_float::{NotNan, OrderedFloat}; -#[cfg(feature = "ordered-float")] use num_traits::Float; use num_traits::Signed; +#[cfg(feature = "ordered-float")] +use ordered_float::{NotNan, OrderedFloat}; use AbsDiffEq; @@ -174,6 +174,19 @@ impl UlpsEq for NotNan { } } +#[cfg(feature = "ordered-float")] +impl UlpsEq for NotNan { + #[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 UlpsEq for OrderedFloat { #[inline] @@ -185,4 +198,17 @@ impl UlpsEq for OrderedFloat { fn ulps_eq(&self, other: &OrderedFloat, epsilon: T::Epsilon, max_ulps: u32) -> bool { T::ulps_eq(&self.into_inner(), &other.into_inner(), epsilon, max_ulps) } -} \ No newline at end of file +} + +#[cfg(feature = "ordered-float")] +impl UlpsEq for OrderedFloat { + #[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) + } +} diff --git a/tests/abs_diff_eq.rs b/tests/abs_diff_eq.rs index 90e8f1a..0e64e19 100644 --- a/tests/abs_diff_eq.rs +++ b/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)); + } + } +} diff --git a/tests/relative_eq.rs b/tests/relative_eq.rs index 3a7629e..3079f39 100644 --- a/tests/relative_eq.rs +++ b/tests/relative_eq.rs @@ -439,3 +439,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_relative_eq!(OrderedFloat(1.0f32), OrderedFloat(1.0f32)); + assert_relative_ne!(OrderedFloat(1.0f32), OrderedFloat(2.0f32)); + assert_relative_eq!(OrderedFloat(1.0f32), 1.0f32); + assert_relative_ne!(OrderedFloat(1.0f32), 2.0f32); + assert_relative_eq!(1.0f32, OrderedFloat(1.0f32)); + assert_relative_ne!(1.0f32, OrderedFloat(2.0f32)); + } + + #[test] + #[should_panic] + fn test_basic_panic_eq() { + assert_relative_eq!(OrderedFloat(1.0f32), OrderedFloat(2.0f32)); + } + + #[test] + #[should_panic] + fn test_basic_panic_ne() { + assert_relative_ne!(OrderedFloat(1.0f32), OrderedFloat(1.0f32)); + } + } + + mod test_f64 { + use super::OrderedFloat; + + #[test] + fn test_basic() { + assert_relative_eq!(OrderedFloat(1.0f64), OrderedFloat(1.0f64)); + assert_relative_ne!(OrderedFloat(1.0f64), OrderedFloat(2.0f64)); + assert_relative_eq!(OrderedFloat(1.0f64), 1.0f64); + assert_relative_ne!(OrderedFloat(1.0f64), 2.0f64); + assert_relative_eq!(1.0f64, OrderedFloat(1.0f64)); + assert_relative_ne!(1.0f64, OrderedFloat(2.0f64)); + } + + #[test] + #[should_panic] + fn test_basic_panic_eq() { + assert_relative_eq!(OrderedFloat(1.0f64), OrderedFloat(2.0f64)); + } + + #[test] + #[should_panic] + fn test_basic_panic_ne() { + assert_relative_ne!(OrderedFloat(1.0f64), OrderedFloat(1.0f64)); + } + } +} \ No newline at end of file diff --git a/tests/ulps_eq.rs b/tests/ulps_eq.rs index b0e89ed..6e0c5c5 100644 --- a/tests/ulps_eq.rs +++ b/tests/ulps_eq.rs @@ -437,3 +437,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_ulps_eq!(OrderedFloat(1.0f32), OrderedFloat(1.0f32)); + assert_ulps_ne!(OrderedFloat(1.0f32), OrderedFloat(2.0f32)); + assert_ulps_eq!(OrderedFloat(1.0f32), 1.0f32); + assert_ulps_ne!(OrderedFloat(1.0f32), 2.0f32); + assert_ulps_eq!(1.0f32, OrderedFloat(1.0f32)); + assert_ulps_ne!(1.0f32, OrderedFloat(2.0f32)); + } + + #[test] + #[should_panic] + fn test_basic_panic_eq() { + assert_ulps_eq!(OrderedFloat(1.0f32), OrderedFloat(2.0f32)); + } + + #[test] + #[should_panic] + fn test_basic_panic_ne() { + assert_ulps_ne!(OrderedFloat(1.0f32), OrderedFloat(1.0f32)); + } + } + + mod test_f64 { + use super::OrderedFloat; + + #[test] + fn test_basic() { + assert_ulps_eq!(OrderedFloat(1.0f64), OrderedFloat(1.0f64)); + assert_ulps_ne!(OrderedFloat(1.0f64), OrderedFloat(2.0f64)); + assert_ulps_eq!(OrderedFloat(1.0f64), 1.0f64); + assert_ulps_ne!(OrderedFloat(1.0f64), 2.0f64); + assert_ulps_eq!(1.0f64, OrderedFloat(1.0f64)); + assert_ulps_ne!(1.0f64, OrderedFloat(2.0f64)); + } + + #[test] + #[should_panic] + fn test_basic_panic_eq() { + assert_ulps_eq!(OrderedFloat(1.0f64), OrderedFloat(2.0f64)); + } + + #[test] + #[should_panic] + fn test_basic_panic_ne() { + assert_ulps_ne!(OrderedFloat(1.0f64), OrderedFloat(1.0f64)); + } + } +} From bdc284baa9d003afd7be5ff17fd996a3f3805945 Mon Sep 17 00:00:00 2001 From: MqCreaple Date: Mon, 24 Jul 2023 15:35:32 +0800 Subject: [PATCH 3/3] add more documentation for traits --- Cargo.toml | 4 ++-- src/abs_diff_eq.rs | 16 ++++++++++++++++ src/relative_eq.rs | 17 +++++++++++++++++ tests/relative_eq.rs | 12 ++++++++++++ 4 files changed, 47 insertions(+), 2 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index aac50e9..83f4609 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -29,6 +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 } \ No newline at end of file diff --git a/src/abs_diff_eq.rs b/src/abs_diff_eq.rs index 117e858..f75d06d 100644 --- a/src/abs_diff_eq.rs +++ b/src/abs_diff_eq.rs @@ -7,6 +7,22 @@ use num_traits::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: PartialEq where Rhs: ?Sized, diff --git a/src/relative_eq.rs b/src/relative_eq.rs index a8ff556..1e92c1d 100644 --- a/src/relative_eq.rs +++ b/src/relative_eq.rs @@ -9,6 +9,23 @@ 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: AbsDiffEq where Rhs: ?Sized, diff --git a/tests/relative_eq.rs b/tests/relative_eq.rs index 3079f39..c8c9030 100644 --- a/tests/relative_eq.rs +++ b/tests/relative_eq.rs @@ -187,6 +187,12 @@ mod test_f32 { assert_relative_ne!(f32::MIN_POSITIVE, 0.000001f32); assert_relative_ne!(-f32::MIN_POSITIVE, 0.000001f32); } + + #[test] + fn custom_test() { + assert_relative_eq!(1.0f64, 1.5f64, max_relative = 0.34); + assert_relative_ne!(1.0f64, 1.5f64, max_relative = 0.33); + } } #[cfg(test)] @@ -352,6 +358,12 @@ mod test_f64 { assert_relative_ne!(f64::MIN_POSITIVE, 0.000000000000001f64); assert_relative_ne!(-f64::MIN_POSITIVE, 0.000000000000001f64); } + + #[test] + fn custom_test() { + assert_relative_eq!(1.0f64, 1.5f64, max_relative = 0.34); + assert_relative_ne!(1.0f64, 1.5f64, max_relative = 0.33); + } } mod test_ref {