PullRequestInc
diff --git a/‎src/internal/strconv/atoi.go‎
Lines changed: 0 additions & 2 deletions b/‎src/internal/strconv/atoi.go‎
Lines changed: 0 additions & 2 deletions
diff --git a/‎src/internal/strconv/export_test.go‎
Lines changed: 3 additions & 0 deletions b/‎src/internal/strconv/export_test.go‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎src/internal/strconv/ftoa.go‎
Lines changed: 15 additions & 16 deletions b/‎src/internal/strconv/ftoa.go‎
Lines changed: 15 additions & 16 deletions
diff --git a/‎src/internal/strconv/ftoa_test.go‎
Lines changed: 11 additions & 1 deletion b/‎src/internal/strconv/ftoa_test.go‎
Lines changed: 11 additions & 1 deletion
diff --git a/‎src/internal/strconv/ftoafixed.go‎
Lines changed: 156 additions & 0 deletions b/‎src/internal/strconv/ftoafixed.go‎
Lines changed: 156 additions & 0 deletions
@@ -41,8 +41,6 @@ const intSize = 32 << (^uint(0) >> 63)
 // IntSize is the size in bits of an int or uint value.
 const IntSize = intSize
 
-const maxUint64 = 1<<64 - 1
-
 // ParseUint is like [ParseInt] but for unsigned numbers.
 //
 // A sign prefix is not permitted.
 
@@ -18,6 +18,9 @@ var (
 	Pow10            = pow10
 	Umul128          = umul128
 	Umul192          = umul192
+	Div5Tab          = div5Tab
+	DivisiblePow5    = divisiblePow5
+	TrimZeros        = trimZeros
 )
 
 func NewDecimal(i uint64) *decimal {
 
@@ -123,16 +123,17 @@ func genericFtoa(dst []byte, val float64, fmt byte, prec, bitSize int) []byte {
 		return bigFtoa(dst, prec, fmt, neg, mant, exp, flt)
 	}
 
-	var digs decimalSlice
-	ok := false
 	// Negative precision means "only as much as needed to be exact."
 	shortest := prec < 0
+	var digs decimalSlice
+	if mant == 0 {
+		return formatDigits(dst, shortest, neg, digs, prec, fmt)
+	}
 	if shortest {
 		// Use Ryu algorithm.
 		var buf [32]byte
 		digs.d = buf[:]
 		ryuFtoaShortest(&digs, mant, exp-int(flt.mantbits), flt)
-		ok = true
 		// Precision for shortest representation mode.
 		switch fmt {
 		case 'e', 'E':
@@ -142,7 +143,11 @@ func genericFtoa(dst []byte, val float64, fmt byte, prec, bitSize int) []byte {
 		case 'g', 'G':
 			prec = digs.nd
 		}
-	} else if fmt != 'f' {
+		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 {
@@ -157,21 +162,15 @@ func genericFtoa(dst []byte, val float64, fmt byte, prec, bitSize int) []byte {
 			// Invalid mode.
 			digits = 1
 		}
-		var buf [24]byte
-		if bitSize == 32 && digits <= 9 {
+		if digits <= 18 {
+			var buf [24]byte
 			digs.d = buf[:]
-			ryuFtoaFixed32(&digs, uint32(mant), exp-int(flt.mantbits), digits)
-			ok = true
-		} else if digits <= 18 {
-			digs.d = buf[:]
-			ryuFtoaFixed64(&digs, mant, exp-int(flt.mantbits), digits)
-			ok = true
+			fixedFtoa(&digs, mant, exp-int(flt.mantbits), digits)
+			return formatDigits(dst, false, neg, digs, prec, fmt)
 		}
 	}
-	if !ok {
-		return bigFtoa(dst, prec, fmt, neg, mant, exp, flt)
-	}
-	return formatDigits(dst, shortest, neg, digs, prec, fmt)
+
+	return bigFtoa(dst, prec, fmt, neg, mant, exp, flt)
 }
 
 // bigFtoa uses multiprecision computations to format a float.
 
@@ -177,6 +177,16 @@ var ftoatests = []ftoaTest{
 	{1.801439850948199e+16, 'g', -1, "1.801439850948199e+16"},
 	{5.960464477539063e-08, 'g', -1, "5.960464477539063e-08"},
 	{1.012e-320, 'g', -1, "1.012e-320"},
+
+	// Cases from TestFtoaRandom that caught bugs in fixedFtoa.
+	{8177880169308380. * (1 << 1), 'e', 14, "1.63557603386168e+16"},
+	{8393378656576888. * (1 << 1), 'e', 15, "1.678675731315378e+16"},
+	{8738676561280626. * (1 << 4), 'e', 16, "1.3981882498049002e+17"},
+	{8291032395191335. / (1 << 30), 'e', 5, "7.72163e+06"},
+
+	// Exercise divisiblePow5 case in fixedFtoa
+	{2384185791015625. * (1 << 12), 'e', 5, "9.76562e+18"},
+	{2384185791015625. * (1 << 13), 'e', 5, "1.95312e+19"},
 }
 
 func TestFtoa(t *testing.T) {
@@ -253,7 +263,7 @@ func TestFtoaRandom(t *testing.T) {
 		shortSlow = FormatFloat(x, 'e', prec, 64)
 		SetOptimize(true)
 		if shortSlow != shortFast {
-			t.Errorf("%b printed as %s, want %s", x, shortFast, shortSlow)
+			t.Errorf("%b printed with %%.%de as %s, want %s", x, prec, shortFast, shortSlow)
 		}
 	}
 }
 
@@ -0,0 +1,156 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package strconv
+
+import "math/bits"
+
+var uint64pow10 = [...]uint64{
+	1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+	1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
+}
+
+// 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) {
+	// 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.
+	//
+	// Adams proved in the Ryu paper that 128-bit precision in the
+	// power-of-10 constant is sufficient to produce correctly
+	// rounded output for all float64s, up to 18 digits.
+	// https://dl.acm.org/doi/10.1145/3192366.3192369
+	//
+	// TODO(rsc): The paper is not focused on, nor terribly clear about,
+	// this fact in this context, and the proof seems too complicated.
+	// Post a shorter, more direct proof and link to it here.
+
+	if digits > 18 {
+		panic("fixedFtoa called with digits > 18")
+	}
+
+	// Shift mantissa to have 64 bits,
+	// so that the 192-bit product below will
+	// have at least 63 bits in its top word.
+	b := 64 - bits.Len64(mant)
+	mant <<= b
+	exp -= b
+
+	// We have f = mant * 2^exp ≥ 2^(63+exp)
+	// and we want to multiply it by some 10^p
+	// to make it have the number of digits plus one rounding bit:
+	//
+	//	2 * 10^(digits-1) ≤ f * 10^p < ~2 * 10^digits
+	//
+	// The lower bound is required, but the upper bound is approximate:
+	// we must not have too few digits, but we can round away extra ones.
+	//
+	//	f * 10^p ≥ 2 * 10^(digits-1)
+	//	10^p ≥ 2 * 10^(digits-1) / f                         [dividing by f]
+	//	p ≥ (log₁₀ 2) + (digits-1) - log₁₀ f                 [taking log₁₀]
+	//	p ≥ (log₁₀ 2) + (digits-1) - log₁₀ (mant * 2^exp)    [expanding f]
+	//	p ≥ (log₁₀ 2) + (digits-1) - (log₁₀ 2) * (64 + exp)  [mant < 2⁶⁴]
+	//	p ≥ (digits - 1) - (log₁₀ 2) * (63 + exp)            [refactoring]
+	//
+	// Once we have p, we can compute the scaled value:
+	//
+	//	dm * 2^de = mant * 2^exp * 10^p
+	//	          = mant * 2^exp * pow/2^128 * 2^exp2.
+	//	          = (mant * pow/2^128) * 2^(exp+exp2).
+	p := (digits - 1) - mulLog10_2(63+exp)
+	pow, exp2, ok := pow10(p)
+	if !ok {
+		// This never happens due to the range of float32/float64 exponent
+		panic("fixedFtoa: pow10 out of range")
+	}
+	if -22 <= p && p < 0 {
+		// Special case: Let q=-p. q is in [1,22]. We are dividing by 10^q
+		// and the mantissa may be a multiple of 5^q (5^22 < 2^53),
+		// in which case the division must be computed exactly and
+		// recorded as exact for correct rounding. Our normal computation is:
+		//
+		//	dm = floor(mant * floor(10^p * 2^s))
+		//
+		// for some scaling shift s. To make this an exact division,
+		// it suffices to change the inner floor to a ceil:
+		//
+		//	dm = floor(mant * ceil(10^p * 2^s))
+		//
+		// In the range of values we are using, the floor and ceil
+		// cancel each other out and the high 64 bits of the product
+		// come out exactly right.
+		// (This is the same trick compilers use for division by constants.
+		// See Hacker's Delight, 2nd ed., Chapter 10.)
+		pow.Lo++
+	}
+	dm, lo1, lo0 := umul192(mant, pow)
+	de := exp + exp2
+
+	// Check whether any bits have been truncated from dm.
+	// If so, set dt != 0. If not, leave dt == 0 (meaning dm is exact).
+	var dt uint
+	switch {
+	default:
+		// Most powers of 10 use a truncated constant,
+		// meaning the result is also truncated.
+		dt = 1
+	case 0 <= p && p <= 55:
+		// Small positive powers of 10 (up to 10⁵⁵) can be represented
+		// precisely in a 128-bit mantissa (5⁵⁵ ≤ 2¹²⁸), so the only truncation
+		// comes from discarding the low bits of the 192-bit product.
+		//
+		// TODO(rsc): The new proof mentioned above should also
+		// prove that we can't have lo1 == 0 and lo0 != 0.
+		// After proving that, drop computation and use of lo0 here.
+		dt = bool2uint(lo1|lo0 != 0)
+	case -22 <= p && p < 0 && divisiblePow5(mant, -p):
+		// If the original mantissa was a multiple of 5^p,
+		// the result is exact. (See comment above for pow.Lo++.)
+		dt = 0
+	}
+
+	// The value we want to format is dm * 2^de, where de < 0.
+	// Multply by 2^de by shifting, but leave one extra bit for rounding.
+	// After the shift, the "integer part" of dm is dm>>1,
+	// the "rounding bit" (the first fractional bit) is dm&1,
+	// and the "truncated bit" (have any bits been discarded?) is dt.
+	shift := -de - 1
+	dt |= bool2uint(dm&(1<<shift-1) != 0)
+	dm >>= shift
+
+	// Set decimal point in eventual formatted digits,
+	// so we can update it as we adjust the digits.
+	d.dp = digits - p
+
+	// Trim excess digit if any, updating truncation and decimal point.
+	// The << 1 is leaving room for the rounding bit.
+	max := uint64pow10[digits] << 1
+	if dm >= max {
+		var r uint
+		dm, r = dm/10, uint(dm%10)
+		dt |= bool2uint(r != 0)
+		d.dp++
+	}
+
+	// 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)
+	// (b) or the fractional part is ≥ 0.5 and the integer part is odd
+	//     (dm&1 != 0 and dm&2 != 0).
+	// The bitwise expression encodes that logic.
+	dm += uint64(uint(dm) & (dt | uint(dm)>>1) & 1)
+	dm >>= 1
+	if dm == max>>1 {
+		// 999... rolled over to 1000...
+		dm = uint64pow10[digits-1]
+		d.dp++
+	}
+
+	// Format digits into d.
+	formatBase10(d.d[:digits], dm)
+	d.nd = digits
+	for d.d[d.nd-1] == '0' {
+		d.nd--
+	}
+}
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,9 @@ var (`
`18`	`18`	`Pow10 = pow10`
`19`	`19`	`Umul128 = umul128`
`20`	`20`	`Umul192 = umul192`
	`21`	`+ Div5Tab = div5Tab`
	`22`	`+ DivisiblePow5 = divisiblePow5`
	`23`	`+ TrimZeros = trimZeros`
`21`	`24`	`)`
`22`	`25`
`23`	`26`	`func NewDecimal(i uint64) *decimal {`
Original file line number	Diff line number	Diff line change
`@@ -177,6 +177,16 @@ var ftoatests = []ftoaTest{`
`177`	`177`	`{1.801439850948199e+16, 'g', -1, "1.801439850948199e+16"},`
`178`	`178`	`{5.960464477539063e-08, 'g', -1, "5.960464477539063e-08"},`
`179`	`179`	`{1.012e-320, 'g', -1, "1.012e-320"},`
	`180`	`+`
	`181`	`+ // Cases from TestFtoaRandom that caught bugs in fixedFtoa.`
	`182`	`+ {8177880169308380. * (1 << 1), 'e', 14, "1.63557603386168e+16"},`
	`183`	`+ {8393378656576888. * (1 << 1), 'e', 15, "1.678675731315378e+16"},`
	`184`	`+ {8738676561280626. * (1 << 4), 'e', 16, "1.3981882498049002e+17"},`
	`185`	`+ {8291032395191335. / (1 << 30), 'e', 5, "7.72163e+06"},`
	`186`	`+`
	`187`	`+ // Exercise divisiblePow5 case in fixedFtoa`
	`188`	`+ {2384185791015625. * (1 << 12), 'e', 5, "9.76562e+18"},`
	`189`	`+ {2384185791015625. * (1 << 13), 'e', 5, "1.95312e+19"},`
`180`	`190`	`}`
`181`	`191`
`182`	`192`	`func TestFtoa(t *testing.T) {`
`@@ -253,7 +263,7 @@ func TestFtoaRandom(t *testing.T) {`
`253`	`263`	`shortSlow = FormatFloat(x, 'e', prec, 64)`
`254`	`264`	`SetOptimize(true)`
`255`	`265`	`if shortSlow != shortFast {`
`256`		`- t.Errorf("%b printed as %s, want %s", x, shortFast, shortSlow)`
	`266`	`+ t.Errorf("%b printed with %%.%de as %s, want %s", x, prec, shortFast, shortSlow)`
`257`	`267`	`}`
`258`	`268`	`}`
`259`	`269`	`}`