py/formatfloat: Special-case handling of whole parts uses integer math.

dpwe · dpwe · commit af73bde8d222 · 2022-07-07T17:13:06.000-04:00
diff --git a/py/formatfloat.c b/py/formatfloat.c
@@ -174,7 +174,9 @@ int mp_format_float(FPTYPE f, char *buf, size_t buf_size, char fmt, int prec, ch
     int num_digits = 0;
     const FPTYPE *pos_pow = g_pos_pow;
     const FPTYPE *neg_pow = g_neg_pow;
-
+    uint32_t f_int = 0;
+    uint32_t u_int = 0;
+    
     if (fp_iszero(f)) {
         e = 0;
         if (fmt == 'f') {
@@ -261,31 +263,40 @@ int mp_format_float(FPTYPE f, char *buf, size_t buf_size, char fmt, int prec, ch
     } else {
         // Build positive exponent
 
-        // First block is only for numbers that could be integers exactly-represented in float32.
-        if (f < FPCONST(1e10)) {
-            // In this case, we *won't* normalize f down to lie in 1 <= f < 10 because the
-            // repeated scaling by 0.1 cumulates errors in the representation, meaning numbers
-            // that start as integers become non-integers.  Instead, we find the scale by
-            // increasing a reference value through repeated multiplications by 10.  This
-            // whole number in the range 1e0..1e10 will be exactly represented.
-            FPTYPE cumulated_power = FPCONST(1.0);
-            for (e = 0, e1 = FPDECEXP; e1; e1 >>= 1, pos_pow++) {
-                if ((cumulated_power * *pos_pow) <= f) {
-                    e += e1;
-                    cumulated_power *= *pos_pow;
-                }
+        // First block is only for numbers that could be integers
+        // exactly-represented in float32. We handle the integer part
+        // by casting into a uint32_t, so exclude numbers larger than that
+        // limit (2^32, which is much larger than the 2^24 that is fully
+        // represented in a float32).
+        if (f < FPCONST(4294967296.0)) {  // 2^32
+            // In this case, we *won't* normalize f down to lie in 1 <= f < 10
+            // because the repeated scaling by 0.1 cumulates errors in the
+            // representation, meaning numbers that start as integers become
+            // non-integers.  Instead, we work in the integer domain and find
+            // the scale by increasing a reference value through repeated
+            // (integer) multiplications by 10.
+            f_int = (uint32_t)f;
+            u_int = 1;
+            e = 0;
+            while((u_int * 10L) <= f_int) {
+                u_int *= 10L;
+                ++e;
             }
-            // f is NOT normalized to be 1 <= f < 10; the mantissa printing is modified
-            // to handle this.
+            // Note: u_int == 10**e is re-used in the mantissa printing below.
+
+            // f is NOT normalized to be 1 <= f < 10; the mantissa printing is
+            // modified to handle this.
         } else {
-            // Calculate the exponent and normalize f to lie in the range 1 <= f < 10.
+            // Calculate the exponent and normalize f to lie in the range
+            // 1 <= f < 10.
             for (e = 0, e1 = FPDECEXP; e1; e1 >>= 1, pos_pow++, neg_pow++) {
                 if (*pos_pow <= f) {
                     e += e1;
                     f *= *neg_pow;
                 }
             }
-            // It can be that f was right on the edge of an entry in pos_pow needs to be reduced
+            // It can be that f was right on the edge of an entry in pos_pow
+            // needs to be reduced
             if ((int)f >= 10) {
                 e += 1;
                 f *= FPCONST(0.1);
@@ -341,9 +352,9 @@ int mp_format_float(FPTYPE f, char *buf, size_t buf_size, char fmt, int prec, ch
     // before the decimal.
     //
     // For numbers in the range 1e1 to 1e10 (which includes all whole-values
-    // that can be exactly represented in float32s), we do NOT normalize f
-    // to avoid the small departures from whole numbers the scaling would
-    // incur.
+    // that can be exactly, continuously represented in float32s), we do NOT
+    // normalize f, to avoid the small departures from whole numbers the
+    // scaling would incur.
 
     // For e, prec is # digits after the decimal
     // For f, prec is # digits after the decimal
@@ -362,50 +373,36 @@ int mp_format_float(FPTYPE f, char *buf, size_t buf_size, char fmt, int prec, ch
     }
 
     int num_digits_left = num_digits;
-    if (f >= FPCONST(10.0)) {
+    // If f_int is nonzero, it's because 1.0 < f < 2**32, so the integer
+    // part is fully represented in f_int (a uint32_t).
+    if (f_int >= 10) {
         // Print any leading digits to bring f down to < 10.
-        // As above, we avoid modifying f to avoid distorting whole numbers.
-        // Instead, we construct a comparison value that is always a whole
-        // number (because it does not involve multiplying by any non-whole
-        // numbers) and subtract that as we print each digit.
+        // We work with an integer version of the whole-number part of f,
+        // then adjust f only by subtracting integers as we print each
+        // digit.  This avoids distorting f via multiplication by inexact
+        // negative powers of 10.
+        // u_int was already set to 10**e when f_int was set up.
         for (int digit_index = e; digit_index > 0; --digit_index) {
-            // Construct the power-of-10 "unit" for this digit by multiplying
-            // up powers of 10 (so it remains a whole number as long as
-            // possible).  Because we start with the highest-value digit,
-            // and because dividing by 10 would spoil our guarantee of
-            // wholeness, we build it up from scratch every digit.
-            FPTYPE unit = FPCONST(1.0);
-            // Re-use the idiom from finding e to make unit = 10^digit_index.
-            const FPTYPE *pos_pow_2 = g_pos_pow;
-            for (int ee = digit_index, e2 = FPDECEXP; e2; e2 >>= 1, pos_pow_2++) {
-                if (ee >= e2) {
-                    ee -= e2;
-                    unit *= *pos_pow_2;
-                }
-            }
-            // Step through the 10 possible values of this digit until we
-            // find the one before going beyond f.
-            int d;
-            FPTYPE cumulated_units = FPCONST(0.0);
-            for (d = 0; d < 10; ++d) {
-                if (f < cumulated_units + unit) {
-                    break;
-                }
-                cumulated_units += unit;
-            }
+            // Integer division will safely give us the leading digit.
+            int d = f_int / u_int;
+            f_int -= (d * u_int);
+            // Reduce our full floating point value by the integer value we're
+            // printing. 
+            f -= (FPTYPE)(d * u_int);
             *s++ = '0' + d;
-            f -= cumulated_units;
             if (dec == 0 && prec > 0) {
                 *s++ = '.';
             }
             --dec;
             --num_digits_left;
+            // Integer division safely reduces the integer unit base.
+            u_int /= 10;
             // Special case the last digit.
             if (num_digits_left == 0) {
-                // We're going to fall through to the rounding code which expects
+                // We're going to fall through to rounding code which expects
                 // f to be a residual in the range 1 <= f < 10, and will apply
-                // rounding if it's >= 5.  So now we need to construct that residual.
-                f *= (FPCONST(10.) / unit);
+                // rounding if it's >= 5.  So we need to construct the residual.
+                f *= (FPCONST(1.) / u_int);
                 break;
             }
         }
diff --git a/tests/float/float_format_int.py b/tests/float/float_format_int.py
@@ -1,13 +1,20 @@
 # Test that integers format to exact values.
 
 for b in [13, 123, 457, 23456]:
-    for r in range(1, 3):
+    for r in range(1, 6):
         e_fmt = "{:." + str(r) + "e}"
         f_fmt = "{:." + str(r) + "f}"
         g_fmt = "{:." + str(r) + "g}"
-        for e in range(-9, 5):
+        for e in range(0, 5):
             f = b * (10**e)
             title = str(b) + "x 10^" + str(e)
             print(title, "with format", e_fmt, "gives", e_fmt.format(f))
             print(title, "with format", f_fmt, "gives", f_fmt.format(f))
             print(title, "with format", g_fmt, "gives", g_fmt.format(f))
+
+# The largest integer you can store exactly in float32.
+print("{:f}".format(16777215))
+# The largest integer smaller than 4e9 which can be exactly represented in a
+# float32. Space between adjacent values is 256 at this point.
+# 4e9 is the threshold for the special-case code in formatfloat.c.
+print("{:f}".format(3999999744))
