spatial.hpp

Go to the documentation of this file.

#pragma once
 
#include <charconv>
#include <cmath>
#include <compare>
#include <concepts>
#include <cstdint>
#include <limits>
#include <quanta/core.hpp>
#include <ratio>
#include <string>
 
namespace quanta::spatial {
 
// 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 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 meter_unit {
    static constexpr const char* symbol = "m";
};
 
struct square_meter_unit {
    static constexpr const char* symbol = "m²";
};
 
struct cubic_meter_unit {
    static constexpr const char* symbol = "m³";
};
 
 
// Base of quantity that supplies the nested `period` alias for lengths only.
// Generic code that recognises duration-like or distance-like types by their
// `period` member must not accept areas or volumes, so other units get an
// empty base. Non-ratio precisions also get the empty base, leaving the
// diagnostic to quantity's own static_assert.
template<typename Unit, typename Precision>
struct _period_base {};
 
template<typename Precision>
    requires _is_ratio<Precision>::value
struct _period_base<meter_unit, Precision> {
    using period = typename Precision::type;
};
template<typename Unit, typename Rep, typename Precision>
class quantity : public _period_base<Unit, Precision> {
    static_assert(!is_quantity_v<Rep>, "rep cannot be a quanta::spatial::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()));
}
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator*(const quantity<meter_unit, R1, P1>& lhs, const quantity<meter_unit, R2, P2>& rhs) {
    return _product<square_meter_unit>(lhs, rhs);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator*(const quantity<meter_unit, R1, P1>& lhs, const quantity<square_meter_unit, R2, P2>& rhs) {
    return _product<cubic_meter_unit>(lhs, rhs);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator*(const quantity<square_meter_unit, R1, P1>& lhs, const quantity<meter_unit, R2, P2>& rhs) {
    return _product<cubic_meter_unit>(lhs, rhs);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator/(const quantity<square_meter_unit, R1, P1>& lhs, const quantity<meter_unit, R2, P2>& rhs) {
    return _quotient<meter_unit>(lhs, rhs);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto operator/(const quantity<cubic_meter_unit, R1, P1>& lhs, const quantity<meter_unit, R2, P2>& rhs) {
    return _quotient<square_meter_unit>(lhs, rhs);
}
 
template<typename R1, typename P1, typename R2, typename P2>
constexpr auto
operator/(const quantity<cubic_meter_unit, R1, P1>& lhs, const quantity<square_meter_unit, R2, P2>& rhs) {
    return _quotient<meter_unit>(lhs, rhs);
}
 
 
// ============================================================================
// Type aliases
// ============================================================================
 
template<typename Rep, typename Precision = std::ratio<1>>
using length = quantity<meter_unit, Rep, Precision>;
 
using nanometers = length<int64_t, std::nano>;
using micrometers = length<int64_t, std::micro>;
using millimeters = length<int64_t, std::milli>;
using centimeters = length<int64_t, std::centi>;
using meters = length<int64_t>;
using kilometers = length<int64_t, std::kilo>;
 
using mils = length<int64_t, std::ratio<127, 5000000>>;
using inches = length<int64_t, std::ratio<127, 5000>>;
using feet = length<int64_t, std::ratio<381, 1250>>;
using yards = length<int64_t, std::ratio<1143, 1250>>;
using miles = length<int64_t, std::ratio<201168, 125>>;
using nautical_miles = length<int64_t, std::ratio<1852>>;
 
template<typename Rep, typename Precision = std::ratio<1>>
using area = quantity<square_meter_unit, Rep, Precision>;
 
using square_millimeters = area<int64_t, std::micro>;
using square_centimeters = area<int64_t, std::ratio<1, 10000>>;
using square_meters = area<int64_t>;
using hectares = area<int64_t, std::ratio<10000>>;
using square_kilometers = area<int64_t, std::mega>;
 
using square_inches = area<int64_t, std::ratio<16129, 25000000>>;
using square_feet = area<int64_t, std::ratio<145161, 1562500>>;
using square_yards = area<int64_t, std::ratio<1306449, 1562500>>;
using acres = area<int64_t, std::ratio<316160658, 78125>>;
using square_miles = area<int64_t, std::ratio<40468564224, 15625>>;
 
template<typename Rep, typename Precision = std::ratio<1>>
using volume = quantity<cubic_meter_unit, Rep, Precision>;
 
using microliters = volume<int64_t, std::nano>;
using cubic_millimeters = microliters;
using milliliters = volume<int64_t, std::micro>;
using cubic_centimeters = milliliters;
using liters = volume<int64_t, std::milli>;
using cubic_meters = volume<int64_t>;
 
using cubic_inches = volume<int64_t, std::ratio<2048383, 125000000000>>;
using cubic_feet = volume<int64_t, std::ratio<55306341, 1953125000>>;
using cubic_yards = volume<int64_t, std::ratio<1493271207, 1953125000>>;
using us_gallons = volume<int64_t, std::ratio<473176473, 125000000000>>;
 
 
// ============================================================================
// 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::centi> {
    static constexpr const char* symbol = "c";
};
 
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<typename R>
using _square_ratio = std::ratio_multiply<R, R>;
 
template<typename R>
using _cube_ratio = std::ratio_multiply<std::ratio_multiply<R, R>, R>;
 
// Areas and volumes have no SI prefix rule: only the explicit specializations
// below have suffixes.
template<typename Precision>
struct quantity_suffix<square_meter_unit, Precision> {};
 
template<typename Precision>
struct quantity_suffix<cubic_meter_unit, Precision> {};
 
template<>
struct quantity_suffix<meter_unit, std::ratio<127, 5000000>> {
    static std::string value() { return "mil"; }
};
 
template<>
struct quantity_suffix<meter_unit, std::ratio<127, 5000>> {
    static std::string value() { return "in"; }
};
 
template<>
struct quantity_suffix<meter_unit, std::ratio<381, 1250>> {
    static std::string value() { return "ft"; }
};
 
template<>
struct quantity_suffix<meter_unit, std::ratio<1143, 1250>> {
    static std::string value() { return "yd"; }
};
 
template<>
struct quantity_suffix<meter_unit, std::ratio<201168, 125>> {
    static std::string value() { return "mi"; }
};
 
template<>
struct quantity_suffix<meter_unit, std::ratio<1852>> {
    static std::string value() { return "nmi"; }
};
 
// Area
template<>
struct quantity_suffix<square_meter_unit, _square_ratio<std::nano>> {
    static std::string value() { return "nm²"; }
};
 
template<>
struct quantity_suffix<square_meter_unit, _square_ratio<std::micro>> {
    static std::string value() { return "µm²"; }
};
 
template<>
struct quantity_suffix<square_meter_unit, _square_ratio<std::milli>> {
    static std::string value() { return "mm²"; }
};
 
template<>
struct quantity_suffix<square_meter_unit, _square_ratio<std::centi>> {
    static std::string value() { return "cm²"; }
};
 
template<>
struct quantity_suffix<square_meter_unit, std::ratio<1>> {
    static std::string value() { return "m²"; }
};
 
template<>
struct quantity_suffix<square_meter_unit, _square_ratio<std::hecto>> {
    static std::string value() { return "ha"; }
    static std::string power_value() { return "hm²"; }
};
 
template<>
struct quantity_suffix<square_meter_unit, _square_ratio<std::kilo>> {
    static std::string value() { return "km²"; }
};
 
template<>
struct quantity_suffix<square_meter_unit, _square_ratio<mils::precision>> {
    static std::string value() { return "mil²"; }
};
 
template<>
struct quantity_suffix<square_meter_unit, _square_ratio<inches::precision>> {
    static std::string value() { return "in²"; }
};
 
template<>
struct quantity_suffix<square_meter_unit, _square_ratio<feet::precision>> {
    static std::string value() { return "ft²"; }
};
 
template<>
struct quantity_suffix<square_meter_unit, _square_ratio<yards::precision>> {
    static std::string value() { return "yd²"; }
};
 
template<>
struct quantity_suffix<square_meter_unit, acres::precision> {
    static std::string value() { return "ac"; }
};
 
template<>
struct quantity_suffix<square_meter_unit, _square_ratio<miles::precision>> {
    static std::string value() { return "mi²"; }
};
 
template<>
struct quantity_suffix<square_meter_unit, _square_ratio<nautical_miles::precision>> {
    static std::string value() { return "nmi²"; }
};
 
// Volume
template<>
struct quantity_suffix<cubic_meter_unit, _cube_ratio<std::micro>> {
    static std::string value() { return "µm³"; }
};
 
template<>
struct quantity_suffix<cubic_meter_unit, _cube_ratio<std::milli>> {
    static std::string value() { return "µL"; }
    static std::string power_value() { return "mm³"; }
};
 
template<>
struct quantity_suffix<cubic_meter_unit, _cube_ratio<std::centi>> {
    static std::string value() { return "mL"; }
    static std::string power_value() { return "cm³"; }
};
 
template<>
struct quantity_suffix<cubic_meter_unit, _cube_ratio<std::deci>> {
    static std::string value() { return "L"; }
    static std::string power_value() { return "dm³"; }
};
 
template<>
struct quantity_suffix<cubic_meter_unit, std::ratio<1>> {
    static std::string value() { return "m³"; }
};
 
template<>
struct quantity_suffix<cubic_meter_unit, _cube_ratio<std::kilo>> {
    static std::string value() { return "km³"; }
};
 
template<>
struct quantity_suffix<cubic_meter_unit, _cube_ratio<inches::precision>> {
    static std::string value() { return "in³"; }
};
 
template<>
struct quantity_suffix<cubic_meter_unit, _cube_ratio<feet::precision>> {
    static std::string value() { return "ft³"; }
};
 
template<>
struct quantity_suffix<cubic_meter_unit, _cube_ratio<yards::precision>> {
    static std::string value() { return "yd³"; }
};
 
template<>
struct quantity_suffix<cubic_meter_unit, _cube_ratio<miles::precision>> {
    static std::string value() { return "mi³"; }
};
 
template<>
struct quantity_suffix<cubic_meter_unit, _cube_ratio<nautical_miles::precision>> {
    static std::string value() { return "nmi³"; }
};
 
template<>
struct quantity_suffix<cubic_meter_unit, us_gallons::precision> {
    static std::string value() { return "gal"; }
};
 
template<typename Unit, typename Precision>
concept _has_suffix = requires { quantity_suffix<Unit, Precision>::value(); };
 
// The power-form suffix: power_value() when the specialization provides it,
// otherwise the default suffix.
template<typename Unit, typename Precision>
std::string _power_suffix() {
    if constexpr (requires { quantity_suffix<Unit, Precision>::power_value(); }) {
        return quantity_suffix<Unit, Precision>::power_value();
    } else {
        return quantity_suffix<Unit, Precision>::value();
    }
}
 
// A value and suffix to display, for the base-unit and scaled forms.
struct _display {
    double value;
    std::string suffix;
};
 
// Metric precisions are exactly the powers of ten (of the base unit); the
// imperial, nautical and US customary ones are not.
template<typename Precision>
concept _metric_precision = detail::_power_of_ten_precision<Precision>;
 
// The units the scaled form chooses between, by power-of-ten exponent of the
// base unit, in ascending order. Units without a list render in their own
// precision.
template<typename Unit>
struct _scale_units {};
 
template<>
struct _scale_units<meter_unit> {
    static constexpr detail::_scale_entry values[] = {{-9, "nm"}, {-6, "µm"}, {-3, "mm"}, {0, "m"}, {3, "km"}};
};
 
template<>
struct _scale_units<square_meter_unit> {
    static constexpr detail::_scale_entry values[] = {{-18, "nm²"}, {-12, "µm²"}, {-6, "mm²"}, {0, "m²"}, {6, "km²"}};
};
 
template<>
struct _scale_units<cubic_meter_unit> {
    static constexpr detail::_scale_entry values[] = {{-9, "µL"}, {-6, "mL"}, {-3, "L"}, {0, "m³"}};
};
 
// The quantity in the unit's base unit (m, m² or m³), as a double.
template<typename Unit, typename Rep, typename Precision>
_display _base_unit_display(const quantity<Unit, Rep, Precision>& q) {
    using p = typename Precision::type;
    return {detail::_ratio_value<p>(q.count()), Unit::symbol};
}
 
// The quantity in the largest candidate unit in which its magnitude is at
// least 1, else the smallest; zero (keeping its sign) and non-finite values
// are shown in the base unit, as the base-unit form would show them. Non-metric
// precisions are shown in their own 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 unit (1000 mm) are exactly 1 in it.
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 (_metric_precision<p> && requires { _scale_units<Unit>::values; }) {
        if (count == 0 || !std::isfinite(count)) {
            return {count, Unit::symbol};
        }
        const detail::_scaled s = detail::_pick_scale(count, _precision_exponent<p>, _scale_units<Unit>::values);
        return {s.value, s.label};
    } 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, with the power form ('p'); see detail::_unit_formatter.
template<typename Unit, typename Precision>
struct _format_traits {
    static constexpr const char* markers = "pbs";
    static constexpr bool has_own_unit = true;
 
    static std::string own_unit(bool power) {
        const std::string suffix = power ? _power_suffix<Unit, Precision>() : 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
 
struct power_form_t {
    explicit power_form_t() = default;
};
 
inline constexpr power_form_t power_form{};
 
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, power_form_t) {
    return _count_string(q.count()) + _power_suffix<Unit, typename Precision::type>();
}
 
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::spatial
 
namespace std {
 
template<typename Unit, typename Rep1, typename Precision1, typename Rep2, typename Precision2>
struct common_type<
    quanta::spatial::quantity<Unit, Rep1, Precision1>,
    quanta::spatial::quantity<Unit, Rep2, Precision2>> {
private:
    using common_precision = quanta::detail::_common_precision<Precision1, Precision2>;
 
public:
    using type = quanta::spatial::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
// (millimeters(250) -> "250mm"; floating-point counts in the shortest fixed
// notation that round-trips, as to_string does: length<double>(1e6) ->
// "1000000m", never "1e+06m"). 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}", millimeters(1500)) == "1500.0mm" and
// std::format("{:.1f}", feet(6)) == "6.0ft".
//
// 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:
// - 'p' (power form, see quanta::spatial::power_form) keeps the count and writes the
//   suffix as a power of a length unit: std::format("{:p}", milliliters(24))
//   == "24cm³" and std::format("{:p.1f}", milliliters(24)) == "24.0cm³".
// - 'b' (base unit, see quanta::base_unit) shows the value in m, m² or m³:
//   std::format("{:b.1f}", millimeters(1500)) == "1.5m".
// - 's' (scaled, see quanta::scaled) shows a metric value in a unit suited
//   to its magnitude: std::format("{:s}", milliliters(1500)) == "1.5L".
// 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}", milliliters(24)) == "0.000024m³".
//
// A spec starting with 'p', 'b' or 's' is always a marker, so these letters
// cannot be the fill character of a spec that starts with a fill
// ("{:p>10.1f}" is the marker followed by ">10.1f").
template<typename Unit, typename Rep, typename Precision>
    requires quanta::spatial::_has_suffix<Unit, typename Precision::type>
struct formatter<quanta::spatial::quantity<Unit, Rep, Precision>, char>
    : private quanta::detail::_unit_formatter<quanta::spatial::_format_traits<Unit, typename Precision::type>> {
    using quanta::detail::_unit_formatter<quanta::spatial::_format_traits<Unit, typename Precision::type>>::parse;
 
    template<typename FormatContext>
    auto format(const quanta::spatial::quantity<Unit, Rep, Precision>& q, FormatContext& ctx) const {
        return this->format_quantity(q, ctx);
    }
};
#endif
 
} // namespace std
 
namespace quanta {
inline namespace literals {
inline namespace spatial_literals {
template<char... Digits>
constexpr quanta::spatial::nanometers operator""_nm() {
    return detail::check_overflow<quanta::spatial::nanometers, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::micrometers operator""_um() {
    return detail::check_overflow<quanta::spatial::micrometers, Digits...>();
}
 
#if QUANTA_HAS_UTF8_LITERALS
template<char... Digits>
constexpr quanta::spatial::micrometers operator""_µm() {
    return detail::check_overflow<quanta::spatial::micrometers, Digits...>();
}
#endif
 
template<char... Digits>
constexpr quanta::spatial::millimeters operator""_mm() {
    return detail::check_overflow<quanta::spatial::millimeters, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::centimeters operator""_cm() {
    return detail::check_overflow<quanta::spatial::centimeters, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::meters operator""_m() {
    return detail::check_overflow<quanta::spatial::meters, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::kilometers operator""_km() {
    return detail::check_overflow<quanta::spatial::kilometers, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::mils operator""_mil() {
    return detail::check_overflow<quanta::spatial::mils, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::inches operator""_in() {
    return detail::check_overflow<quanta::spatial::inches, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::feet operator""_ft() {
    return detail::check_overflow<quanta::spatial::feet, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::yards operator""_yd() {
    return detail::check_overflow<quanta::spatial::yards, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::miles operator""_mi() {
    return detail::check_overflow<quanta::spatial::miles, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::nautical_miles operator""_nmi() {
    return detail::check_overflow<quanta::spatial::nautical_miles, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::square_millimeters operator""_mm2() {
    return detail::check_overflow<quanta::spatial::square_millimeters, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::square_centimeters operator""_cm2() {
    return detail::check_overflow<quanta::spatial::square_centimeters, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::square_meters operator""_m2() {
    return detail::check_overflow<quanta::spatial::square_meters, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::hectares operator""_ha() {
    return detail::check_overflow<quanta::spatial::hectares, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::square_kilometers operator""_km2() {
    return detail::check_overflow<quanta::spatial::square_kilometers, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::square_inches operator""_in2() {
    return detail::check_overflow<quanta::spatial::square_inches, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::square_feet operator""_ft2() {
    return detail::check_overflow<quanta::spatial::square_feet, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::square_yards operator""_yd2() {
    return detail::check_overflow<quanta::spatial::square_yards, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::acres operator""_ac() {
    return detail::check_overflow<quanta::spatial::acres, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::square_miles operator""_mi2() {
    return detail::check_overflow<quanta::spatial::square_miles, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::microliters operator""_uL() {
    return detail::check_overflow<quanta::spatial::microliters, Digits...>();
}
 
#if QUANTA_HAS_UTF8_LITERALS
template<char... Digits>
constexpr quanta::spatial::microliters operator""_µL() {
    return detail::check_overflow<quanta::spatial::microliters, Digits...>();
}
#endif
 
template<char... Digits>
constexpr quanta::spatial::milliliters operator""_mL() {
    return detail::check_overflow<quanta::spatial::milliliters, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::liters operator""_L() {
    return detail::check_overflow<quanta::spatial::liters, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::cubic_meters operator""_m3() {
    return detail::check_overflow<quanta::spatial::cubic_meters, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::cubic_millimeters operator""_mm3() {
    return detail::check_overflow<quanta::spatial::cubic_millimeters, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::cubic_centimeters operator""_cm3() {
    return detail::check_overflow<quanta::spatial::cubic_centimeters, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::cubic_inches operator""_in3() {
    return detail::check_overflow<quanta::spatial::cubic_inches, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::cubic_feet operator""_ft3() {
    return detail::check_overflow<quanta::spatial::cubic_feet, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::cubic_yards operator""_yd3() {
    return detail::check_overflow<quanta::spatial::cubic_yards, Digits...>();
}
 
template<char... Digits>
constexpr quanta::spatial::us_gallons operator""_gal() {
    return detail::check_overflow<quanta::spatial::us_gallons, Digits...>();
}
 
} // namespace spatial_literals
} // namespace literals
 
namespace spatial {
using namespace literals::spatial_literals;
} // namespace spatial
} // namespace quanta