strconv: clean up powers-of-10 table, tests

Both Eisel-Lemire and Ryu depend on a table of
truncated 128-bit mantissas of powers of 10,
and so will Dragonbox.

This CL:
 - Moves the table to a separate file, so it doesn't look tied to Eisel-Lemire.
 - Introduces a uint128 type in math.go for the table values,
   since .Hi and .Lo are clearer than [1] and [0].
 - Generates the table from a standalone generator pow10gen.go.
 - Adds a new pow10 function in math.go to handle table access details.
 - Factors a 64x128->192-bit multiply into umul192 in math.go.
 - Moves multiplication by log₁₀ 2 and log₂ 10 into math.go.
 - Introduces an import_test.go to avoid having to type differently
   cased names in test code versus regular code.
 - Introduces named constants for the floating-point size parameters.
   Previously these were only in the floatInfo global variables.
 - Changes the BenchmarkAppendUintVarlen subtest names
   to be more useful.

Change-Id: I9826ee5f41c5c19be3b6a7c3c5f277ec6c23b39a
Reviewed-on: https://go-review.googlesource.com/c/go/+/712661
Reviewed-by: Alan Donovan <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: David Chase <[email protected]>

Author: rsc

src/strconv/atof.go

@@ -460,7 +460,7 @@ func atof64exact(mantissa uint64, exp int, neg bool) (f float64, ok bool) {
 // If possible to compute mantissa*10^exp to 32-bit float f exactly,
 // entirely in floating-point math, do so, avoiding the machinery above.
 func atof32exact(mantissa uint64, exp int, neg bool) (f float32, ok bool) {
-	if mantissa>>float32info.mantbits != 0 {
+	if mantissa>>float32MantBits != 0 {
 		return
 	}
 	f = float32(mantissa)

src/strconv/atoi_test.go

@@ -501,11 +501,11 @@ func TestAtoi(t *testing.T) {
 }
 
 func bitSizeErrStub(name string, bitSize int) error {
-	return BitSizeError(name, "0", bitSize)
+	return bitSizeError(name, "0", bitSize)
 }
 
 func baseErrStub(name string, base int) error {
-	return BaseError(name, "0", base)
+	return baseError(name, "0", base)
 }
 
 func noErrStub(name string, arg int) error {

src/strconv/eisel_lemire.go

@@ -4,7 +4,27 @@
 
 package strconv
 
+type Uint128 = uint128
+
 var (
-	BitSizeError = bitSizeError
-	BaseError    = baseError
+	BaseError        = baseError
+	BitSizeError     = bitSizeError
+	MulLog10_2       = mulLog10_2
+	MulLog2_10       = mulLog2_10
+	ParseFloatPrefix = parseFloatPrefix
+	Pow10            = pow10
+	Umul128          = umul128
+	Umul192          = umul192
 )
+
+func NewDecimal(i uint64) *decimal {
+	d := new(decimal)
+	d.Assign(i)
+	return d
+}
+
+func SetOptimize(b bool) bool {
+	old := optimize
+	optimize = b
+	return old
+}

src/strconv/export_test.go

@@ -12,15 +12,25 @@ package strconv
 
 import "math"
 
-// TODO: move elsewhere?
 type floatInfo struct {
 	mantbits uint
 	expbits  uint
 	bias     int
 }
 
-var float32info = floatInfo{23, 8, -127}
-var float64info = floatInfo{52, 11, -1023}
+const (
+	float32MantBits = 23
+	float32ExpBits  = 8
+	float32Bias     = -127
+	float64MantBits = 52
+	float64ExpBits  = 11
+	float64Bias     = -1023
+)
+
+var (
+	float32info = floatInfo{float32MantBits, float32ExpBits, float32Bias}
+	float64info = floatInfo{float64MantBits, float64ExpBits, float64Bias}
+)
 
 // FormatFloat converts the floating-point number f to a string,
 // according to the format fmt and precision prec. It rounds the

src/strconv/ftoa.go

@@ -40,8 +40,8 @@ func ryuFtoaFixed32(d *decimalSlice, mant uint32, exp int, prec int) {
 	//     mant*(2^e2)*(10^q) >= 10^(prec-1)
 	// Because mant >= 2^24, it is enough to choose:
 	//     2^(e2+24) >= 10^(-q+prec-1)
-	// or q = -mulByLog2Log10(e2+24) + prec - 1
-	q := -mulByLog2Log10(e2+24) + prec - 1
+	// or q = -mulLog10_2(e2+24) + prec - 1
+	q := -mulLog10_2(e2+24) + prec - 1
 
 	// Now compute mant*(2^e2)*(10^q).
 	// Is it an exact computation?
@@ -107,11 +107,11 @@ func ryuFtoaFixed64(d *decimalSlice, mant uint64, exp int, prec int) {
 	//     mant*(2^e2)*(10^q) >= 10^(prec-1)
 	// Because mant >= 2^54, it is enough to choose:
 	//     2^(e2+54) >= 10^(-q+prec-1)
-	// or q = -mulByLog2Log10(e2+54) + prec - 1
+	// or q = -mulLog10_2(e2+54) + prec - 1
 	//
-	// The minimal required exponent is -mulByLog2Log10(1025)+18 = -291
-	// The maximal required exponent is mulByLog2Log10(1074)+18 = 342
-	q := -mulByLog2Log10(e2+54) + prec - 1
+	// The minimal required exponent is -mulLog10_2(1025)+18 = -291
+	// The maximal required exponent is mulLog10_2(1074)+18 = 342
+	q := -mulLog10_2(e2+54) + prec - 1
 
 	// Now compute mant*(2^e2)*(10^q).
 	// Is it an exact computation?
@@ -242,7 +242,7 @@ func ryuFtoaShortest(d *decimalSlice, mant uint64, exp int, flt *floatInfo) {
 		return
 	}
 	// Find 10^q *larger* than 2^-e2
-	q := mulByLog2Log10(-e2) + 1
+	q := mulLog10_2(-e2) + 1
 
 	// We are going to multiply by 10^q using 128-bit arithmetic.
 	// The exponent is the same for all 3 numbers.
@@ -326,26 +326,6 @@ func ryuFtoaShortest(d *decimalSlice, mant uint64, exp int, flt *floatInfo) {
 	d.dp -= q
 }
 
-// mulByLog2Log10 returns math.Floor(x * log(2)/log(10)) for an integer x in
-// the range -1600 <= x && x <= +1600.
-//
-// The range restriction lets us work in faster integer arithmetic instead of
-// slower floating point arithmetic. Correctness is verified by unit tests.
-func mulByLog2Log10(x int) int {
-	// log(2)/log(10) ≈ 0.30102999566 ≈ 78913 / 2^18
-	return (x * 78913) >> 18
-}
-
-// mulByLog10Log2 returns math.Floor(x * log(10)/log(2)) for an integer x in
-// the range -500 <= x && x <= +500.
-//
-// The range restriction lets us work in faster integer arithmetic instead of
-// slower floating point arithmetic. Correctness is verified by unit tests.
-func mulByLog10Log2(x int) int {
-	// log(10)/log(2) ≈ 3.32192809489 ≈ 108853 / 2^15
-	return (x * 108853) >> 15
-}
-
 // computeBounds returns a floating-point vector (l, c, u)×2^e2
 // where the mantissas are 55-bit (or 26-bit) integers, describing the interval
 // represented by the input float64 or float32.
@@ -482,7 +462,7 @@ func ryuDigits32(d *decimalSlice, lower, central, upper uint32,
 
 // mult64bitPow10 takes a floating-point input with a 25-bit
 // mantissa and multiplies it with 10^q. The resulting mantissa
-// is m*P >> 57 where P is a 64-bit element of the detailedPowersOfTen tables.
+// is m*P >> 57 where P is a 64-bit truncated power of 10.
 // It is typically 31 or 32-bit wide.
 // The returned boolean is true if all trimmed bits were zero.
 //
@@ -495,23 +475,23 @@ func mult64bitPow10(m uint32, e2, q int) (resM uint32, resE int, exact bool) {
 		// P == 1<<63
 		return m << 6, e2 - 6, true
 	}
-	if q < detailedPowersOfTenMinExp10 || detailedPowersOfTenMaxExp10 < q {
+	pow, exp2, ok := pow10(q)
+	if !ok {
 		// This never happens due to the range of float32/float64 exponent
 		panic("mult64bitPow10: power of 10 is out of range")
 	}
-	pow := detailedPowersOfTen[q-detailedPowersOfTenMinExp10][1]
 	if q < 0 {
 		// Inverse powers of ten must be rounded up.
-		pow += 1
+		pow.Hi++
 	}
-	hi, lo := bits.Mul64(uint64(m), pow)
-	e2 += mulByLog10Log2(q) - 63 + 57
+	hi, lo := bits.Mul64(uint64(m), pow.Hi)
+	e2 += exp2 - 63 + 57
 	return uint32(hi<<7 | lo>>57), e2, lo<<7 == 0
 }
 
 // mult128bitPow10 takes a floating-point input with a 55-bit
 // mantissa and multiplies it with 10^q. The resulting mantissa
-// is m*P >> 119 where P is a 128-bit element of the detailedPowersOfTen tables.
+// is m*P >> 119 where P is a 128-bit truncated power of 10.
 // It is typically 63 or 64-bit wide.
 // The returned boolean is true is all trimmed bits were zero.
 //
@@ -524,23 +504,19 @@ func mult128bitPow10(m uint64, e2, q int) (resM uint64, resE int, exact bool) {
 		// P == 1<<127
 		return m << 8, e2 - 8, true
 	}
-	if q < detailedPowersOfTenMinExp10 || detailedPowersOfTenMaxExp10 < q {
+	pow, exp2, ok := pow10(q)
+	if !ok {
 		// This never happens due to the range of float32/float64 exponent
 		panic("mult128bitPow10: power of 10 is out of range")
 	}
-	pow := detailedPowersOfTen[q-detailedPowersOfTenMinExp10]
 	if q < 0 {
 		// Inverse powers of ten must be rounded up.
-		pow[0] += 1
+		pow.Lo++
 	}
-	e2 += mulByLog10Log2(q) - 127 + 119
+	e2 += exp2 - 127 + 119
 
-	// long multiplication
-	l1, l0 := bits.Mul64(m, pow[0])
-	h1, h0 := bits.Mul64(m, pow[1])
-	mid, carry := bits.Add64(l1, h0, 0)
-	h1 += carry
-	return h1<<9 | mid>>55, e2, mid<<9 == 0 && l0 == 0
+	hi, mid, lo := umul192(m, pow)
+	return hi<<9 | mid>>55, e2, mid<<9 == 0 && lo == 0
 }
 
 func divisibleByPower5(m uint64, k int) bool {

src/strconv/ftoaryu.go

@@ -0,0 +1,20 @@
+// 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_test
+
+import . "strconv"
+
+type uint128 = Uint128
+
+var (
+	baseError        = BaseError
+	bitSizeError     = BitSizeError
+	mulLog10_2       = MulLog10_2
+	mulLog2_10       = MulLog2_10
+	parseFloatPrefix = ParseFloatPrefix
+	pow10            = Pow10
+	umul128          = Umul128
+	umul192          = Umul192
+)

src/strconv/ftoaryu_test.go

@@ -5,6 +5,7 @@
 package strconv_test
 
 import (
+	"fmt"
 	. "strconv"
 	"testing"
 )
@@ -230,7 +231,7 @@ func BenchmarkAppendIntSmall(b *testing.B) {
 
 func BenchmarkAppendUintVarlen(b *testing.B) {
 	for _, test := range varlenUints {
-		b.Run(test.out, func(b *testing.B) {
+		b.Run(fmt.Sprint("digits=", len(test.out)), func(b *testing.B) {
 			dst := make([]byte, 0, 30)
 			for j := 0; j < b.N; j++ {
 				dst = AppendUint(dst[:0], test.in, 10)