Method format_float

include/fmt/format.h:3001–3288

template <typename Float>
FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs, buffer<char>& buf) -> int {
    // float is passed as double to reduce the number of instantiations.
    static_assert(!std::is_same<Float, float>::value, "");
    FMT_ASSERT(value >= 0, "value is negative");
    auto converted_value = convert_float(value);

    const bool fixed = specs.format == float_format::fixed;
    if (value <= 0) { // <= instead of == to silence a warning.
        if (precision <= 0 || !fixed) {
            buf.push_back('0');
            return 0;
        }
        buf.try_resize(to_unsigned(precision));
        fill_n(buf.data(), precision, '0');
        return -precision;
    }

    int exp = 0;
    bool use_dragon = true;
    unsigned dragon_flags = 0;
    if (!is_fast_float<Float>() || is_constant_evaluated()) {
        const auto inv_log2_10 = 0.3010299956639812; // 1 / log2(10)
        using info = dragonbox::float_info<decltype(converted_value)>;
        const auto f = basic_fp<typename info::carrier_uint>(converted_value);
        // Compute exp, an approximate power of 10, such that
        //   10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1).
        // This is based on log10(value) == log2(value) / log2(10) and approximation
        // of log2(value) by e + num_fraction_bits idea from double-conversion.
        auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10;
        exp = static_cast<int>(e);
        if (e > exp) ++exp; // Compute ceil.
        dragon_flags = dragon::fixup;
    } else if (precision < 0) {
        // Use Dragonbox for the shortest format.
        if (specs.binary32) {
            auto dec = dragonbox::to_decimal(static_cast<float>(value));
            write<char>(buffer_appender<char>(buf), dec.significand);
            return dec.exponent;
        }
        auto dec = dragonbox::to_decimal(static_cast<double>(value));
        write<char>(buffer_appender<char>(buf), dec.significand);
        return dec.exponent;
    } else {
        // Extract significand bits and exponent bits.
        using info = dragonbox::float_info<double>;
        auto br = bit_cast<uint64_t>(static_cast<double>(value));

        const uint64_t significand_mask = (static_cast<uint64_t>(1) << num_significand_bits<double>()) - 1;
        uint64_t significand = (br & significand_mask);
        int exponent = static_cast<int>((br & exponent_mask<double>()) >> num_significand_bits<double>());

        if (exponent != 0) { // Check if normal.
            exponent -= exponent_bias<double>() + num_significand_bits<double>();
            significand |= (static_cast<uint64_t>(1) << num_significand_bits<double>());
            significand <<= 1;
        } else {
            // Normalize subnormal inputs.
            FMT_ASSERT(significand != 0, "zeros should not appear here");