// See comments for InitialScaledStartValues
private static void InitialScaledStartValuesNegativeExponentPositivePower(
double v,
int estimated_power,
bool need_boundary_deltas,
Bignum numerator,
Bignum denominator,
Bignum delta_minus,
Bignum delta_plus)
{
var bits = (ulong)BitConverter.DoubleToInt64Bits(v);
ulong significand = DoubleHelper.Significand(bits);
int exponent = DoubleHelper.Exponent(bits);
// v = f * 2^e with e < 0, and with estimated_power >= 0.
// This means that e is close to 0 (have a look at how estimated_power is
// computed).
// numerator = significand
// since v = significand * 2^exponent this is equivalent to
// numerator = v * / 2^-exponent
numerator.AssignUInt64(significand);
// denominator = 10^estimated_power * 2^-exponent (with exponent < 0)
denominator.AssignPowerUInt16(10, estimated_power);
denominator.ShiftLeft(-exponent);
if (need_boundary_deltas)
{
// Introduce a common denominator so that the deltas to the boundaries are
// integers.
denominator.ShiftLeft(1);
numerator.ShiftLeft(1);
// Let v = f * 2^e, then m+ - v = 1/2 * 2^e; With the common
// denominator (of 2) delta_plus equals 2^e.
// Given that the denominator already includes v's exponent the distance
// to the boundaries is simply 1.
delta_plus.AssignUInt16(1);
// Same for delta_minus (with adjustments below if f == 2^p-1).
delta_minus.AssignUInt16(1);
// If the significand (without the hidden bit) is 0, then the lower
// boundary is closer than just one ulp (unit in the last place).
// There is only one exception: if the next lower number is a denormal
// then the distance is 1 ulp. Since the exponent is close to zero
// (otherwise estimated_power would have been negative) this cannot happen
// here either.
ulong v_bits = bits;
if ((v_bits & DoubleHelper.KSignificandMask) == 0)
{
// The lower boundary is closer at half the distance of "normal" numbers.
// Increase the denominator and adapt all but the delta_minus.
denominator.ShiftLeft(1); // *2
numerator.ShiftLeft(1); // *2
delta_plus.ShiftLeft(1); // *2
}
}
}
// See comments for InitialScaledStartValues.
private static void InitialScaledStartValuesPositiveExponent(
double v,
int estimated_power,
bool need_boundary_deltas,
Bignum numerator,
Bignum denominator,
Bignum delta_minus,
Bignum delta_plus)
{
// A positive exponent implies a positive power.
Debug.Assert(estimated_power >= 0);
// Since the estimated_power is positive we simply multiply the denominator
// by 10^estimated_power.
// numerator = v.
var bits = (ulong)BitConverter.DoubleToInt64Bits(v);
numerator.AssignUInt64(DoubleHelper.Significand(bits));
numerator.ShiftLeft(DoubleHelper.Exponent(bits));
// denominator = 10^estimated_power.
denominator.AssignPowerUInt16(10, estimated_power);
if (need_boundary_deltas)
{
// Introduce a common denominator so that the deltas to the boundaries are
// integers.
denominator.ShiftLeft(1);
numerator.ShiftLeft(1);
// Let v = f * 2^e, then m+ - v = 1/2 * 2^e; With the common
// denominator (of 2) delta_plus equals 2^e.
delta_plus.AssignUInt16(1);
delta_plus.ShiftLeft(DoubleHelper.Exponent(bits));
// Same for delta_minus (with adjustments below if f == 2^p-1).
delta_minus.AssignUInt16(1);
delta_minus.ShiftLeft(DoubleHelper.Exponent(bits));
// If the significand (without the hidden bit) is 0, then the lower
// boundary is closer than just half a ulp (unit in the last place).
// There is only one exception: if the next lower number is a denormal then
// the distance is 1 ulp. This cannot be the case for exponent >= 0 (but we
// have to test it in the other function where exponent < 0).
ulong v_bits = bits;
if ((v_bits & DoubleHelper.KSignificandMask) == 0)
{
// The lower boundary is closer at half the distance of "normal" numbers.
// Increase the common denominator and adapt all but the delta_minus.
denominator.ShiftLeft(1); // *2
numerator.ShiftLeft(1); // *2
delta_plus.ShiftLeft(1); // *2
}
}
}