internal/strconv: handle %f with fixedFtoa when possible

author Russ Cox <rsc@golang.org>

Sun, 2 Nov 2025 17:32:01 +0000 (12:32 -0500)

committer Russ Cox <rsc@golang.org>

Tue, 4 Nov 2025 19:43:22 +0000 (11:43 -0800)
author Russ Cox <rsc@golang.org>
Sun, 2 Nov 2025 17:32:01 +0000 (12:32 -0500)
committer Russ Cox <rsc@golang.org>
Tue, 4 Nov 2025 19:43:22 +0000 (11:43 -0800)
diff --git a/src/internal/strconv/ftoa.go b/src/internal/strconv/ftoa.go

index fd30f28289ae9d4efc6bbede5f2966f4477f0f0b..64be29e23efc7bc0c9bb6bd4cfe6dbee202201cb 100644 (file)
--- a/src/internal/strconv/ftoa.go
+++ b/src/internal/strconv/ftoa.go
@@ -146,28 +146,38 @@ func genericFtoa(dst []byte, val float64, fmt byte, prec, bitSize int) []byte {
                 return formatDigits(dst, shortest, neg, digs, prec, fmt)
         }
  
-       // TODO figure out when we can use fast code for f
-       if fmt != 'f' {
-               // Fixed number of digits.
-               digits := prec
-               switch fmt {
-               case 'e', 'E':
-                       digits++
-               case 'g', 'G':
-                       if prec == 0 {
-                               prec = 1
-                       }
-                       digits = prec
-               default:
-                       // Invalid mode.
-                       digits = 1
+       // Fixed number of digits.
+       digits := prec
+       switch fmt {
+       case 'f':
+               // %f precision specifies digits after the decimal point.
+               // Estimate an upper bound on the total number of digits needed.
+               // ftoaFixed will shorten as needed according to prec.
+               if exp >= 0 {
+                       digits = 1 + mulLog10_2(1+exp) + prec
+               } else {
+                       digits = 1 + prec - mulLog10_2(-exp)
                 }
-               if digits <= 18 {
+       case 'e', 'E':
+               digits++
+       case 'g', 'G':
+               if prec == 0 {
+                       prec = 1
+               }
+               digits = prec
+       default:
+               // Invalid mode.
+               digits = 1
+       }
+       if digits <= 18 {
+               // digits <= 0 happens for %f on very small numbers
+               // and means that we're guaranteed to print all zeros.
+               if digits > 0 {
                         var buf [24]byte
                         digs.d = buf[:]
-                       fixedFtoa(&digs, mant, exp-int(flt.mantbits), digits)
-                       return formatDigits(dst, false, neg, digs, prec, fmt)
+                       fixedFtoa(&digs, mant, exp-int(flt.mantbits), digits, prec, fmt)
                 }
+               return formatDigits(dst, false, neg, digs, prec, fmt)
         }
  
         return bigFtoa(dst, prec, fmt, neg, mant, exp, flt)
diff --git a/src/internal/strconv/ftoa_test.go b/src/internal/strconv/ftoa_test.go

index 4e6f4629288c35276f14fc33fd13e8237ddcb063..0393c3e17c3b59a035f369f6ed7351defec76dad 100644 (file)
--- a/src/internal/strconv/ftoa_test.go
+++ b/src/internal/strconv/ftoa_test.go
@@ -42,6 +42,29 @@ var ftoatests = []ftoaTest{
         {2000000, 'g', -1, "2e+06"},
         {1e10, 'g', -1, "1e+10"},
  
+       // f conversion basic cases
+       {12345, 'f', 2, "12345.00"},
+       {1234.5, 'f', 2, "1234.50"},
+       {123.45, 'f', 2, "123.45"},
+       {12.345, 'f', 2, "12.35"},
+       {1.2345, 'f', 2, "1.23"},
+       {0.12345, 'f', 2, "0.12"},
+       {0.12945, 'f', 2, "0.13"},
+       {0.012345, 'f', 2, "0.01"},
+       {0.015, 'f', 2, "0.01"},
+       {0.016, 'f', 2, "0.02"},
+       {0.0052345, 'f', 2, "0.01"},
+       {0.0012345, 'f', 2, "0.00"},
+       {0.00012345, 'f', 2, "0.00"},
+       {0.000012345, 'f', 2, "0.00"},
+
+       {0.996644984, 'f', 6, "0.996645"},
+       {0.996644984, 'f', 5, "0.99664"},
+       {0.996644984, 'f', 4, "0.9966"},
+       {0.996644984, 'f', 3, "0.997"},
+       {0.996644984, 'f', 2, "1.00"},
+       {0.996644984, 'f', 1, "1.0"},
+
         // g conversion and zero suppression
         {400, 'g', 2, "4e+02"},
         {40, 'g', 2, "40"},
diff --git a/src/internal/strconv/ftoafixed.go b/src/internal/strconv/ftoafixed.go

index f3542d1cf584aa4137478840afd00c7d4956e7b3..7f297e924e160682843cafd1178235548de810d3 100644 (file)
--- a/src/internal/strconv/ftoafixed.go
+++ b/src/internal/strconv/ftoafixed.go
@@ -13,7 +13,9 @@ var uint64pow10 = [...]uint64{
  
  // fixedFtoa formats a number of decimal digits of mant*(2^exp) into d,
  // where mant > 0 and 1 ≤ digits ≤ 18.
-func fixedFtoa(d *decimalSlice, mant uint64, exp, digits int) {
+// If fmt == 'f', digits is a conservative overestimate, and the final
+// number of digits is prec past the decimal point.
+func fixedFtoa(d *decimalSlice, mant uint64, exp, digits, prec int, fmt byte) {
         // The strategy here is to multiply (mant * 2^exp) by a power of 10
         // to make the resulting integer be the number of digits we want.
         //
@@ -133,6 +135,28 @@ func fixedFtoa(d *decimalSlice, mant uint64, exp, digits int) {
                 d.dp++
         }
  
+       // If this is %.*f we may have overestimated the digits needed.
+       // Now that we know where the decimal point is,
+       // trim to the actual number of digits, which is d.dp+prec.
+       if fmt == 'f' && digits != d.dp+prec {
+               for digits > d.dp+prec {
+                       var r uint
+                       dm, r = dm/10, uint(dm%10)
+                       dt |= bool2uint(r != 0)
+                       digits--
+               }
+
+               // Dropping those digits can create a new leftmost
+               // non-zero digit, like if we are formatting %.1f and
+               // convert 0.09 -> 0.1. Detect and adjust for that.
+               if digits <= 0 {
+                       digits = 1
+                       d.dp++
+               }
+
+               max = uint64pow10[digits] << 1
+       }
+
         // Round and shift away rounding bit.
         // We want to round up when
         // (a) the fractional part is > 0.5 (dm&1 != 0 and dt == 1)
@@ -148,9 +172,13 @@ func fixedFtoa(d *decimalSlice, mant uint64, exp, digits int) {
         }
  
         // Format digits into d.
-       formatBase10(d.d[:digits], dm)
-       d.nd = digits
-       for d.d[d.nd-1] == '0' {
-               d.nd--
+       if dm != 0 {
+               if formatBase10(d.d[:digits], dm) != 0 {
+                       panic("formatBase10")
+               }
+               d.nd = digits
+               for d.d[d.nd-1] == '0' {
+                       d.nd--
+               }
         }
  }
author	Russ Cox <rsc@golang.org>
	Sun, 2 Nov 2025 17:32:01 +0000 (12:32 -0500)
committer	Russ Cox <rsc@golang.org>
	Tue, 4 Nov 2025 19:43:22 +0000 (11:43 -0800)
src/internal/strconv/ftoa.go		patch \| blob \| history
src/internal/strconv/ftoa_test.go		patch \| blob \| history
src/internal/strconv/ftoafixed.go		patch \| blob \| history