format_float()

fl::string fl::printf_detail::format_float ( float value, int precision )

inline

Definition at line 341 of file stdio.h.

                                                                      {
    // Non-finite first. These used to reach the integer cast below and print
    // as `-21474836.48` -- a plausible-looking number for a value that is not
    // a number at all.
    if (value != value) {
        return fl::string("nan");
    }
    if (!float_is_finite(value)) {
        return fl::string(value < 0.0f ? "-inf" : "inf");
    }
 
    if (precision < 0) {
        // Default precision - use sstream's default behavior
        sstream stream;
        stream << value;
        return stream.str();
    }
 
    // Past what an integer accumulator can hold, digit-by-digit rendering is
    // not available at all, so say so in a different shape rather than
    // printing a wrong number.
    if (value >= kFloatDecimalLimit || value <= -kFloatDecimalLimit) {
        return format_float_scientific(value, precision > 0 ? precision : 6);
    }
 
    const bool negative = value < 0.0f;
    const float magnitude = negative ? -value : value;
 
    // Split before scaling, not after. Multiplying the whole value by the
    // multiplier in float loses the low digits of a large integer part -- 1e9
    // at precision 2 came out as 999999979.52, because 1e11 is not
    // representable in a float. Only the fractional residue is scaled; the
    // integer part goes through as an integer.
    //
    // Above 2^24 a float has no fractional part, so the residue is exactly
    // zero there and the clamp below is for the rounding of the cast back,
    // not for a value that genuinely has digits to lose.
    fl::i64 int_part = static_cast<fl::i64>(magnitude);
    float residue = magnitude - static_cast<float>(int_part);
    if (residue < 0.0f) {
        residue = 0.0f;
    }
 
    if (precision == 0) {
        if (residue >= 0.5f) {
            ++int_part;
        }
        sstream stream;
        if (negative && int_part != 0) {
            stream << "-";
        }
        stream << int_part;
        return stream.str();
    }
 
    fl::i64 multiplier = 1;
    for (int i = 0; i < precision; ++i) {
        multiplier *= 10;
    }
 
    fl::i64 frac_part =
        static_cast<fl::i64>(residue * static_cast<float>(multiplier) + 0.5f);
    if (frac_part >= multiplier) {
        // Rounded up through the next whole unit.
        frac_part -= multiplier;
        ++int_part;
    }
 
    sstream stream;
    // The sign is printed from the sign of the input, not recovered from the
    // integer part, so -0.5 keeps its sign at precision 1.
    if (negative && (int_part != 0 || frac_part != 0)) {
        stream << "-";
    }
    stream << int_part;
    stream << ".";
 
    // Emit exactly `precision` fractional digits, zero-padded on the left.
    // The previous implementation stopped padding once temp_multiplier dropped
    // to 1, which produced "0.0"/"1.0" instead of "0.00"/"1.00" for any
    // integer-valued input. It also omitted the digits entirely when
    // frac_part == 0.
    fl::i64 temp_multiplier = multiplier / 10;
    while (temp_multiplier > 0) {
        const fl::i64 digit = (frac_part / temp_multiplier) % 10;
        stream << static_cast<char>('0' + static_cast<int>(digit));
        temp_multiplier /= 10;
    }
 
    return stream.str();
}

References fl::FL_NO_EXCEPT, float_is_finite(), format_float_scientific(), kFloatDecimalLimit, fl::sstream::str(), and fl::type_rank< T >::value.

Referenced by format_arg(), format_float_scientific(), format_floating(), and fl::ftoa().

Here is the call graph for this function:

Here is the caller graph for this function: