Unify fixed-point format of floating numbers

Author: ChJR

common/src/float_ops.rs

@@ -107,6 +107,15 @@ fn format_inf(case: Case) -> String {
     inf.to_string()
 }
 
+pub fn format_fixed(precision: usize, magnitude: f64, case: Case) -> String {
+    match magnitude {
+        magnitude if magnitude.is_finite() => format!("{:.*}", precision, magnitude),
+        magnitude if magnitude.is_nan() => format_nan(case),
+        magnitude if magnitude.is_infinite() => format_inf(case),
+        _ => "".to_string(),
+    }
+}
+
 // 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_exponent(precision: usize, magnitude: f64, case: Case) -> String {

vm/src/cformat.rs

@@ -305,9 +305,13 @@ impl CFormatSpec {
         };
 
         let magnitude_string = match &self.format_type {
-            CFormatType::Float(CFloatType::PointDecimal(_)) => {
+            CFormatType::Float(CFloatType::PointDecimal(case)) => {
+                let case = match case {
+                    CFormatCase::Lowercase => float_ops::Case::Lower,
+                    CFormatCase::Uppercase => float_ops::Case::Upper,
+                };
                 let magnitude = num.abs();
-                format!("{:.*}", precision, magnitude)
+                float_ops::format_fixed(precision, magnitude, case)
             }
             CFormatType::Float(CFloatType::Exponent(case)) => {
                 let case = match case {

vm/src/format.rs

@@ -347,16 +347,16 @@ impl FormatSpec {
         let precision = self.precision.unwrap_or(6);
         let magnitude = num.abs();
         let raw_magnitude_string_result: Result<String, &'static str> = match self.format_type {
-            Some(FormatType::FixedPointUpper) => match magnitude {
-                magnitude if magnitude.is_nan() => Ok("NAN".to_owned()),
-                magnitude if magnitude.is_infinite() => Ok("INF".to_owned()),
-                _ => Ok(format!("{:.*}", precision, magnitude)),
-            },
-            Some(FormatType::FixedPointLower) => match magnitude {
-                magnitude if magnitude.is_nan() => Ok("nan".to_owned()),
-                magnitude if magnitude.is_infinite() => Ok("inf".to_owned()),
-                _ => Ok(format!("{:.*}", precision, magnitude)),
-            },
+            Some(FormatType::FixedPointUpper) => Ok(float_ops::format_fixed(
+                precision,
+                magnitude,
+                float_ops::Case::Upper,
+            )),
+            Some(FormatType::FixedPointLower) => Ok(float_ops::format_fixed(
+                precision,
+                magnitude,
+                float_ops::Case::Lower,
+            )),
             Some(FormatType::Decimal) => Err("Unknown format code 'd' for object of type 'float'"),
             Some(FormatType::Binary) => Err("Unknown format code 'b' for object of type 'float'"),
             Some(FormatType::Octal) => Err("Unknown format code 'o' for object of type 'float'"),