electro.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 <limits>
#include <quanta/core.hpp>
#include <ratio>
#include <string>
#include <system_error>
#include <type_traits>
 
namespace quanta::electro {
 
// 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 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>
struct _is_chrono_duration : std::false_type {};
 
template<typename Rep, typename Period>
struct _is_chrono_duration<std::chrono::duration<Rep, Period>> : std::true_type {};
 
template<typename T>
concept duration_like = _is_chrono_duration<std::remove_cvref_t<T>>::value;
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(); }
};
 
// ============================================================================
// 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 quanta::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> &&
        detail::_lossless_conversion<Rep2, Precision2, rep, precision> &&
        detail::_quantity_castable<quantity<Unit, Rep2, Precision2>, quantity>
    constexpr quantity(const quantity<Unit, Rep2, Precision2>& q)
        : _r(quantity_cast<quantity>(q).count()) {}
 
    template<typename Rep2, typename Precision2>
        requires(!detail::_lossless_conversion<Rep2, Precision2, rep, precision> ||
                 !std::convertible_to<const Rep2&, rep>) &&
        detail::_quantity_castable<quantity<Unit, Rep2, Precision2>, quantity>
    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>
    requires(!std::is_same_v<typename ToQuantity::unit, Unit>) ||
    detail::_quantity_cast_requirements<quantity<Unit, Rep, Precision>, ToQuantity>
constexpr ToQuantity quantity_cast(const quantity<Unit, Rep, Precision>& q) {
    // The constraint admits a cast between units, so that this reports it.
    static_assert(
        std::is_same_v<typename ToQuantity::unit, Unit>, "quantity_cast cannot convert between different units"
    );
    return detail::_quantity_cast<ToQuantity>(q);
}
 
template<typename ToQuantity, typename Unit, typename Rep, typename Precision>
constexpr ToQuantity floor(const quantity<Unit, Rep, Precision>& q) {
    return detail::_floor_cast(quantity_cast<ToQuantity>(q), q);
}
 
template<typename ToQuantity, typename Unit, typename Rep, typename Precision>
constexpr ToQuantity ceil(const quantity<Unit, Rep, Precision>& q) {
    return detail::_ceil_cast(quantity_cast<ToQuantity>(q), q);
}
 
template<typename ToQuantity, typename Unit, typename Rep, typename Precision>
constexpr ToQuantity trunc(const quantity<Unit, Rep, Precision>& q) {
    return quantity_cast<ToQuantity>(q);
}
 
template<typename ToQuantity, typename Unit, typename Rep, typename Precision>
constexpr ToQuantity round(const quantity<Unit, Rep, Precision>& q) {
    return detail::_round_cast<ToQuantity>(q, [&q] { return floor<ToQuantity>(q); });
}
 
template<typename Unit, typename Rep, typename Precision>
constexpr quantity<Unit, Rep, Precision> abs(const quantity<Unit, Rep, Precision>& q) {
    return detail::_abs(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(); };
 
// The unit the base-unit form (the `b` format marker, to_string(q,
// base_unit)) renders in, as `scale`-sized units labeled `suffix`. SI-prefixed
// precisions render in the unprefixed unit ("3.3V"); the hour-based charge and
// energy precisions render in Ah and Wh ("0.2Ah", never "720C").
template<typename Unit, typename Precision>
struct _base_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 _base_display_unit<coulomb_unit, std::ratio<18, 5>> : _ampere_hour_display_unit {};
 
template<>
struct _base_display_unit<coulomb_unit, std::ratio<3600>> : _ampere_hour_display_unit {};
 
template<>
struct _base_display_unit<joule_unit, std::ratio<3600>> : _watt_hour_display_unit {};
 
template<>
struct _base_display_unit<joule_unit, std::ratio<3600000>> : _watt_hour_display_unit {};
 
// A value and suffix to display, for the base-unit and scaled forms.
struct _display {
    double value;
    std::string suffix;
};
 
// The quantity in its base unit (see _base_display_unit), as a double.
template<typename Unit, typename Rep, typename Precision>
_display _base_unit_display(const quantity<Unit, Rep, Precision>& q) {
    using display = _base_display_unit<Unit, typename Precision::type>;
    // display units per count
    using upc = typename std::ratio_divide<typename Precision::type, typename display::scale>::type;
    return {detail::_ratio_value<upc>(q.count()), display::suffix};
}
 
// Precisions that are SI prefixes (see si_prefix) of the unit.
template<typename Precision>
concept _si_precision = requires { si_prefix<Precision>::symbol; } && detail::_power_of_ten_precision<Precision>;
 
// The quantity with the largest SI prefix for which its magnitude is at least
// 1, else the smallest; zero (keeping its sign) and non-finite values are
// shown in the unprefixed unit. 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 mV) are exactly 1 in it. Precisions that are not SI
// prefixes (mAh, Ah, Wh, kWh) are shown in their own unit.
template<typename Unit, typename Rep, typename Precision>
_display _scaled_display(const quantity<Unit, Rep, Precision>& q) {
    using p = typename Precision::type;
    const double count = static_cast<double>(q.count());
    if constexpr (_si_precision<p>) {
        if (count == 0 || !std::isfinite(count)) {
            return _base_unit_display(q);
        }
        // The si_prefix set, femto to tera
        const detail::_scaled s = detail::_pick_scale(count, _precision_exponent<p>, detail::_si_scale);
        return {s.value, std::string(s.label) + Unit::symbol};
    } else {
        return {count, quantity_suffix<Unit, p>::value()};
    }
}
 
#if CONFIG_QUANTA_STD_FORMAT
// How std::format renders a quantity of the given unit and (reduced)
// precision; see detail::_unit_formatter.
template<typename Unit, typename Precision>
struct _format_traits {
    static constexpr const char* markers = "bs";
    static constexpr bool has_own_unit = true;
 
    static std::string own_unit(bool) {
        const std::string suffix = quantity_suffix<Unit, Precision>::value();
        return suffix;
    }
 
    template<typename OutputIt>
    static OutputIt append_own_unit(OutputIt out, const std::string& suffix) {
        return std::format_to(out, "{}", suffix);
    }
 
    template<typename Q>
    static _display base_display(const Q& q) {
        return _base_unit_display(q);
    }
 
    template<typename Q>
    static _display scaled_display(const Q& q) {
        return _scaled_display(q);
    }
 
    template<typename OutputIt>
    static OutputIt append_label(OutputIt out, const _display& d) {
        return std::format_to(out, "{}", d.suffix);
    }
};
#endif
 
using quanta::base_unit;
using quanta::base_unit_t;
 
using quanta::scaled;
using quanta::scaled_t;
 
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 _count_string(q.count()) + quantity_suffix<Unit, typename Precision::type>::value();
}
 
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, base_unit_t) {
    const _display d = _base_unit_display(q);
    return _fixed_string(d.value) + d.suffix;
}
 
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, scaled_t) {
    const _display d = _scaled_display(q);
    return _fixed_string(d.value) + d.suffix;
}
 
} // namespace quanta::electro
 
namespace std {
 
template<typename Unit, typename Rep1, typename Precision1, typename Rep2, typename Precision2>
struct common_type<
    quanta::electro::quantity<Unit, Rep1, Precision1>,
    quanta::electro::quantity<Unit, Rep2, Precision2>> {
private:
    using common_precision = quanta::detail::_common_precision<Precision1, Precision2>;
 
public:
    using type = quanta::electro::quantity<Unit, std::common_type_t<Rep1, Rep2>, common_precision>;
};
 
#if CONFIG_QUANTA_STD_FORMAT
// "{}" prints the exact stored count with a precision-qualified unit
// (millivolts(3300) -> "3300mV"; floating-point counts in the shortest fixed
// notation that round-trips, as to_string does: voltage<double>(1e6) ->
// "1000000V", never "1e+06V"). A non-empty spec controls only how the number
// is rendered (as double), never the unit, so both forms use the same suffix:
// std::format("{:.1f}", millivolts(3300)) == "3300.0mV" and
// std::format("{:.1f}", milliampere_hours(200)) == "200.0mAh".
//
// 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 the unprefixed
//   unit, or in Ah/Wh for the hour-based precisions:
//   std::format("{:b.1f}", millivolts(3300)) == "3.3V".
// - 's' (scaled, see quanta::scaled) shows the value with an SI prefix
//   suited to its magnitude: std::format("{:s}", ohms(4700)) == "4.7kΩ".
// 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(q, quanta::base_unit) or to_string(q, quanta::scaled):
// std::format("{:b}", millivolts(24)) == "0.024V".
//
// 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 ("{:b>8.1f}" is the
// marker followed by ">8.1f").
template<typename Unit, typename Rep, typename Precision>
    requires quanta::electro::_has_suffix<Unit, typename Precision::type>
struct formatter<quanta::electro::quantity<Unit, Rep, Precision>, char>
    : private quanta::detail::_unit_formatter<quanta::electro::_format_traits<Unit, typename Precision::type>> {
    using quanta::detail::_unit_formatter<quanta::electro::_format_traits<Unit, typename Precision::type>>::parse;
 
    template<typename FormatContext>
    auto format(const quanta::electro::quantity<Unit, Rep, Precision>& q, FormatContext& ctx) const {
        return this->format_quantity(q, ctx);
    }
};
#endif
 
} // namespace std
 
namespace quanta {
inline namespace literals {
inline namespace electro_literals {
template<char... Digits>
constexpr quanta::electro::microvolts operator""_uV() {
    return detail::check_overflow<quanta::electro::microvolts, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::millivolts operator""_mV() {
    return detail::check_overflow<quanta::electro::millivolts, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::volts operator""_V() {
    return detail::check_overflow<quanta::electro::volts, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::kilovolts operator""_kV() {
    return detail::check_overflow<quanta::electro::kilovolts, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::microamperes operator""_uA() {
    return detail::check_overflow<quanta::electro::microamperes, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::milliamperes operator""_mA() {
    return detail::check_overflow<quanta::electro::milliamperes, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::amperes operator""_A() {
    return detail::check_overflow<quanta::electro::amperes, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::milliohms operator""_mOhm() {
    return detail::check_overflow<quanta::electro::milliohms, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::ohms operator""_Ohm() {
    return detail::check_overflow<quanta::electro::ohms, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::kiloohms operator""_kOhm() {
    return detail::check_overflow<quanta::electro::kiloohms, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::megaohms operator""_MOhm() {
    return detail::check_overflow<quanta::electro::megaohms, Digits...>();
}
 
#if QUANTA_HAS_UTF8_LITERALS
template<char... Digits>
constexpr quanta::electro::milliohms operator""_mΩ() {
    return detail::check_overflow<quanta::electro::milliohms, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::ohms operator""_Ω() {
    return detail::check_overflow<quanta::electro::ohms, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::kiloohms operator""_kΩ() {
    return detail::check_overflow<quanta::electro::kiloohms, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::megaohms operator""_MΩ() {
    return detail::check_overflow<quanta::electro::megaohms, Digits...>();
}
#endif
 
template<char... Digits>
constexpr quanta::electro::microwatts operator""_uW() {
    return detail::check_overflow<quanta::electro::microwatts, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::milliwatts operator""_mW() {
    return detail::check_overflow<quanta::electro::milliwatts, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::watts operator""_W() {
    return detail::check_overflow<quanta::electro::watts, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::kilowatts operator""_kW() {
    return detail::check_overflow<quanta::electro::kilowatts, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::megawatts operator""_MW() {
    return detail::check_overflow<quanta::electro::megawatts, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::coulombs operator""_C() {
    return detail::check_overflow<quanta::electro::coulombs, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::milliampere_hours operator""_mAh() {
    return detail::check_overflow<quanta::electro::milliampere_hours, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::ampere_hours operator""_Ah() {
    return detail::check_overflow<quanta::electro::ampere_hours, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::millijoules operator""_mJ() {
    return detail::check_overflow<quanta::electro::millijoules, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::joules operator""_J() {
    return detail::check_overflow<quanta::electro::joules, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::kilojoules operator""_kJ() {
    return detail::check_overflow<quanta::electro::kilojoules, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::watt_hours operator""_Wh() {
    return detail::check_overflow<quanta::electro::watt_hours, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::kilowatt_hours operator""_kWh() {
    return detail::check_overflow<quanta::electro::kilowatt_hours, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::picofarads operator""_pF() {
    return detail::check_overflow<quanta::electro::picofarads, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::nanofarads operator""_nF() {
    return detail::check_overflow<quanta::electro::nanofarads, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::microfarads operator""_uF() {
    return detail::check_overflow<quanta::electro::microfarads, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::farads operator""_F() {
    return detail::check_overflow<quanta::electro::farads, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::nanohenries operator""_nH() {
    return detail::check_overflow<quanta::electro::nanohenries, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::microhenries operator""_uH() {
    return detail::check_overflow<quanta::electro::microhenries, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::millihenries operator""_mH() {
    return detail::check_overflow<quanta::electro::millihenries, Digits...>();
}
 
template<char... Digits>
constexpr quanta::electro::henries operator""_H() {
    return detail::check_overflow<quanta::electro::henries, Digits...>();
}
 
} // namespace electro_literals
} // namespace literals
 
namespace electro {
using namespace literals::electro_literals;
} // namespace electro
} // namespace quanta