switch the algorithm

Author: tgross35

src/math/generic/floor.rs

@@ -1,25 +1,60 @@
 /* SPDX-License-Identifier: MIT
  * origin: musl src/math/floor.c */
 
-use super::super::{Float, Int};
+use super::super::{Float, Int, IntTy, MinInt};
 
 pub fn floor<F: Float>(x: F) -> F {
-    let toint = F::ONE / F::EPSILON;
+    let zero = IntTy::<F>::ZERO;
 
-    let e = x.exp().unsigned();
+    let mut ix = x.to_bits();
+    let e = x.exp_unbiased();
 
-    if e >= F::SIG_BITS + F::EXP_BIAS || x == F::ZERO {
+    // If the represented value has no fractional part, no truncation is needed.
+    if e >= F::SIG_BITS as i32 {
         return x;
     }
 
-    let neg = x.is_sign_negative();
+    if e >= 0 {
+        let m = F::SIG_MASK >> e.unsigned();
+        if ix & m == zero {
+            return x;
+        }
+
+        force_eval!(x + F::MAX);
+
+        if x.is_sign_negative() {
+            ix += m;
+        }
+
+        ix &= !m;
+    } else {
+        force_eval!(x + F::MAX);
 
-    let y = if neg { x - toint + toint - x } else { x + toint - toint - x };
-    if e < F::EXP_BIAS {
-        force_eval!(y);
-        return if neg { F::NEG_ONE } else { F::ZERO };
+        if x.is_sign_positive() {
+            ix = F::ZERO.to_bits();
+        } else if ix << 1 != zero {
+            ix = F::NEG_ONE.to_bits();
+        }
     }
-    if y > F::ZERO { x + y - F::ONE } else { x + y }
+
+    F::from_bits(ix)
+
+    // let toint = F::ONE / F::EPSILON;
+
+    // let e = x.exp().unsigned();
+
+    // if e >= F::SIG_BITS + F::EXP_BIAS || x == F::ZERO {
+    //     return x;
+    // }
+
+    // let neg = x.is_sign_negative();
+
+    // let y = if neg { x - toint + toint - x } else { x + toint - toint - x };
+    // if e < F::EXP_BIAS {
+    //     force_eval!(y);
+    //     return if neg { F::NEG_ONE } else { F::ZERO };
+    // }
+    // if y > F::ZERO { x + y - F::ONE } else { x + y }
 }
 
 // // NB: using `exp` here and comparing to values adjusted by `EXP_BIAS` has better