Disable comparing subnormal values on ARM for f32 and f64.

Replaces dca2031 where specific tests were disabled. With the change `f{32|64}::Test` implementation considers zero and subnormal values equal. Part of #392.
iliekturtles · Jan 27, 2023 · 037109a · 037109a
1 parent aab4751
commit 037109a
Show file tree

Hide file tree

Showing 3 changed files with 36 additions and 12 deletions.
diff --git a/src/si/area.rs b/src/si/area.rs
@@ -84,8 +84,6 @@ mod tests {
         }
 
         #[test]
-        // #392: Disable tests on ARM until issues with floating point behavior can be resolved.
-        #[cfg(not(target_arch = "arm"))]
         fn check_units() {
             // Values too large for f32.
             if TypeId::of::<f64>() == TypeId::of::<V>() {

diff --git a/src/si/volume.rs b/src/si/volume.rs
@@ -157,8 +157,6 @@ mod tests {
         }
 
         #[test]
-        // #392: Disable tests on ARM until issues with floating point behavior can be resolved.
-        #[cfg(not(target_arch = "arm"))]
         fn check_units() {
             // Values too large for f32.
             if TypeId::of::<f64>() == TypeId::of::<V>() {

diff --git a/src/tests/mod.rs b/src/tests/mod.rs
@@ -108,17 +108,29 @@ mod test_trait {
         impl super::super::Test for V {
             /// Assert that `lhs` and `rhs` are exactly equal.
             fn assert_eq(lhs: &Self, rhs: &Self) {
-                match (lhs.is_nan(), rhs.is_nan()) {
-                    (true, true) => {}
+                use crate::lib::num::FpCategory::*;
+
+                match (lhs.classify(), rhs.classify()) {
+                    (Nan, Nan) => {}
+                    // #392: Disable on ARM until floating point behavior issues can be resolved.
+                    #[cfg(target_arch = "arm")]
+                    (Zero, Subnormal)
+                        | (Subnormal, Zero) => {}
                     _ => { assert_eq!(lhs, rhs); }
                 }
             }
 
             /// Assert that `lhs` and `rhs` are approximately equal for floating point types or
             /// exactly equal for other types.
             fn assert_approx_eq(lhs: &Self, rhs: &Self) {
-                match (lhs.is_nan(), rhs.is_nan()) {
-                    (true, true) => {}
+                use crate::lib::num::FpCategory::*;
+
+                match (lhs.classify(), rhs.classify()) {
+                    (Nan, Nan) => {}
+                    // #392: Disable on ARM until floating point behavior issues can be resolved.
+                    #[cfg(target_arch = "arm")]
+                    (Zero, Subnormal)
+                        | (Subnormal, Zero) => {}
                     _ => {
                         assert_ulps_eq!(lhs, rhs, epsilon = EPS_FACTOR * V::epsilon(),
                             max_ulps = ULPS);
@@ -128,15 +140,31 @@ mod test_trait {
 
             /// Exactly compare `lhs` and `rhs` and return the result.
             fn eq(lhs: &Self, rhs: &Self) -> bool {
-                (lhs.is_nan() && rhs.is_nan())
-                    || lhs == rhs
+                use crate::lib::num::FpCategory::*;
+
+                match (lhs.classify(), rhs.classify()) {
+                    (Nan, Nan) => true,
+                    // #392: Disable on ARM until floating point behavior issues can be resolved.
+                    #[cfg(target_arch = "arm")]
+                    (Zero, Subnormal)
+                        | (Subnormal, Zero) => true,
+                    _ => lhs == rhs,
+                }
             }
 
             /// Approximately compare `lhs` and `rhs` for floating point types or exactly compare
             /// for other types and return the result.
             fn approx_eq(lhs: &Self, rhs: &Self) -> bool {
-                (lhs.is_nan() && rhs.is_nan())
-                    || ulps_eq!(lhs, rhs, epsilon = EPS_FACTOR * V::epsilon(), max_ulps = ULPS)
+                use crate::lib::num::FpCategory::*;
+
+                match (lhs.classify(), rhs.classify()) {
+                    (Nan, Nan) => true,
+                    // #392: Disable on ARM until floating point behavior issues can be resolved.
+                    #[cfg(target_arch = "arm")]
+                    (Zero, Subnormal)
+                        | (Subnormal, Zero) => true,
+                    _ => ulps_eq!(lhs, rhs, epsilon = EPS_FACTOR * V::epsilon(), max_ulps = ULPS),
+                }
             }
         }
     }