/// <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); }