643 lines
25 KiB
Go
643 lines
25 KiB
Go
package fast
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
)
|
|
|
|
const (
|
|
kMinimalTargetExponent = -60
|
|
kMaximalTargetExponent = -32
|
|
|
|
kTen4 = 10000
|
|
kTen5 = 100000
|
|
kTen6 = 1000000
|
|
kTen7 = 10000000
|
|
kTen8 = 100000000
|
|
kTen9 = 1000000000
|
|
)
|
|
|
|
type Mode int
|
|
|
|
const (
|
|
ModeShortest Mode = iota
|
|
ModePrecision
|
|
)
|
|
|
|
// Adjusts the last digit of the generated number, and screens out generated
|
|
// solutions that may be inaccurate. A solution may be inaccurate if it is
|
|
// outside the safe interval, or if we cannot prove that it is closer to the
|
|
// input than a neighboring representation of the same length.
|
|
//
|
|
// Input: * buffer containing the digits of too_high / 10^kappa
|
|
// - distance_too_high_w == (too_high - w).f() * unit
|
|
// - unsafe_interval == (too_high - too_low).f() * unit
|
|
// - rest = (too_high - buffer * 10^kappa).f() * unit
|
|
// - ten_kappa = 10^kappa * unit
|
|
// - unit = the common multiplier
|
|
//
|
|
// Output: returns true if the buffer is guaranteed to contain the closest
|
|
//
|
|
// representable number to the input.
|
|
// Modifies the generated digits in the buffer to approach (round towards) w.
|
|
func roundWeed(buffer []byte, distance_too_high_w, unsafe_interval, rest, ten_kappa, unit uint64) bool {
|
|
small_distance := distance_too_high_w - unit
|
|
big_distance := distance_too_high_w + unit
|
|
|
|
// Let w_low = too_high - big_distance, and
|
|
// w_high = too_high - small_distance.
|
|
// Note: w_low < w < w_high
|
|
//
|
|
// The real w (* unit) must lie somewhere inside the interval
|
|
// ]w_low; w_high[ (often written as "(w_low; w_high)")
|
|
|
|
// Basically the buffer currently contains a number in the unsafe interval
|
|
// ]too_low; too_high[ with too_low < w < too_high
|
|
//
|
|
// too_high - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
// ^v 1 unit ^ ^ ^ ^
|
|
// boundary_high --------------------- . . . .
|
|
// ^v 1 unit . . . .
|
|
// - - - - - - - - - - - - - - - - - - - + - - + - - - - - - . .
|
|
// . . ^ . .
|
|
// . big_distance . . .
|
|
// . . . . rest
|
|
// small_distance . . . .
|
|
// v . . . .
|
|
// w_high - - - - - - - - - - - - - - - - - - . . . .
|
|
// ^v 1 unit . . . .
|
|
// w ---------------------------------------- . . . .
|
|
// ^v 1 unit v . . .
|
|
// w_low - - - - - - - - - - - - - - - - - - - - - . . .
|
|
// . . v
|
|
// buffer --------------------------------------------------+-------+--------
|
|
// . .
|
|
// safe_interval .
|
|
// v .
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - .
|
|
// ^v 1 unit .
|
|
// boundary_low ------------------------- unsafe_interval
|
|
// ^v 1 unit v
|
|
// too_low - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
//
|
|
//
|
|
// Note that the value of buffer could lie anywhere inside the range too_low
|
|
// to too_high.
|
|
//
|
|
// boundary_low, boundary_high and w are approximations of the real boundaries
|
|
// and v (the input number). They are guaranteed to be precise up to one unit.
|
|
// In fact the error is guaranteed to be strictly less than one unit.
|
|
//
|
|
// Anything that lies outside the unsafe interval is guaranteed not to round
|
|
// to v when read again.
|
|
// Anything that lies inside the safe interval is guaranteed to round to v
|
|
// when read again.
|
|
// If the number inside the buffer lies inside the unsafe interval but not
|
|
// inside the safe interval then we simply do not know and bail out (returning
|
|
// false).
|
|
//
|
|
// Similarly we have to take into account the imprecision of 'w' when finding
|
|
// the closest representation of 'w'. If we have two potential
|
|
// representations, and one is closer to both w_low and w_high, then we know
|
|
// it is closer to the actual value v.
|
|
//
|
|
// By generating the digits of too_high we got the largest (closest to
|
|
// too_high) buffer that is still in the unsafe interval. In the case where
|
|
// w_high < buffer < too_high we try to decrement the buffer.
|
|
// This way the buffer approaches (rounds towards) w.
|
|
// There are 3 conditions that stop the decrementation process:
|
|
// 1) the buffer is already below w_high
|
|
// 2) decrementing the buffer would make it leave the unsafe interval
|
|
// 3) decrementing the buffer would yield a number below w_high and farther
|
|
// away than the current number. In other words:
|
|
// (buffer{-1} < w_high) && w_high - buffer{-1} > buffer - w_high
|
|
// Instead of using the buffer directly we use its distance to too_high.
|
|
// Conceptually rest ~= too_high - buffer
|
|
// We need to do the following tests in this order to avoid over- and
|
|
// underflows.
|
|
_DCHECK(rest <= unsafe_interval)
|
|
for rest < small_distance && // Negated condition 1
|
|
unsafe_interval-rest >= ten_kappa && // Negated condition 2
|
|
(rest+ten_kappa < small_distance || // buffer{-1} > w_high
|
|
small_distance-rest >= rest+ten_kappa-small_distance) {
|
|
buffer[len(buffer)-1]--
|
|
rest += ten_kappa
|
|
}
|
|
|
|
// We have approached w+ as much as possible. We now test if approaching w-
|
|
// would require changing the buffer. If yes, then we have two possible
|
|
// representations close to w, but we cannot decide which one is closer.
|
|
if rest < big_distance && unsafe_interval-rest >= ten_kappa &&
|
|
(rest+ten_kappa < big_distance ||
|
|
big_distance-rest > rest+ten_kappa-big_distance) {
|
|
return false
|
|
}
|
|
|
|
// Weeding test.
|
|
// The safe interval is [too_low + 2 ulp; too_high - 2 ulp]
|
|
// Since too_low = too_high - unsafe_interval this is equivalent to
|
|
// [too_high - unsafe_interval + 4 ulp; too_high - 2 ulp]
|
|
// Conceptually we have: rest ~= too_high - buffer
|
|
return (2*unit <= rest) && (rest <= unsafe_interval-4*unit)
|
|
}
|
|
|
|
// Rounds the buffer upwards if the result is closer to v by possibly adding
|
|
// 1 to the buffer. If the precision of the calculation is not sufficient to
|
|
// round correctly, return false.
|
|
// The rounding might shift the whole buffer in which case the kappa is
|
|
// adjusted. For example "99", kappa = 3 might become "10", kappa = 4.
|
|
//
|
|
// If 2*rest > ten_kappa then the buffer needs to be round up.
|
|
// rest can have an error of +/- 1 unit. This function accounts for the
|
|
// imprecision and returns false, if the rounding direction cannot be
|
|
// unambiguously determined.
|
|
//
|
|
// Precondition: rest < ten_kappa.
|
|
func roundWeedCounted(buffer []byte, rest, ten_kappa, unit uint64, kappa *int) bool {
|
|
_DCHECK(rest < ten_kappa)
|
|
// The following tests are done in a specific order to avoid overflows. They
|
|
// will work correctly with any uint64 values of rest < ten_kappa and unit.
|
|
//
|
|
// If the unit is too big, then we don't know which way to round. For example
|
|
// a unit of 50 means that the real number lies within rest +/- 50. If
|
|
// 10^kappa == 40 then there is no way to tell which way to round.
|
|
if unit >= ten_kappa {
|
|
return false
|
|
}
|
|
// Even if unit is just half the size of 10^kappa we are already completely
|
|
// lost. (And after the previous test we know that the expression will not
|
|
// over/underflow.)
|
|
if ten_kappa-unit <= unit {
|
|
return false
|
|
}
|
|
// If 2 * (rest + unit) <= 10^kappa we can safely round down.
|
|
if (ten_kappa-rest > rest) && (ten_kappa-2*rest >= 2*unit) {
|
|
return true
|
|
}
|
|
|
|
// If 2 * (rest - unit) >= 10^kappa, then we can safely round up.
|
|
if (rest > unit) && (ten_kappa-(rest-unit) <= (rest - unit)) {
|
|
// Increment the last digit recursively until we find a non '9' digit.
|
|
buffer[len(buffer)-1]++
|
|
for i := len(buffer) - 1; i > 0; i-- {
|
|
if buffer[i] != '0'+10 {
|
|
break
|
|
}
|
|
buffer[i] = '0'
|
|
buffer[i-1]++
|
|
}
|
|
// If the first digit is now '0'+ 10 we had a buffer with all '9's. With the
|
|
// exception of the first digit all digits are now '0'. Simply switch the
|
|
// first digit to '1' and adjust the kappa. Example: "99" becomes "10" and
|
|
// the power (the kappa) is increased.
|
|
if buffer[0] == '0'+10 {
|
|
buffer[0] = '1'
|
|
*kappa += 1
|
|
}
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Returns the biggest power of ten that is less than or equal than the given
|
|
// number. We furthermore receive the maximum number of bits 'number' has.
|
|
// If number_bits == 0 then 0^-1 is returned
|
|
// The number of bits must be <= 32.
|
|
// Precondition: number < (1 << (number_bits + 1)).
|
|
func biggestPowerTen(number uint32, number_bits int) (power uint32, exponent int) {
|
|
switch number_bits {
|
|
case 32, 31, 30:
|
|
if kTen9 <= number {
|
|
power = kTen9
|
|
exponent = 9
|
|
break
|
|
}
|
|
fallthrough
|
|
case 29, 28, 27:
|
|
if kTen8 <= number {
|
|
power = kTen8
|
|
exponent = 8
|
|
break
|
|
}
|
|
fallthrough
|
|
case 26, 25, 24:
|
|
if kTen7 <= number {
|
|
power = kTen7
|
|
exponent = 7
|
|
break
|
|
}
|
|
fallthrough
|
|
case 23, 22, 21, 20:
|
|
if kTen6 <= number {
|
|
power = kTen6
|
|
exponent = 6
|
|
break
|
|
}
|
|
fallthrough
|
|
case 19, 18, 17:
|
|
if kTen5 <= number {
|
|
power = kTen5
|
|
exponent = 5
|
|
break
|
|
}
|
|
fallthrough
|
|
case 16, 15, 14:
|
|
if kTen4 <= number {
|
|
power = kTen4
|
|
exponent = 4
|
|
break
|
|
}
|
|
fallthrough
|
|
case 13, 12, 11, 10:
|
|
if 1000 <= number {
|
|
power = 1000
|
|
exponent = 3
|
|
break
|
|
}
|
|
fallthrough
|
|
case 9, 8, 7:
|
|
if 100 <= number {
|
|
power = 100
|
|
exponent = 2
|
|
break
|
|
}
|
|
fallthrough
|
|
case 6, 5, 4:
|
|
if 10 <= number {
|
|
power = 10
|
|
exponent = 1
|
|
break
|
|
}
|
|
fallthrough
|
|
case 3, 2, 1:
|
|
if 1 <= number {
|
|
power = 1
|
|
exponent = 0
|
|
break
|
|
}
|
|
fallthrough
|
|
case 0:
|
|
power = 0
|
|
exponent = -1
|
|
}
|
|
return
|
|
}
|
|
|
|
// Generates the digits of input number w.
|
|
// w is a floating-point number (DiyFp), consisting of a significand and an
|
|
// exponent. Its exponent is bounded by kMinimalTargetExponent and
|
|
// kMaximalTargetExponent.
|
|
//
|
|
// Hence -60 <= w.e() <= -32.
|
|
//
|
|
// Returns false if it fails, in which case the generated digits in the buffer
|
|
// should not be used.
|
|
// Preconditions:
|
|
// - low, w and high are correct up to 1 ulp (unit in the last place). That
|
|
// is, their error must be less than a unit of their last digits.
|
|
// - low.e() == w.e() == high.e()
|
|
// - low < w < high, and taking into account their error: low~ <= high~
|
|
// - kMinimalTargetExponent <= w.e() <= kMaximalTargetExponent
|
|
//
|
|
// Postconditions: returns false if procedure fails.
|
|
//
|
|
// otherwise:
|
|
// * buffer is not null-terminated, but len contains the number of digits.
|
|
// * buffer contains the shortest possible decimal digit-sequence
|
|
// such that LOW < buffer * 10^kappa < HIGH, where LOW and HIGH are the
|
|
// correct values of low and high (without their error).
|
|
// * if more than one decimal representation gives the minimal number of
|
|
// decimal digits then the one closest to W (where W is the correct value
|
|
// of w) is chosen.
|
|
//
|
|
// Remark: this procedure takes into account the imprecision of its input
|
|
//
|
|
// numbers. If the precision is not enough to guarantee all the postconditions
|
|
// then false is returned. This usually happens rarely (~0.5%).
|
|
//
|
|
// Say, for the sake of example, that
|
|
//
|
|
// w.e() == -48, and w.f() == 0x1234567890ABCDEF
|
|
//
|
|
// w's value can be computed by w.f() * 2^w.e()
|
|
// We can obtain w's integral digits by simply shifting w.f() by -w.e().
|
|
//
|
|
// -> w's integral part is 0x1234
|
|
// w's fractional part is therefore 0x567890ABCDEF.
|
|
//
|
|
// Printing w's integral part is easy (simply print 0x1234 in decimal).
|
|
// In order to print its fraction we repeatedly multiply the fraction by 10 and
|
|
// get each digit. Example the first digit after the point would be computed by
|
|
//
|
|
// (0x567890ABCDEF * 10) >> 48. -> 3
|
|
//
|
|
// The whole thing becomes slightly more complicated because we want to stop
|
|
// once we have enough digits. That is, once the digits inside the buffer
|
|
// represent 'w' we can stop. Everything inside the interval low - high
|
|
// represents w. However we have to pay attention to low, high and w's
|
|
// imprecision.
|
|
func digitGen(low, w, high diyfp, buffer []byte) (kappa int, buf []byte, res bool) {
|
|
_DCHECK(low.e == w.e && w.e == high.e)
|
|
_DCHECK(low.f+1 <= high.f-1)
|
|
_DCHECK(kMinimalTargetExponent <= w.e && w.e <= kMaximalTargetExponent)
|
|
// low, w and high are imprecise, but by less than one ulp (unit in the last
|
|
// place).
|
|
// If we remove (resp. add) 1 ulp from low (resp. high) we are certain that
|
|
// the new numbers are outside of the interval we want the final
|
|
// representation to lie in.
|
|
// Inversely adding (resp. removing) 1 ulp from low (resp. high) would yield
|
|
// numbers that are certain to lie in the interval. We will use this fact
|
|
// later on.
|
|
// We will now start by generating the digits within the uncertain
|
|
// interval. Later we will weed out representations that lie outside the safe
|
|
// interval and thus _might_ lie outside the correct interval.
|
|
unit := uint64(1)
|
|
too_low := diyfp{f: low.f - unit, e: low.e}
|
|
too_high := diyfp{f: high.f + unit, e: high.e}
|
|
// too_low and too_high are guaranteed to lie outside the interval we want the
|
|
// generated number in.
|
|
unsafe_interval := too_high.minus(too_low)
|
|
// We now cut the input number into two parts: the integral digits and the
|
|
// fractionals. We will not write any decimal separator though, but adapt
|
|
// kappa instead.
|
|
// Reminder: we are currently computing the digits (stored inside the buffer)
|
|
// such that: too_low < buffer * 10^kappa < too_high
|
|
// We use too_high for the digit_generation and stop as soon as possible.
|
|
// If we stop early we effectively round down.
|
|
one := diyfp{f: 1 << -w.e, e: w.e}
|
|
// Division by one is a shift.
|
|
integrals := uint32(too_high.f >> -one.e)
|
|
// Modulo by one is an and.
|
|
fractionals := too_high.f & (one.f - 1)
|
|
divisor, divisor_exponent := biggestPowerTen(integrals, diyFpKSignificandSize-(-one.e))
|
|
kappa = divisor_exponent + 1
|
|
buf = buffer
|
|
for kappa > 0 {
|
|
digit := int(integrals / divisor)
|
|
buf = append(buf, byte('0'+digit))
|
|
integrals %= divisor
|
|
kappa--
|
|
// Note that kappa now equals the exponent of the divisor and that the
|
|
// invariant thus holds again.
|
|
rest := uint64(integrals)<<-one.e + fractionals
|
|
// Invariant: too_high = buffer * 10^kappa + DiyFp(rest, one.e)
|
|
// Reminder: unsafe_interval.e == one.e
|
|
if rest < unsafe_interval.f {
|
|
// Rounding down (by not emitting the remaining digits) yields a number
|
|
// that lies within the unsafe interval.
|
|
res = roundWeed(buf, too_high.minus(w).f,
|
|
unsafe_interval.f, rest,
|
|
uint64(divisor)<<-one.e, unit)
|
|
return
|
|
}
|
|
divisor /= 10
|
|
}
|
|
// The integrals have been generated. We are at the point of the decimal
|
|
// separator. In the following loop we simply multiply the remaining digits by
|
|
// 10 and divide by one. We just need to pay attention to multiply associated
|
|
// data (like the interval or 'unit'), too.
|
|
// Note that the multiplication by 10 does not overflow, because w.e >= -60
|
|
// and thus one.e >= -60.
|
|
_DCHECK(one.e >= -60)
|
|
_DCHECK(fractionals < one.f)
|
|
_DCHECK(0xFFFFFFFFFFFFFFFF/10 >= one.f)
|
|
for {
|
|
fractionals *= 10
|
|
unit *= 10
|
|
unsafe_interval.f *= 10
|
|
// Integer division by one.
|
|
digit := byte(fractionals >> -one.e)
|
|
buf = append(buf, '0'+digit)
|
|
fractionals &= one.f - 1 // Modulo by one.
|
|
kappa--
|
|
if fractionals < unsafe_interval.f {
|
|
res = roundWeed(buf, too_high.minus(w).f*unit, unsafe_interval.f, fractionals, one.f, unit)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generates (at most) requested_digits of input number w.
|
|
// w is a floating-point number (DiyFp), consisting of a significand and an
|
|
// exponent. Its exponent is bounded by kMinimalTargetExponent and
|
|
// kMaximalTargetExponent.
|
|
//
|
|
// Hence -60 <= w.e() <= -32.
|
|
//
|
|
// Returns false if it fails, in which case the generated digits in the buffer
|
|
// should not be used.
|
|
// Preconditions:
|
|
// - w is correct up to 1 ulp (unit in the last place). That
|
|
// is, its error must be strictly less than a unit of its last digit.
|
|
// - kMinimalTargetExponent <= w.e() <= kMaximalTargetExponent
|
|
//
|
|
// Postconditions: returns false if procedure fails.
|
|
//
|
|
// otherwise:
|
|
// * buffer is not null-terminated, but length contains the number of
|
|
// digits.
|
|
// * the representation in buffer is the most precise representation of
|
|
// requested_digits digits.
|
|
// * buffer contains at most requested_digits digits of w. If there are less
|
|
// than requested_digits digits then some trailing '0's have been removed.
|
|
// * kappa is such that
|
|
// w = buffer * 10^kappa + eps with |eps| < 10^kappa / 2.
|
|
//
|
|
// Remark: This procedure takes into account the imprecision of its input
|
|
//
|
|
// numbers. If the precision is not enough to guarantee all the postconditions
|
|
// then false is returned. This usually happens rarely, but the failure-rate
|
|
// increases with higher requested_digits.
|
|
func digitGenCounted(w diyfp, requested_digits int, buffer []byte) (kappa int, buf []byte, res bool) {
|
|
_DCHECK(kMinimalTargetExponent <= w.e && w.e <= kMaximalTargetExponent)
|
|
|
|
// w is assumed to have an error less than 1 unit. Whenever w is scaled we
|
|
// also scale its error.
|
|
w_error := uint64(1)
|
|
// We cut the input number into two parts: the integral digits and the
|
|
// fractional digits. We don't emit any decimal separator, but adapt kappa
|
|
// instead. Example: instead of writing "1.2" we put "12" into the buffer and
|
|
// increase kappa by 1.
|
|
one := diyfp{f: 1 << -w.e, e: w.e}
|
|
// Division by one is a shift.
|
|
integrals := uint32(w.f >> -one.e)
|
|
// Modulo by one is an and.
|
|
fractionals := w.f & (one.f - 1)
|
|
divisor, divisor_exponent := biggestPowerTen(integrals, diyFpKSignificandSize-(-one.e))
|
|
kappa = divisor_exponent + 1
|
|
buf = buffer
|
|
// Loop invariant: buffer = w / 10^kappa (integer division)
|
|
// The invariant holds for the first iteration: kappa has been initialized
|
|
// with the divisor exponent + 1. And the divisor is the biggest power of ten
|
|
// that is smaller than 'integrals'.
|
|
for kappa > 0 {
|
|
digit := byte(integrals / divisor)
|
|
buf = append(buf, '0'+digit)
|
|
requested_digits--
|
|
integrals %= divisor
|
|
kappa--
|
|
// Note that kappa now equals the exponent of the divisor and that the
|
|
// invariant thus holds again.
|
|
if requested_digits == 0 {
|
|
break
|
|
}
|
|
divisor /= 10
|
|
}
|
|
|
|
if requested_digits == 0 {
|
|
rest := uint64(integrals)<<-one.e + fractionals
|
|
res = roundWeedCounted(buf, rest, uint64(divisor)<<-one.e, w_error, &kappa)
|
|
return
|
|
}
|
|
|
|
// The integrals have been generated. We are at the point of the decimal
|
|
// separator. In the following loop we simply multiply the remaining digits by
|
|
// 10 and divide by one. We just need to pay attention to multiply associated
|
|
// data (the 'unit'), too.
|
|
// Note that the multiplication by 10 does not overflow, because w.e >= -60
|
|
// and thus one.e >= -60.
|
|
_DCHECK(one.e >= -60)
|
|
_DCHECK(fractionals < one.f)
|
|
_DCHECK(0xFFFFFFFFFFFFFFFF/10 >= one.f)
|
|
for requested_digits > 0 && fractionals > w_error {
|
|
fractionals *= 10
|
|
w_error *= 10
|
|
// Integer division by one.
|
|
digit := byte(fractionals >> -one.e)
|
|
buf = append(buf, '0'+digit)
|
|
requested_digits--
|
|
fractionals &= one.f - 1 // Modulo by one.
|
|
kappa--
|
|
}
|
|
if requested_digits != 0 {
|
|
res = false
|
|
} else {
|
|
res = roundWeedCounted(buf, fractionals, one.f, w_error, &kappa)
|
|
}
|
|
return
|
|
}
|
|
|
|
// Provides a decimal representation of v.
|
|
// Returns true if it succeeds, otherwise the result cannot be trusted.
|
|
// There will be *length digits inside the buffer (not null-terminated).
|
|
// If the function returns true then
|
|
//
|
|
// v == (double) (buffer * 10^decimal_exponent).
|
|
//
|
|
// The digits in the buffer are the shortest representation possible: no
|
|
// 0.09999999999999999 instead of 0.1. The shorter representation will even be
|
|
// chosen even if the longer one would be closer to v.
|
|
// The last digit will be closest to the actual v. That is, even if several
|
|
// digits might correctly yield 'v' when read again, the closest will be
|
|
// computed.
|
|
func grisu3(f float64, buffer []byte) (digits []byte, decimal_exponent int, result bool) {
|
|
v := double(f)
|
|
w := v.toNormalizedDiyfp()
|
|
|
|
// boundary_minus and boundary_plus are the boundaries between v and its
|
|
// closest floating-point neighbors. Any number strictly between
|
|
// boundary_minus and boundary_plus will round to v when convert to a double.
|
|
// Grisu3 will never output representations that lie exactly on a boundary.
|
|
boundary_minus, boundary_plus := v.normalizedBoundaries()
|
|
ten_mk_minimal_binary_exponent := kMinimalTargetExponent - (w.e + diyFpKSignificandSize)
|
|
ten_mk_maximal_binary_exponent := kMaximalTargetExponent - (w.e + diyFpKSignificandSize)
|
|
ten_mk, mk := getCachedPowerForBinaryExponentRange(ten_mk_minimal_binary_exponent, ten_mk_maximal_binary_exponent)
|
|
|
|
_DCHECK(
|
|
(kMinimalTargetExponent <=
|
|
w.e+ten_mk.e+diyFpKSignificandSize) &&
|
|
(kMaximalTargetExponent >= w.e+ten_mk.e+diyFpKSignificandSize))
|
|
// Note that ten_mk is only an approximation of 10^-k. A DiyFp only contains a
|
|
// 64 bit significand and ten_mk is thus only precise up to 64 bits.
|
|
|
|
// The DiyFp::Times procedure rounds its result, and ten_mk is approximated
|
|
// too. The variable scaled_w (as well as scaled_boundary_minus/plus) are now
|
|
// off by a small amount.
|
|
// In fact: scaled_w - w*10^k < 1ulp (unit in the last place) of scaled_w.
|
|
// In other words: let f = scaled_w.f() and e = scaled_w.e(), then
|
|
// (f-1) * 2^e < w*10^k < (f+1) * 2^e
|
|
scaled_w := w.times(ten_mk)
|
|
_DCHECK(scaled_w.e ==
|
|
boundary_plus.e+ten_mk.e+diyFpKSignificandSize)
|
|
// In theory it would be possible to avoid some recomputations by computing
|
|
// the difference between w and boundary_minus/plus (a power of 2) and to
|
|
// compute scaled_boundary_minus/plus by subtracting/adding from
|
|
// scaled_w. However the code becomes much less readable and the speed
|
|
// enhancements are not terrific.
|
|
scaled_boundary_minus := boundary_minus.times(ten_mk)
|
|
scaled_boundary_plus := boundary_plus.times(ten_mk)
|
|
// DigitGen will generate the digits of scaled_w. Therefore we have
|
|
// v == (double) (scaled_w * 10^-mk).
|
|
// Set decimal_exponent == -mk and pass it to DigitGen. If scaled_w is not an
|
|
// integer than it will be updated. For instance if scaled_w == 1.23 then
|
|
// the buffer will be filled with "123" und the decimal_exponent will be
|
|
// decreased by 2.
|
|
var kappa int
|
|
kappa, digits, result = digitGen(scaled_boundary_minus, scaled_w, scaled_boundary_plus, buffer)
|
|
decimal_exponent = -mk + kappa
|
|
return
|
|
}
|
|
|
|
// The "counted" version of grisu3 (see above) only generates requested_digits
|
|
// number of digits. This version does not generate the shortest representation,
|
|
// and with enough requested digits 0.1 will at some point print as 0.9999999...
|
|
// Grisu3 is too imprecise for real halfway cases (1.5 will not work) and
|
|
// therefore the rounding strategy for halfway cases is irrelevant.
|
|
func grisu3Counted(v float64, requested_digits int, buffer []byte) (digits []byte, decimal_exponent int, result bool) {
|
|
w := double(v).toNormalizedDiyfp()
|
|
ten_mk_minimal_binary_exponent := kMinimalTargetExponent - (w.e + diyFpKSignificandSize)
|
|
ten_mk_maximal_binary_exponent := kMaximalTargetExponent - (w.e + diyFpKSignificandSize)
|
|
ten_mk, mk := getCachedPowerForBinaryExponentRange(ten_mk_minimal_binary_exponent, ten_mk_maximal_binary_exponent)
|
|
|
|
_DCHECK(
|
|
(kMinimalTargetExponent <=
|
|
w.e+ten_mk.e+diyFpKSignificandSize) &&
|
|
(kMaximalTargetExponent >= w.e+ten_mk.e+diyFpKSignificandSize))
|
|
// Note that ten_mk is only an approximation of 10^-k. A DiyFp only contains a
|
|
// 64 bit significand and ten_mk is thus only precise up to 64 bits.
|
|
|
|
// The DiyFp::Times procedure rounds its result, and ten_mk is approximated
|
|
// too. The variable scaled_w (as well as scaled_boundary_minus/plus) are now
|
|
// off by a small amount.
|
|
// In fact: scaled_w - w*10^k < 1ulp (unit in the last place) of scaled_w.
|
|
// In other words: let f = scaled_w.f() and e = scaled_w.e(), then
|
|
// (f-1) * 2^e < w*10^k < (f+1) * 2^e
|
|
scaled_w := w.times(ten_mk)
|
|
// We now have (double) (scaled_w * 10^-mk).
|
|
// DigitGen will generate the first requested_digits digits of scaled_w and
|
|
// return together with a kappa such that scaled_w ~= buffer * 10^kappa. (It
|
|
// will not always be exactly the same since DigitGenCounted only produces a
|
|
// limited number of digits.)
|
|
var kappa int
|
|
kappa, digits, result = digitGenCounted(scaled_w, requested_digits, buffer)
|
|
decimal_exponent = -mk + kappa
|
|
|
|
return
|
|
}
|
|
|
|
// v must be > 0 and must not be Inf or NaN
|
|
func Dtoa(v float64, mode Mode, requested_digits int, buffer []byte) (digits []byte, decimal_point int, result bool) {
|
|
defer func() {
|
|
if x := recover(); x != nil {
|
|
if x == dcheckFailure {
|
|
panic(fmt.Errorf("DCHECK assertion failed while formatting %s in mode %d", strconv.FormatFloat(v, 'e', 50, 64), mode))
|
|
}
|
|
panic(x)
|
|
}
|
|
}()
|
|
var decimal_exponent int
|
|
startPos := len(buffer)
|
|
switch mode {
|
|
case ModeShortest:
|
|
digits, decimal_exponent, result = grisu3(v, buffer)
|
|
case ModePrecision:
|
|
digits, decimal_exponent, result = grisu3Counted(v, requested_digits, buffer)
|
|
}
|
|
if result {
|
|
decimal_point = len(digits) - startPos + decimal_exponent
|
|
} else {
|
|
digits = digits[:startPos]
|
|
}
|
|
return
|
|
}
|