Example #1
0
        // Let v = significand * 2^exponent.
        // Computes v / 10^estimated_power exactly, as a ratio of two bignums, numerator
        // and denominator. The functions GenerateShortestDigits and
        // GenerateCountedDigits will then convert this ratio to its decimal
        // representation d, with the required accuracy.
        // Then d * 10^estimated_power is the representation of v.
        // (Note: the fraction and the estimated_power might get adjusted before
        // generating the decimal representation.)
        //
        // The initial start values consist of:
        //  - a scaled numerator: s.t. numerator/denominator == v / 10^estimated_power.
        //  - a scaled (common) denominator.
        //  optionally (used by GenerateShortestDigits to decide if it has the shortest
        //  decimal converting back to v):
        //  - v - m-: the distance to the lower boundary.
        //  - m+ - v: the distance to the upper boundary.
        //
        // v, m+, m-, and therefore v - m- and m+ - v all share the same denominator.
        //
        // Let ep == estimated_power, then the returned values will satisfy:
        //  v / 10^ep = numerator / denominator.
        //  v's boundarys m- and m+:
        //    m- / 10^ep == v / 10^ep - delta_minus / denominator
        //    m+ / 10^ep == v / 10^ep + delta_plus / denominator
        //  Or in other words:
        //    m- == v - delta_minus * 10^ep / denominator;
        //    m+ == v + delta_plus * 10^ep / denominator;
        //
        // Since 10^(k-1) <= v < 10^k    (with k == estimated_power)
        //  or       10^k <= v < 10^(k+1)
        //  we then have 0.1 <= numerator/denominator < 1
        //           or    1 <= numerator/denominator < 10
        //
        // It is then easy to kickstart the digit-generation routine.
        //
        // The boundary-deltas are only filled if need_boundary_deltas is set.
        private static void InitialScaledStartValues(
            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);

            if (DoubleHelper.Exponent(bits) >= 0)
            {
                InitialScaledStartValuesPositiveExponent(
                    v,
                    estimated_power,
                    need_boundary_deltas,
                    numerator,
                    denominator,
                    delta_minus,
                    delta_plus);
            }
            else if (estimated_power >= 0)
            {
                InitialScaledStartValuesNegativeExponentPositivePower(
                    v,
                    estimated_power,
                    need_boundary_deltas,
                    numerator,
                    denominator,
                    delta_minus,
                    delta_plus);
            }
            else
            {
                InitialScaledStartValuesNegativeExponentNegativePower(
                    v,
                    estimated_power,
                    need_boundary_deltas,
                    numerator,
                    denominator,
                    delta_minus,
                    delta_plus);
            }
        }
Example #2
0
        // 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.
        private static bool Grisu3(double v, FastDtoaBuilder buffer)
        {
            long  bits = BitConverter.DoubleToInt64Bits(v);
            DiyFp w    = DoubleHelper.AsNormalizedDiyFp(bits);
            // 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.
            DiyFp boundaryMinus = new DiyFp(), boundaryPlus = new DiyFp();

            DoubleHelper.NormalizedBoundaries(bits, boundaryMinus, boundaryPlus);

            var tenMk = new DiyFp(); // Cached power of ten: 10^-k
            int mk = CachedPowers.GetCachedPower(w.E + DiyFp.KSignificandSize,
                                                 MinimalTargetExponent, MaximalTargetExponent, tenMk);

            // 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
            DiyFp scaledW = DiyFp.Times(w, tenMk);

            // 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 terriffic.
            DiyFp scaledBoundaryMinus = DiyFp.Times(boundaryMinus, tenMk);
            DiyFp scaledBoundaryPlus  = DiyFp.Times(boundaryPlus, tenMk);

            // 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.
            return(DigitGen(scaledBoundaryMinus, scaledW, scaledBoundaryPlus, buffer, mk));
        }
Example #3
0
        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;
            }
        }
Example #4
0
        // See comments for InitialScaledStartValues
        private static void InitialScaledStartValuesNegativeExponentNegativePower(
            double v,
            int estimated_power,
            bool need_boundary_deltas,
            Bignum numerator,
            Bignum denominator,
            Bignum delta_minus,
            Bignum delta_plus)
        {
            const ulong kMinimalNormalizedExponent = 0x0010000000000000;

            var   bits        = (ulong)BitConverter.DoubleToInt64Bits(v);
            ulong significand = DoubleHelper.Significand(bits);
            int   exponent    = DoubleHelper.Exponent(bits);
            // Instead of multiplying the denominator with 10^estimated_power we
            // multiply all values (numerator and deltas) by 10^-estimated_power.

            // Use numerator as temporary container for power_ten.
            Bignum power_ten = numerator;

            power_ten.AssignPowerUInt16(10, -estimated_power);

            if (need_boundary_deltas)
            {
                // Since power_ten == numerator we must make a copy of 10^estimated_power
                // before we complete the computation of the numerator.
                // delta_plus = delta_minus = 10^estimated_power
                delta_plus.AssignBignum(power_ten);
                delta_minus.AssignBignum(power_ten);
            }

            // numerator = significand * 2 * 10^-estimated_power
            //  since v = significand * 2^exponent this is equivalent to
            // numerator = v * 10^-estimated_power * 2 * 2^-exponent.
            // Remember: numerator has been abused as power_ten. So no need to assign it
            //  to itself.
            numerator.MultiplyByUInt64(significand);

            // denominator = 2 * 2^-exponent with exponent < 0.
            denominator.AssignUInt16(1);
            denominator.ShiftLeft(-exponent);

            if (need_boundary_deltas)
            {
                // Introduce a common denominator so that the deltas to the boundaries are
                // integers.
                numerator.ShiftLeft(1);
                denominator.ShiftLeft(1);
                // With this shift the boundaries have their correct value, since
                // delta_plus = 10^-estimated_power, and
                // delta_minus = 10^-estimated_power.
                // These assignments have been done earlier.

                // The special case where the lower boundary is twice as close.
                // This time we have to look out for the exception too.
                ulong v_bits = bits;
                if ((v_bits & DoubleHelper.KSignificandMask) == 0 &&
                    // The only exception where a significand == 0 has its boundaries at
                    // "normal" distances:
                    (v_bits & DoubleHelper.KExponentMask) != kMinimalNormalizedExponent)
                {
                    numerator.ShiftLeft(1);   // *2
                    denominator.ShiftLeft(1); // *2
                    delta_plus.ShiftLeft(1);  // *2
                }
            }
        }