electro.hpp

Go to the documentation of this file.

#pragma once
 
#include <charconv>
#include <chrono>
#include <cmath>
#include <compare>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <ratio>
#include <string>
#include <system_error>
#include <type_traits>
#include <version> // pulls in __cpp_lib_format so the detection below works in non-IDF builds
#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>
 
#if !defined(__GNUC__) || defined(__clang__) || __GNUC__ >= 14
#define ELECTRO_HAS_UTF8_LITERALS 1
#else
#define ELECTRO_HAS_UTF8_LITERALS 0
#endif
 
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>
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(); }
};
 
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(); };
 
// 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;
    double v = static_cast<double>(q.count());
    if constexpr (upc::num != 1) {
        v *= static_cast<double>(upc::num);
    }
    if constexpr (upc::den != 1) {
        v /= static_cast<double>(upc::den);
    }
    return {v, display::suffix};
}
 
consteval bool _is_power_of_ten(intmax_t n) {
    while (n >= 10 && n % 10 == 0) {
        n /= 10;
    }
    return n == 1;
}
 
consteval int _log10(intmax_t n) {
    int e = 0;
    while (n >= 10) {
        n /= 10;
        ++e;
    }
    return e;
}
 
// Precisions that are SI prefixes (see si_prefix) of the unit.
template<typename Precision>
concept _si_precision =
    requires { si_prefix<Precision>::symbol; } && _is_power_of_ten(Precision::num) && _is_power_of_ten(Precision::den);
 
template<typename Precision>
inline constexpr int _precision_exponent = _log10(Precision::num) - _log10(Precision::den);
 
// 10^k as a double, exact for |k| <= 22.
constexpr double _pow10(int k) {
    double r = 1.0;
    for (int i = 0; i < (k < 0 ? -k : k); ++i) {
        r *= 10.0;
    }
    return r;
}
 
// v x 10^k with a single rounding (exact power of ten for |k| <= 22).
constexpr double _scale_pow10(double v, int k) {
    return k >= 0 ? v * _pow10(k) : v / _pow10(-k);
}
 
// The prefixes the scaled form chooses between: the si_prefix set, by
// power-of-ten exponent, in ascending order.
struct _scale_prefix {
    int exponent;
    const char* symbol;
};
 
inline constexpr _scale_prefix _scale_prefixes[] = {
    {-15, si_prefix<std::femto>::symbol},
    {-12, si_prefix<std::pico>::symbol},
    {-9, si_prefix<std::nano>::symbol},
    {-6, si_prefix<std::micro>::symbol},
    {-3, si_prefix<std::milli>::symbol},
    {0, si_prefix<std::ratio<1>>::symbol},
    {3, si_prefix<std::kilo>::symbol},
    {6, si_prefix<std::mega>::symbol},
    {9, si_prefix<std::giga>::symbol},
    {12, si_prefix<std::tera>::symbol},
};
 
// 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);
        }
        constexpr std::size_t n = std::extent_v<decltype(_scale_prefixes)>;
        for (std::size_t i = n; i-- > 1;) {
            const double v = _scale_pow10(count, _precision_exponent<p> - _scale_prefixes[i].exponent);
            if (v >= 1.0 || v <= -1.0) {
                return {v, std::string(_scale_prefixes[i].symbol) + Unit::symbol};
            }
        }
        return {
            _scale_pow10(count, _precision_exponent<p> - _scale_prefixes[0].exponent),
            std::string(_scale_prefixes[0].symbol) + Unit::symbol
        };
    } else {
        return {count, quantity_suffix<Unit, p>::value()};
    }
}
 
// The shortest fixed-notation representation of v that round-trips: never
// scientific notation, and no trailing zeros (2.5 -> "2.5", 1e6 -> "1000000",
// 1e-15 -> "0.000000000000001"). Used wherever a floating-point value is
// rendered without a format spec, so to_string and std::format agree.
template<std::floating_point T>
std::string _fixed_string(T v) {
    std::string s(32, '\0');
    for (;;) {
        const auto result = std::to_chars(s.data(), s.data() + s.size(), v, std::chars_format::fixed);
        if (result.ec == std::errc()) {
            s.resize(static_cast<std::size_t>(result.ptr - s.data()));
            return s;
        }
        s.resize(s.size() * 2);
    }
}
 
// A count rendered without a format spec: integers exactly, floating-point
// counts in shortest round-trip fixed notation.
template<typename Rep>
std::string _count_string(const Rep& r) {
    if constexpr (std::floating_point<Rep>) {
        return _fixed_string(r);
    } else {
        return std::to_string(r);
    }
}
 
// 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;
}
struct base_unit_t {
    explicit base_unit_t() = default;
};
 
inline constexpr base_unit_t base_unit{};
 
struct scaled_t {
    explicit scaled_t() = default;
};
 
inline constexpr scaled_t scaled{};
 
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 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"; 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 electro::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 electro::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, electro::base_unit) or to_string(q, electro::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 electro::_has_suffix<Unit, typename Precision::type>
struct formatter<electro::quantity<Unit, Rep, Precision>, char> {
private:
    enum class _unit_form { own, base, scaled };
 
    std::formatter<double> _num;
    bool _has_spec = false;
    _unit_form _form = _unit_form::own;
 
public:
    constexpr auto parse(format_parse_context& ctx) {
        auto it = ctx.begin();
        if (it != ctx.end() && (*it == 'b' || *it == 's')) {
            _form = *it == 'b' ? _unit_form::base : _unit_form::scaled;
            ctx.advance_to(++it);
        }
        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 (_form != _unit_form::own) {
            const electro::_display d =
                _form == _unit_form::base ? electro::_base_unit_display(q) : electro::_scaled_display(q);
            auto out = _has_spec ? _num.format(d.value, ctx)
                                 : std::format_to(ctx.out(), "{}", electro::_fixed_string(d.value));
            return std::format_to(out, "{}", d.suffix);
        }
        const std::string suffix = electro::quantity_suffix<Unit, typename Precision::type>::value();
        if (_has_spec) {
            auto out = _num.format(static_cast<double>(q.count()), ctx);
            return std::format_to(out, "{}", suffix);
        }
        if constexpr (std::floating_point<Rep>) {
            return std::format_to(ctx.out(), "{}{}", electro::_fixed_string(q.count()), suffix);
        } else {
            return std::format_to(ctx.out(), "{}{}", q.count(), suffix);
        }
    }
};
#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...>();
}
 
#if ELECTRO_HAS_UTF8_LITERALS
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...>();
}
#endif
 
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