Unify format_float_as_exponent to clarify

Author: ChJR

common/src/float_ops.rs

@@ -83,6 +83,23 @@ pub fn is_integer(v: f64) -> bool {
     (v - v.round()).abs() < std::f64::EPSILON
 }
 
+// Formats floats into Python style exponent notation, by first formatting in Rust style
+// exponent notation (`1.0000e0`), then convert to Python style (`1.0000e+00`).
+pub fn format_float_as_exponent(precision: usize, magnitude: f64) -> String {
+    if magnitude.is_nan() {
+        return "nan".to_string();
+    }
+    if magnitude.is_infinite() {
+        return "inf".to_string();
+    }
+
+    let r_exp = format!("{:.*e}", precision, magnitude);
+    let mut parts = r_exp.splitn(2, 'e');
+    let base = parts.next().unwrap();
+    let exponent = parts.next().unwrap().parse::<i64>().unwrap();
+    format!("{}e{:+#03}", base, exponent)
+}
+
 pub fn to_string(value: f64) -> String {
     let lit = format!("{:e}", value);
     if let Some(position) = lit.find('e') {

vm/src/cformat.rs

@@ -1,4 +1,5 @@
 use crate::builtins::{float, int, pystr, tuple};
+use crate::common::float_ops;
 /// Implementation of Printf-Style string formatting
 /// [https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting]
 use crate::format::get_num_digits;
@@ -242,24 +243,6 @@ impl CFormatSpec {
         }
     }
 
-    fn normalize_float(&self, num: f64) -> (f64, i32) {
-        let mut fraction = num;
-        let mut exponent = 0;
-        loop {
-            if fraction >= 10.0 {
-                fraction /= 10.0;
-                exponent += 1;
-            } else if fraction < 1.0 && fraction > 0.0 {
-                fraction *= 10.0;
-                exponent -= 1;
-            } else {
-                break;
-            }
-        }
-
-        (fraction, exponent)
-    }
-
     pub(crate) fn format_float(&self, num: f64) -> Result<String, String> {
         let sign_string = if num.is_sign_positive() {
             self.flags.sign_string()
@@ -281,8 +264,8 @@ impl CFormatSpec {
                     Some(CFormatQuantity::Amount(p)) => p,
                     _ => 6,
                 };
-                let (fraction, exponent) = self.normalize_float(num.abs());
-                Ok(format!("{:.*}e{:+03}", precision, fraction, exponent))
+                let magnitude = num.abs();
+                Ok(float_ops::format_float_as_exponent(precision, magnitude))
             }
             CFormatType::Float(CFloatType::General(_)) => {
                 Err("Not yet implemented for %g and %G".to_owned())

vm/src/format.rs

@@ -277,16 +277,6 @@ fn parse_format_spec(text: &str) -> Result<FormatSpec, &'static str> {
     })
 }
 
-// Formats floats into Python style exponent notation, by first formatting in Rust style
-// exponent notation (`1.0000e0`), then convert to Python style (`1.0000e+00`).
-fn format_float_as_exponent(precision: usize, magnitude: f64, separator: &str) -> String {
-    let r_exp = format!("{:.*e}", precision, magnitude);
-    let mut parts = r_exp.splitn(2, 'e');
-    let base = parts.next().unwrap();
-    let exponent = parts.next().unwrap().parse::<i64>().unwrap();
-    format!("{}{}+{:02}", base, separator, exponent)
-}
-
 impl FormatSpec {
     pub(crate) fn parse(text: &str) -> Result<FormatSpec, &'static str> {
         parse_format_spec(text)
@@ -385,16 +375,12 @@ impl FormatSpec {
             Some(FormatType::GeneralFormatLower) => {
                 Err("Format code 'g' for object of type 'float' not implemented yet")
             }
-            Some(FormatType::ExponentUpper) => match magnitude {
-                magnitude if magnitude.is_nan() => Ok("NAN".to_owned()),
-                magnitude if magnitude.is_infinite() => Ok("INF".to_owned()),
-                _ => Ok(format_float_as_exponent(precision, magnitude, "E")),
-            },
-            Some(FormatType::ExponentLower) => match magnitude {
-                magnitude if magnitude.is_nan() => Ok("nan".to_owned()),
-                magnitude if magnitude.is_infinite() => Ok("inf".to_owned()),
-                _ => Ok(format_float_as_exponent(precision, magnitude, "e")),
-            },
+            Some(FormatType::ExponentUpper) => {
+                Ok(float_ops::format_float_as_exponent(precision, magnitude).to_uppercase())
+            }
+            Some(FormatType::ExponentLower) => {
+                Ok(float_ops::format_float_as_exponent(precision, magnitude).to_lowercase())
+            }
             Some(FormatType::Percentage) => match magnitude {
                 magnitude if magnitude.is_nan() => Ok("nan%".to_owned()),
                 magnitude if magnitude.is_infinite() => Ok("inf%".to_owned()),