Add exponential formatting to BigInt

src/bigint.rs

@@ -12,12 +12,12 @@ use core::{i128, u128};
 use core::{i64, u64};
 
 use num_integer::{Integer, Roots};
-use num_traits::{Num, One, Pow, Signed, Zero};
+use num_traits::{Num, One, Pow, Signed, Zero, ToPrimitive};
 
 use self::Sign::{Minus, NoSign, Plus};
 
 use crate::big_digit::BigDigit;
-use crate::biguint::to_str_radix_reversed;
+use crate::biguint::{to_str_radix_reversed, fmt_exp_slow};
 use crate::biguint::{BigUint, IntDigits, U32Digits, U64Digits};
 
 mod addition;
@@ -174,6 +174,50 @@ impl fmt::UpperHex for BigInt {
     }
 }
 
+impl fmt::LowerExp for BigInt {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Option::Some(small) = self.to_u64() {
+            fmt::LowerExp::fmt(&small, f)
+        } else {
+            // The max digits that can fit into a f64, which ensures
+            // that printing won't have rounding errors.
+            const MAX_FLOAT_DIGITS: usize = 14;
+            if f.precision().filter(|x| x < &MAX_FLOAT_DIGITS).is_some() {
+                let as_f64 = self.to_f64().unwrap();
+                if as_f64.is_finite() {
+                    fmt::LowerExp::fmt(&as_f64, f)
+                } else {
+                    fmt_exp_slow(self.magnitude(), f, false, !self.is_negative())
+                }
+            } else {
+                fmt_exp_slow(self.magnitude(), f, false, !self.is_negative())
+            }
+        }
+    }
+}
+
+impl fmt::UpperExp for BigInt {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Option::Some(small) = self.to_i64() {
+            fmt::UpperExp::fmt(&small, f)
+        } else {
+            // The max digits that can fit into a f64, which ensures
+            // that printing won't have rounding errors.
+            const MAX_FLOAT_DIGITS: usize = 14;
+            if f.precision().filter(|&x| x < MAX_FLOAT_DIGITS).is_some() {
+                let as_f64 = self.to_f64().unwrap();
+                if as_f64.is_finite() {
+                    fmt::UpperExp::fmt(&as_f64, f)
+                } else {
+                    fmt_exp_slow(self.magnitude(), f, true, !self.is_negative())
+                }
+            } else {
+                fmt_exp_slow(self.magnitude(), f, true, !self.is_negative())
+            }
+        }
+    }
+}
+
 // !-2 = !...f fe = ...0 01 = +1
 // !-1 = !...f ff = ...0 00 =  0
 // ! 0 = !...0 00 = ...f ff = -1

src/biguint.rs

@@ -4,7 +4,7 @@ use crate::std_alloc::{String, Vec};
 use core::cmp;
 use core::cmp::Ordering;
 use core::default::Default;
-use core::fmt;
+use core::fmt::{self, Write};
 use core::hash;
 use core::mem;
 use core::str;
@@ -33,6 +33,7 @@ mod serde;
 
 pub(crate) use self::convert::to_str_radix_reversed;
 pub use self::iter::{U32Digits, U64Digits};
+use crate::Sign;
 
 /// A big unsigned integer type.
 pub struct BigUint {
@@ -143,6 +144,72 @@ impl fmt::Octal for BigUint {
     }
 }
 
+impl fmt::LowerExp for BigUint {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Option::Some(small) = self.to_u64() {
+            fmt::LowerExp::fmt(&small, f)
+        } else {
+            // The max digits that can fit into a f64, which ensures
+            // that printing won't have rounding errors.
+            const MAX_FLOAT_DIGITS: usize = 14;
+            if f.precision().filter(|x| x < &MAX_FLOAT_DIGITS).is_some() {
+                let as_f64 = self.to_f64().unwrap();
+                if as_f64.is_finite() {
+                    fmt::LowerExp::fmt(&as_f64, f)
+                } else {
+                    fmt_exp_slow(self, f, false, true)
+                }
+            } else {
+                fmt_exp_slow(self, f, false, true)
+            }
+        }
+    }
+}
+
+impl fmt::UpperExp for BigUint {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Option::Some(small) = self.to_u64() {
+            fmt::UpperExp::fmt(&small, f)
+        } else {
+            // The max digits that can fit into a f64, which ensures
+            // that printing won't have rounding errors.
+            const MAX_FLOAT_DIGITS: usize = 14;
+            if f.precision().filter(|&x| x < MAX_FLOAT_DIGITS).is_some() {
+                let as_f64 = self.to_f64().unwrap();
+                if as_f64.is_finite() {
+                    fmt::UpperExp::fmt(&as_f64, f)
+                } else {
+                    fmt_exp_slow(self, f, true, true)
+                }
+            } else {
+                fmt_exp_slow(self, f, true, true)
+            }
+        }
+    }
+}
+
+pub(crate) fn fmt_exp_slow(x: &BigUint, f: &mut fmt::Formatter<'_>, upper: bool, is_nonneg: bool) -> fmt::Result {
+    let precision = f.precision().unwrap_or(16);
+    let digits = to_str_radix_reversed(x, 10);
+    let mut buffer = String::with_capacity(precision + 5);
+    debug_assert!(digits.len() > 1, "Values with fewer digits should use direct formatting");
+    let mut iter = digits.iter().rev();
+    buffer.push(*iter.next().unwrap() as char);
+    buffer.push('.');
+    for &ch in iter.take(precision) {
+        buffer.push(ch as char);
+    }
+    // Add trailing zeroes when explicit precision given
+    if f.precision().is_some() {
+        for _ in 0..precision.saturating_sub(digits.len() - 1) {
+            buffer.push('0');
+        }
+    }
+    buffer.push(if upper { 'E' } else { 'e' });
+    write!(buffer, "{}", digits.len() - 1)?;
+    f.pad_integral(is_nonneg, "", &buffer)
+}
+
 impl Zero for BigUint {
     #[inline]
     fn zero() -> BigUint {