Add disguised-fast-path optimisation + tests

Author: aldanor

src/float.rs

@@ -31,6 +31,7 @@ pub trait Float:
     const MAX_EXPONENT_ROUND_TO_EVEN: i32;
     const MIN_EXPONENT_FAST_PATH: i64;
     const MAX_EXPONENT_FAST_PATH: i64;
+    const MAX_EXPONENT_DISGUISED_FAST_PATH: i64;
     const MINIMUM_EXPONENT: i32;
     const INFINITE_POWER: i32;
     const SIGN_INDEX: usize;
@@ -56,6 +57,7 @@ impl Float for f32 {
     const MAX_EXPONENT_ROUND_TO_EVEN: i32 = 10;
     const MIN_EXPONENT_FAST_PATH: i64 = -10; // assuming FLT_EVAL_METHOD = 0
     const MAX_EXPONENT_FAST_PATH: i64 = 10;
+    const MAX_EXPONENT_DISGUISED_FAST_PATH: i64 = 17;
     const MINIMUM_EXPONENT: i32 = -127;
     const INFINITE_POWER: i32 = 0xFF;
     const SIGN_INDEX: usize = 31;
@@ -90,6 +92,7 @@ impl Float for f64 {
     const MAX_EXPONENT_ROUND_TO_EVEN: i32 = 23;
     const MIN_EXPONENT_FAST_PATH: i64 = -22; // assuming FLT_EVAL_METHOD = 0
     const MAX_EXPONENT_FAST_PATH: i64 = 22;
+    const MAX_EXPONENT_DISGUISED_FAST_PATH: i64 = 37;
     const MINIMUM_EXPONENT: i32 = -1023;
     const INFINITE_POWER: i32 = 0x7FF;
     const SIGN_INDEX: usize = 63;

src/number.rs

@@ -3,6 +3,25 @@ use crate::float::Float;
 
 const MIN_19DIGIT_INT: u64 = 100_0000_0000_0000_0000;
 
+pub const INT_POW10: [u64; 16] = [
+    1,
+    10,
+    100,
+    1000,
+    10000,
+    100000,
+    1000000,
+    10000000,
+    100000000,
+    1000000000,
+    10000000000,
+    100000000000,
+    1000000000000,
+    10000000000000,
+    100000000000000,
+    1000000000000000,
+];
+
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 pub struct Number {
     pub exponent: i64,
@@ -15,20 +34,31 @@ impl Number {
     #[inline]
     fn is_fast_path<F: Float>(&self) -> bool {
         F::MIN_EXPONENT_FAST_PATH <= self.exponent
-            && self.exponent <= F::MAX_EXPONENT_FAST_PATH
+            && self.exponent <= F::MAX_EXPONENT_DISGUISED_FAST_PATH
             && self.mantissa <= F::MAX_MANTISSA_FAST_PATH
             && !self.many_digits
     }
 
     #[inline]
     pub fn try_fast_path<F: Float>(&self) -> Option<F> {
         if self.is_fast_path::<F>() {
-            let mut value = F::from_u64(self.mantissa);
-            if self.exponent < 0 {
-                value = value / F::pow10_fast_path((-self.exponent) as _);
+            let mut value = if self.exponent <= F::MAX_EXPONENT_FAST_PATH {
+                // normal fast path
+                let value = F::from_u64(self.mantissa);
+                if self.exponent < 0 {
+                    value / F::pow10_fast_path((-self.exponent) as _)
+                } else {
+                    value * F::pow10_fast_path(self.exponent as _)
+                }
             } else {
-                value = value * F::pow10_fast_path(self.exponent as _);
-            }
+                // disguised fast path
+                let shift = self.exponent - F::MAX_EXPONENT_FAST_PATH;
+                let mantissa = self.mantissa.checked_mul(INT_POW10[shift as usize])?;
+                if mantissa > F::MAX_MANTISSA_FAST_PATH {
+                    return None;
+                }
+                F::from_u64(mantissa) * F::pow10_fast_path(F::MAX_EXPONENT_FAST_PATH as _)
+            };
             if self.negative {
                 value = -value;
             }

tests/test_basic.rs

@@ -277,6 +277,7 @@ fn test_f64_general() {
     check_f64!(4503599627370497.5);
     check_f64!(45035996.273704995);
     check_f64!(45035996.273704985);
+    check_f64!(1.2345e30);
 }
 
 #[test]
@@ -402,6 +403,7 @@ fn test_f32_basic() {
          0.000000000000000000000000000000000000011754942106924410754870294448492873488270\
          52428745893333857174530571588870475618904265502351336181163787841796875"
     );
+    check_f32!(1.2345e15);
 }
 
 #[test]