Esempio n. 1
0
        /// <summary>
        /// Convert a 64-bit floating point number to an exponential notation string.
        /// </summary>
        internal static void ToExponentialString(StringBuilder result, ulong ieeeMantissa,
                                                 uint ieeeExponent, int precision, RyuFormatOptions options,
                                                 NumberFormatInfo info)
        {
            bool printDP = precision > 0, soft = (options & RyuFormatOptions.SoftPrecision) !=
                                                 0;
            uint digits = 0U;
            int  printedDigits = 0, availDigits = 0, exp = 0, exponent = Decode(ieeeMantissa,
                                                                                ieeeExponent, out ulong mantissa), start = result.Length;
            ulong mantShift = mantissa << MANTISSA_SHIFT;

            ++precision;

            if (exponent >= -RyuFloat64.DOUBLE_MANTISSA_BITS)
            {
                int idx = (exponent < 0) ? 0 : RyuUtils.IndexForExponent(exponent), i =
                    RyuUtils.LengthForIndex(idx) - 1, j = Pow10BitsForIndex(idx) - exponent +
                                                          MANTISSA_SHIFT, p = RyuTables.POW10_OFFSET_D[idx] + i;
                for (; i >= 0; i--)
                {
                    // Temporary: j is usually around 128, and by shifting a bit, we push it
                    // to 128 or above, which is a slightly faster code path in
                    // MulShiftMod1E9. Instead, we can just increase the multipliers
                    digits = RyuUtils.MulShiftMod1E9(mantShift, RyuTables.POW10_SPLIT_D[p, 0],
                                                     RyuTables.POW10_SPLIT_D[p, 1], RyuTables.POW10_SPLIT_D[p, 2], j);
                    if (printedDigits > 0)
                    {
                        if (printedDigits + 9 > precision)
                        {
                            availDigits = 9;
                            break;
                        }
                        RyuUtils.Append9Digits(result, digits);
                        printedDigits += 9;
                    }
                    else if (digits != 0U)
                    {
                        availDigits = RyuUtils.DecimalLength9(digits);
                        exp         = i * 9 + availDigits - 1;
                        if (availDigits > precision)
                        {
                            break;
                        }
                        RyuUtils.AppendDDigits(result, digits, availDigits + 1, printDP, info);
                        printedDigits = availDigits;
                        availDigits   = 0;
                    }
                    p--;
                }
            }

            if (exponent < 0 && availDigits == 0)
            {
                int idx = (-exponent) >> 4, pMax = RyuTables.POW10_OFFSET_2_D[idx + 1], p =
                    RyuTables.POW10_OFFSET_2_D[idx], j = MANTISSA_SHIFT +
                                                         POW10_ADDITIONAL_BITS - exponent - (idx << 4);
                for (int i = RyuTables.MIN_BLOCK_2_D[idx]; i < 200; i++)
                {
                    digits = (p >= pMax) ? 0U : RyuUtils.MulShiftMod1E9(mantShift,
                                                                        RyuTables.POW10_SPLIT_2_D[p, 0], RyuTables.POW10_SPLIT_2_D[p, 1],
                                                                        RyuTables.POW10_SPLIT_2_D[p, 2], j);
                    if (printedDigits > 0)
                    {
                        if (printedDigits + 9 > precision)
                        {
                            availDigits = 9;
                            break;
                        }
                        RyuUtils.Append9Digits(result, digits);
                        printedDigits += 9;
                    }
                    else if (digits != 0)
                    {
                        availDigits = RyuUtils.DecimalLength9(digits);
                        exp         = (i + 1) * -9 + availDigits - 1;
                        if (availDigits > precision)
                        {
                            break;
                        }
                        RyuUtils.AppendDDigits(result, digits, availDigits + 1, printDP, info);
                        printedDigits = availDigits;
                        availDigits   = 0;
                    }
                    p++;
                }
            }

            // 0 = don't round up; 1 = round up unconditionally; 2 = round up if odd
            int  maxDigits = precision - printedDigits, roundFlag;
            uint lastDigit = 0U;

            if (availDigits == 0)
            {
                digits = 0U;
            }
            if (availDigits > maxDigits)
            {
                lastDigit = RyuUtils.LastDigit(ref digits, availDigits - maxDigits);
            }
            if (lastDigit != 5U)
            {
                roundFlag = (lastDigit > 5U) ? 1 : 0;
            }
            else
            {
                // Is m * 2^e2 * 10^(precision + 1 - exp) integer?
                // precision was already increased by 1, so we don't need to write + 1 here.
                int  rexp           = precision - exp;
                bool trailingZeroes = HasTrailingZeroes(exponent, rexp, mantissa);
                if (rexp < 0 && trailingZeroes)
                {
                    trailingZeroes = RyuUtils.IsMultipleOf5Power(mantissa, -rexp);
                }
                roundFlag = trailingZeroes ? 2 : 1;
            }
            if (printedDigits > 0)
            {
                if (digits == 0U)
                {
                    if (!soft)
                    {
                        RyuUtils.Append0(result, maxDigits);
                    }
                }
                else
                {
                    RyuUtils.AppendCDigits(result, digits, maxDigits);
                }
            }
            else
            {
                RyuUtils.AppendDDigits(result, digits, maxDigits + 1, printDP, info);
            }

            if (roundFlag != 0 && RyuUtils.RoundResult(result, start, roundFlag, out _, info))
            {
                exp++;
            }

            if (soft)
            {
                RyuUtils.SoftenResult(result, info);
            }

            RyuUtils.AppendExponent(result, exp, options, info);
        }