frequency.hpp

Go to the documentation of this file.

#pragma once
 
#include <assert.h>
#include <charconv>
#include <chrono>
#include <cmath>
#include <compare>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <limits>
#include <quanta/core.hpp>
#include <ratio>
#include <string>
#include <system_error>
#include <type_traits>
 
namespace quanta::frequency {
 
// The shared trait, re-exported for convenience; specialize quanta::treat_as_inexact.
using quanta::treat_as_inexact;
using quanta::treat_as_inexact_v;
 
template<typename Rep, typename Precision = std::ratio<1>>
class frequency;
 
template<typename T>
struct is_frequency : std::false_type {};
 
template<typename Rep, typename Precision>
struct is_frequency<frequency<Rep, Precision>> : std::true_type {};
 
template<typename T>
inline constexpr bool is_frequency_v = is_frequency<T>::value;
 
template<typename Rep>
concept not_frequency = !_is_specialization_of_v<Rep, frequency>;
 
template<typename T>
concept duration_like = _is_specialization_of_v<std::remove_cvref_t<T>, std::chrono::duration>;
 
template<typename T>
concept distance_like = !duration_like<T> && requires(T t) {
    { t.count() };
    typename T::period;
    typename T::rep;
};
 
template<typename Rep>
struct frequency_values {
    static constexpr Rep zero() noexcept { return Rep(0); }
 
    static constexpr Rep max() noexcept { return std::numeric_limits<Rep>::max(); }
 
    static constexpr Rep min() noexcept { return std::numeric_limits<Rep>::lowest(); }
};
 
template<typename Rep, typename Precision>
class frequency {
    static_assert(!is_frequency<Rep>::value, "rep cannot be a quanta::frequency::frequency");
    static_assert(_is_ratio<Precision>::value, "precision must be a specialization of std::ratio");
    static_assert(Precision::num > 0, "precision must be positive");
 
public:
    using rep = Rep;
    using precision = typename Precision::type;
 
    constexpr frequency() = default;
    frequency(const frequency&) = default;
 
    template<typename Rep2>
        requires std::convertible_to<const Rep2&, rep> && (treat_as_inexact_v<rep> || !treat_as_inexact_v<Rep2>)
    constexpr explicit frequency(const Rep2& r)
        : _r(static_cast<rep>(r)) {}
 
    template<typename Rep2, typename Precision2>
        requires std::convertible_to<const Rep2&, rep> &&
        detail::_lossless_conversion<Rep2, Precision2, rep, precision> &&
        detail::_quantity_castable<frequency<Rep2, Precision2>, frequency>
    constexpr frequency(const frequency<Rep2, Precision2>& f)
        : _r(frequency_cast<frequency>(f).count()) {}
 
    template<typename Rep2, typename Precision2>
        requires(!detail::_lossless_conversion<Rep2, Precision2, rep, precision> ||
                 !std::convertible_to<const Rep2&, rep>) &&
        detail::_quantity_castable<frequency<Rep2, Precision2>, frequency>
    constexpr explicit frequency(const frequency<Rep2, Precision2>& f)
        : _r(frequency_cast<frequency>(f).count()) {}
 
    ~frequency() = default;
    frequency& operator=(const frequency&) = default;
 
    constexpr rep count() const { return _r; }
 
    constexpr frequency<typename std::common_type<rep>::type, precision> operator+() const {
        return frequency<typename std::common_type<rep>::type, precision>(_r);
    }
 
    constexpr frequency<typename std::common_type<rep>::type, precision> operator-() const {
        return frequency<typename std::common_type<rep>::type, precision>(-_r);
    }
 
    constexpr frequency& operator++() {
        ++_r;
        return *this;
    }
 
    constexpr frequency operator++(int) { return frequency(_r++); }
 
    constexpr frequency& operator--() {
        --_r;
        return *this;
    }
 
    constexpr frequency operator--(int) { return frequency(_r--); }
 
    constexpr frequency& operator+=(const frequency& f) {
        _r += f.count();
        return *this;
    }
 
    constexpr frequency& operator-=(const frequency& f) {
        _r -= f.count();
        return *this;
    }
 
    constexpr frequency& operator*=(const rep& r) {
        _r *= r;
        return *this;
    }
 
    constexpr frequency& operator/=(const rep& r) {
        _r /= r;
        return *this;
    }
 
    constexpr frequency& operator%=(const rep& r)
        requires(!treat_as_inexact_v<rep>)
    {
        _r %= r;
        return *this;
    }
 
    constexpr frequency& operator%=(const frequency& f)
        requires(!treat_as_inexact_v<rep>)
    {
        _r %= f.count();
        return *this;
    }
 
    static constexpr frequency zero() noexcept { return frequency(frequency_values<rep>::zero()); }
 
    static constexpr frequency min() noexcept { return frequency(frequency_values<rep>::min()); }
 
    static constexpr frequency max() noexcept { return frequency(frequency_values<rep>::max()); }
 
    template<duration_like Duration>
    constexpr Duration period() const {
        // Period ratio is the inverse of frequency precision
        // For frequency<Rep, ratio<N,D>>, the period of 1 tick is ratio<D,N> seconds
        using period_ratio = std::ratio_divide<std::ratio<1>, precision>;
        using duration_period = typename Duration::period;
        using cf = std::ratio_divide<period_ratio, duration_period>;
        using duration_rep = typename Duration::rep;
 
        if (_r == rep(0)) {
            return Duration::max();
        }
 
        // Integer-only path when both types are integral
        if constexpr (std::is_integral_v<rep> && std::is_integral_v<duration_rep>) {
            using wider_t = detail::_conversion_integer<rep, duration_rep>;
 
            wider_t count = static_cast<wider_t>(_r);
 
            if constexpr (cf::den == 1 && cf::num == 1) {
                // period_ticks = 1 / freq_count (in the target duration units)
                return Duration(static_cast<duration_rep>(1 / count));
            } else if constexpr (cf::den == 1) {
                // period_ticks = num / freq_count
                // Use GCD: g = gcd(num, count), then (num/g) / (count/g)
                wider_t num = static_cast<wider_t>(cf::num);
                wider_t g = _runtime_gcd(num, count);
                wider_t reduced_num = num / g;
                wider_t reduced_count = count / g;
                return Duration(static_cast<duration_rep>(reduced_num / reduced_count));
            } else if constexpr (cf::num == 1) {
                // period_ticks = 1 / (freq_count * den)
                wider_t denom = count * static_cast<wider_t>(cf::den);
                return Duration(static_cast<duration_rep>(1 / denom));
            } else {
                // period_ticks = num / (freq_count * den)
                // Use GCD: g = gcd(num, count), then (num/g) / ((count/g) * den)
                wider_t num = static_cast<wider_t>(cf::num);
                wider_t g = _runtime_gcd(num, count);
                wider_t reduced_num = num / g;
                wider_t reduced_count = count / g;
                wider_t denom = reduced_count * static_cast<wider_t>(cf::den);
                return Duration(static_cast<duration_rep>(reduced_num / denom));
            }
        } else {
            // Floating-point path
            using cr = std::common_type_t<duration_rep, double>;
 
            if constexpr (cf::den == 1 && cf::num == 1) {
                return Duration(static_cast<duration_rep>(1.0 / static_cast<double>(_r)));
            } else if constexpr (cf::den == 1) {
                return Duration(static_cast<duration_rep>(static_cast<cr>(cf::num) / static_cast<double>(_r)));
            } else if constexpr (cf::num == 1) {
                return Duration(static_cast<duration_rep>(1.0 / (static_cast<double>(_r) * static_cast<cr>(cf::den))));
            } else {
                return Duration(
                    static_cast<duration_rep>(
                        static_cast<cr>(cf::num) / (static_cast<double>(_r) * static_cast<cr>(cf::den))
                    )
                );
            }
        }
    }
 
    constexpr frequency harmonic(unsigned int n) const { return *this * n; }
 
    constexpr frequency subharmonic(unsigned int n) const {
        assert(n > 0 && "subharmonic divisor must be positive");
        return *this / n;
    }
 
    template<typename T = double>
    frequency octave_shift(T octaves) const {
        double multiplier = std::pow(2.0, static_cast<double>(octaves));
        if constexpr (std::is_integral_v<rep>) {
            return frequency(static_cast<rep>(std::round(static_cast<double>(_r) * multiplier)));
        } else {
            return frequency(static_cast<rep>(static_cast<double>(_r) * multiplier));
        }
    }
 
    template<typename T = double>
    frequency semitone_shift(T semitones) const {
        double multiplier = std::pow(2.0, static_cast<double>(semitones) / 12.0);
        if constexpr (std::is_integral_v<rep>) {
            return frequency(static_cast<rep>(std::round(static_cast<double>(_r) * multiplier)));
        } else {
            return frequency(static_cast<rep>(static_cast<double>(_r) * multiplier));
        }
    }
 
    template<typename T = double>
    T octaves_from(const frequency& other) const {
        return static_cast<T>(std::log2(static_cast<double>(_r) / static_cast<double>(other._r)));
    }
 
    template<typename T = double>
    T semitones_from(const frequency& other) const {
        return static_cast<T>(12.0 * std::log2(static_cast<double>(_r) / static_cast<double>(other._r)));
    }
 
    template<distance_like Distance, duration_like Duration>
    constexpr Distance wavelength(const Duration& time_per_unit_distance) const {
        // Get the period of this frequency
        using period_rep = double;
        using period_ratio = std::ratio_divide<std::ratio<1>, precision>;
 
        if (_r == rep(0)) {
            return Distance::max();
        }
 
        // Calculate period in our internal representation (1/frequency)
        period_rep wave_period = 1.0 / static_cast<double>(_r);
 
        // Convert to common time representation
        using duration_period = typename Duration::period;
        using time_cf = std::ratio_divide<period_ratio, duration_period>;
        using time_cr = std::common_type_t<period_rep, typename Duration::rep, double>;
 
        // Calculate period in time_per_unit_distance units
        time_cr period_in_duration_units;
        if constexpr (time_cf::den == 1 && time_cf::num == 1) {
            period_in_duration_units = static_cast<time_cr>(wave_period);
        } else if constexpr (time_cf::den == 1) {
            period_in_duration_units = static_cast<time_cr>(wave_period) * static_cast<time_cr>(time_cf::num);
        } else if constexpr (time_cf::num == 1) {
            period_in_duration_units = static_cast<time_cr>(wave_period) / static_cast<time_cr>(time_cf::den);
        } else {
            period_in_duration_units = static_cast<time_cr>(wave_period) * static_cast<time_cr>(time_cf::num) /
                static_cast<time_cr>(time_cf::den);
        }
 
        // Wavelength = period / time_per_unit_distance
        double wavelength_count = period_in_duration_units / static_cast<double>(time_per_unit_distance.count());
 
        return Distance(static_cast<typename Distance::rep>(wavelength_count));
    }
 
    template<distance_like Distance>
    constexpr Distance wavelength(double velocity = 299792458.0) const {
        if (_r == rep(0)) {
            return Distance::max();
        }
 
        // Convert frequency to Hz
        double freq_hz = detail::_ratio_value<precision>(_r);
 
        // Calculate wavelength in meters: wavelength = velocity / frequency
        double wavelength_meters = velocity / freq_hz;
 
        // Convert from meters to the target distance type's units
        // Distance::period represents the ratio of the distance unit to meters
        using distance_period = typename Distance::period;
        double wavelength_in_units =
            wavelength_meters * static_cast<double>(distance_period::den) / static_cast<double>(distance_period::num);
 
        return Distance(static_cast<typename Distance::rep>(wavelength_in_units));
    }
 
private:
    rep _r{};
};
 
template<typename ToFreq, typename Rep, typename Precision>
    requires detail::_quantity_cast_requirements<frequency<Rep, Precision>, ToFreq>
constexpr ToFreq frequency_cast(const frequency<Rep, Precision>& f) {
    return detail::_quantity_cast<ToFreq>(f);
}
 
template<typename ToFreq, typename Rep, typename Precision>
constexpr ToFreq floor(const frequency<Rep, Precision>& f) {
    return detail::_floor_cast(frequency_cast<ToFreq>(f), f);
}
 
template<typename ToFreq, typename Rep, typename Precision>
constexpr ToFreq ceil(const frequency<Rep, Precision>& f) {
    return detail::_ceil_cast(frequency_cast<ToFreq>(f), f);
}
 
template<typename ToFreq, typename Rep, typename Precision>
constexpr ToFreq trunc(const frequency<Rep, Precision>& f) {
    return frequency_cast<ToFreq>(f);
}
 
template<typename ToFreq, typename Rep, typename Precision>
constexpr ToFreq round(const frequency<Rep, Precision>& f) {
    return detail::_round_cast<ToFreq>(f, [&f] { return floor<ToFreq>(f); });
}
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
constexpr auto beat(const frequency<Rep1, Precision1>& f1, const frequency<Rep2, Precision2>& f2)
    -> std::common_type_t<frequency<Rep1, Precision1>, frequency<Rep2, Precision2>> {
    using cf = std::common_type_t<frequency<Rep1, Precision1>, frequency<Rep2, Precision2>>;
    return abs(cf(f1) - cf(f2));
}
 
template<typename Rep, typename Precision>
constexpr frequency<Rep, Precision> abs(const frequency<Rep, Precision>& f) {
    return detail::_abs(f);
}
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
constexpr auto operator+(const frequency<Rep1, Precision1>& lhs, const frequency<Rep2, Precision2>& rhs)
    -> std::common_type_t<frequency<Rep1, Precision1>, frequency<Rep2, Precision2>> {
    using cf = std::common_type_t<frequency<Rep1, Precision1>, frequency<Rep2, Precision2>>;
    return cf(cf(lhs).count() + cf(rhs).count());
}
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
constexpr auto operator-(const frequency<Rep1, Precision1>& lhs, const frequency<Rep2, Precision2>& rhs)
    -> std::common_type_t<frequency<Rep1, Precision1>, frequency<Rep2, Precision2>> {
    using cf = std::common_type_t<frequency<Rep1, Precision1>, frequency<Rep2, Precision2>>;
    return cf(cf(lhs).count() - cf(rhs).count());
}
 
template<typename Rep1, typename Precision, typename Rep2>
    requires not_frequency<Rep2> && std::convertible_to<const Rep2&, std::common_type_t<Rep1, Rep2>>
constexpr auto operator*(const frequency<Rep1, Precision>& f, const Rep2& r)
    -> frequency<std::common_type_t<Rep1, Rep2>, Precision> {
    using cf = frequency<std::common_type_t<Rep1, Rep2>, Precision>;
    return cf(cf(f).count() * r);
}
 
template<typename Rep1, typename Rep2, typename Precision>
    requires not_frequency<Rep1> && std::convertible_to<const Rep1&, std::common_type_t<Rep1, Rep2>>
constexpr auto operator*(const Rep1& r, const frequency<Rep2, Precision>& f)
    -> frequency<std::common_type_t<Rep1, Rep2>, Precision> {
    return f * r;
}
 
template<typename Rep1, typename Precision, typename Rep2>
    requires not_frequency<Rep2> && std::convertible_to<const Rep2&, std::common_type_t<Rep1, Rep2>>
constexpr auto operator/(const frequency<Rep1, Precision>& f, const Rep2& s)
    -> frequency<std::common_type_t<Rep1, Rep2>, Precision> {
    using cf = frequency<std::common_type_t<Rep1, Rep2>, Precision>;
    return cf(cf(f).count() / s);
}
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
constexpr auto operator/(const frequency<Rep1, Precision1>& lhs, const frequency<Rep2, Precision2>& rhs)
    -> std::common_type_t<Rep1, Rep2> {
    using cf = std::common_type_t<frequency<Rep1, Precision1>, frequency<Rep2, Precision2>>;
    return cf(lhs).count() / cf(rhs).count();
}
 
template<typename Rep1, typename Precision, typename Rep2>
    requires not_frequency<Rep2> && std::convertible_to<const Rep2&, std::common_type_t<Rep1, Rep2>> &&
    (!treat_as_inexact_v<Rep1> && !treat_as_inexact_v<Rep2>)
constexpr auto operator%(const frequency<Rep1, Precision>& f, const Rep2& s)
    -> frequency<std::common_type_t<Rep1, Rep2>, Precision> {
    using cf = frequency<std::common_type_t<Rep1, Rep2>, Precision>;
    return cf(cf(f).count() % s);
}
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
    requires(!treat_as_inexact_v<Rep1> && !treat_as_inexact_v<Rep2>)
constexpr auto operator%(const frequency<Rep1, Precision1>& lhs, const frequency<Rep2, Precision2>& rhs)
    -> std::common_type_t<frequency<Rep1, Precision1>, frequency<Rep2, Precision2>> {
    using cf = std::common_type_t<frequency<Rep1, Precision1>, frequency<Rep2, Precision2>>;
    return cf(cf(lhs).count() % cf(rhs).count());
}
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
constexpr bool operator==(const frequency<Rep1, Precision1>& lhs, const frequency<Rep2, Precision2>& rhs) {
    using ct = std::common_type_t<frequency<Rep1, Precision1>, frequency<Rep2, Precision2>>;
    return ct(lhs).count() == ct(rhs).count();
}
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
    requires std::three_way_comparable<std::common_type_t<Rep1, Rep2>>
constexpr auto operator<=>(const frequency<Rep1, Precision1>& lhs, const frequency<Rep2, Precision2>& rhs) {
    using ct = std::common_type_t<frequency<Rep1, Precision1>, frequency<Rep2, Precision2>>;
    return ct(lhs).count() <=> ct(rhs).count();
}
 
using millihertz = frequency<int64_t, std::milli>;
using hertz = frequency<int64_t>;
using kilohertz = frequency<int64_t, std::kilo>;
using megahertz = frequency<int64_t, std::mega>;
using gigahertz = frequency<int64_t, std::giga>;
using terahertz = frequency<int64_t, std::tera>;
 
 
// SI prefix for a hertz-per-count ratio; nullptr when unmapped.
template<typename Ratio>
struct _si_prefix {
    static constexpr const char* value = nullptr;
};
template<>
struct _si_prefix<std::femto> {
    static constexpr const char* value = "f";
};
template<>
struct _si_prefix<std::pico> {
    static constexpr const char* value = "p";
};
template<>
struct _si_prefix<std::nano> {
    static constexpr const char* value = "n";
};
template<>
struct _si_prefix<std::micro> {
    static constexpr const char* value = "µ";
};
template<>
struct _si_prefix<std::milli> {
    static constexpr const char* value = "m";
};
template<>
struct _si_prefix<std::ratio<1>> {
    static constexpr const char* value = "";
};
template<>
struct _si_prefix<std::kilo> {
    static constexpr const char* value = "k";
};
template<>
struct _si_prefix<std::mega> {
    static constexpr const char* value = "M";
};
template<>
struct _si_prefix<std::giga> {
    static constexpr const char* value = "G";
};
template<>
struct _si_prefix<std::tera> {
    static constexpr const char* value = "T";
};
template<typename Ratio>
inline constexpr const char* _si_prefix_v = _si_prefix<typename Ratio::type>::value;
 
// A value and SI prefix (of hertz) to display, for the base-unit and scaled
// forms.
struct _display {
    double value;
    const char* prefix;
};
 
// Precisions that are exactly a power of ten of one hertz, whether or not
// they have an SI prefix (std::deci and std::deca do not).
template<typename Precision>
concept _decimal_precision = detail::_power_of_ten_precision<Precision>;
 
// The frequency in hertz, as a double.
template<typename Rep, typename Precision>
_display _base_unit_display(const frequency<Rep, Precision>& f) {
    using p = typename frequency<Rep, Precision>::precision;
    return {detail::_ratio_value<p>(f.count()), _si_prefix_v<std::ratio<1>>};
}
 
// The frequency with the largest SI prefix in which its magnitude is at least
// 1, else the smallest; zero (keeping its sign) and non-finite values are
// shown in hertz, as the base-unit form would show them. For a power-of-ten precision each candidate's
// value is computed from the count with a single scaling by a power of ten, so
// values that land exactly on a prefix (1000 Hz) are exactly 1 in it; other
// precisions are scaled from their value in hertz.
template<typename Rep, typename Precision>
_display _scaled_display(const frequency<Rep, Precision>& f) {
    using p = typename frequency<Rep, Precision>::precision;
    double x;
    int exponent;
    if constexpr (_decimal_precision<p>) {
        x = static_cast<double>(f.count());
        exponent = _precision_exponent<p>;
    } else {
        x = _base_unit_display(f).value;
        exponent = 0;
    }
    if (x == 0 || !std::isfinite(x)) {
        return {x, _si_prefix_v<std::ratio<1>>};
    }
    // The prefixes _si_prefix maps, femto to tera
    const detail::_scaled s = detail::_pick_scale(x, exponent, detail::_si_scale);
    return {s.value, s.label};
}
 
#if CONFIG_QUANTA_STD_FORMAT
// How std::format renders a frequency of the given (reduced) precision; see
// detail::_unit_formatter. A precision with no SI prefix has no own unit.
template<typename Precision>
struct _format_traits {
    static constexpr const char* markers = "bs";
    static constexpr bool has_own_unit = _si_prefix_v<Precision> != nullptr;
 
    // Reports "{}" for a precision with no own unit. The parameter only gives
    // the function a path that is a constant expression, as a constexpr
    // function needs; the formatter always calls it with true.
    static constexpr void no_own_unit_error(bool fail = true) {
        if (fail) {
            _format_error("frequency: precision has no SI prefix; use an explicit format spec");
        }
    }
 
    // The own unit is written from constants; there is nothing to obtain.
    static constexpr bool own_unit(bool power) { return power; }
 
    template<typename OutputIt>
    static OutputIt append_own_unit(OutputIt out, bool) {
        out = _format_append(out, _si_prefix_v<Precision>);
        return _format_append(out, "Hz");
    }
 
    template<typename F>
    static _display base_display(const F& f) {
        return _base_unit_display(f);
    }
 
    template<typename F>
    static _display scaled_display(const F& f) {
        return _scaled_display(f);
    }
 
    template<typename OutputIt>
    static OutputIt append_label(OutputIt out, const _display& d) {
        out = _format_append(out, d.prefix);
        return _format_append(out, "Hz");
    }
};
#endif
 
using quanta::base_unit;
using quanta::base_unit_t;
 
using quanta::scaled;
using quanta::scaled_t;
 
template<typename Rep, typename Precision>
std::string to_string(const frequency<Rep, Precision>& f) {
    using precision = typename frequency<Rep, Precision>::precision;
    static_assert(_si_prefix_v<precision> != nullptr, "frequency: precision has no SI prefix");
    return _count_string(f.count()) + _si_prefix_v<precision> + "Hz";
}
 
template<typename Rep, typename Precision>
std::string to_string(const frequency<Rep, Precision>& f, base_unit_t) {
    const _display d = _base_unit_display(f);
    return _fixed_string(d.value) + d.prefix + "Hz";
}
 
template<typename Rep, typename Precision>
std::string to_string(const frequency<Rep, Precision>& f, scaled_t) {
    const _display d = _scaled_display(f);
    return _fixed_string(d.value) + d.prefix + "Hz";
}
 
} // namespace quanta::frequency
 
namespace std {
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
struct common_type<quanta::frequency::frequency<Rep1, Precision1>, quanta::frequency::frequency<Rep2, Precision2>> {
private:
    using common_precision = quanta::detail::_common_precision<Precision1, Precision2>;
 
public:
    using type = quanta::frequency::frequency<std::common_type_t<Rep1, Rep2>, common_precision>;
};
 
#if CONFIG_QUANTA_STD_FORMAT
// "{}" prints the exact stored count with a precision-qualified unit
// (kilohertz(433) -> "433kHz"; floating-point counts in the shortest fixed
// notation that round-trips, as to_string does: frequency<double>(1e6) ->
// "1000000Hz", never "1e+06Hz"). A non-empty spec controls only how the number
// is rendered (as double), never the unit, so both forms use the same unit:
// std::format("{:.1f}", millihertz(1500)) == "1500.0mHz".
//
// The unit changes only when the spec opts in with a single leading marker
// letter; the rest of the spec is then handled as above:
// - 'b' (base unit, see quanta::base_unit) shows the value in hertz:
//   std::format("{:b.1f}", millihertz(1500)) == "1.5Hz".
// - 's' (scaled, see quanta::scaled) shows the value with the SI prefix suited
//   to its magnitude: std::format("{:s}", megahertz(2400)) == "2.4GHz".
// With 'b' or 's' and nothing after the marker, the value is rendered in the
// shortest fixed notation that round-trips (never scientific), exactly as by
// to_string(f, quanta::base_unit) or to_string(f, quanta::scaled):
// std::format("{:b}", millihertz(24)) == "0.024Hz".
//
// A spec starting with 'b' or 's' is always a marker, so these letters cannot
// be the fill character of a spec that starts with a fill ("{:s>10.1f}" is the
// marker followed by ">10.1f").
//
// A precision with no SI prefix (e.g. std::deci) has no unit of its own: "{}"
// is a format error (a compile error for a constant format string), and a spec
// without a marker renders the value in hertz, as 'b' does:
// std::format("{:.1f}", frequency<int64_t, std::deci>(225)) == "22.5Hz".
template<typename Rep, typename Precision>
struct formatter<quanta::frequency::frequency<Rep, Precision>>
    : private quanta::detail::_unit_formatter<
          quanta::frequency::_format_traits<typename quanta::frequency::frequency<Rep, Precision>::precision>> {
    using quanta::detail::_unit_formatter<
        quanta::frequency::_format_traits<typename quanta::frequency::frequency<Rep, Precision>::precision>>::parse;
 
    template<typename FormatContext>
    auto format(const quanta::frequency::frequency<Rep, Precision>& f, FormatContext& ctx) const {
        return this->format_quantity(f, ctx);
    }
};
#endif
 
} // namespace std
 
namespace quanta {
inline namespace literals {
inline namespace frequency_literals {
template<char... Digits>
constexpr quanta::frequency::millihertz operator""_mHz() {
    return detail::check_overflow<quanta::frequency::millihertz, Digits...>();
}
 
template<char... Digits>
constexpr quanta::frequency::hertz operator""_Hz() {
    return detail::check_overflow<quanta::frequency::hertz, Digits...>();
}
 
template<char... Digits>
constexpr quanta::frequency::kilohertz operator""_kHz() {
    return detail::check_overflow<quanta::frequency::kilohertz, Digits...>();
}
 
template<char... Digits>
constexpr quanta::frequency::megahertz operator""_MHz() {
    return detail::check_overflow<quanta::frequency::megahertz, Digits...>();
}
 
template<char... Digits>
constexpr quanta::frequency::gigahertz operator""_GHz() {
    return detail::check_overflow<quanta::frequency::gigahertz, Digits...>();
}
 
template<char... Digits>
constexpr quanta::frequency::terahertz operator""_THz() {
    return detail::check_overflow<quanta::frequency::terahertz, Digits...>();
}
 
} // namespace frequency_literals
} // namespace literals
 
namespace frequency {
using namespace literals::frequency_literals;
} // namespace frequency
} // namespace quanta