Beispiel #1
0
        /// <summary>
        /// Converts a single precision floating point number to a string.
        /// </summary>
        /// <param name="result">The location where the result will be placed.</param>
        /// <param name="value">The value to format.</param>
        /// <param name="precision">The precision to output when formatting.</param>
        /// <param name="options">The format mode to use.</param>
        /// <param name="provider">The provider used to determine how the value will be
        /// formatted.</param>
        public static void ToString(StringBuilder result, float value, int precision,
                                    RyuFormatOptions options = RyuFormatOptions.RoundtripMode,
                                    IFormatProvider provider = null)
        {
            var info = RyuUtils.GetFormatInfo(provider);
            // Step 1: Decode the floating-point number, and unify normalized and subnormal
            // cases
            bool ieeeSign = RyuFloat32.Decode(value, out uint ieeeMantissa,
                                              out uint ieeeExponent);

            // Case distinction; exit early for the easy cases
            bool mZero = ieeeMantissa == 0UL;

            if (ieeeExponent == RyuFloat32.EXPONENT_MASK)
            {
                RyuUtils.GenerateSpecial(result, ieeeSign, !mZero, info);
            }
            else if (mZero && ieeeExponent == 0UL)
            {
                RyuUtils.GenerateZero(result, ieeeSign, precision, options, info);
            }
            else if ((options & RyuFormatOptions.RoundtripMode) != 0)
            {
                new RyuFloat32(ieeeSign, ieeeMantissa, ieeeExponent).ToRoundtripString(result,
                                                                                       options, info);
            }
        }
Beispiel #2
0
        /// <summary>
        /// Appends the exponent for exponential and roundtrip notation.
        /// </summary>
        internal static void AppendExponent(StringBuilder result, int exponent,
                                            RyuFormatOptions options, NumberFormatInfo info)
        {
            bool compat = (options & RyuFormatOptions.CompatibleExponent) != 0;

#if DEBUG
            if (exponent < -9999 || exponent > 9999)
            {
                throw new ArgumentOutOfRangeException(nameof(exponent), exponent,
                                                      "4 digit exponent limit");
            }
#endif
            result.Append('E');
            if (exponent < 0)
            {
                result.Append(info.NegativeSign);
                exponent = -exponent;
            }
            else if (compat || (options & RyuFormatOptions.ExponentialMode) != 0)
            {
                result.Append(info.PositiveSign);
            }

            if (exponent >= 100)
            {
                int e100 = exponent / 100;
                if (e100 >= 10)
                {
                    result.Append(RyuTables.DIGIT_TABLE[e100]);
                }
                else
                {
                    result.Append(e100.DigitToChar());
                }
                result.Append(RyuTables.DIGIT_TABLE[exponent - 100 * e100]);
            }
            else
            {
                if (compat)
                {
                    result.Append(ZERO);
                }
                if (exponent >= 10)
                {
                    result.Append(RyuTables.DIGIT_TABLE[exponent]);
                }
                else
                {
                    if (compat)
                    {
                        result.Append(ZERO);
                    }
                    result.Append(exponent.DigitToChar());
                }
            }
        }
Beispiel #3
0
        /// <summary>
        /// Generates the output for positive (and negative) zero.
        /// </summary>
        internal static void GenerateZero(StringBuilder result, bool sign, int precision,
                                          RyuFormatOptions options, NumberFormatInfo info)
        {
            bool compat = (options & RyuFormatOptions.CompatibleExponent) != 0, hard =
                precision > 0 && (options & RyuFormatOptions.SoftPrecision) == 0;

            if ((options & RyuFormatOptions.RoundtripMode) != 0)
            {
                // Roundtrip mode just needs +0 or -0
                if (sign)
                {
                    result.Append("-");
                }
                if (compat)
                {
                    result.Append("0E+000");
                }
                else
                {
                    result.Append("0E0");
                }
            }
            else if ((options & RyuFormatOptions.ExponentialMode) != 0)
            {
                // Exponential mode
                result.Append(ZERO);
                if (hard)
                {
                    result.Append(info.NumberDecimalSeparator);
                    Append0(result, precision);
                }
                if (compat)
                {
                    result.Append("E+000");
                }
                else
                {
                    result.Append("E0");
                }
            }
            else
            {
                // Fixed mode
                result.Append(ZERO);
                if (hard)
                {
                    result.Append(info.NumberDecimalSeparator);
                    Append0(result, precision);
                }
            }
        }
Beispiel #4
0
        /// <summary>
        /// Convert a 32-bit Ryu floating point number to a roundtrip notation string.
        /// </summary>
        public void ToRoundtripString(StringBuilder result, RyuFormatOptions options,
                                      NumberFormatInfo info = null)
        {
            // Step 5: Print the decimal representation
            if (info == null)
            {
                info = CultureInfo.CurrentCulture.NumberFormat;
            }
            if (sign)
            {
                result.Append(info.NegativeSign);
            }
#if DEBUG
            if (info.NumberDecimalSeparator.Length > 1)
            {
                throw new ArgumentException("Requires a single character decimal point");
            }
#endif

            // Print the decimal digits
            uint mantissa = this.mantissa;
            int  olength = RyuUtils.DecimalLength9(mantissa), start = result.Length, index =
                olength + start;
            result.Length = index + 1;
            index         = RyuUtils.PrintGroups42(result, ref mantissa, index);
            // Group of 1
            if (mantissa >= 10U)
            {
                string digits = RyuTables.DIGIT_TABLE[mantissa];
                // We can't use memcpy here: the decimal dot goes between these two digits
                result[index--] = digits[1];
                result[start]   = digits[0];
            }
            else
            {
                result[start] = mantissa.DigitToChar();
            }

            // Print decimal point if needed
            if (olength > 1)
            {
                result[start + 1] = info.NumberDecimalSeparator[0];
                index            += olength;
            }
            result.Length = index;

            RyuUtils.AppendExponent(result, exponent + olength - 1, options, info);
        }
Beispiel #5
0
        /// <summary>
        /// Convert a 64-bit Ryu floating point number to a roundtrip notation string.
        /// </summary>
        public void ToRoundtripString(StringBuilder result, RyuFormatOptions options,
                                      NumberFormatInfo info = null)
        {
            // Step 5: Print the decimal representation
            if (info == null)
            {
                info = CultureInfo.CurrentCulture.NumberFormat;
            }
            if (sign)
            {
                result.Append(info.NegativeSign);
            }
#if DEBUG
            if (info.NumberDecimalSeparator.Length > 1)
            {
                throw new ArgumentException("Requires a single character decimal point");
            }
#endif
            ulong mantissa = this.mantissa;
            uint  mantissaShort;
            int   olength = RyuUtils.DecimalLength17(mantissa), start = result.Length, index =
                olength + start;
            result.Length = index + 1;
            // Print the decimal digits: group of 8
            if ((mantissa >> 32) != 0U)
            {
                // We prefer 32-bit operations, even on 64-bit platforms.
                // We have at most 17 digits, and uint can store 9 digits.
                // If output doesn't fit into uint, we cut off 8 digits,
                // so the rest will fit into uint
                ulong q = mantissa / 100000000UL;
                mantissaShort = (uint)mantissa - 100000000U * (uint)q;
                uint o10000 = mantissaShort / 10000U;
                uint c0 = mantissaShort - 10000U * o10000, d0 = o10000 % 10000U;
                uint c1 = c0 / 100U, d1 = d0 / 100U;

                mantissa = q;
                index    = result.WriteDigits(index, c0 - 100U * c1);
                index    = result.WriteDigits(index, c1);
                index    = result.WriteDigits(index, d0 - 100U * d1);
                index    = result.WriteDigits(index, d1);
            }
            mantissaShort = (uint)mantissa;
            index         = RyuUtils.PrintGroups42(result, ref mantissaShort, index);
            // Group of 1
            if (mantissaShort >= 10U)
            {
                string digits = RyuTables.DIGIT_TABLE[mantissaShort];
                // We can't use memcpy here: the decimal dot goes between these two digits
                result[index--] = digits[1];
                result[start]   = digits[0];
            }
            else
            {
                result[start] = mantissaShort.DigitToChar();
            }

            // Print decimal point if needed
            if (olength > 1)
            {
                result[start + 1] = info.NumberDecimalSeparator[0];
                index            += olength;
            }
            result.Length = index;

            RyuUtils.AppendExponent(result, exponent + olength - 1, options, info);
        }
Beispiel #6
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);
        }
Beispiel #7
0
        /// <summary>
        /// Convert a 64-bit floating point number to a fixed notation string.
        /// </summary>
        internal static void ToFixedString(StringBuilder result, ulong ieeeMantissa,
                                           uint ieeeExponent, int precision, RyuFormatOptions options,
                                           NumberFormatInfo info)
        {
            bool zero = true, soft = (options & RyuFormatOptions.SoftPrecision) != 0;
            int  exponent = Decode(ieeeMantissa, ieeeExponent, out ulong mantissa), start =
                result.Length;
            ulong mShift = mantissa << MANTISSA_SHIFT;
            uint  digits;

            if (exponent >= -RyuFloat64.DOUBLE_MANTISSA_BITS)
            {
                int idx = (exponent < 0) ? 0 : RyuUtils.IndexForExponent(exponent), p10bits =
                    Pow10BitsForIndex(idx), i = RyuUtils.LengthForIndex(idx) - 1, p =
                    RyuTables.POW10_OFFSET_D[idx] + i, j = p10bits - exponent + MANTISSA_SHIFT;
                for (; i >= 0; i--)
                {
                    digits = RyuUtils.MulShiftMod1E9(mShift, RyuTables.POW10_SPLIT_D[p, 0],
                                                     RyuTables.POW10_SPLIT_D[p, 1], RyuTables.POW10_SPLIT_D[p, 2], j);
                    if (!zero)
                    {
                        RyuUtils.Append9Digits(result, digits);
                    }
                    else if (digits != 0U)
                    {
                        RyuUtils.AppendNDigits(result, RyuUtils.DecimalLength9(digits),
                                               digits);
                        zero = false;
                    }
                    p--;
                }
            }

            if (zero)
            {
                result.Append(RyuUtils.ZERO);
            }
            if ((options & RyuFormatOptions.ThousandsSeparators) != 0)
            {
                RyuUtils.AddThousands(result, start, info);
            }
            if (precision > 0 && (!soft || exponent < 0))
            {
                result.Append(info.NumberDecimalSeparator);
            }

            if (exponent < 0)
            {
                // 0 = don't round up; 1 = round up unconditionally; 2 = round up if odd
                int idx = (-exponent) >> 4, roundFlag = 0, i = 0, blocks = precision / 9 + 1,
                    minBlock = RyuTables.MIN_BLOCK_2_D[idx];
                if (blocks <= minBlock)
                {
                    RyuUtils.Append0(result, precision);
                    i = blocks;
                }
                else if (i < minBlock)
                {
                    RyuUtils.Append0(result, 9 * minBlock);
                    i = minBlock;
                }
                int p = RyuTables.POW10_OFFSET_2_D[idx] + i - minBlock, pMax = RyuTables.
                                                                               POW10_OFFSET_2_D[idx + 1], j = MANTISSA_SHIFT + POW10_ADDITIONAL_BITS -
                                                                                                              exponent - (idx << 4);
                for (; i < blocks; ++i)
                {
                    if (p >= pMax)
                    {
                        // If the remaining digits are all 0, then no rounding required
                        if (!soft)
                        {
                            RyuUtils.Append0(result, precision - 9 * i);
                        }
                        break;
                    }
                    digits = RyuUtils.MulShiftMod1E9(mShift, RyuTables.POW10_SPLIT_2_D[p, 0],
                                                     RyuTables.POW10_SPLIT_2_D[p, 1], RyuTables.POW10_SPLIT_2_D[p, 2], j);
                    if (i < blocks - 1)
                    {
                        RyuUtils.Append9Digits(result, digits);
                    }
                    else
                    {
                        int  maximum   = precision - 9 * i;
                        uint lastDigit = RyuUtils.LastDigit(ref digits, 9 - maximum);
                        // Is m * 10^(additionalDigits + 1) / 2^(-e2) integer?
                        if (lastDigit > 5U)
                        {
                            roundFlag = 1;
                        }
                        else if (lastDigit < 5U)
                        {
                            roundFlag = 0;
                        }
                        else if (HasTrailingZeroes(exponent, precision + 1, mantissa))
                        {
                            roundFlag = 2;
                        }
                        else
                        {
                            roundFlag = 1;
                        }
                        if (maximum > 0)
                        {
                            RyuUtils.AppendCDigits(result, digits, maximum);
                        }
                        break;
                    }
                    p++;
                }
                if (roundFlag != 0 && RyuUtils.RoundResult(result, start, roundFlag,
                                                           out int decimalIndex, info))
                {
                    if (decimalIndex > 0)
                    {
                        result[decimalIndex++] = RyuUtils.ZERO;
                        result[decimalIndex]   = info.NumberDecimalSeparator[0];
                    }
                    result.Append(RyuUtils.ZERO);
                }
                if (soft && precision > 0)
                {
                    RyuUtils.SoftenResult(result, info);
                }
            }
            else if (!soft)
            {
                RyuUtils.Append0(result, precision);
            }
        }