electro.hpp

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <compare>
#include <concepts>
#include <cstdint>
#include <limits>
#include <ratio>
#include <string>
#ifndef CONFIG_ELECTRO_STD_FORMAT
#if __has_include(<format>) && defined(__cpp_lib_format)
#define CONFIG_ELECTRO_STD_FORMAT 1
#else
#define CONFIG_ELECTRO_STD_FORMAT 0
#endif
#endif
 
#if CONFIG_ELECTRO_STD_FORMAT
#include <format>
#endif
#include <assert.h>
 
namespace electro {
 
template<typename Unit, typename Rep, typename Precision = std::ratio<1>>
class quantity;
 
template<typename T>
struct is_quantity : std::false_type {};
 
template<typename Unit, typename Rep, typename Precision>
struct is_quantity<quantity<Unit, Rep, Precision>> : std::true_type {};
 
template<typename T>
inline constexpr bool is_quantity_v = is_quantity<T>::value;
 
template<typename Rep>
concept not_quantity = !is_quantity_v<Rep>;
 
template<typename T>
concept duration_like = requires(T t) {
    { t.count() };
    typename T::period;
    typename T::rep;
} && !is_quantity_v<T>;
template<typename Rep>
struct quantity_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 T>
struct _is_ratio : std::false_type {};
 
template<std::intmax_t Num, std::intmax_t Denom>
struct _is_ratio<std::ratio<Num, Denom>> : std::true_type {};
 
template<typename T>
struct treat_as_inexact : std::bool_constant<std::floating_point<T>> {};
 
template<typename T>
inline constexpr bool treat_as_inexact_v = treat_as_inexact<T>::value;
 
consteval intmax_t _gcd(intmax_t m, intmax_t n) noexcept {
    while (n != 0) {
        intmax_t rem = m % n;
        m = n;
        n = rem;
    }
    return m;
}
 
// Runtime GCD for integer types (using Euclidean algorithm)
template<typename T>
constexpr T _runtime_gcd(T m, T n) noexcept {
    if (m < 0) {
        m = -m;
    }
    if (n < 0) {
        n = -n;
    }
    while (n != 0) {
        T rem = m % n;
        m = n;
        n = rem;
    }
    return m;
}
 
template<typename R1, typename R2>
inline constexpr intmax_t _safe_ratio_divide_den = [] {
    constexpr intmax_t g1 = _gcd(R1::num, R2::num);
    constexpr intmax_t g2 = _gcd(R1::den, R2::den);
    return (R1::den / g2) * (R2::num / g1);
}();
 
template<typename From, typename To>
concept _harmonic_precision = _safe_ratio_divide_den<From, To> == 1;
// ============================================================================
// Units
// ============================================================================
 
struct volt_unit {
    static constexpr const char* symbol = "V";
};
 
struct ampere_unit {
    static constexpr const char* symbol = "A";
};
 
struct ohm_unit {
    static constexpr const char* symbol = "Ω";
};
 
struct watt_unit {
    static constexpr const char* symbol = "W";
};
 
struct coulomb_unit {
    static constexpr const char* symbol = "C";
};
 
struct joule_unit {
    static constexpr const char* symbol = "J";
};
 
struct farad_unit {
    static constexpr const char* symbol = "F";
};
 
struct henry_unit {
    static constexpr const char* symbol = "H";
};
 
 
template<typename Unit, typename Rep, typename Precision>
class quantity {
    static_assert(!is_quantity_v<Rep>, "rep cannot be an electro::quantity");
    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 unit = Unit;
    using rep = Rep;
    using precision = typename Precision::type;
 
    constexpr quantity() = default;
    quantity(const quantity&) = default;
 
    template<typename Rep2>
        requires std::convertible_to<const Rep2&, rep> && (treat_as_inexact_v<rep> || !treat_as_inexact_v<Rep2>)
    constexpr explicit quantity(const Rep2& r)
        : _r(static_cast<rep>(r)) {}
 
    template<typename Rep2, typename Precision2>
        requires std::convertible_to<const Rep2&, rep> &&
        (treat_as_inexact_v<rep> || (_harmonic_precision<Precision2, precision> && !treat_as_inexact_v<Rep2>))
    constexpr quantity(const quantity<Unit, Rep2, Precision2>& q)
        : _r(quantity_cast<quantity>(q).count()) {}
 
    template<typename Rep2, typename Precision2>
        requires(!std::is_same_v<quantity, quantity<Unit, Rep2, Precision2>>) && (!treat_as_inexact_v<rep>) &&
        (!_harmonic_precision<Precision2, precision>)
    constexpr explicit quantity(const quantity<Unit, Rep2, Precision2>& q)
        : _r(quantity_cast<quantity>(q).count()) {}
 
    ~quantity() = default;
    quantity& operator=(const quantity&) = default;
 
    constexpr rep count() const { return _r; }
 
    constexpr quantity<Unit, typename std::common_type<rep>::type, precision> operator+() const {
        return quantity<Unit, typename std::common_type<rep>::type, precision>(_r);
    }
 
    constexpr quantity<Unit, typename std::common_type<rep>::type, precision> operator-() const {
        return quantity<Unit, typename std::common_type<rep>::type, precision>(-_r);
    }
 
    constexpr quantity& operator++() {
        ++_r;
        return *this;
    }
 
    constexpr quantity operator++(int) { return quantity(_r++); }
 
    constexpr quantity& operator--() {
        --_r;
        return *this;
    }
 
    constexpr quantity operator--(int) { return quantity(_r--); }
 
    constexpr quantity& operator+=(const quantity& q) {
        _r += q.count();
        return *this;
    }
 
    constexpr quantity& operator-=(const quantity& q) {
        _r -= q.count();
        return *this;
    }
 
    constexpr quantity& operator*=(const rep& r) {
        _r *= r;
        return *this;
    }
 
    constexpr quantity& operator/=(const rep& r) {
        _r /= r;
        return *this;
    }
 
    constexpr quantity& operator%=(const rep& r)
        requires(!treat_as_inexact_v<rep>)
    {
        _r %= r;
        return *this;
    }
 
    constexpr quantity& operator%=(const quantity& q)
        requires(!treat_as_inexact_v<rep>)
    {
        _r %= q.count();
        return *this;
    }
 
    static constexpr quantity zero() noexcept { return quantity(quantity_values<rep>::zero()); }
 
    static constexpr quantity min() noexcept { return quantity(quantity_values<rep>::min()); }
 
    static constexpr quantity max() noexcept { return quantity(quantity_values<rep>::max()); }
 
private:
    rep _r{};
};
 
template<typename ToQuantity, typename Unit, typename Rep, typename Precision>
constexpr ToQuantity quantity_cast(const quantity<Unit, Rep, Precision>& q) {
    static_assert(
        std::is_same_v<typename ToQuantity::unit, Unit>, "quantity_cast cannot convert between different units"
    );
    if constexpr (std::is_same_v<ToQuantity, quantity<Unit, Rep, Precision>>) {
        return q;
    } else {
        using to_rep = typename ToQuantity::rep;
        using to_precision = typename ToQuantity::precision;
        using cf = std::ratio_divide<Precision, to_precision>;
 
        // Use wider intermediate type for integer-to-integer conversions
        if constexpr (std::is_integral_v<Rep> && std::is_integral_v<to_rep>) {
#ifdef __SIZEOF_INT128__
            using cr = std::common_type_t<to_rep, Rep, intmax_t>;
            using wider_t = std::conditional_t<std::is_signed_v<cr>, __int128, unsigned __int128>;
#else
            using wider_t = intmax_t;
#endif
 
            if constexpr (cf::den == 1 && cf::num == 1) {
                return ToQuantity(static_cast<to_rep>(q.count()));
            } else if constexpr (cf::den == 1) {
                wider_t result = static_cast<wider_t>(q.count()) * static_cast<wider_t>(cf::num);
                return ToQuantity(static_cast<to_rep>(result));
            } else if constexpr (cf::num == 1) {
                wider_t result = static_cast<wider_t>(q.count()) / static_cast<wider_t>(cf::den);
                return ToQuantity(static_cast<to_rep>(result));
            } else {
                // Use GCD to reduce operands: count * num / den
                wider_t count = static_cast<wider_t>(q.count());
                wider_t den = static_cast<wider_t>(cf::den);
                wider_t g = _runtime_gcd(count, den);
                wider_t reduced_count = count / g;
                wider_t reduced_den = den / g;
                wider_t result = reduced_count * static_cast<wider_t>(cf::num) / reduced_den;
                return ToQuantity(static_cast<to_rep>(result));
            }
        } else {
            // Floating-point path
            using cr = std::common_type_t<to_rep, Rep, intmax_t>;
            if constexpr (cf::den == 1 && cf::num == 1) {
                return ToQuantity(static_cast<to_rep>(q.count()));
            } else if constexpr (cf::den == 1) {
                return ToQuantity(static_cast<to_rep>(static_cast<cr>(q.count()) * static_cast<cr>(cf::num)));
            } else if constexpr (cf::num == 1) {
                return ToQuantity(static_cast<to_rep>(static_cast<cr>(q.count()) / static_cast<cr>(cf::den)));
            } else {
                return ToQuantity(
                    static_cast<to_rep>(
                        static_cast<cr>(q.count()) * static_cast<cr>(cf::num) / static_cast<cr>(cf::den)
                    )
                );
            }
        }
    }
}
 
template<typename ToQuantity, typename Unit, typename Rep, typename Precision>
constexpr ToQuantity floor(const quantity<Unit, Rep, Precision>& q) {
    using to_rep = typename ToQuantity::rep;
    ToQuantity result = quantity_cast<ToQuantity>(q);
 
    if constexpr (std::is_integral_v<Rep> && std::is_integral_v<to_rep>) {
        if (result > q) {
            return ToQuantity(result.count() - to_rep(1));
        }
    }
 
    return result;
}
 
template<typename ToQuantity, typename Unit, typename Rep, typename Precision>
constexpr ToQuantity ceil(const quantity<Unit, Rep, Precision>& q) {
    using to_rep = typename ToQuantity::rep;
    ToQuantity result = quantity_cast<ToQuantity>(q);
 
    if constexpr (std::is_integral_v<Rep> && std::is_integral_v<to_rep>) {
        if (result < q) {
            return ToQuantity(result.count() + to_rep(1));
        }
    }
 
    return result;
}
 
template<typename ToQuantity, typename Unit, typename Rep, typename Precision>
constexpr ToQuantity round(const quantity<Unit, Rep, Precision>& q) {
    using to_rep = typename ToQuantity::rep;
 
    if constexpr (std::is_integral_v<Rep> && std::is_integral_v<to_rep>) {
        ToQuantity lower = floor<ToQuantity>(q);
        ToQuantity upper = lower + ToQuantity(to_rep(1));
 
        auto diff_lower = q - lower;
        auto diff_upper = upper - q;
 
        if (diff_lower < diff_upper) {
            return lower;
        } else if (diff_lower > diff_upper) {
            return upper;
        } else {
            // Tie: round to even
            return (lower.count() % to_rep(2) == to_rep(0)) ? lower : upper;
        }
    } else {
        return quantity_cast<ToQuantity>(q);
    }
}
 
template<typename Unit, typename Rep, typename Precision>
constexpr quantity<Unit, Rep, Precision> abs(const quantity<Unit, Rep, Precision>& q) {
    return q >= quantity<Unit, Rep, Precision>::zero() ? q : -q;
}
 
// ============================================================================
// Same-unit arithmetic
// ============================================================================
 
template<typename Unit, typename Rep1, typename Precision1, typename Rep2, typename Precision2>
constexpr auto operator+(const quantity<Unit, Rep1, Precision1>& lhs, const quantity<Unit, Rep2, Precision2>& rhs)
    -> std::common_type_t<quantity<Unit, Rep1, Precision1>, quantity<Unit, Rep2, Precision2>> {
    using cq = std::common_type_t<quantity<Unit, Rep1, Precision1>, quantity<Unit, Rep2, Precision2>>;
    return cq(cq(lhs).count() + cq(rhs).count());
}
 
template<typename Unit, typename Rep1, typename Precision1, typename Rep2, typename Precision2>
constexpr auto operator-(const quantity<Unit, Rep1, Precision1>& lhs, const quantity<Unit, Rep2, Precision2>& rhs)
    -> std::common_type_t<quantity<Unit, Rep1, Precision1>, quantity<Unit, Rep2, Precision2>> {
    using cq = std::common_type_t<quantity<Unit, Rep1, Precision1>, quantity<Unit, Rep2, Precision2>>;
    return cq(cq(lhs).count() - cq(rhs).count());
}
 
template<typename Unit, typename Rep1, typename Precision, typename Rep2>
    requires not_quantity<Rep2> && std::convertible_to<const Rep2&, std::common_type_t<Rep1, Rep2>>
constexpr auto operator*(const quantity<Unit, Rep1, Precision>& q, const Rep2& r)
    -> quantity<Unit, std::common_type_t<Rep1, Rep2>, Precision> {
    using cq = quantity<Unit, std::common_type_t<Rep1, Rep2>, Precision>;
    return cq(cq(q).count() * r);
}
 
template<typename Unit, typename Rep1, typename Rep2, typename Precision>
    requires not_quantity<Rep1> && std::convertible_to<const Rep1&, std::common_type_t<Rep1, Rep2>>
constexpr auto operator*(const Rep1& r, const quantity<Unit, Rep2, Precision>& q)
    -> quantity<Unit, std::common_type_t<Rep1, Rep2>, Precision> {
    return q * r;
}
 
template<typename Unit, typename Rep1, typename Precision, typename Rep2>
    requires not_quantity<Rep2> && std::convertible_to<const Rep2&, std::common_type_t<Rep1, Rep2>>
constexpr auto operator/(const quantity<Unit, Rep1, Precision>& q, const Rep2& s)
    -> quantity<Unit, std::common_type_t<Rep1, Rep2>, Precision> {
    using cq = quantity<Unit, std::common_type_t<Rep1, Rep2>, Precision>;
    return cq(cq(q).count() / s);
}
 
template<typename Unit, typename Rep1, typename Precision1, typename Rep2, typename Precision2>
constexpr auto operator/(const quantity<Unit, Rep1, Precision1>& lhs, const quantity<Unit, Rep2, Precision2>& rhs)
    -> std::common_type_t<Rep1, Rep2> {
    using cq = std::common_type_t<quantity<Unit, Rep1, Precision1>, quantity<Unit, Rep2, Precision2>>;
    return cq(lhs).count() / cq(rhs).count();
}
 
template<typename Unit, typename Rep1, typename Precision, typename Rep2>
    requires not_quantity<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 quantity<Unit, Rep1, Precision>& q, const Rep2& s)
    -> quantity<Unit, std::common_type_t<Rep1, Rep2>, Precision> {
    using cq = quantity<Unit, std::common_type_t<Rep1, Rep2>, Precision>;
    return cq(cq(q).count() % s);
}
 
template<typename Unit, typename Rep1, typename Precision1, typename Rep2, typename Precision2>
    requires(!treat_as_inexact_v<Rep1> && !treat_as_inexact_v<Rep2>)
constexpr auto operator%(const quantity<Unit, Rep1, Precision1>& lhs, const quantity<Unit, Rep2, Precision2>& rhs)
    -> std::common_type_t<quantity<Unit, Rep1, Precision1>, quantity<Unit, Rep2, Precision2>> {
    using cq = std::common_type_t<quantity<Unit, Rep1, Precision1>, quantity<Unit, Rep2, Precision2>>;
    return cq(cq(lhs).count() % cq(rhs).count());
}
 
template<typename Unit, typename Rep1, typename Precision1, typename Rep2, typename Precision2>
constexpr bool operator==(const quantity<Unit, Rep1, Precision1>& lhs, const quantity<Unit, Rep2, Precision2>& rhs) {
    using ct = std::common_type_t<quantity<Unit, Rep1, Precision1>, quantity<Unit, Rep2, Precision2>>;
    return ct(lhs).count() == ct(rhs).count();
}
 
template<typename Unit, typename Rep1, typename Precision1, typename Rep2, typename Precision2>
    requires std::three_way_comparable<std::common_type_t<Rep1, Rep2>>
constexpr auto operator<=>(const quantity<Unit, Rep1, Precision1>& lhs, const quantity<Unit, Rep2, Precision2>& rhs) {
    using ct = std::common_type_t<quantity<Unit, Rep1, Precision1>, quantity<Unit, Rep2, Precision2>>;
    return ct(lhs).count() <=> ct(rhs).count();
}
 
// ============================================================================
// Cross-unit arithmetic
// ============================================================================
 
// Product of two quantities, in the given result unit. Counts multiply and
// precisions multiply, so no conversion factor is needed and the result is
// exact for integer representations.
template<typename ToUnit, typename U1, typename R1, typename P1, typename U2, typename R2, typename P2>
constexpr auto _product(const quantity<U1, R1, P1>& lhs, const quantity<U2, R2, P2>& rhs) {
    using cr = std::common_type_t<R1, R2>;
    using result_t = quantity<ToUnit, cr, std::ratio_multiply<P1, P2>>;
    return result_t(static_cast<cr>(lhs.count()) * static_cast<cr>(rhs.count()));
}
 
// Quotient of two quantities, in the given result unit. Counts divide and
// precisions divide; for integer representations the count division truncates.
template<typename ToUnit, typename U1, typename R1, typename P1, typename U2, typename R2, typename P2>
constexpr auto _quotient(const quantity<U1, R1, P1>& lhs, const quantity<U2, R2, P2>& rhs) {
    using cr = std::common_type_t<R1, R2>;
    using result_t = quantity<ToUnit, cr, std::ratio_divide<P1, P2>>;
    return result_t(static_cast<cr>(lhs.count()) / static_cast<cr>(rhs.count()));
}
 
// Product of a quantity and a duration, in the given result unit.
template<typename ToUnit, typename U1, typename R1, typename P1, duration_like D>
constexpr auto _duration_product(const quantity<U1, R1, P1>& lhs, const D& rhs) {
    using cr = std::common_type_t<R1, typename D::rep>;
    using result_t = quantity<ToUnit, cr, std::ratio_multiply<P1, typename D::period>>;
    return result_t(static_cast<cr>(lhs.count()) * static_cast<cr>(rhs.count()));
}
 
// Quotient of a quantity and a duration, in the given result unit.
template<typename ToUnit, typename U1, typename R1, typename P1, duration_like D>
constexpr auto _duration_quotient(const quantity<U1, R1, P1>& lhs, const D& rhs) {
    using cr = std::common_type_t<R1, typename D::rep>;
    using result_t = quantity<ToUnit, cr, std::ratio_divide<P1, typename D::period>>;
    return result_t(static_cast<cr>(lhs.count()) / static_cast<cr>(rhs.count()));
}
 
// Quotient of two quantities yielding a std::chrono::duration.
template<typename U1, typename R1, typename P1, typename U2, typename R2, typename P2>
constexpr auto _quotient_duration(const quantity<U1, R1, P1>& lhs, const quantity<U2, R2, P2>& rhs) {
    using cr = std::common_type_t<R1, R2>;
    using result_t = std::chrono::duration<cr, std::ratio_divide<P1, P2>>;
    return result_t(static_cast<cr>(lhs.count()) / static_cast<cr>(rhs.count()));
}
 
// Product of two quantities yielding a std::chrono::duration.
template<typename U1, typename R1, typename P1, typename U2, typename R2, typename P2>
constexpr auto _product_duration(const quantity<U1, R1, P1>& lhs, const quantity<U2, R2, P2>& rhs) {
    using cr = std::common_type_t<R1, R2>;
    using result_t = std::chrono::duration<cr, std::ratio_multiply<P1, P2>>;
    return result_t(static_cast<cr>(lhs.count()) * static_cast<cr>(rhs.count()));
}
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator*(const quantity<ampere_unit, R1, P1>& i, const quantity<ohm_unit, R2, P2>& r) {
    return _product<volt_unit>(i, r);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator*(const quantity<ohm_unit, R1, P1>& r, const quantity<ampere_unit, R2, P2>& i) {
    return _product<volt_unit>(r, i);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator/(const quantity<volt_unit, R1, P1>& v, const quantity<ohm_unit, R2, P2>& r) {
    return _quotient<ampere_unit>(v, r);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator/(const quantity<volt_unit, R1, P1>& v, const quantity<ampere_unit, R2, P2>& i) {
    return _quotient<ohm_unit>(v, i);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator*(const quantity<volt_unit, R1, P1>& v, const quantity<ampere_unit, R2, P2>& i) {
    return _product<watt_unit>(v, i);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator*(const quantity<ampere_unit, R1, P1>& i, const quantity<volt_unit, R2, P2>& v) {
    return _product<watt_unit>(i, v);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator/(const quantity<watt_unit, R1, P1>& p, const quantity<volt_unit, R2, P2>& v) {
    return _quotient<ampere_unit>(p, v);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator/(const quantity<watt_unit, R1, P1>& p, const quantity<ampere_unit, R2, P2>& i) {
    return _quotient<volt_unit>(p, i);
}
 
template<typename R1, typename P1, duration_like D>
constexpr auto operator*(const quantity<ampere_unit, R1, P1>& i, const D& t) {
    return _duration_product<coulomb_unit>(i, t);
}
 
template<duration_like D, typename R1, typename P1>
constexpr auto operator*(const D& t, const quantity<ampere_unit, R1, P1>& i) {
    return _duration_product<coulomb_unit>(i, t);
}
 
template<typename R1, typename P1, duration_like D>
constexpr auto operator/(const quantity<coulomb_unit, R1, P1>& q, const D& t) {
    return _duration_quotient<ampere_unit>(q, t);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator/(const quantity<coulomb_unit, R1, P1>& q, const quantity<ampere_unit, R2, P2>& i) {
    return _quotient_duration(q, i);
}
 
template<typename R1, typename P1, duration_like D>
constexpr auto operator*(const quantity<watt_unit, R1, P1>& p, const D& t) {
    return _duration_product<joule_unit>(p, t);
}
 
template<duration_like D, typename R1, typename P1>
constexpr auto operator*(const D& t, const quantity<watt_unit, R1, P1>& p) {
    return _duration_product<joule_unit>(p, t);
}
 
template<typename R1, typename P1, duration_like D>
constexpr auto operator/(const quantity<joule_unit, R1, P1>& e, const D& t) {
    return _duration_quotient<watt_unit>(e, t);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator/(const quantity<joule_unit, R1, P1>& e, const quantity<watt_unit, R2, P2>& p) {
    return _quotient_duration(e, p);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator/(const quantity<joule_unit, R1, P1>& e, const quantity<volt_unit, R2, P2>& v) {
    return _quotient<coulomb_unit>(e, v);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator/(const quantity<joule_unit, R1, P1>& e, const quantity<coulomb_unit, R2, P2>& q) {
    return _quotient<volt_unit>(e, q);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator*(const quantity<farad_unit, R1, P1>& c, const quantity<volt_unit, R2, P2>& v) {
    return _product<coulomb_unit>(c, v);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator*(const quantity<volt_unit, R1, P1>& v, const quantity<farad_unit, R2, P2>& c) {
    return _product<coulomb_unit>(v, c);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator/(const quantity<coulomb_unit, R1, P1>& q, const quantity<volt_unit, R2, P2>& v) {
    return _quotient<farad_unit>(q, v);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator/(const quantity<coulomb_unit, R1, P1>& q, const quantity<farad_unit, R2, P2>& c) {
    return _quotient<volt_unit>(q, c);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator*(const quantity<ohm_unit, R1, P1>& r, const quantity<farad_unit, R2, P2>& c) {
    return _product_duration(r, c);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator*(const quantity<farad_unit, R1, P1>& c, const quantity<ohm_unit, R2, P2>& r) {
    return _product_duration(c, r);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator/(const quantity<henry_unit, R1, P1>& l, const quantity<ohm_unit, R2, P2>& r) {
    return _quotient_duration(l, r);
}
 
 
// ============================================================================
// Type aliases
// ============================================================================
 
template<typename Rep, typename Precision = std::ratio<1>>
using voltage = quantity<volt_unit, Rep, Precision>;
 
template<typename Rep, typename Precision = std::ratio<1>>
using current = quantity<ampere_unit, Rep, Precision>;
 
template<typename Rep, typename Precision = std::ratio<1>>
using resistance = quantity<ohm_unit, Rep, Precision>;
 
template<typename Rep, typename Precision = std::ratio<1>>
using power = quantity<watt_unit, Rep, Precision>;
 
template<typename Rep, typename Precision = std::ratio<1>>
using charge = quantity<coulomb_unit, Rep, Precision>;
 
template<typename Rep, typename Precision = std::ratio<1>>
using energy = quantity<joule_unit, Rep, Precision>;
 
template<typename Rep, typename Precision = std::ratio<1>>
using capacitance = quantity<farad_unit, Rep, Precision>;
 
template<typename Rep, typename Precision = std::ratio<1>>
using inductance = quantity<henry_unit, Rep, Precision>;
 
using microvolts = voltage<int64_t, std::micro>;
using millivolts = voltage<int64_t, std::milli>;
using volts = voltage<int64_t>;
using kilovolts = voltage<int64_t, std::kilo>;
 
using microamperes = current<int64_t, std::micro>;
using milliamperes = current<int64_t, std::milli>;
using amperes = current<int64_t>;
using microamps = microamperes;
using milliamps = milliamperes;
using amps = amperes;
 
using milliohms = resistance<int64_t, std::milli>;
using ohms = resistance<int64_t>;
using kiloohms = resistance<int64_t, std::kilo>;
using megaohms = resistance<int64_t, std::mega>;
using gigaohms = resistance<int64_t, std::giga>;
 
using microwatts = power<int64_t, std::micro>;
using milliwatts = power<int64_t, std::milli>;
using watts = power<int64_t>;
using kilowatts = power<int64_t, std::kilo>;
using megawatts = power<int64_t, std::mega>;
using gigawatts = power<int64_t, std::giga>;
 
using microcoulombs = charge<int64_t, std::micro>;
using millicoulombs = charge<int64_t, std::milli>;
using coulombs = charge<int64_t>;
using milliampere_hours = charge<int64_t, std::ratio<18, 5>>;
using ampere_hours = charge<int64_t, std::ratio<3600>>;
 
using millijoules = energy<int64_t, std::milli>;
using joules = energy<int64_t>;
using kilojoules = energy<int64_t, std::kilo>;
using megajoules = energy<int64_t, std::mega>;
using watt_hours = energy<int64_t, std::ratio<3600>>;
using kilowatt_hours = energy<int64_t, std::ratio<3600000>>;
 
using picofarads = capacitance<int64_t, std::pico>;
using nanofarads = capacitance<int64_t, std::nano>;
using microfarads = capacitance<int64_t, std::micro>;
using millifarads = capacitance<int64_t, std::milli>;
using farads = capacitance<int64_t>;
 
using nanohenries = inductance<int64_t, std::nano>;
using microhenries = inductance<int64_t, std::micro>;
using millihenries = inductance<int64_t, std::milli>;
using henries = inductance<int64_t>;
 
 
// ============================================================================
// String conversion and formatting
// ============================================================================
 
template<typename Precision>
struct si_prefix;
 
template<>
struct si_prefix<std::femto> {
    static constexpr const char* symbol = "f";
};
 
template<>
struct si_prefix<std::pico> {
    static constexpr const char* symbol = "p";
};
 
template<>
struct si_prefix<std::nano> {
    static constexpr const char* symbol = "n";
};
 
template<>
struct si_prefix<std::micro> {
    static constexpr const char* symbol = "µ";
};
 
template<>
struct si_prefix<std::milli> {
    static constexpr const char* symbol = "m";
};
 
template<>
struct si_prefix<std::ratio<1>> {
    static constexpr const char* symbol = "";
};
 
template<>
struct si_prefix<std::kilo> {
    static constexpr const char* symbol = "k";
};
 
template<>
struct si_prefix<std::mega> {
    static constexpr const char* symbol = "M";
};
 
template<>
struct si_prefix<std::giga> {
    static constexpr const char* symbol = "G";
};
 
template<>
struct si_prefix<std::tera> {
    static constexpr const char* symbol = "T";
};
template<typename Unit, typename Precision>
struct quantity_suffix {
    static std::string value()
        requires requires { si_prefix<Precision>::symbol; }
    {
        return std::string(si_prefix<Precision>::symbol) + Unit::symbol;
    }
};
 
template<>
struct quantity_suffix<coulomb_unit, std::ratio<18, 5>> {
    static std::string value() { return "mAh"; }
};
 
template<>
struct quantity_suffix<coulomb_unit, std::ratio<3600>> {
    static std::string value() { return "Ah"; }
};
 
template<>
struct quantity_suffix<joule_unit, std::ratio<3600>> {
    static std::string value() { return "Wh"; }
};
 
template<>
struct quantity_suffix<joule_unit, std::ratio<3600000>> {
    static std::string value() { return "kWh"; }
};
 
template<typename Unit, typename Precision>
concept _has_suffix = requires { quantity_suffix<Unit, Precision>::value(); };
 
// Display family for a (unit, precision) pair when a format spec is given:
// the value is rendered in `scale`-sized units labeled `suffix`. SI-prefixed
// precisions render in the base unit ("3.3V"); conventional non-decade
// precisions render in their conventional unit ("0.2Ah", never "720.0C").
template<typename Unit, typename Precision>
struct _display_unit {
    using scale = std::ratio<1>;
    static constexpr const char* suffix = Unit::symbol;
};
 
struct _ampere_hour_display_unit {
    using scale = std::ratio<3600>;
    static constexpr const char* suffix = "Ah";
};
 
struct _watt_hour_display_unit {
    using scale = std::ratio<3600>;
    static constexpr const char* suffix = "Wh";
};
 
template<>
struct _display_unit<coulomb_unit, std::ratio<18, 5>> : _ampere_hour_display_unit {};
 
template<>
struct _display_unit<coulomb_unit, std::ratio<3600>> : _ampere_hour_display_unit {};
 
template<>
struct _display_unit<joule_unit, std::ratio<3600>> : _watt_hour_display_unit {};
 
template<>
struct _display_unit<joule_unit, std::ratio<3600000>> : _watt_hour_display_unit {};
 
// Appends a NUL-terminated string to a format output iterator.
template<typename OutputIt>
constexpr OutputIt _format_append(OutputIt out, const char* s) {
    for (; *s != '\0'; ++s) {
        *out++ = *s;
    }
    return out;
}
template<typename Unit, typename Rep, typename Precision>
    requires _has_suffix<Unit, typename Precision::type>
inline std::string to_string(const quantity<Unit, Rep, Precision>& q) {
    return std::to_string(q.count()) + quantity_suffix<Unit, typename Precision::type>::value();
}
 
} // namespace electro
 
namespace std {
 
template<typename Unit, typename Rep1, typename Precision1, typename Rep2, typename Precision2>
struct common_type<electro::quantity<Unit, Rep1, Precision1>, electro::quantity<Unit, Rep2, Precision2>> {
private:
    using common_precision = std::ratio<
        electro::_gcd(Precision1::num, Precision2::num),
        (Precision1::den / electro::_gcd(Precision1::den, Precision2::den)) * Precision2::den>;
 
public:
    using type = electro::quantity<Unit, std::common_type_t<Rep1, Rep2>, common_precision>;
};
 
#if CONFIG_ELECTRO_STD_FORMAT
// "{}" prints the exact stored count with a precision-qualified unit
// (millivolts(3300) -> "3300mV"). A non-empty spec is applied to the value in
// display units (as double): std::format("{:.1f}", millivolts(3300)) == "3.3V".
// SI-prefixed precisions display in the base unit; conventional non-decade
// precisions display in their conventional unit ("0.2Ah").
template<typename Unit, typename Rep, typename Precision>
    requires electro::_has_suffix<Unit, typename Precision::type>
struct formatter<electro::quantity<Unit, Rep, Precision>, char> {
private:
    using _display = electro::_display_unit<Unit, typename Precision::type>;
    // display units per count
    using _upc = typename ratio_divide<typename Precision::type, typename _display::scale>::type;
    std::formatter<double> _num;
    bool _has_spec = false;
 
public:
    constexpr auto parse(format_parse_context& ctx) {
        auto it = ctx.begin();
        if (it == ctx.end() || *it == '}') {
            return it;
        }
        _has_spec = true;
        return _num.parse(ctx);
    }
 
    template<typename FormatContext>
    auto format(const electro::quantity<Unit, Rep, Precision>& q, FormatContext& ctx) const {
        if (_has_spec) {
            double value = static_cast<double>(q.count()) * _upc::num / _upc::den;
            auto out = _num.format(value, ctx);
            return electro::_format_append(out, _display::suffix);
        }
        return std::format_to(
            ctx.out(), "{}{}", q.count(), electro::quantity_suffix<Unit, typename Precision::type>::value()
        );
    }
};
#endif
 
} // namespace std
 
namespace electro_literals {
namespace detail {
 
template<unsigned long long Value, unsigned long long Power>
struct pow10 {
    static constexpr unsigned long long value = 10 * pow10<Value, Power - 1>::value;
};
 
template<unsigned long long Value>
struct pow10<Value, 0> {
    static constexpr unsigned long long value = Value;
};
 
template<char... Digits>
struct parse_int;
 
template<char D, char... Rest>
struct parse_int<D, Rest...> {
    static_assert(D >= '0' && D <= '9', "invalid digit");
    static constexpr unsigned long long value = pow10<D - '0', sizeof...(Rest)>::value + parse_int<Rest...>::value;
};
 
template<char D>
struct parse_int<D> {
    static_assert(D >= '0' && D <= '9', "invalid digit");
    static constexpr unsigned long long value = D - '0';
};
 
template<typename Quantity, char... Digits>
constexpr Quantity check_overflow() {
    using parsed = parse_int<Digits...>;
    constexpr typename Quantity::rep repval = parsed::value;
    static_assert(
        repval >= 0 && static_cast<unsigned long long>(repval) == parsed::value,
        "literal value cannot be represented by quantity type"
    );
    return Quantity(repval);
}
 
} // namespace detail
template<char... Digits>
constexpr electro::microvolts operator""_uV() {
    return detail::check_overflow<electro::microvolts, Digits...>();
}
 
template<char... Digits>
constexpr electro::millivolts operator""_mV() {
    return detail::check_overflow<electro::millivolts, Digits...>();
}
 
template<char... Digits>
constexpr electro::volts operator""_V() {
    return detail::check_overflow<electro::volts, Digits...>();
}
 
template<char... Digits>
constexpr electro::kilovolts operator""_kV() {
    return detail::check_overflow<electro::kilovolts, Digits...>();
}
 
template<char... Digits>
constexpr electro::microamperes operator""_uA() {
    return detail::check_overflow<electro::microamperes, Digits...>();
}
 
template<char... Digits>
constexpr electro::milliamperes operator""_mA() {
    return detail::check_overflow<electro::milliamperes, Digits...>();
}
 
template<char... Digits>
constexpr electro::amperes operator""_A() {
    return detail::check_overflow<electro::amperes, Digits...>();
}
 
template<char... Digits>
constexpr electro::milliohms operator""_mOhm() {
    return detail::check_overflow<electro::milliohms, Digits...>();
}
 
template<char... Digits>
constexpr electro::ohms operator""_Ohm() {
    return detail::check_overflow<electro::ohms, Digits...>();
}
 
template<char... Digits>
constexpr electro::kiloohms operator""_kOhm() {
    return detail::check_overflow<electro::kiloohms, Digits...>();
}
 
template<char... Digits>
constexpr electro::megaohms operator""_MOhm() {
    return detail::check_overflow<electro::megaohms, Digits...>();
}
 
template<char... Digits>
constexpr electro::milliohms operator""_mΩ() {
    return detail::check_overflow<electro::milliohms, Digits...>();
}
 
template<char... Digits>
constexpr electro::ohms operator""_Ω() {
    return detail::check_overflow<electro::ohms, Digits...>();
}
 
template<char... Digits>
constexpr electro::kiloohms operator""_kΩ() {
    return detail::check_overflow<electro::kiloohms, Digits...>();
}
 
template<char... Digits>
constexpr electro::megaohms operator""_MΩ() {
    return detail::check_overflow<electro::megaohms, Digits...>();
}
 
template<char... Digits>
constexpr electro::microwatts operator""_uW() {
    return detail::check_overflow<electro::microwatts, Digits...>();
}
 
template<char... Digits>
constexpr electro::milliwatts operator""_mW() {
    return detail::check_overflow<electro::milliwatts, Digits...>();
}
 
template<char... Digits>
constexpr electro::watts operator""_W() {
    return detail::check_overflow<electro::watts, Digits...>();
}
 
template<char... Digits>
constexpr electro::kilowatts operator""_kW() {
    return detail::check_overflow<electro::kilowatts, Digits...>();
}
 
template<char... Digits>
constexpr electro::megawatts operator""_MW() {
    return detail::check_overflow<electro::megawatts, Digits...>();
}
 
template<char... Digits>
constexpr electro::coulombs operator""_C() {
    return detail::check_overflow<electro::coulombs, Digits...>();
}
 
template<char... Digits>
constexpr electro::milliampere_hours operator""_mAh() {
    return detail::check_overflow<electro::milliampere_hours, Digits...>();
}
 
template<char... Digits>
constexpr electro::ampere_hours operator""_Ah() {
    return detail::check_overflow<electro::ampere_hours, Digits...>();
}
 
template<char... Digits>
constexpr electro::millijoules operator""_mJ() {
    return detail::check_overflow<electro::millijoules, Digits...>();
}
 
template<char... Digits>
constexpr electro::joules operator""_J() {
    return detail::check_overflow<electro::joules, Digits...>();
}
 
template<char... Digits>
constexpr electro::kilojoules operator""_kJ() {
    return detail::check_overflow<electro::kilojoules, Digits...>();
}
 
template<char... Digits>
constexpr electro::watt_hours operator""_Wh() {
    return detail::check_overflow<electro::watt_hours, Digits...>();
}
 
template<char... Digits>
constexpr electro::kilowatt_hours operator""_kWh() {
    return detail::check_overflow<electro::kilowatt_hours, Digits...>();
}
 
template<char... Digits>
constexpr electro::picofarads operator""_pF() {
    return detail::check_overflow<electro::picofarads, Digits...>();
}
 
template<char... Digits>
constexpr electro::nanofarads operator""_nF() {
    return detail::check_overflow<electro::nanofarads, Digits...>();
}
 
template<char... Digits>
constexpr electro::microfarads operator""_uF() {
    return detail::check_overflow<electro::microfarads, Digits...>();
}
 
template<char... Digits>
constexpr electro::farads operator""_F() {
    return detail::check_overflow<electro::farads, Digits...>();
}
 
template<char... Digits>
constexpr electro::nanohenries operator""_nH() {
    return detail::check_overflow<electro::nanohenries, Digits...>();
}
 
template<char... Digits>
constexpr electro::microhenries operator""_uH() {
    return detail::check_overflow<electro::microhenries, Digits...>();
}
 
template<char... Digits>
constexpr electro::millihenries operator""_mH() {
    return detail::check_overflow<electro::millihenries, Digits...>();
}
 
template<char... Digits>
constexpr electro::henries operator""_H() {
    return detail::check_overflow<electro::henries, Digits...>();
}
 
} // namespace electro_literals