thermo.hpp

Go to the documentation of this file.

#pragma once
 
#include <compare>
#include <concepts>
#include <cstdint>
#include <cstdlib>
#include <limits>
#include <ratio>
#include <string>
#include <version> // pulls in __cpp_lib_format so the detection below works in non-IDF builds
#ifndef CONFIG_THERMO_STD_FORMAT
#if __has_include(<format>) && defined(__cpp_lib_format)
#define CONFIG_THERMO_STD_FORMAT 1
#else
#define CONFIG_THERMO_STD_FORMAT 0
#endif
#endif
 
#if CONFIG_THERMO_STD_FORMAT
#include <format>
#endif
#include <assert.h>
 
static_assert(__cplusplus >= 202302L, "thermo requires C++23 or later");
 
namespace thermo {
 
template<typename Rep, typename Precision = std::ratio<1>>
class delta;
 
template<typename _T>
struct is_delta : std::false_type {};
 
template<typename Rep, typename Precision>
struct is_delta<delta<Rep, Precision>> : std::true_type {};
 
template<typename T, template<typename...> class Template>
struct _is_specialization_of : std::false_type {};
 
template<template<typename...> class Template, typename... Args>
struct _is_specialization_of<Template<Args...>, Template> : std::true_type {};
 
template<typename T, template<typename...> class Template>
inline constexpr bool _is_specialization_of_v = _is_specialization_of<T, Template>::value;
 
template<typename Rep>
concept not_delta = !_is_specialization_of_v<Rep, delta>;
 
template<typename Rep>
struct delta_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;
}
 
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;
template<typename Rep, typename Precision>
class delta {
    static_assert(!is_delta<Rep>::value, "rep cannot be a thermo::delta");
    static_assert(_is_ratio<Precision>::value, "precision must be a specialization of std::ratio");
    static_assert(Precision::num > 0, "precision must be positive");
 
public:
    using rep = Rep;
    using precision = typename Precision::type;
 
    constexpr delta() = default;
    delta(const delta&) = default;
 
    template<typename Rep2>
        requires std::convertible_to<const Rep2&, rep> && (treat_as_inexact_v<rep> || !treat_as_inexact_v<Rep2>)
    constexpr explicit delta(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 delta(const delta<Rep2, Precision2>& temp)
        : _r(delta_cast<delta>(temp).count()) {}
 
    ~delta() = default;
    delta& operator=(const delta&) = default;
 
    constexpr rep count() const { return _r; }
 
    constexpr delta<typename std::common_type<rep>::type, precision> operator+() const {
        return delta<typename std::common_type<rep>::type, precision>(_r);
    }
 
    constexpr delta<typename std::common_type<rep>::type, precision> operator-() const {
        return delta<typename std::common_type<rep>::type, precision>(-_r);
    }
 
    constexpr delta& operator++() {
        ++_r;
        return *this;
    }
 
    constexpr delta operator++(int) { return delta(_r++); }
 
    constexpr delta& operator--() {
        --_r;
        return *this;
    }
 
    constexpr delta operator--(int) { return delta(_r--); }
 
    constexpr delta& operator+=(const delta& d) {
        _r += d.count();
        return *this;
    }
 
    constexpr delta& operator-=(const delta& d) {
        _r -= d.count();
        return *this;
    }
 
    constexpr delta& operator*=(const rep& r) {
        _r *= r;
        return *this;
    }
 
    constexpr delta& operator/=(const rep& r) {
        _r /= r;
        return *this;
    }
 
    constexpr delta& operator%=(const rep& r)
        requires(!treat_as_inexact_v<rep>)
    {
        _r %= r;
        return *this;
    }
 
    constexpr delta& operator%=(const delta& d)
        requires(!treat_as_inexact_v<rep>)
    {
        _r %= d.count();
        return *this;
    }
 
    static constexpr delta zero() noexcept { return delta(delta_values<rep>::zero()); }
 
    static constexpr delta min() noexcept { return delta(delta_values<rep>::min()); }
 
    static constexpr delta max() noexcept { return delta(delta_values<rep>::max()); }
 
private:
    rep _r{};
};
 
template<typename ToDelta, typename Rep, typename Precision>
constexpr ToDelta delta_cast(const delta<Rep, Precision>& d) {
    if constexpr (std::is_same_v<ToDelta, delta<Rep, Precision>>) {
        return d;
    } else {
        using to_rep = typename ToDelta::rep;
        using to_precision = typename ToDelta::precision;
        using cf = std::ratio_divide<Precision, to_precision>;
        using cr = std::common_type_t<to_rep, Rep, intmax_t>;
 
        if constexpr (cf::den == 1 && cf::num == 1) {
            return ToDelta(static_cast<to_rep>(d.count()));
        } else if constexpr (cf::den == 1) {
            return ToDelta(static_cast<to_rep>(static_cast<cr>(d.count()) * static_cast<cr>(cf::num)));
        } else if constexpr (cf::num == 1) {
            return ToDelta(static_cast<to_rep>(static_cast<cr>(d.count()) / static_cast<cr>(cf::den)));
        } else {
            return ToDelta(
                static_cast<to_rep>(static_cast<cr>(d.count()) * static_cast<cr>(cf::num) / static_cast<cr>(cf::den))
            );
        }
    }
}
 
template<typename ToDelta, typename Rep, typename Precision>
constexpr ToDelta ceil(const delta<Rep, Precision>& d) {
    ToDelta result = delta_cast<ToDelta>(d);
    if (result < d) {
        return ToDelta(result.count() + 1);
    }
    return result;
}
 
template<typename ToDelta, typename Rep, typename Precision>
constexpr ToDelta floor(const delta<Rep, Precision>& d) {
    ToDelta result = delta_cast<ToDelta>(d);
    if (result > d) {
        return ToDelta(result.count() - 1);
    }
    return result;
}
 
template<typename ToDelta, typename Rep, typename Precision>
constexpr ToDelta trunc(const delta<Rep, Precision>& d) {
    return delta_cast<ToDelta>(d);
}
 
template<typename ToDelta, typename Rep, typename Precision>
constexpr ToDelta round(const delta<Rep, Precision>& d) {
    ToDelta result = delta_cast<ToDelta>(d);
    if (result == d) {
        return result;
    }
 
    // Calculate the midpoint between result and the next value
    ToDelta next = (result < d) ? ToDelta(result.count() + 1) : ToDelta(result.count() - 1);
 
    // Convert both to source type for comparison
    auto result_in_source = delta_cast<delta<Rep, Precision>>(result);
    auto next_in_source = delta_cast<delta<Rep, Precision>>(next);
 
    // Calculate distances
    auto dist_to_result = (d > result_in_source) ? d - result_in_source : result_in_source - d;
    auto dist_to_next = (d > next_in_source) ? d - next_in_source : next_in_source - d;
 
    // If closer to next, or exactly halfway and away from zero, use next
    if (dist_to_next < dist_to_result) {
        return next;
    } else if (dist_to_next == dist_to_result) {
        // Tie: round away from zero
        if (d.count() >= 0) {
            return (next > result) ? next : result;
        } else {
            return (next < result) ? next : result;
        }
    }
 
    return result;
}
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
constexpr auto operator+(const delta<Rep1, Precision1>& lhs, const delta<Rep2, Precision2>& rhs)
    -> std::common_type_t<delta<Rep1, Precision1>, delta<Rep2, Precision2>> {
    using cd = std::common_type_t<delta<Rep1, Precision1>, delta<Rep2, Precision2>>;
    return cd(cd(lhs).count() + cd(rhs).count());
}
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
constexpr auto operator-(const delta<Rep1, Precision1>& lhs, const delta<Rep2, Precision2>& rhs)
    -> std::common_type_t<delta<Rep1, Precision1>, delta<Rep2, Precision2>> {
    using cd = std::common_type_t<delta<Rep1, Precision1>, delta<Rep2, Precision2>>;
    return cd(cd(lhs).count() - cd(rhs).count());
}
 
template<typename Rep1, typename Precision, typename Rep2>
    requires not_delta<Rep2> && std::convertible_to<const Rep2&, std::common_type_t<Rep1, Rep2>>
constexpr auto operator*(const delta<Rep1, Precision>& d, const Rep2& r)
    -> delta<std::common_type_t<Rep1, Rep2>, Precision> {
    using cd = delta<std::common_type_t<Rep1, Rep2>, Precision>;
    return cd(cd(d).count() * r);
}
 
template<typename Rep1, typename Rep2, typename Precision>
    requires not_delta<Rep1> && std::convertible_to<const Rep1&, std::common_type_t<Rep1, Rep2>>
constexpr auto operator*(const Rep1& r, const delta<Rep2, Precision>& d)
    -> delta<std::common_type_t<Rep1, Rep2>, Precision> {
    return d * r;
}
 
template<typename Rep1, typename Precision, typename Rep2>
    requires not_delta<Rep2> && std::convertible_to<const Rep2&, std::common_type_t<Rep1, Rep2>>
constexpr auto operator/(const delta<Rep1, Precision>& d, const Rep2& s)
    -> delta<std::common_type_t<Rep1, Rep2>, Precision> {
    using cd = delta<std::common_type_t<Rep1, Rep2>, Precision>;
    return cd(cd(d).count() / s);
}
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
constexpr auto operator/(const delta<Rep1, Precision1>& lhs, const delta<Rep2, Precision2>& rhs)
    -> std::common_type_t<Rep1, Rep2> {
    using cd = std::common_type_t<delta<Rep1, Precision1>, delta<Rep2, Precision2>>;
    return cd(lhs).count() / cd(rhs).count();
}
 
template<typename Rep1, typename Precision, typename Rep2>
    requires not_delta<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 delta<Rep1, Precision>& d, const Rep2& s)
    -> delta<std::common_type_t<Rep1, Rep2>, Precision> {
    using cd = delta<std::common_type_t<Rep1, Rep2>, Precision>;
    return cd(cd(d).count() % s);
}
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
    requires(!treat_as_inexact_v<Rep1> && !treat_as_inexact_v<Rep2>)
constexpr auto operator%(const delta<Rep1, Precision1>& lhs, const delta<Rep2, Precision2>& rhs)
    -> std::common_type_t<delta<Rep1, Precision1>, delta<Rep2, Precision2>> {
    using cd = std::common_type_t<delta<Rep1, Precision1>, delta<Rep2, Precision2>>;
    return cd(cd(lhs).count() % cd(rhs).count());
}
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
constexpr bool operator==(const delta<Rep1, Precision1>& lhs, const delta<Rep2, Precision2>& rhs) {
    using ct = std::common_type_t<delta<Rep1, Precision1>, delta<Rep2, Precision2>>;
    return ct(lhs).count() == ct(rhs).count();
}
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
    requires std::three_way_comparable<std::common_type_t<Rep1, Rep2>>
constexpr auto operator<=>(const delta<Rep1, Precision1>& lhs, const delta<Rep2, Precision2>& rhs) {
    using ct = std::common_type_t<delta<Rep1, Precision1>, delta<Rep2, Precision2>>;
    return ct(lhs).count() <=> ct(rhs).count();
}
 
using delta_celsius = delta<int64_t>;
using delta_decicelsius = delta<int64_t, std::deci>;
using delta_millicelsius = delta<int64_t, std::milli>;
using delta_kelvin = delta<int64_t>;
using delta_decikelvin = delta<int64_t, std::deci>;
using delta_millikelvin = delta<int64_t, std::milli>;
using delta_fahrenheit = delta<int64_t, std::ratio<5, 9>>;
using delta_decifahrenheit = delta<int64_t, std::ratio<5, 90>>;
using delta_millifahrenheit = delta<int64_t, std::ratio<5, 9000>>;
 
// SI prefix for a degrees-per-count ratio; nullptr when unmapped.
template<typename Ratio>
struct _si_prefix {
    static constexpr const char* value = nullptr;
};
template<>
struct _si_prefix<std::ratio<1>> {
    static constexpr const char* value = "";
};
template<>
struct _si_prefix<std::ratio<1, 10>> {
    static constexpr const char* value = "d";
};
template<>
struct _si_prefix<std::ratio<1, 1000>> {
    static constexpr const char* value = "m";
};
template<typename Ratio>
inline constexpr const char* _si_prefix_v = _si_prefix<typename Ratio::type>::value;
 
// Display family (degree size + unit suffix) for a delta precision, keyed on
// NORMALIZED ratios. Undefined primary template: unmapped precisions have no
// determinable unit and are not formattable.
template<typename Precision>
struct _delta_unit;
struct _celsius_delta_unit {
    using degree = std::ratio<1>;
    static constexpr const char* suffix = "°C";
};
struct _fahrenheit_delta_unit {
    using degree = std::ratio<5, 9>;
    static constexpr const char* suffix = "°F";
};
template<>
struct _delta_unit<std::ratio<1>> : _celsius_delta_unit {};
template<>
struct _delta_unit<std::ratio<1, 10>> : _celsius_delta_unit {};
template<>
struct _delta_unit<std::ratio<1, 1000>> : _celsius_delta_unit {};
template<>
struct _delta_unit<std::ratio<5, 9>> : _fahrenheit_delta_unit {};
template<>
struct _delta_unit<std::ratio<1, 18>> : _fahrenheit_delta_unit {}; // 5/90 normalized
template<>
struct _delta_unit<std::ratio<1, 1800>> : _fahrenheit_delta_unit {}; // 5/9000 normalized
 
// 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;
}
 
#if CONFIG_THERMO_STD_FORMAT
// Reports an unusable format spec from a formatter's parse().
//
// std::format constant-evaluates parse() to check the format string, so
// throwing there makes a bad spec a compile error rather than a runtime fault.
// Where exceptions are unavailable, calling a non-constexpr function fails that
// same constant evaluation and so reports the error at compile time too; a
// runtime parse (std::vformat with a runtime format string) has no way to
// report it and terminates.
[[noreturn]] inline void _format_error(const char* what) {
#if defined(__cpp_exceptions) && __cpp_exceptions
    throw std::format_error(what);
#else
    (void)what;
    std::abort();
#endif
}
#endif
template<typename Rep, typename Precision>
    requires(!treat_as_inexact_v<Rep>)
std::string to_string(const delta<Rep, Precision>& d) {
    using unit = _delta_unit<typename delta<Rep, Precision>::precision>;
    using dpc = std::ratio_divide<typename delta<Rep, Precision>::precision, typename unit::degree>;
    static_assert(_si_prefix_v<dpc> != nullptr, "thermo: precision has no SI prefix");
    return std::to_string(d.count()) + "Δ" + _si_prefix_v<dpc> + unit::suffix;
}
 
// ============================================================================
// Temperature Scales and Absolute Temperatures
// ============================================================================
 
struct celsius_scale {
    using offset = std::ratio<27315, 100>;
    using degree = std::ratio<1>;
    static constexpr const char* suffix = "°C";
};
 
struct kelvin_scale {
    using offset = std::ratio<0>;
    using degree = std::ratio<1>;
    static constexpr const char* suffix = "K";
};
 
struct fahrenheit_scale {
    using offset = std::ratio<45967, 180>;
    using degree = std::ratio<5, 9>;
    static constexpr const char* suffix = "°F";
};
 
template<typename Scale>
inline constexpr bool _is_relative_scale = std::ratio_not_equal_v<typename Scale::offset, std::ratio<0>>;
template<typename Scale, typename Delta = delta<int64_t>>
class temperature;
 
template<typename Scale1, typename Delta1, typename Scale2, typename Delta2>
struct _lossless_temperature_conversion_impl {
    using from_prec = typename Delta1::precision;
    using to_prec = typename Delta2::precision;
    using from_off = typename Scale1::offset;
    using to_off = typename Scale2::offset;
 
    using prec_ratio = std::ratio_divide<from_prec, to_prec>;
    using offset_diff = std::ratio_subtract<from_off, to_off>;
    using offset_in_target_units = std::ratio_divide<offset_diff, to_prec>;
 
    static constexpr bool value = prec_ratio::den == 1 && offset_in_target_units::den == 1;
};
 
template<typename Scale1, typename Delta1, typename Scale2, typename Delta2>
concept _lossless_temperature_conversion = _lossless_temperature_conversion_impl<Scale1, Delta1, Scale2, Delta2>::value;
 
template<typename T>
struct is_temperature : std::false_type {};
 
template<typename Scale, typename Delta>
struct is_temperature<temperature<Scale, Delta>> : std::true_type {};
 
template<typename T>
inline constexpr bool is_temperature_v = is_temperature<T>::value;
template<typename ToTemp, typename Scale, typename Delta>
constexpr ToTemp temperature_cast(const temperature<Scale, Delta>& t);
 
template<typename Scale, typename Delta>
class temperature {
    static_assert(is_delta<Delta>::value, "Delta must be a thermo::delta type");
 
public:
    using scale = Scale;
    using delta_type = Delta;
    using rep = typename Delta::rep;
 
    constexpr temperature() = default;
    temperature(const temperature&) = default;
 
    template<typename Rep2>
        requires std::convertible_to<const Rep2&, rep> && (treat_as_inexact_v<rep> || !treat_as_inexact_v<Rep2>)
    constexpr explicit temperature(const Rep2& r)
        : _d(static_cast<rep>(r)) {}
 
    constexpr explicit temperature(const Delta& d)
        : _d(d) {}
 
    // Same-scale, different precision - implicit when lossless
    template<typename Delta2>
        requires(!std::is_same_v<Delta, Delta2>) &&
        (treat_as_inexact_v<rep> ||
         (_harmonic_precision<typename Delta2::precision, typename Delta::precision> &&
          !treat_as_inexact_v<typename Delta2::rep>))
    constexpr temperature(const temperature<Scale, Delta2>& t)
        : _d(delta_cast<Delta>(Delta2(t.count()))) {}
 
    // Same-scale, different precision - explicit when lossy
    template<typename Delta2>
        requires(!std::is_same_v<Delta, Delta2>) && (!treat_as_inexact_v<rep>) &&
        (!_harmonic_precision<typename Delta2::precision, typename Delta::precision>)
    constexpr explicit temperature(const temperature<Scale, Delta2>& t)
        : _d(delta_cast<Delta>(Delta2(t.count()))) {}
 
    // Cross-scale/precision conversion - implicit when lossless
    template<typename Scale2, typename Delta2>
        requires(!std::is_same_v<temperature, temperature<Scale2, Delta2>>) &&
        _lossless_temperature_conversion<Scale2, Delta2, Scale, Delta> &&
        (treat_as_inexact_v<rep> || !treat_as_inexact_v<typename Delta2::rep>)
    constexpr temperature(const temperature<Scale2, Delta2>& t)
        : temperature(temperature_cast<temperature>(t)) {}
 
    // Cross-scale/precision conversion - explicit when lossy
    template<typename Scale2, typename Delta2>
        requires(!std::is_same_v<temperature, temperature<Scale2, Delta2>>) &&
        (!_lossless_temperature_conversion<Scale2, Delta2, Scale, Delta>)
    constexpr explicit temperature(const temperature<Scale2, Delta2>& t)
        : temperature(temperature_cast<temperature>(t)) {}
 
    ~temperature() = default;
    temperature& operator=(const temperature&) = default;
 
    constexpr rep count() const { return _d.count(); }
 
    constexpr temperature& operator++() {
        ++_d;
        return *this;
    }
 
    constexpr temperature operator++(int) { return temperature(_d++); }
 
    constexpr temperature& operator--() {
        --_d;
        return *this;
    }
 
    constexpr temperature operator--(int) { return temperature(_d--); }
 
    constexpr temperature operator-() const
        requires _is_relative_scale<Scale>
    {
        return temperature(-_d);
    }
 
    template<typename Rep2, typename Precision2>
    constexpr temperature& operator+=(const delta<Rep2, Precision2>& d) {
        _d += d;
        return *this;
    }
 
    template<typename Rep2, typename Precision2>
    constexpr temperature& operator-=(const delta<Rep2, Precision2>& d) {
        _d -= d;
        return *this;
    }
 
    static constexpr temperature min() noexcept { return temperature(Delta::min()); }
 
    static constexpr temperature max() noexcept { return temperature(Delta::max()); }
 
private:
    Delta _d{};
};
 
template<typename ToTemp, typename Scale, typename Delta>
constexpr ToTemp temperature_cast(const temperature<Scale, Delta>& t) {
    using ToScale = typename ToTemp::scale;
    using ToDelta = typename ToTemp::delta_type;
    using to_rep = typename ToDelta::rep;
 
    if constexpr (std::is_same_v<Scale, ToScale> && std::is_same_v<Delta, ToDelta>) {
        return t;
    } else if constexpr (std::is_same_v<Scale, ToScale>) {
        return ToTemp(delta_cast<ToDelta>(Delta(t.count())));
    } else {
        using from_prec = typename Delta::precision;
        using from_off = typename Scale::offset;
        using to_prec = typename ToDelta::precision;
        using to_off = typename ToScale::offset;
 
        using offset_diff = std::ratio_subtract<from_off, to_off>;
        using common_rep = std::common_type_t<typename Delta::rep, to_rep, intmax_t>;
 
        common_rep from_val = static_cast<common_rep>(t.count());
 
        using prec_ratio = std::ratio_divide<from_prec, to_prec>;
        using offset_ratio = std::ratio_divide<offset_diff, to_prec>;
 
        if constexpr (treat_as_inexact_v<common_rep>) {
            constexpr double pr = static_cast<double>(prec_ratio::num) / prec_ratio::den;
            constexpr double or_ = static_cast<double>(offset_ratio::num) / offset_ratio::den;
            common_rep result = from_val * pr + or_;
            return ToTemp(ToDelta(static_cast<to_rep>(result)));
        } else {
            constexpr intmax_t combined_den =
                static_cast<intmax_t>(prec_ratio::den) * static_cast<intmax_t>(offset_ratio::den);
            common_rep numerator =
                from_val * static_cast<common_rep>(prec_ratio::num) * static_cast<common_rep>(offset_ratio::den) +
                static_cast<common_rep>(offset_ratio::num) * static_cast<common_rep>(prec_ratio::den);
            common_rep result = numerator / static_cast<common_rep>(combined_den);
            return ToTemp(ToDelta(static_cast<to_rep>(result)));
        }
    }
}
 
template<typename Scale, typename Delta1, typename Delta2>
constexpr auto operator+(const temperature<Scale, Delta1>& lhs, const temperature<Scale, Delta2>& rhs)
    -> temperature<Scale, std::common_type_t<Delta1, Delta2>> {
    using cd = std::common_type_t<Delta1, Delta2>;
    return temperature<Scale, cd>(cd(lhs.count()) + cd(rhs.count()));
}
 
template<typename Scale, typename Delta1, typename Delta2>
constexpr auto operator-(const temperature<Scale, Delta1>& lhs, const temperature<Scale, Delta2>& rhs)
    -> temperature<Scale, std::common_type_t<Delta1, Delta2>> {
    using cd = std::common_type_t<Delta1, Delta2>;
    return temperature<Scale, cd>(cd(lhs.count()) - cd(rhs.count()));
}
 
template<typename Scale, typename Delta1, typename Delta2>
constexpr auto difference(const temperature<Scale, Delta1>& lhs, const temperature<Scale, Delta2>& rhs)
    -> std::common_type_t<Delta1, Delta2> {
    using cd = std::common_type_t<Delta1, Delta2>;
    return cd(lhs.count() - rhs.count());
}
 
template<typename Scale, typename Delta1, typename Rep2, typename Precision2>
constexpr auto operator+(const temperature<Scale, Delta1>& t, const delta<Rep2, Precision2>& d)
    -> temperature<Scale, std::common_type_t<Delta1, delta<Rep2, Precision2>>> {
    using result_delta = std::common_type_t<Delta1, delta<Rep2, Precision2>>;
    return temperature<Scale, result_delta>(result_delta(t.count()) + result_delta(d));
}
 
template<typename Rep1, typename Precision1, typename Scale, typename Delta2>
constexpr auto operator+(const delta<Rep1, Precision1>& d, const temperature<Scale, Delta2>& t)
    -> temperature<Scale, std::common_type_t<delta<Rep1, Precision1>, Delta2>> {
    return t + d;
}
 
template<typename Scale, typename Delta1, typename Rep2, typename Precision2>
constexpr auto operator-(const temperature<Scale, Delta1>& t, const delta<Rep2, Precision2>& d)
    -> temperature<Scale, std::common_type_t<Delta1, delta<Rep2, Precision2>>> {
    using result_delta = std::common_type_t<Delta1, delta<Rep2, Precision2>>;
    return temperature<Scale, result_delta>(result_delta(t.count()) - result_delta(d));
}
 
template<typename Scale, typename Delta1, typename Delta2>
constexpr bool operator==(const temperature<Scale, Delta1>& lhs, const temperature<Scale, Delta2>& rhs) {
    return lhs.count() == rhs.count();
}
 
template<typename Scale, typename Delta1, typename Delta2>
    requires std::three_way_comparable<std::common_type_t<typename Delta1::rep, typename Delta2::rep>>
constexpr auto operator<=>(const temperature<Scale, Delta1>& lhs, const temperature<Scale, Delta2>& rhs) {
    return lhs.count() <=> rhs.count();
}
 
using celsius = temperature<celsius_scale>;
using decicelsius = temperature<celsius_scale, delta<int64_t, std::deci>>;
using millicelsius = temperature<celsius_scale, delta<int64_t, std::milli>>;
using kelvin = temperature<kelvin_scale>;
using decikelvin = temperature<kelvin_scale, delta<int64_t, std::deci>>;
using millikelvin = temperature<kelvin_scale, delta<int64_t, std::milli>>;
using fahrenheit = temperature<fahrenheit_scale, delta<int64_t, std::ratio<5, 9>>>;
using decifahrenheit = temperature<fahrenheit_scale, delta<int64_t, std::ratio<5, 90>>>;
using millifahrenheit = temperature<fahrenheit_scale, delta<int64_t, std::ratio<5, 9000>>>;
 
template<typename Scale, typename Rep, typename Precision>
    requires(!treat_as_inexact_v<Rep>)
std::string to_string(const temperature<Scale, delta<Rep, Precision>>& t) {
    using dpc = std::ratio_divide<typename delta<Rep, Precision>::precision, typename Scale::degree>;
    static_assert(_si_prefix_v<dpc> != nullptr, "thermo: precision has no SI prefix");
    return std::to_string(t.count()) + _si_prefix_v<dpc> + Scale::suffix;
}
 
} // namespace thermo
 
namespace std {
 
template<typename Rep1, typename Precision1, typename Rep2, typename Precision2>
struct common_type<thermo::delta<Rep1, Precision1>, thermo::delta<Rep2, Precision2>> {
private:
    using common_precision = std::ratio<
        thermo::_gcd(Precision1::num, Precision2::num),
        (Precision1::den / thermo::_gcd(Precision1::den, Precision2::den)) * Precision2::den>;
 
public:
    using type = thermo::delta<std::common_type_t<Rep1, Rep2>, common_precision>;
};
 
template<typename Scale, typename Delta1, typename Delta2>
struct common_type<thermo::temperature<Scale, Delta1>, thermo::temperature<Scale, Delta2>> {
    using type = thermo::temperature<Scale, std::common_type_t<Delta1, Delta2>>;
};
 
#if CONFIG_THERMO_STD_FORMAT
// "{}" prints the exact stored count with a precision-qualified unit
// (millicelsius(22500) -> "22500m°C"). A non-empty spec is applied to the
// value in scale degrees (as double), honoring the standard floating-point
// format spec: std::format("{:.1f}", millicelsius(22534)) == "22.5°C".
template<typename Scale, typename Rep, typename Precision>
struct formatter<thermo::temperature<Scale, thermo::delta<Rep, Precision>>> {
private:
    using _delta_t = thermo::delta<Rep, Precision>;
    using _dpc = typename ratio_divide<typename _delta_t::precision, typename Scale::degree>::type;
    static constexpr const char* _prefix = thermo::_si_prefix_v<_dpc>;
    std::formatter<double> _num;
    bool _has_spec = false;
 
public:
    constexpr auto parse(format_parse_context& ctx) {
        auto it = ctx.begin();
        if (it == ctx.end() || *it == '}') {
            if constexpr (_prefix == nullptr) {
                thermo::_format_error("thermo: precision has no SI prefix; use an explicit format spec");
            }
            return it;
        }
        _has_spec = true;
        return _num.parse(ctx);
    }
 
    template<typename FormatContext>
    auto format(const thermo::temperature<Scale, _delta_t>& t, FormatContext& ctx) const {
        if (_has_spec) {
            double degrees = static_cast<double>(t.count()) * _dpc::num / _dpc::den;
            auto out = _num.format(degrees, ctx);
            return thermo::_format_append(out, Scale::suffix);
        }
        auto out = std::format_to(ctx.out(), "{}", t.count());
        out = thermo::_format_append(out, _prefix);
        return thermo::_format_append(out, Scale::suffix);
    }
};
 
// "{}" prints the exact stored count with a precision-qualified unit
// (delta_millicelsius(1500) -> "1500Δm°C"). A non-empty spec is applied to
// the value in scale degrees (as double):
// std::format("{:.1f}", delta_millicelsius(1500)) == "1.5Δ°C".
template<typename Rep, typename Precision>
struct formatter<thermo::delta<Rep, Precision>> {
private:
    using _delta_t = thermo::delta<Rep, Precision>;
    using _unit = thermo::_delta_unit<typename _delta_t::precision>; // hard error if unmapped
    using _dpc = typename ratio_divide<typename _delta_t::precision, typename _unit::degree>::type;
    static constexpr const char* _prefix = thermo::_si_prefix_v<_dpc>;
    std::formatter<double> _num;
    bool _has_spec = false;
 
public:
    constexpr auto parse(format_parse_context& ctx) {
        auto it = ctx.begin();
        if (it == ctx.end() || *it == '}') {
            if constexpr (_prefix == nullptr) {
                thermo::_format_error("thermo: precision has no SI prefix; use an explicit format spec");
            }
            return it;
        }
        _has_spec = true;
        return _num.parse(ctx);
    }
 
    template<typename FormatContext>
    auto format(const _delta_t& d, FormatContext& ctx) const {
        if (_has_spec) {
            double degrees = static_cast<double>(d.count()) * _dpc::num / _dpc::den;
            auto out = _num.format(degrees, ctx);
            out = thermo::_format_append(out, "Δ");
            return thermo::_format_append(out, _unit::suffix);
        }
        auto out = std::format_to(ctx.out(), "{}", d.count());
        out = thermo::_format_append(out, "Δ");
        out = thermo::_format_append(out, _prefix);
        return thermo::_format_append(out, _unit::suffix);
    }
};
#endif
 
} // namespace std
 
namespace thermo_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 Delta, char... Digits>
constexpr Delta check_overflow() {
    using parsed = parse_int<Digits...>;
    constexpr typename Delta::rep repval = parsed::value;
    static_assert(
        repval >= 0 && static_cast<unsigned long long>(repval) == parsed::value,
        "literal value cannot be represented by delta type"
    );
    return Delta(repval);
}
 
} // namespace detail
template<char... Digits>
constexpr thermo::celsius operator""_c() {
    return thermo::celsius(detail::check_overflow<thermo::delta_celsius, Digits...>());
}
 
template<char... Digits>
constexpr thermo::decicelsius operator""_dc() {
    return thermo::decicelsius(detail::check_overflow<thermo::delta_decicelsius, Digits...>());
}
 
template<char... Digits>
constexpr thermo::millicelsius operator""_mc() {
    return thermo::millicelsius(detail::check_overflow<thermo::delta_millicelsius, Digits...>());
}
 
template<char... Digits>
constexpr thermo::kelvin operator""_k() {
    return thermo::kelvin(detail::check_overflow<thermo::delta_kelvin, Digits...>());
}
 
template<char... Digits>
constexpr thermo::decikelvin operator""_dk() {
    return thermo::decikelvin(detail::check_overflow<thermo::delta_decikelvin, Digits...>());
}
 
template<char... Digits>
constexpr thermo::millikelvin operator""_mk() {
    return thermo::millikelvin(detail::check_overflow<thermo::delta_millikelvin, Digits...>());
}
 
template<char... Digits>
constexpr thermo::fahrenheit operator""_f() {
    return thermo::fahrenheit(detail::check_overflow<thermo::delta_fahrenheit, Digits...>());
}
 
template<char... Digits>
constexpr thermo::decifahrenheit operator""_df() {
    return thermo::decifahrenheit(detail::check_overflow<thermo::delta_decifahrenheit, Digits...>());
}
 
template<char... Digits>
constexpr thermo::millifahrenheit operator""_mf() {
    return thermo::millifahrenheit(detail::check_overflow<thermo::delta_millifahrenheit, Digits...>());
}
 
template<char... Digits>
constexpr thermo::delta_celsius operator""_Δc() {
    return detail::check_overflow<thermo::delta_celsius, Digits...>();
}
 
template<char... Digits>
constexpr thermo::delta_millicelsius operator""_Δmc() {
    return detail::check_overflow<thermo::delta_millicelsius, Digits...>();
}
 
template<char... Digits>
constexpr thermo::delta_kelvin operator""_Δk() {
    return detail::check_overflow<thermo::delta_kelvin, Digits...>();
}
 
template<char... Digits>
constexpr thermo::delta_millikelvin operator""_Δmk() {
    return detail::check_overflow<thermo::delta_millikelvin, Digits...>();
}
 
template<char... Digits>
constexpr thermo::delta_fahrenheit operator""_Δf() {
    return detail::check_overflow<thermo::delta_fahrenheit, Digits...>();
}
 
template<char... Digits>
constexpr thermo::delta_millifahrenheit operator""_Δmf() {
    return detail::check_overflow<thermo::delta_millifahrenheit, Digits...>();
}
 
} // namespace thermo_literals