// 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.
static bool RoundWeedCounted(
DtoaBuilder buffer,
ulong rest,
ulong ten_kappa,
ulong unit,
ref int 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._chars[buffer.Length - 1]++;
for (int i = buffer.Length - 1; i > 0; --i)
{
if (buffer._chars[i] != '0' + 10)
{
break;
}
buffer._chars[i] = '0';
buffer._chars[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._chars[0] == '0' + 10)
{
buffer._chars[0] = '1';
kappa += 1;
}
return(true);
}
return(false);
}
// Generates 'requested_digits' after the decimal point. It might omit
// trailing '0's. If the input number is too small then no digits at all are
// generated (ex.: 2 fixed digits for 0.00001).
//
// Input verifies: 1 <= (numerator + delta) / denominator < 10.
static void BignumToFixed(
int requested_digits,
ref int decimal_point,
Bignum numerator,
Bignum denominator,
DtoaBuilder buffer)
{
// Note that we have to look at more than just the requested_digits, since
// a number could be rounded up. Example: v=0.5 with requested_digits=0.
// Even though the power of v equals 0 we can't just stop here.
if (-(decimal_point) > requested_digits)
{
// The number is definitively too small.
// Ex: 0.001 with requested_digits == 1.
// Set decimal-point to -requested_digits. This is what Gay does.
// Note that it should not have any effect anyways since the string is
// empty.
decimal_point = -requested_digits;
buffer.Reset();
return;
}
if (-decimal_point == requested_digits)
{
// We only need to verify if the number rounds down or up.
// Ex: 0.04 and 0.06 with requested_digits == 1.
Debug.Assert(decimal_point == -requested_digits);
// Initially the fraction lies in range (1, 10]. Multiply the denominator
// by 10 so that we can compare more easily.
denominator.Times10();
if (Bignum.PlusCompare(numerator, numerator, denominator) >= 0)
{
// If the fraction is >= 0.5 then we have to include the rounded
// digit.
buffer[0] = '1';
decimal_point++;
}
else
{
// Note that we caught most of similar cases earlier.
buffer.Reset();
}
}
else
{
// The requested digits correspond to the digits after the point.
// The variable 'needed_digits' includes the digits before the point.
int needed_digits = (decimal_point) + requested_digits;
GenerateCountedDigits(needed_digits, ref decimal_point, numerator, denominator, buffer);
}
}
// Let v = numerator / denominator < 10.
// Then we generate 'count' digits of d = x.xxxxx... (without the decimal point)
// from left to right. Once 'count' digits have been produced we decide wether
// to round up or down. Remainders of exactly .5 round upwards. Numbers such
// as 9.999999 propagate a carry all the way, and change the
// exponent (decimal_point), when rounding upwards.
static void GenerateCountedDigits(
int count,
ref int decimal_point,
Bignum numerator,
Bignum denominator,
DtoaBuilder buffer)
{
Debug.Assert(count >= 0);
for (int i = 0; i < count - 1; ++i)
{
uint d = numerator.DivideModuloIntBignum(denominator);
Debug.Assert(d <= 9); // digit is a uint and therefore always positive.
// digit = numerator / denominator (integer division).
// numerator = numerator % denominator.
buffer.Append((char)(d + '0'));
// Prepare for next iteration.
numerator.Times10();
}
// Generate the last digit.
uint digit = numerator.DivideModuloIntBignum(denominator);
if (Bignum.PlusCompare(numerator, numerator, denominator) >= 0)
{
digit++;
}
buffer.Append((char)(digit + '0'));
// Correct bad digits (in case we had a sequence of '9's). Propagate the
// carry until we hat a non-'9' or til we reach the first digit.
for (int i = count - 1; i > 0; --i)
{
if (buffer[i] != '0' + 10)
{
break;
}
buffer[i] = '0';
buffer[i - 1]++;
}
if (buffer[0] == '0' + 10)
{
// Propagate a carry past the top place.
buffer[0] = '1';
decimal_point++;
}
}
// 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 ctannot 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.
private static bool RoundWeed(
DtoaBuilder buffer,
ulong distanceTooHighW,
ulong unsafeInterval,
ulong rest,
ulong tenKappa,
ulong unit)
{
ulong smallDistance = distanceTooHighW - unit;
ulong bigDistance = distanceTooHighW + 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_low[ (often written as "(w_low; w_low)")
// 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 rounding
// the buffer. If we have two potential representations we need to make sure
// that the chosen one is closer to w_low and w_high since v can be anywhere
// between them.
//
// 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
while (rest < smallDistance && // Negated condition 1
unsafeInterval - rest >= tenKappa && // Negated condition 2
(rest + tenKappa < smallDistance || // buffer{-1} > w_high
smallDistance - rest >= rest + tenKappa - smallDistance))
{
buffer.DecreaseLast();
rest += tenKappa;
}
// 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 < bigDistance &&
unsafeInterval - rest >= tenKappa &&
(rest + tenKappa < bigDistance ||
bigDistance - rest > rest + tenKappa - bigDistance))
{
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 <= unsafeInterval - 4 * unit));
}
public static void DoubleToAscii(
DtoaBuilder buffer,
double v,
DtoaMode mode,
int requested_digits,
out bool negative,
out int point)
{
Debug.Assert(!double.IsNaN(v));
Debug.Assert(!double.IsInfinity(v));
Debug.Assert(mode == DtoaMode.Shortest || requested_digits >= 0);
point = 0;
negative = false;
buffer.Reset();
if (v < 0)
{
negative = true;
v = -v;
}
if (v == 0)
{
buffer[0] = '0';
point = 1;
return;
}
if (mode == DtoaMode.Precision && requested_digits == 0)
{
return;
}
bool fast_worked = false;
switch (mode)
{
case DtoaMode.Shortest:
fast_worked = FastDtoa.NumberToString(v, DtoaMode.Shortest, 0, out point, buffer);
break;
case DtoaMode.Fixed:
//fast_worked = FastFixedDtoa(v, requested_digits, buffer, length, point);
ExceptionHelper.ThrowNotImplementedException();
break;
case DtoaMode.Precision:
fast_worked = FastDtoa.NumberToString(v, DtoaMode.Precision, requested_digits, out point, buffer);
break;
default:
ExceptionHelper.ThrowArgumentOutOfRangeException <string>();
return;
}
if (fast_worked)
{
return;
}
// If the fast dtoa didn't succeed use the slower bignum version.
buffer.Reset();
BignumDtoa.NumberToString(v, mode, requested_digits, buffer, out point);
}
public static void NumberToString(
double v,
DtoaMode mode,
int requested_digits,
DtoaBuilder builder,
out int decimal_point)
{
var bits = (ulong)BitConverter.DoubleToInt64Bits(v);
var significand = DoubleHelper.Significand(bits);
var is_even = (significand & 1) == 0;
var exponent = DoubleHelper.Exponent(bits);
var normalized_exponent = DoubleHelper.NormalizedExponent(significand, exponent);
// estimated_power might be too low by 1.
var estimated_power = EstimatePower(normalized_exponent);
// Shortcut for Fixed.
// The requested digits correspond to the digits after the point. If the
// number is much too small, then there is no need in trying to get any
// digits.
if (mode == DtoaMode.Fixed && -estimated_power - 1 > requested_digits)
{
// Set decimal-point to -requested_digits. This is what Gay does.
// Note that it should not have any effect anyways since the string is
// empty.
decimal_point = -requested_digits;
return;
}
Bignum numerator = new Bignum();
Bignum denominator = new Bignum();
Bignum delta_minus = new Bignum();
Bignum delta_plus = new Bignum();
// Make sure the bignum can grow large enough. The smallest double equals
// 4e-324. In this case the denominator needs fewer than 324*4 binary digits.
// The maximum double is 1.7976931348623157e308 which needs fewer than
// 308*4 binary digits.
var need_boundary_deltas = mode == DtoaMode.Shortest;
InitialScaledStartValues(
v,
estimated_power,
need_boundary_deltas,
numerator,
denominator,
delta_minus,
delta_plus);
// We now have v = (numerator / denominator) * 10^estimated_power.
FixupMultiply10(
estimated_power,
is_even,
out decimal_point,
numerator,
denominator,
delta_minus,
delta_plus);
// We now have v = (numerator / denominator) * 10^(decimal_point-1), and
// 1 <= (numerator + delta_plus) / denominator < 10
switch (mode)
{
case DtoaMode.Shortest:
GenerateShortestDigits(
numerator,
denominator,
delta_minus,
delta_plus,
is_even,
builder);
break;
case DtoaMode.Fixed:
BignumToFixed(
requested_digits,
ref decimal_point,
numerator,
denominator,
builder);
break;
case DtoaMode.Precision:
GenerateCountedDigits(
requested_digits,
ref decimal_point,
numerator,
denominator,
builder);
break;
default:
ExceptionHelper.ThrowArgumentOutOfRangeException();
break;
}
}
// The procedure starts generating digits from the left to the right and stops
// when the generated digits yield the shortest decimal representation of v. A
// decimal representation of v is a number lying closer to v than to any other
// double, so it converts to v when read.
//
// This is true if d, the decimal representation, is between m- and m+, the
// upper and lower boundaries. d must be strictly between them if !is_even.
// m- := (numerator - delta_minus) / denominator
// m+ := (numerator + delta_plus) / denominator
//
// Precondition: 0 <= (numerator+delta_plus) / denominator < 10.
// If 1 <= (numerator+delta_plus) / denominator < 10 then no leading 0 digit
// will be produced. This should be the standard precondition.
private static void GenerateShortestDigits(
Bignum numerator,
Bignum denominator,
Bignum delta_minus,
Bignum delta_plus,
bool is_even,
DtoaBuilder buffer)
{
// Small optimization: if delta_minus and delta_plus are the same just reuse
// one of the two bignums.
if (Bignum.Equal(delta_minus, delta_plus))
{
delta_plus = delta_minus;
}
buffer.Reset();
while (true)
{
uint digit;
digit = numerator.DivideModuloIntBignum(denominator);
// digit = numerator / denominator (integer division).
// numerator = numerator % denominator.
buffer.Append((char)(digit + '0'));
// Can we stop already?
// If the remainder of the division is less than the distance to the lower
// boundary we can stop. In this case we simply round down (discarding the
// remainder).
// Similarly we test if we can round up (using the upper boundary).
bool in_delta_room_minus;
bool in_delta_room_plus;
if (is_even)
{
in_delta_room_minus = Bignum.LessEqual(numerator, delta_minus);
}
else
{
in_delta_room_minus = Bignum.Less(numerator, delta_minus);
}
if (is_even)
{
in_delta_room_plus = Bignum.PlusCompare(numerator, delta_plus, denominator) >= 0;
}
else
{
in_delta_room_plus = Bignum.PlusCompare(numerator, delta_plus, denominator) > 0;
}
if (!in_delta_room_minus && !in_delta_room_plus)
{
// Prepare for next iteration.
numerator.Times10();
delta_minus.Times10();
// We optimized delta_plus to be equal to delta_minus (if they share the
// same value). So don't multiply delta_plus if they point to the same
// object.
if (delta_minus != delta_plus)
{
delta_plus.Times10();
}
}
else if (in_delta_room_minus && in_delta_room_plus)
{
// Let's see if 2*numerator < denominator.
// If yes, then the next digit would be < 5 and we can round down.
int compare = Bignum.PlusCompare(numerator, numerator, denominator);
if (compare < 0)
{
// Remaining digits are less than .5. -> Round down (== do nothing).
}
else if (compare > 0)
{
// Remaining digits are more than .5 of denominator. . Round up.
// Note that the last digit could not be a '9' as otherwise the whole
// loop would have stopped earlier.
// We still have an assert here in case the preconditions were not
// satisfied.
buffer[buffer.Length - 1]++;
}
else
{
// Halfway case.
// TODO(floitsch): need a way to solve half-way cases.
// For now let's round towards even (since this is what Gay seems to
// do).
if ((buffer[buffer.Length - 1] - '0') % 2 == 0)
{
// Round down => Do nothing.
}
else
{
buffer[buffer.Length - 1]++;
}
}
return;
}
else if (in_delta_room_minus)
{
// Round down (== do nothing).
return;
}
else
{
// in_delta_room_plus
// Round up.
// Note again that the last digit could not be '9' since this would have
// stopped the loop earlier.
// We still have an DCHECK here, in case the preconditions were not
// satisfied.
buffer[buffer.Length - 1]++;
return;
}
}
}
