567 lines
16 KiB
Go
567 lines
16 KiB
Go
// Copyright 2021 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"
|
||
)
|
||
|
||
// binary to decimal conversion using the Ryū algorithm.
|
||
//
|
||
// See Ulf Adams, "Ryū: Fast Float-to-String Conversion" (doi:10.1145/3192366.3192369)
|
||
//
|
||
// Fixed precision formatting is a variant of the original paper's
|
||
// algorithm, where a single multiplication by 10^k is required,
|
||
// sharing the same rounding guarantees.
|
||
|
||
// ryuFtoaFixed32 formats mant*(2^exp) with prec decimal digits.
|
||
func ryuFtoaFixed32(d *decimalSlice, mant uint32, exp int, prec int) {
|
||
if prec < 0 {
|
||
panic("ryuFtoaFixed32 called with negative prec")
|
||
}
|
||
if prec > 9 {
|
||
panic("ryuFtoaFixed32 called with prec > 9")
|
||
}
|
||
// Zero input.
|
||
if mant == 0 {
|
||
d.nd, d.dp = 0, 0
|
||
return
|
||
}
|
||
// Renormalize to a 25-bit mantissa.
|
||
e2 := exp
|
||
if b := bits.Len32(mant); b < 25 {
|
||
mant <<= uint(25 - b)
|
||
e2 += int(b) - 25
|
||
}
|
||
// Choose an exponent such that rounded mant*(2^e2)*(10^q) has
|
||
// at least prec decimal digits, i.e
|
||
// 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
|
||
|
||
// Now compute mant*(2^e2)*(10^q).
|
||
// Is it an exact computation?
|
||
// Only small positive powers of 10 are exact (5^28 has 66 bits).
|
||
exact := q <= 27 && q >= 0
|
||
|
||
di, dexp2, d0 := mult64bitPow10(mant, e2, q)
|
||
if dexp2 >= 0 {
|
||
panic("not enough significant bits after mult64bitPow10")
|
||
}
|
||
// As a special case, computation might still be exact, if exponent
|
||
// was negative and if it amounts to computing an exact division.
|
||
// In that case, we ignore all lower bits.
|
||
// Note that division by 10^11 cannot be exact as 5^11 has 26 bits.
|
||
if q < 0 && q >= -10 && divisibleByPower5(uint64(mant), -q) {
|
||
exact = true
|
||
d0 = true
|
||
}
|
||
// Remove extra lower bits and keep rounding info.
|
||
extra := uint(-dexp2)
|
||
extraMask := uint32(1<<extra - 1)
|
||
|
||
di, dfrac := di>>extra, di&extraMask
|
||
roundUp := false
|
||
if exact {
|
||
// If we computed an exact product, d + 1/2
|
||
// should round to d+1 if 'd' is odd.
|
||
roundUp = dfrac > 1<<(extra-1) ||
|
||
(dfrac == 1<<(extra-1) && !d0) ||
|
||
(dfrac == 1<<(extra-1) && d0 && di&1 == 1)
|
||
} else {
|
||
// otherwise, d+1/2 always rounds up because
|
||
// we truncated below.
|
||
roundUp = dfrac>>(extra-1) == 1
|
||
}
|
||
if dfrac != 0 {
|
||
d0 = false
|
||
}
|
||
// Proceed to the requested number of digits
|
||
formatDecimal(d, uint64(di), !d0, roundUp, prec)
|
||
// Adjust exponent
|
||
d.dp -= q
|
||
}
|
||
|
||
// ryuFtoaFixed64 formats mant*(2^exp) with prec decimal digits.
|
||
func ryuFtoaFixed64(d *decimalSlice, mant uint64, exp int, prec int) {
|
||
if prec > 18 {
|
||
panic("ryuFtoaFixed64 called with prec > 18")
|
||
}
|
||
// Zero input.
|
||
if mant == 0 {
|
||
d.nd, d.dp = 0, 0
|
||
return
|
||
}
|
||
// Renormalize to a 55-bit mantissa.
|
||
e2 := exp
|
||
if b := bits.Len64(mant); b < 55 {
|
||
mant = mant << uint(55-b)
|
||
e2 += int(b) - 55
|
||
}
|
||
// Choose an exponent such that rounded mant*(2^e2)*(10^q) has
|
||
// at least prec decimal digits, i.e
|
||
// 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
|
||
//
|
||
// The minimal required exponent is -mulByLog2Log10(1025)+18 = -291
|
||
// The maximal required exponent is mulByLog2Log10(1074)+18 = 342
|
||
q := -mulByLog2Log10(e2+54) + prec - 1
|
||
|
||
// Now compute mant*(2^e2)*(10^q).
|
||
// Is it an exact computation?
|
||
// Only small positive powers of 10 are exact (5^55 has 128 bits).
|
||
exact := q <= 55 && q >= 0
|
||
|
||
di, dexp2, d0 := mult128bitPow10(mant, e2, q)
|
||
if dexp2 >= 0 {
|
||
panic("not enough significant bits after mult128bitPow10")
|
||
}
|
||
// As a special case, computation might still be exact, if exponent
|
||
// was negative and if it amounts to computing an exact division.
|
||
// In that case, we ignore all lower bits.
|
||
// Note that division by 10^23 cannot be exact as 5^23 has 54 bits.
|
||
if q < 0 && q >= -22 && divisibleByPower5(mant, -q) {
|
||
exact = true
|
||
d0 = true
|
||
}
|
||
// Remove extra lower bits and keep rounding info.
|
||
extra := uint(-dexp2)
|
||
extraMask := uint64(1<<extra - 1)
|
||
|
||
di, dfrac := di>>extra, di&extraMask
|
||
roundUp := false
|
||
if exact {
|
||
// If we computed an exact product, d + 1/2
|
||
// should round to d+1 if 'd' is odd.
|
||
roundUp = dfrac > 1<<(extra-1) ||
|
||
(dfrac == 1<<(extra-1) && !d0) ||
|
||
(dfrac == 1<<(extra-1) && d0 && di&1 == 1)
|
||
} else {
|
||
// otherwise, d+1/2 always rounds up because
|
||
// we truncated below.
|
||
roundUp = dfrac>>(extra-1) == 1
|
||
}
|
||
if dfrac != 0 {
|
||
d0 = false
|
||
}
|
||
// Proceed to the requested number of digits
|
||
formatDecimal(d, di, !d0, roundUp, prec)
|
||
// Adjust exponent
|
||
d.dp -= q
|
||
}
|
||
|
||
var uint64pow10 = [...]uint64{
|
||
1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
|
||
1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
|
||
}
|
||
|
||
// formatDecimal fills d with at most prec decimal digits
|
||
// of mantissa m. The boolean trunc indicates whether m
|
||
// is truncated compared to the original number being formatted.
|
||
func formatDecimal(d *decimalSlice, m uint64, trunc bool, roundUp bool, prec int) {
|
||
max := uint64pow10[prec]
|
||
trimmed := 0
|
||
for m >= max {
|
||
a, b := m/10, m%10
|
||
m = a
|
||
trimmed++
|
||
if b > 5 {
|
||
roundUp = true
|
||
} else if b < 5 {
|
||
roundUp = false
|
||
} else { // b == 5
|
||
// round up if there are trailing digits,
|
||
// or if the new value of m is odd (round-to-even convention)
|
||
roundUp = trunc || m&1 == 1
|
||
}
|
||
if b != 0 {
|
||
trunc = true
|
||
}
|
||
}
|
||
if roundUp {
|
||
m++
|
||
}
|
||
if m >= max {
|
||
// Happens if di was originally 99999....xx
|
||
m /= 10
|
||
trimmed++
|
||
}
|
||
// render digits (similar to formatBits)
|
||
n := uint(prec)
|
||
d.nd = int(prec)
|
||
v := m
|
||
for v >= 100 {
|
||
var v1, v2 uint64
|
||
if v>>32 == 0 {
|
||
v1, v2 = uint64(uint32(v)/100), uint64(uint32(v)%100)
|
||
} else {
|
||
v1, v2 = v/100, v%100
|
||
}
|
||
n -= 2
|
||
d.d[n+1] = smallsString[2*v2+1]
|
||
d.d[n+0] = smallsString[2*v2+0]
|
||
v = v1
|
||
}
|
||
if v > 0 {
|
||
n--
|
||
d.d[n] = smallsString[2*v+1]
|
||
}
|
||
if v >= 10 {
|
||
n--
|
||
d.d[n] = smallsString[2*v]
|
||
}
|
||
for d.d[d.nd-1] == '0' {
|
||
d.nd--
|
||
trimmed++
|
||
}
|
||
d.dp = d.nd + trimmed
|
||
}
|
||
|
||
// ryuFtoaShortest formats mant*2^exp with prec decimal digits.
|
||
func ryuFtoaShortest(d *decimalSlice, mant uint64, exp int, flt *floatInfo) {
|
||
if mant == 0 {
|
||
d.nd, d.dp = 0, 0
|
||
return
|
||
}
|
||
// If input is an exact integer with fewer bits than the mantissa,
|
||
// the previous and next integer are not admissible representations.
|
||
if exp <= 0 && bits.TrailingZeros64(mant) >= -exp {
|
||
mant >>= uint(-exp)
|
||
ryuDigits(d, mant, mant, mant, true, false)
|
||
return
|
||
}
|
||
ml, mc, mu, e2 := computeBounds(mant, exp, flt)
|
||
if e2 == 0 {
|
||
ryuDigits(d, ml, mc, mu, true, false)
|
||
return
|
||
}
|
||
// Find 10^q *larger* than 2^-e2
|
||
q := mulByLog2Log10(-e2) + 1
|
||
|
||
// We are going to multiply by 10^q using 128-bit arithmetic.
|
||
// The exponent is the same for all 3 numbers.
|
||
var dl, dc, du uint64
|
||
var dl0, dc0, du0 bool
|
||
if flt == &float32info {
|
||
var dl32, dc32, du32 uint32
|
||
dl32, _, dl0 = mult64bitPow10(uint32(ml), e2, q)
|
||
dc32, _, dc0 = mult64bitPow10(uint32(mc), e2, q)
|
||
du32, e2, du0 = mult64bitPow10(uint32(mu), e2, q)
|
||
dl, dc, du = uint64(dl32), uint64(dc32), uint64(du32)
|
||
} else {
|
||
dl, _, dl0 = mult128bitPow10(ml, e2, q)
|
||
dc, _, dc0 = mult128bitPow10(mc, e2, q)
|
||
du, e2, du0 = mult128bitPow10(mu, e2, q)
|
||
}
|
||
if e2 >= 0 {
|
||
panic("not enough significant bits after mult128bitPow10")
|
||
}
|
||
// Is it an exact computation?
|
||
if q > 55 {
|
||
// Large positive powers of ten are not exact
|
||
dl0, dc0, du0 = false, false, false
|
||
}
|
||
if q < 0 && q >= -24 {
|
||
// Division by a power of ten may be exact.
|
||
// (note that 5^25 is a 59-bit number so division by 5^25 is never exact).
|
||
if divisibleByPower5(ml, -q) {
|
||
dl0 = true
|
||
}
|
||
if divisibleByPower5(mc, -q) {
|
||
dc0 = true
|
||
}
|
||
if divisibleByPower5(mu, -q) {
|
||
du0 = true
|
||
}
|
||
}
|
||
// Express the results (dl, dc, du)*2^e2 as integers.
|
||
// Extra bits must be removed and rounding hints computed.
|
||
extra := uint(-e2)
|
||
extraMask := uint64(1<<extra - 1)
|
||
// Now compute the floored, integral base 10 mantissas.
|
||
dl, fracl := dl>>extra, dl&extraMask
|
||
dc, fracc := dc>>extra, dc&extraMask
|
||
du, fracu := du>>extra, du&extraMask
|
||
// Is it allowed to use 'du' as a result?
|
||
// It is always allowed when it is truncated, but also
|
||
// if it is exact and the original binary mantissa is even
|
||
// When disallowed, we can subtract 1.
|
||
uok := !du0 || fracu > 0
|
||
if du0 && fracu == 0 {
|
||
uok = mant&1 == 0
|
||
}
|
||
if !uok {
|
||
du--
|
||
}
|
||
// Is 'dc' the correctly rounded base 10 mantissa?
|
||
// The correct rounding might be dc+1
|
||
cup := false // don't round up.
|
||
if dc0 {
|
||
// If we computed an exact product, the half integer
|
||
// should round to next (even) integer if 'dc' is odd.
|
||
cup = fracc > 1<<(extra-1) ||
|
||
(fracc == 1<<(extra-1) && dc&1 == 1)
|
||
} else {
|
||
// otherwise, the result is a lower truncation of the ideal
|
||
// result.
|
||
cup = fracc>>(extra-1) == 1
|
||
}
|
||
// Is 'dl' an allowed representation?
|
||
// Only if it is an exact value, and if the original binary mantissa
|
||
// was even.
|
||
lok := dl0 && fracl == 0 && (mant&1 == 0)
|
||
if !lok {
|
||
dl++
|
||
}
|
||
// We need to remember whether the trimmed digits of 'dc' are zero.
|
||
c0 := dc0 && fracc == 0
|
||
// render digits
|
||
ryuDigits(d, dl, dc, du, c0, cup)
|
||
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.
|
||
func computeBounds(mant uint64, exp int, flt *floatInfo) (lower, central, upper uint64, e2 int) {
|
||
if mant != 1<<flt.mantbits || exp == flt.bias+1-int(flt.mantbits) {
|
||
// regular case (or denormals)
|
||
lower, central, upper = 2*mant-1, 2*mant, 2*mant+1
|
||
e2 = exp - 1
|
||
return
|
||
} else {
|
||
// border of an exponent
|
||
lower, central, upper = 4*mant-1, 4*mant, 4*mant+2
|
||
e2 = exp - 2
|
||
return
|
||
}
|
||
}
|
||
|
||
func ryuDigits(d *decimalSlice, lower, central, upper uint64,
|
||
c0, cup bool) {
|
||
lhi, llo := divmod1e9(lower)
|
||
chi, clo := divmod1e9(central)
|
||
uhi, ulo := divmod1e9(upper)
|
||
if uhi == 0 {
|
||
// only low digits (for denormals)
|
||
ryuDigits32(d, llo, clo, ulo, c0, cup, 8)
|
||
} else if lhi < uhi {
|
||
// truncate 9 digits at once.
|
||
if llo != 0 {
|
||
lhi++
|
||
}
|
||
c0 = c0 && clo == 0
|
||
cup = (clo > 5e8) || (clo == 5e8 && cup)
|
||
ryuDigits32(d, lhi, chi, uhi, c0, cup, 8)
|
||
d.dp += 9
|
||
} else {
|
||
d.nd = 0
|
||
// emit high part
|
||
n := uint(9)
|
||
for v := chi; v > 0; {
|
||
v1, v2 := v/10, v%10
|
||
v = v1
|
||
n--
|
||
d.d[n] = byte(v2 + '0')
|
||
}
|
||
d.d = d.d[n:]
|
||
d.nd = int(9 - n)
|
||
// emit low part
|
||
ryuDigits32(d, llo, clo, ulo,
|
||
c0, cup, d.nd+8)
|
||
}
|
||
// trim trailing zeros
|
||
for d.nd > 0 && d.d[d.nd-1] == '0' {
|
||
d.nd--
|
||
}
|
||
// trim initial zeros
|
||
for d.nd > 0 && d.d[0] == '0' {
|
||
d.nd--
|
||
d.dp--
|
||
d.d = d.d[1:]
|
||
}
|
||
}
|
||
|
||
// ryuDigits32 emits decimal digits for a number less than 1e9.
|
||
func ryuDigits32(d *decimalSlice, lower, central, upper uint32,
|
||
c0, cup bool, endindex int) {
|
||
if upper == 0 {
|
||
d.dp = endindex + 1
|
||
return
|
||
}
|
||
trimmed := 0
|
||
// Remember last trimmed digit to check for round-up.
|
||
// c0 will be used to remember zeroness of following digits.
|
||
cNextDigit := 0
|
||
for upper > 0 {
|
||
// Repeatedly compute:
|
||
// l = Ceil(lower / 10^k)
|
||
// c = Round(central / 10^k)
|
||
// u = Floor(upper / 10^k)
|
||
// and stop when c goes out of the (l, u) interval.
|
||
l := (lower + 9) / 10
|
||
c, cdigit := central/10, central%10
|
||
u := upper / 10
|
||
if l > u {
|
||
// don't trim the last digit as it is forbidden to go below l
|
||
// other, trim and exit now.
|
||
break
|
||
}
|
||
// Check that we didn't cross the lower boundary.
|
||
// The case where l < u but c == l-1 is essentially impossible,
|
||
// but may happen if:
|
||
// lower = ..11
|
||
// central = ..19
|
||
// upper = ..31
|
||
// and means that 'central' is very close but less than
|
||
// an integer ending with many zeros, and usually
|
||
// the "round-up" logic hides the problem.
|
||
if l == c+1 && c < u {
|
||
c++
|
||
cdigit = 0
|
||
cup = false
|
||
}
|
||
trimmed++
|
||
// Remember trimmed digits of c
|
||
c0 = c0 && cNextDigit == 0
|
||
cNextDigit = int(cdigit)
|
||
lower, central, upper = l, c, u
|
||
}
|
||
// should we round up?
|
||
if trimmed > 0 {
|
||
cup = cNextDigit > 5 ||
|
||
(cNextDigit == 5 && !c0) ||
|
||
(cNextDigit == 5 && c0 && central&1 == 1)
|
||
}
|
||
if central < upper && cup {
|
||
central++
|
||
}
|
||
// We know where the number ends, fill directly
|
||
endindex -= trimmed
|
||
v := central
|
||
n := endindex
|
||
for n > d.nd {
|
||
v1, v2 := v/100, v%100
|
||
d.d[n] = smallsString[2*v2+1]
|
||
d.d[n-1] = smallsString[2*v2+0]
|
||
n -= 2
|
||
v = v1
|
||
}
|
||
if n == d.nd {
|
||
d.d[n] = byte(v + '0')
|
||
}
|
||
d.nd = endindex + 1
|
||
d.dp = d.nd + trimmed
|
||
}
|
||
|
||
// 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.
|
||
// It is typically 31 or 32-bit wide.
|
||
// The returned boolean is true if all trimmed bits were zero.
|
||
//
|
||
// That is:
|
||
// m*2^e2 * round(10^q) = resM * 2^resE + ε
|
||
// exact = ε == 0
|
||
func mult64bitPow10(m uint32, e2, q int) (resM uint32, resE int, exact bool) {
|
||
if q == 0 {
|
||
// P == 1<<63
|
||
return m << 6, e2 - 6, true
|
||
}
|
||
if q < detailedPowersOfTenMinExp10 || detailedPowersOfTenMaxExp10 < q {
|
||
// 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
|
||
}
|
||
hi, lo := bits.Mul64(uint64(m), pow)
|
||
e2 += mulByLog10Log2(q) - 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.
|
||
// It is typically 63 or 64-bit wide.
|
||
// The returned boolean is true is all trimmed bits were zero.
|
||
//
|
||
// That is:
|
||
// m*2^e2 * round(10^q) = resM * 2^resE + ε
|
||
// exact = ε == 0
|
||
func mult128bitPow10(m uint64, e2, q int) (resM uint64, resE int, exact bool) {
|
||
if q == 0 {
|
||
// P == 1<<127
|
||
return m << 8, e2 - 8, true
|
||
}
|
||
if q < detailedPowersOfTenMinExp10 || detailedPowersOfTenMaxExp10 < q {
|
||
// 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
|
||
}
|
||
e2 += mulByLog10Log2(q) - 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
|
||
}
|
||
|
||
func divisibleByPower5(m uint64, k int) bool {
|
||
if m == 0 {
|
||
return true
|
||
}
|
||
for i := 0; i < k; i++ {
|
||
if m%5 != 0 {
|
||
return false
|
||
}
|
||
m /= 5
|
||
}
|
||
return true
|
||
}
|
||
|
||
// divmod1e9 computes quotient and remainder of division by 1e9,
|
||
// avoiding runtime uint64 division on 32-bit platforms.
|
||
func divmod1e9(x uint64) (uint32, uint32) {
|
||
if !host32bit {
|
||
return uint32(x / 1e9), uint32(x % 1e9)
|
||
}
|
||
// Use the same sequence of operations as the amd64 compiler.
|
||
hi, _ := bits.Mul64(x>>1, 0x89705f4136b4a598) // binary digits of 1e-9
|
||
q := hi >> 28
|
||
return uint32(q), uint32(x - q*1e9)
|
||
}
|