fmt of floating points in plain code, defragemented

Author: pascaldekloe

library/core/src/fmt/float.rs

@@ -6,7 +6,6 @@ use crate::cell::{Cell, Ref, RefCell, RefMut, SyncUnsafeCell, UnsafeCell};
 use crate::char::EscapeDebugExtArgs;
 use crate::hint::assert_unchecked;
 use crate::marker::{PhantomData, PointeeSized};
-use crate::num::fmt as numfmt;
 use crate::ops::Deref;
 use crate::ptr::NonNull;
 use crate::{iter, mem, result, str};
@@ -1779,7 +1778,7 @@ impl<'a> Formatter<'a> {
 
     /// Write a formatted integer to the Formatter. The `digits` string should
     /// hold the representation of the absolute value, without sign. Whether a
-    /// sign ("+" or "-") is written depends both on format paramaters and on
+    /// sign ("+" or "-") is written depends both on format parameters and on
     /// `is_nonnegative`. The `prefix` (e.g., "0x") is written when alternate.
     /// Padding may be included when width is Some. The precision is ignored
     /// for integers.
@@ -2005,53 +2004,6 @@ impl<'a> Formatter<'a> {
         Ok(PostPadding::new(fill, padding - padding_left))
     }
 
-    /// Takes the formatted parts and applies the padding.
-    ///
-    /// Assumes that the caller already has rendered the parts with required precision,
-    /// so that `self.precision` can be ignored.
-    ///
-    /// # Safety
-    ///
-    /// Any `numfmt::Part::Copy` parts in `formatted` must contain valid UTF-8.
-    unsafe fn pad_formatted_parts(&mut self, formatted: &numfmt::Formatted<'_>) -> Result {
-        unsafe fn write_bytes(buf: &mut dyn Write, s: &[u8]) -> Result {
-            // SAFETY: This is used for `numfmt::Part::Num` and `numfmt::Part::Copy`.
-            // It's safe to use for `numfmt::Part::Num` since every char `c` is between
-            // `b'0'` and `b'9'`, which means `s` is valid UTF-8. It's safe to use for
-            // `numfmt::Part::Copy` due to this function's precondition.
-            buf.write_str(unsafe { str::from_utf8_unchecked(s) })
-        }
-
-        let sign = formatted.sign;
-        let out_len = formatted.len() - sign.len();
-        self.pad_number(sign, out_len, |f: &mut Self| {
-            for part in formatted.parts {
-                match *part {
-                    numfmt::Part::Zero(nzeroes) => {
-                        f.write_zeroes(nzeroes)?;
-                    }
-                    numfmt::Part::Num(mut v) => {
-                        let mut s = [0; 5];
-                        let len = part.len();
-                        for c in s[..len].iter_mut().rev() {
-                            *c = b'0' + (v % 10) as u8;
-                            v /= 10;
-                        }
-                        // SAFETY: Per the precondition.
-                        unsafe {
-                            write_bytes(f.buf, &s[..len])?;
-                        }
-                    }
-                    // SAFETY: Per the precondition.
-                    numfmt::Part::Copy(buf) => unsafe {
-                        write_bytes(f.buf, buf)?;
-                    },
-                }
-            }
-            Ok(())
-        })
-    }
-
     /// Write n ASCII digits (U+0030) to the Formatter.
     pub(crate) fn write_zeroes(&mut self, n: usize) -> Result {
         #[cfg(feature = "optimize_for_size")]

library/core/src/fmt/mod.rs

@@ -1,107 +1,107 @@
 //! Decodes a floating-point value into individual parts and error ranges.
 
-use crate::num::FpCategory;
-use crate::num::dec2flt::float::RawFloat;
+use crate::mem::size_of;
 
-/// Decoded unsigned finite value, such that:
+/// Generic representation of finite floating-point values up to 64-bit wide.
+/// The absolute value equals `mant * 2^exp`. All real values `x` such that:
 ///
-/// - The original value equals to `mant * 2^exp`.
+///  lower < x < upper
+///
+/// (or `lower < x ≤ upper` in the tie-to-even case) round to this value under
+/// IEEE 754 round-to-nearest rules, where:
+///
+///  lower = (mant − minus) * 2^exp
+///  upper = (mant + plus)  * 2^exp
 ///
-/// - Any number from `(mant - minus) * 2^exp` to `(mant + plus) * 2^exp` will
-///   round to the original value. The range is inclusive only when
-///   `inclusive` is `true`.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct Decoded {
-    /// The scaled mantissa.
+pub struct Decoded64 {
+    /// Scaled mantissa. The scaling is chosen such that the rounding boundaries
+    /// are integral when expressed as `mant ± {minus, plus}`.
     pub mant: u64,
-    /// The lower error range.
+
+    /// Distance from `mant` to the lower rounding-boundary.
     pub minus: u64,
-    /// The upper error range.
+    /// Distance from `mant` to the upper rounding-boundary.
     pub plus: u64,
-    /// The shared exponent in base 2.
-    pub exp: i16,
-    /// True when the error range is inclusive.
-    ///
-    /// In IEEE 754, this is true when the original mantissa was even.
-    pub inclusive: bool,
-}
 
-/// Decoded unsigned value.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum FullDecoded {
-    /// Not-a-number.
-    Nan,
-    /// Infinities, either positive or negative.
-    Infinite,
-    /// Zero, either positive or negative.
-    Zero,
-    /// Finite numbers with further decoded fields.
-    Finite(Decoded),
-}
+    /// Base-2 exponent for `mant`, `minus`, and `plus`.
+    pub exp: isize,
 
-/// A floating point type which can be `decode`d.
-pub trait DecodableFloat: RawFloat + Copy {
-    /// The minimum positive normalized value.
-    fn min_pos_norm_value() -> Self;
+    /// Indicates whether an exact tie at the upper rounding-boundary (i.e., the
+    /// midpoint between this value and its next representable neighbor) rounds
+    /// to this value. It applies only to the upper boundary; the lower boundary
+    /// is always exclusive. This follows IEEE 754 round-ties-to-even semantics
+    /// and is true iff the original significand was even.
+    pub tie_to_even: bool,
 }
 
-#[cfg(target_has_reliable_f16)]
-impl DecodableFloat for f16 {
-    fn min_pos_norm_value() -> Self {
-        f16::MIN_POSITIVE
-    }
-}
+macro_rules! floats {
+    ($($T:ident)*) => {
+        $(
 
-impl DecodableFloat for f32 {
-    fn min_pos_norm_value() -> Self {
-        f32::MIN_POSITIVE
-    }
-}
+        /// Decode a floating-point into its integer components. The tuple in
+        /// return contains the mantissa m and exponent e, such that original
+        /// value equals `m * 2^e`, ignoring the sign.
+        ///
+        /// For normal numbers: mantissa includes the implied leading 1.
+        /// For denormal numbers: mantissa is shifted to maintain the equation.
+        const fn ${concat(mant_and_exp_, $T)}(v: $T) -> (u64, isize) {
+            const ENC_BITS: usize = size_of::<$T>() * 8;
+            // The encoding of the sign resides in the most significant bit.
+            const SIGN_ENC_BITS: usize = 1;
+            // The encoding of the mantissa resides in the least-significant
+            // bits.
+            const MANT_ENC_BITS: usize = $T::MANTISSA_DIGITS as usize - 1;
+            // The encoding of the exponent resides in the remaining bits,
+            // inbetween sign and the mantissa.
+            const EXP_ENC_BITS: usize = ENC_BITS - (SIGN_ENC_BITS + MANT_ENC_BITS);
 
-impl DecodableFloat for f64 {
-    fn min_pos_norm_value() -> Self {
-        f64::MIN_POSITIVE
-    }
-}
+            let enc = v.to_bits();
+            let exp_enc = (enc << SIGN_ENC_BITS) >> (SIGN_ENC_BITS + MANT_ENC_BITS);
+            let mant_enc = enc & ((1 << MANT_ENC_BITS) - 1);
+
+            const EXP_BIAS: isize = (1 << (EXP_ENC_BITS - 1)) - 1;
+            let exp = exp_enc as isize - (EXP_BIAS + MANT_ENC_BITS as isize);
 
-/// Returns a sign (true when negative) and `FullDecoded` value
-/// from given floating point number.
-pub fn decode<T: DecodableFloat>(v: T) -> (/*negative?*/ bool, FullDecoded) {
-    let (mant, exp, sign) = v.integer_decode();
-    let even = (mant & 1) == 0;
-    let decoded = match v.classify() {
-        FpCategory::Nan => FullDecoded::Nan,
-        FpCategory::Infinite => FullDecoded::Infinite,
-        FpCategory::Zero => FullDecoded::Zero,
-        FpCategory::Subnormal => {
-            // neighbors: (mant - 2, exp) -- (mant, exp) -- (mant + 2, exp)
-            // Float::integer_decode always preserves the exponent,
-            // so the mantissa is scaled for subnormals.
-            FullDecoded::Finite(Decoded { mant, minus: 1, plus: 1, exp, inclusive: even })
+            let mant = if exp_enc != 0 {
+                // Normal numbers have an implied leading 1 to the mantissa
+                // bits.
+                mant_enc | 1 << MANT_ENC_BITS
+            } else {
+                // Account for the effective +1 on exponents of denormal numbers.
+                mant_enc << 1
+            };
+
+            const _: () = assert!(ENC_BITS <= 64);
+            (mant as u64, exp)
         }
-        FpCategory::Normal => {
-            let minnorm = <T as DecodableFloat>::min_pos_norm_value().integer_decode();
-            if mant == minnorm.0 {
-                // neighbors: (maxmant, exp - 1) -- (minnormmant, exp) -- (minnormmant + 1, exp)
-                // where maxmant = minnormmant * 2 - 1
-                FullDecoded::Finite(Decoded {
-                    mant: mant << 2,
-                    minus: 1,
-                    plus: 2,
-                    exp: exp - 2,
-                    inclusive: even,
-                })
+
+        /// Parse a finite, non-zero floating-point into the generic structure.
+        pub fn ${concat(decode_, $T)}(v: $T) -> Decoded64 {
+            let (mant, exp) = ${concat(mant_and_exp_, $T)}(v);
+
+            if v.is_subnormal() {
+                // Subnormal floats have doubled spacing between representable values.
+                // The boundaries are symmetric around `mant` in this scaled integer space.
+                return Decoded64 { mant: mant, minus: 1, plus: 1, exp: exp, tie_to_even: true };
+            }
+            debug_assert!(v.is_normal());
+
+            let is_even = (mant & 1) == 0;
+
+            const MIN_POS_MANT: u64 = ${concat(mant_and_exp_, $T)}($T::MIN_POSITIVE).0;
+            const _: () = assert!(MIN_POS_MANT != 0);
+            if mant == MIN_POS_MANT {
+                // The previous float of the first normal number is the largest subnormal.
+                // The upper boundary is asymmetrically farther away than the lower boundary.
+                Decoded64 { mant: mant << 2, minus: 1, plus: 2, exp: exp - 2, tie_to_even: is_even }
             } else {
-                // neighbors: (mant - 1, exp) -- (mant, exp) -- (mant + 1, exp)
-                FullDecoded::Finite(Decoded {
-                    mant: mant << 1,
-                    minus: 1,
-                    plus: 1,
-                    exp: exp - 1,
-                    inclusive: even,
-                })
+                Decoded64 { mant: mant << 1, minus: 1, plus: 1, exp: exp - 1, tie_to_even: is_even }
             }
         }
+
+        )*
     };
-    (sign < 0, decoded)
 }
+
+floats! { f16 f32 f64 }

library/core/src/num/flt2dec/decoder.rs

@@ -1,14 +1,21 @@
 //! The exponent estimator.
 
-/// Finds `k_0` such that `10^(k_0-1) < mant * 2^exp <= 10^(k_0+1)`.
+/// Estimates the base-10 scaling factor `k = ceil(log10(mant * 2^exp))`.
 ///
-/// This is used to approximate `k = ceil(log_10 (mant * 2^exp))`;
-/// the true `k` is either `k_0` or `k_0+1`.
+/// Returns a lower-bound estimate `r` such that:
+///
+///     k ∈ { r, r + 1 }
 #[doc(hidden)]
-pub fn estimate_scaling_factor(mant: u64, exp: i16) -> i16 {
-    // 2^(nbits-1) < mant <= 2^nbits if mant > 0
+pub fn estimate_scaling_factor(mant: u64, exp: isize) -> isize {
+    // 2^(nbits - 1) < mant <= 2^nbits if mant > 0
     let nbits = 64 - (mant - 1).leading_zeros() as i64;
-    // 1292913986 = floor(2^32 * log_10 2)
-    // therefore this always underestimates (or is exact), but not much.
-    (((nbits + exp as i64) * 1292913986) >> 32) as i16
+    let n = nbits + exp as i64;
+    //  log₁₀(2ⁿ) = n × log₁₀(2)
+    //
+    // To multiply with log₁₀(2) as an integer, the fraction (≈0.3) is scaled.
+    //
+    //  n × log₁₀(2) = (n × log₁₀(2) × C) ÷ C
+    //
+    // With C = 2³², and ⌊log₁₀(2) × 2³²⌋ = 1292913986, we can compute:
+    ((n * 1292913986) >> 32) as isize
 }