units/base.hpp

Go to the documentation of this file.

/*
 
Copyright 2025 Matthew Tolman
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
   http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
 
*/
 
#ifndef MTCORE_UNITS_BASE_HPP
#define MTCORE_UNITS_BASE_HPP
 
#include "mtcore/math/core.hpp"
#include "mtcore/math/templates.hpp"
#include "mtcore/meta/base.hpp"
 
#include <numbers>
#include <ratio>


namespace mtcore::units {
  template<typename Underlying, typename Units>
  struct UnitValue;

  template<size_t UnitCategory, typename S = std::ratio<1>, int PiPow = 0, typename Tr = std::ratio<0>, int exp = 1>
  struct Unit {
    static constexpr size_t Id     = UnitCategory;
    using Scale                    = S;
    static constexpr auto PiPower  = PiPow;
    using Translation              = Tr;
    static constexpr auto EXPONENT = exp;
  };

  template<typename T>
  concept IsUnit = std::same_as<T, Unit<T::Id, typename T::Scale, T::PiPower, typename T::Translation, T::EXPONENT>>;

  template<IsUnit... Us>
  struct Units;
 
  template<size_t Id, typename S, int PiPow, typename Tr, int Exp, IsUnit... Mappings>
  struct Units<Unit<Id, S, PiPow, Tr, Exp>, Mappings...> {
    using Head = Unit<Id, S, PiPow, Tr, Exp>;
    using Rest = Units<Mappings...>;
  };
 
  template<>
  struct Units<> {
    using Head = void;
    using Rest = void;
  };
 
  namespace impl {
    template<typename L, typename R>
    struct ConcatUnits;
 
    template<IsUnit... LU, IsUnit... RU>
    struct ConcatUnits<Units<LU...>, Units<RU...>> {
      using T = Units<LU..., RU...>;
    };

    template<size_t CategoryId, typename T>
    struct GetUnitsImpl;
 
    template<size_t CategoryId, typename S, int PiPow, int exp, typename Tr, typename... Mappings>
    struct GetUnitsImpl<CategoryId, Units<Unit<CategoryId, S, PiPow, Tr, exp>, Mappings...>> {
      using Rest = GetUnitsImpl<CategoryId, Units<Mappings...>>;
      using T    = typename ConcatUnits<Units<Unit<CategoryId, S, PiPow, Tr, exp>>, typename Rest::T>::T;
    };
 
    template<size_t CategoryId, size_t CurId, typename S, int PiPow, int exp, typename Tr, typename... Mappings>
    struct GetUnitsImpl<CategoryId, Units<Unit<CurId, S, PiPow, Tr, exp>, Mappings...>> {
      using Rest = GetUnitsImpl<CategoryId, Units<Mappings...>>;
      using T    = typename Rest::T;
    };
 
    template<size_t CategoryId>
    struct GetUnitsImpl<CategoryId, Units<>> {
      using T = Units<>;
    };

    template<size_t CategoryId, typename U>
    struct GetUnits : GetUnitsImpl<CategoryId, std::remove_cvref_t<U>> {};

    template<size_t CategoryId, typename T, size_t Indx = 0>
    struct GetUnitImpl;
 
    template<size_t CategoryId, typename S, int PiPow, int exp, typename Tr, typename... Mappings, size_t Indx>
    struct GetUnitImpl<CategoryId, Units<Unit<CategoryId, S, PiPow, Tr, exp>, Mappings...>, Indx> {
      using Rest  = GetUnitImpl<CategoryId, Units<Mappings...>, Indx + 1>;
      using Scale = typename math::MultRatios<typename math::IntPowRatio<S, exp>::T, typename Rest::Scale>::T;
      static constexpr auto PiPower = PiPow * exp + Rest::PiPower;
      using Translation = typename math::AddRatios<typename math::NegateRatio<Tr>::T, typename Rest::Translation>::T;
      static constexpr int exponent = exp + Rest::exponent;
      using T                       = Unit<CategoryId, Scale, PiPower, Translation, exponent>;
      using UNIT                    = T;
      static constexpr auto index   = Indx;
      static constexpr bool present = true;
    };
 
    template<size_t CategoryId, size_t CurId, typename S, int PiPow, int exp, typename Tr, typename... Mappings,
             size_t Indx>
    struct GetUnitImpl<CategoryId, Units<Unit<CurId, S, PiPow, Tr, exp>, Mappings...>, Indx> {
      using Rest                    = GetUnitImpl<CategoryId, Units<Mappings...>, Indx + 1>;
      using Scale                   = typename Rest::Scale;
      static constexpr auto PiPower = Rest::PiPower;
      using Translation             = typename Rest::Translation;
      using T                       = typename Rest::T;
      using UNIT                    = typename Rest::UNIT;
      static constexpr int exponent = Rest::exponent;
      static constexpr auto index   = Rest::index;
      static constexpr bool present = Rest::present;
    };
 
    template<size_t CategoryId, size_t Indx>
    struct GetUnitImpl<CategoryId, Units<>, Indx> {
      using Scale                   = std::ratio<1>;
      static constexpr int PiPower  = 0;
      using Translation             = std::ratio<0>;
      using T                       = Unit<CategoryId, Scale, PiPower, Translation>;
      using UNIT                    = T;
      static constexpr int exponent = 0;
      static constexpr auto index   = std::numeric_limits<size_t>::max();
      static constexpr bool present = false;
    };

    template<size_t CategoryId, typename U>
    struct GetUnit : GetUnitImpl<CategoryId, std::remove_cvref_t<U>, 0> {};
 
    static_assert(!GetUnit<4, Units<Unit<1>>>::present);
    static_assert(GetUnit<4, Units<Unit<4>>>::present);
    static_assert(GetUnit<4, Units<Unit<5>, Unit<4>>>::present);
    static_assert(std::same_as<GetUnit<4, Units<Unit<5>, Unit<4>>>::Scale, std::ratio<1>>);
    static_assert(std::same_as<GetUnit<4, Units<Unit<5>, Unit<4, std::ratio<2>>>>::Scale, std::ratio<2>>);
    static_assert(std::same_as<GetUnit<4, Units<Unit<5>, Unit<4, std::ratio<2>>, Unit<4, std::ratio<1, 2>>>>::Scale,
                               std::ratio<1>>);
    static_assert(std::same_as<GetUnit<4, Units<Unit<5>, Unit<4, std::ratio<10>>, Unit<4, std::ratio<1, 2>>>>::Scale,
                               std::ratio<5>>);
    static_assert(std::same_as<GetUnit<4, Units<Unit<5>, Unit<4, std::ratio<10>>, Unit<4, std::ratio<1, 2>>,
                                                Unit<4, std::ratio<1, 5>>>>::Scale,
                               std::ratio<1>>);
    static_assert(std::same_as<GetUnit<4, Units<Unit<5>, Unit<4, std::ratio<10>>, Unit<4, std::ratio<1, 2>>,
                                                Unit<4, std::ratio<1, 10>>>>::Scale,
                               std::ratio<1, 2>>);

    template<int Id, typename L, typename R>
    struct ExpEq {
      static constexpr auto value = GetUnit<Id, L>::exponent == GetUnit<Id, R>::exponent;
    };

    template<bool present, typename... U>
    struct UniqIdSetImpl;
 
    template<typename U, typename UNext, typename... Us>
    struct UniqIdSetImpl<true, Units<U, UNext, Us...>> {
      using T = typename UniqIdSetImpl<GetUnit<UNext::Id, Units<Us...>>::present, Units<UNext, Us...>>::T;
    };
 
    template<typename U, typename UNext, typename... Us>
    struct UniqIdSetImpl<false, Units<U, UNext, Us...>> {
      using T = typename meta::ConcatIntList<
        meta::IntList<U::Id>,
        typename UniqIdSetImpl<GetUnit<UNext::Id, Units<Us...>>::present, Units<UNext, Us...>>::T>::T;
    };
 
    template<typename U>
    struct UniqIdSetImpl<false, Units<U>> {
      using T = meta::IntList<U::Id>;
    };
 
    template<bool p>
    struct UniqIdSetImpl<p, Units<>> {
      using T = meta::IntList<>;
    };

    template<typename T>
    struct UniqIdSet;
 
    template<>
    struct UniqIdSet<const Units<>> {
      using T = meta::IntList<>;
    };
 
    template<>
    struct UniqIdSet<Units<>> {
      using T = meta::IntList<>;
    };
 
    template<IsUnit U, IsUnit... Us>
    struct UniqIdSet<Units<U, Us...>> {
      using T = typename UniqIdSetImpl<GetUnit<U::Id, Units<Us...>>::present, Units<U, Us...>>::T;
    };
 
    template<IsUnit U, IsUnit... Us>
    struct UniqIdSet<const Units<U, Us...>> {
      using T = typename UniqIdSetImpl<GetUnit<U::Id, Units<Us...>>::present, Units<U, Us...>>::T;
    };

    template<typename Ids, typename Left, typename Right>
    struct AllLeftInRightImpl;
 
    template<int... Ids, typename Left, typename Right>
    struct AllLeftInRightImpl<meta::IntList<Ids...>, Left, Right> {
      static constexpr auto value =
        meta::And<GetUnit<Ids, Right>::present...>::value && meta::And<ExpEq<Ids, Left, Right>::value...>::value;
    };

    template<typename Left, typename Right>
    struct AllLeftInRight : AllLeftInRightImpl<typename UniqIdSet<std::remove_cvref_t<Left>>::T,
                                               std::remove_cvref_t<std::remove_cvref_t<Left>>,
                                               std::remove_cvref_t<std::remove_cvref_t<Right>>> {};
 
    static_assert(AllLeftInRight<Units<Unit<1>>, Units<Unit<1>>>::value);
    static_assert(AllLeftInRight<Units<Unit<1>>, Units<Unit<1>>>::value);
    static_assert(AllLeftInRight<Units<Unit<1>>, Units<Unit<1>, Unit<2>>>::value);
    static_assert(AllLeftInRight<Units<Unit<1>, Unit<2>>, Units<Unit<1>, Unit<2>>>::value);
    static_assert(!AllLeftInRight<Units<Unit<1>, Unit<2>, Unit<3>>, Units<Unit<1>, Unit<2>>>::value);
    static_assert(!AllLeftInRight<Units<Unit<1>>, Units<Unit<1>, Unit<1>>>::value);
    static_assert(!AllLeftInRight<Units<Unit<1>, Unit<1>>, Units<Unit<1>>>::value);
    static_assert(AllLeftInRight<Units<Unit<1>, Unit<1>>, Units<Unit<1>, Unit<1>>>::value);

    template<typename Left, typename Right>
    struct CompatibleDimensions {
      static constexpr bool value = AllLeftInRight<Left, Right>::value && AllLeftInRight<Right, Left>::value;
    };

    template<typename From, typename To>
    concept Convertible = CompatibleDimensions<From, To>::value;

    template<typename T, typename Us>
    struct WithoutZeroExponentsImpl;
 
    template<typename Us>
    struct WithoutZeroExponentsImpl<meta::IntList<>, Us> {
      using T = Units<>;
    };
 
    template<int Cur, int... Rest, typename Us>
    struct WithoutZeroExponentsImpl<meta::IntList<Cur, Rest...>, Us> {
      using Nxt = typename WithoutZeroExponentsImpl<meta::IntList<Rest...>, Us>::T;
      using T   = typename meta::If<GetUnit<Cur, Us>::exponent == 0, Nxt,
                                    typename ConcatUnits<typename GetUnits<Cur, Us>::T, Nxt>::T>::T;
    };

    template<typename T>
    struct WithoutZeroExponents;
 
    template<>
    struct WithoutZeroExponents<Units<>> {
      using T = Units<>;
    };
 
    template<typename U, typename... Us>
    struct WithoutZeroExponents<Units<U, Us...>> {
      using T = typename WithoutZeroExponentsImpl<typename UniqIdSet<Units<U, Us...>>::T, Units<U, Us...>>::T;
    };

    template<IsUnit U>
    struct FlipUnit {
      using T = Unit<U::Id, typename U::Scale, U::PiPower, typename U::Translation, -U::EXPONENT>;
    };
 
    static_assert(GetUnit<1, Units<Unit<1>, Unit<1>>>::exponent == 2);
    static_assert(GetUnit<1, Units<Unit<1>, typename FlipUnit<Unit<1>>::T>>::exponent == 0);
 
    static_assert(GetUnit<1, Units<Unit<1>, typename FlipUnit<Unit<1>>::T>>::present == true);
    static_assert(
      GetUnit<1, typename WithoutZeroExponents<Units<Unit<1>, typename FlipUnit<Unit<1>>::T>>::T>::present == false);
    static_assert(GetUnit<1, typename WithoutZeroExponents<Units<Unit<1>, Unit<1>>>::T>::present == true);

    template<typename Ids, typename From, typename To>
    struct ConvertImpl;
 
    template<typename From, typename To>
    struct ConvertImpl<meta::IntList<>, From, To> {
      template<bool, typename U>
      static constexpr U convert(const U &v) {
        return v;
      }
    };
 
    template<int Id, int... Ids, typename From, typename To>
    struct ConvertImpl<meta::IntList<Id, Ids...>, From, To> {
      using FromScale                    = typename GetUnit<Id, From>::Scale;
      using FromTranslation              = typename GetUnit<Id, From>::Translation;
      static constexpr auto FromPiScale  = GetUnit<Id, From>::PiPower;
      static constexpr auto FromExponent = GetUnit<Id, From>::exponent;
 
      using ToScale                    = typename GetUnit<Id, To>::Scale;
      using ToTranslation              = typename GetUnit<Id, To>::Translation;
      static constexpr auto ToPiScale  = GetUnit<Id, To>::PiPower;
      static constexpr auto ToExponent = GetUnit<Id, To>::exponent;
 
      static constexpr auto FSNum = math::RatioParts<FromScale>::Numerator;
      static constexpr auto FSDen = math::RatioParts<FromScale>::Denominator;
      static constexpr auto FTNum = math::RatioParts<FromTranslation>::Numerator;
      static constexpr auto FTDen = math::RatioParts<FromTranslation>::Denominator;
 
      static constexpr auto TSNum = math::RatioParts<ToScale>::Numerator;
      static constexpr auto TSDen = math::RatioParts<ToScale>::Denominator;
      static constexpr auto TTNum = math::RatioParts<ToTranslation>::Numerator;
      static constexpr auto TTDen = math::RatioParts<ToTranslation>::Denominator;
 
      static constexpr auto ScaleMult   = static_cast<long double>(FSNum) * static_cast<long double>(TSDen);
      static constexpr auto ScaleDiv    = static_cast<long double>(FSDen) * static_cast<long double>(TSNum);
      static constexpr auto ScaleFactor = static_cast<long double>(ScaleMult) / static_cast<long double>(ScaleDiv);
      static_assert(ScaleDiv != 0);
 
      static constexpr auto factor = ScaleFactor;
 
      template<bool ignoreChecks, typename U>
      static constexpr U convert(U v) {
        static_assert(!std::is_integral_v<U> || !(FSNum == TSNum && FSDen == TSDen) || (factor == 1) || ignoreChecks,
                      "Possible precision loss detected!");
        if constexpr (FTNum != 0) {
          v -= static_cast<long double>(FTNum) / static_cast<long double>(FTDen);
        }
 
        if constexpr (!std::is_integral_v<U> && std::is_convertible_v<U, long double>) {
          v = static_cast<U>(static_cast<long double>(v) * factor);
        }
        else {
          v = static_cast<U>((static_cast<long double>(v) * ScaleMult) / ScaleDiv);
        }
 
        if constexpr (ToPiScale != 0) {
          v *= std::pow(std::numbers::pi_v<long double>, -ToPiScale);
        }
        if constexpr (FromPiScale) {
          v *= std::pow(std::numbers::pi_v<long double>, FromPiScale);
        }
 
        if constexpr (TTNum != 0) {
          v += static_cast<long double>(TTNum) / static_cast<long double>(TTDen);
        }
        return ConvertImpl<meta::IntList<Ids...>, From, To>::template convert<ignoreChecks>(static_cast<U>(v));
      }
    };

    template<typename From, Convertible<From> To>
    struct Convert : ConvertImpl<typename UniqIdSet<std::remove_cvref_t<From>>::T, std::remove_cvref_t<From>,
                                 std::remove_cvref_t<To>> {};
 
    template<typename T, typename Dest>
    concept ConvertibleTo = AllLeftInRight<T, Dest>::value && AllLeftInRight<Dest, T>::value;
 
    template<typename T>
    constexpr bool gt(T l, T r) {
      return l > r;
    }
 
    template<typename From, typename To>
    struct ConvertMorePrecise {
      using T = typename meta::If<
        gt(Convert<From, To>::template convert<true>(1.), Convert<To, From>::template convert<true>(1.)), To, From>::T;
    };
  }  // namespace impl

  template<typename Underlying>
  struct UnitValue<Underlying, Units<>> {
    Underlying val;
    using UnitsType = Units<>;
    using ValType   = Underlying;

    [[nodiscard]] constexpr operator Underlying() const noexcept { return val; }
    constexpr UnitValue operator+(const UnitValue &o) const { return {val + o.val}; }

    constexpr UnitValue &operator+=(const UnitValue &o) {
      *this = static_cast<UnitValue>((*this) + o);
      return *this;
    }

    constexpr UnitValue operator-(const UnitValue &o) const { return {val - o.val}; }

    constexpr UnitValue &operator-=(const UnitValue &o) {
      *this = static_cast<UnitValue>((*this) + o);
      return *this;
    }

    constexpr auto operator<=>(const UnitValue &o) const noexcept { return val <=> o.val; }
    constexpr auto operator==(const UnitValue &o) const noexcept { return val == o.val; }
    constexpr auto operator<(const UnitValue &o) const noexcept { return val < o.val; }
    constexpr auto operator<=(const UnitValue &o) const noexcept { return val <= o.val; }
    constexpr auto operator>(const UnitValue &o) const noexcept { return val > o.val; }
    constexpr auto operator>=(const UnitValue &o) const noexcept { return val >= o.val; }
    constexpr auto operator!=(const UnitValue &o) const noexcept { return val != o.val; }

    constexpr auto operator<=>(const Underlying &o) const noexcept { return val <=> o; }
    constexpr auto operator==(const Underlying &o) const noexcept { return val == o; }
    constexpr auto operator<(const Underlying &o) const noexcept { return val < o; }
    constexpr auto operator<=(const Underlying &o) const noexcept { return val <= o; }
    constexpr auto operator>(const Underlying &o) const noexcept { return val > o; }
    constexpr auto operator>=(const Underlying &o) const noexcept { return val >= o; }
    constexpr auto operator!=(const Underlying &o) const noexcept { return val != o; }
  };

  template<typename Underlying, typename U1, typename... UnitsSub>
  struct UnitValue<Underlying, Units<U1, UnitsSub...>> {
    Underlying val;
    using Us = Units<U1, UnitsSub...>;
    using UnitsType = Us;
    using ValType = Underlying;

    template<typename OU, impl::Convertible<Us> OD>
    [[nodiscard]] constexpr operator UnitValue<OU, OD>() const {
      if constexpr (std::is_same_v<OD, Us>) {
        return UnitValue<OU, OD>{static_cast<OU>(val)};
      }
      else {
        using Converter = impl::Convert<Us, OD>;
        return {Converter::template convert<false>(val)};
      }
    }

    template<typename Target, typename U = Underlying, bool ignoreChecks = false>
    [[nodiscard]] constexpr auto convert() const {
      using Converter = impl::Convert<Us, Target>;
      return UnitValue<U, std::remove_cv_t<Target>>{Converter::template convert<ignoreChecks>(val)};
    }

    template<typename Target, typename U = Underlying, bool ignoreChecks = false>
    [[nodiscard]] constexpr auto to(Target) const {
      using Converter = impl::Convert<Us, Target>;
      return UnitValue<U, std::remove_cv_t<Target>>{Converter::template convert<ignoreChecks>(val)};
    }

    constexpr auto operator+(const UnitValue &o) const {
      auto r = val + o.val;
      return UnitValue<decltype(r), Us>{r};
    }

    constexpr UnitValue &operator+=(const UnitValue &o) {
      *this = static_cast<UnitValue>((*this) + o);
      return *this;
    }

    constexpr auto operator-(const UnitValue &o) const {
      auto r = val - o.val;
      return UnitValue<decltype(r), Us>{r};
    }

    constexpr UnitValue &operator-=(const UnitValue &o) {
      *this = static_cast<UnitValue>((*this) + o);
      return *this;
    }

    template<typename OV, impl::Convertible<Us> OUs, bool ignoreChecks = false>
    constexpr auto operator+(const UnitValue<OV, OUs> &o) const {
      using Target =
        typename meta::If<std::is_integral_v<Underlying>, typename impl::ConvertMorePrecise<Us, OUs>::T, UnitsType>::T;
      auto r = impl::Convert<Us, Target>::template convert<ignoreChecks>(val) +
               impl::Convert<OUs, Target>::template convert<ignoreChecks>(o.val);
      return UnitValue<decltype(r), Target>{r};
    }

    template<typename OV, impl::Convertible<Us> OUs, bool ignoreChecks = false>
    constexpr UnitValue &operator+=(const UnitValue<OV, OUs> &o) {
      *this = static_cast<UnitValue>((*this) + impl::Convert<OUs, Us>::template convert<ignoreChecks>(o.val));
      return *this;
    }

    template<typename OV, impl::Convertible<Us> OUs, bool ignoreChecks = false>
    constexpr auto operator-(const UnitValue<OV, OUs> &o) const {
      using Target =
        typename meta::If<std::is_integral_v<Underlying>, typename impl::ConvertMorePrecise<Us, OUs>::T, UnitsType>::T;
      auto r = impl::Convert<Us, Target>::template convert<ignoreChecks>(val) -
               impl::Convert<OUs, Target>::template convert<ignoreChecks>(o.val);
      return UnitValue<decltype(r), Target>{r};
    }

    template<typename OV, impl::Convertible<Us> OUs, bool ignoreChecks = false>
    constexpr UnitValue &operator-=(const UnitValue<OV, OUs> &o) {
      *this = static_cast<UnitValue>((*this) - impl::Convert<OUs, Us>::template convert<ignoreChecks>(o.val));
      return *this;
    }

    constexpr auto operator<=>(const UnitValue &o) const noexcept { return val <=> o.val; }
    constexpr auto operator==(const UnitValue &o) const noexcept { return val == o.val; }
    constexpr auto operator<(const UnitValue &o) const noexcept { return val < o.val; }
    constexpr auto operator<=(const UnitValue &o) const noexcept { return val <= o.val; }
    constexpr auto operator>(const UnitValue &o) const noexcept { return val > o.val; }
    constexpr auto operator>=(const UnitValue &o) const noexcept { return val >= o.val; }
    constexpr auto operator!=(const UnitValue &o) const noexcept { return val != o.val; }

    template<typename OV, impl::Convertible<Us> OUs, bool ignoreChecks = false>
    constexpr auto operator<=>(const UnitValue<OV, OUs> &o) const {
      using Target = typename impl::ConvertMorePrecise<Us, OUs>::T;
      return impl::Convert<Us, Target>::template convert<ignoreChecks>(val) <=>
             impl::Convert<OUs, Target>::template convert<ignoreChecks>(o.val);
    }

    template<typename OV, impl::Convertible<Us> OUs, bool ignoreChecks = false>
    constexpr auto operator!=(const UnitValue<OV, OUs> &o) const {
      using Target = typename impl::ConvertMorePrecise<Us, OUs>::T;
      return impl::Convert<Us, Target>::template convert<ignoreChecks>(val) !=
             impl::Convert<OUs, Target>::template convert<ignoreChecks>(o.val);
    }

    template<typename OV, impl::Convertible<Us> OUs, bool ignoreChecks = false>
    constexpr auto operator==(const UnitValue<OV, OUs> &o) const {
      using Target = typename impl::ConvertMorePrecise<Us, OUs>::T;
      return impl::Convert<Us, Target>::template convert<ignoreChecks>(val) ==
             impl::Convert<OUs, Target>::template convert<ignoreChecks>(o.val);
    }

    template<typename OV, impl::Convertible<Us> OUs, bool ignoreChecks = false>
    constexpr auto operator>=(const UnitValue<OV, OUs> &o) const {
      using Target = typename impl::ConvertMorePrecise<Us, OUs>::T;
      return impl::Convert<Us, Target>::template convert<ignoreChecks>(val) >=
             impl::Convert<OUs, Target>::template convert<ignoreChecks>(o.val);
    }

    template<typename OV, impl::Convertible<Us> OUs, bool ignoreChecks = false>
    constexpr auto operator>(const UnitValue<OV, OUs> &o) const {
      using Target = typename impl::ConvertMorePrecise<Us, OUs>::T;
      return impl::Convert<Us, Target>::template convert<ignoreChecks>(val) >
             impl::Convert<OUs, Target>::template convert<ignoreChecks>(o.val);
    }

    template<typename OV, impl::Convertible<Us> OUs, bool ignoreChecks = false>
    constexpr auto operator<=(const UnitValue<OV, OUs> &o) const {
      using Target = typename impl::ConvertMorePrecise<Us, OUs>::T;
      return impl::Convert<Us, Target>::template convert<ignoreChecks>(val) <=
             impl::Convert<OUs, Target>::template convert<ignoreChecks>(o.val);
    }

    template<typename OV, impl::Convertible<Us> OUs, bool ignoreChecks = false>
    constexpr auto operator<(const UnitValue<OV, OUs> &o) const {
      using Target = typename impl::ConvertMorePrecise<Us, OUs>::T;
      return impl::Convert<Us, Target>::template convert<ignoreChecks>(val) <
             impl::Convert<OUs, Target>::template convert<ignoreChecks>(o.val);
    }
  };

  namespace dimensions {
    constexpr size_t LENGTH = 0;
    constexpr size_t MASS = 1;
    constexpr size_t TIME = 2;
    constexpr size_t ANGLE = 3;
    constexpr size_t CURRENT = 4;
    constexpr size_t TEMPERATURE = 5;
    constexpr size_t SUBSTANCE = 6;
    constexpr size_t LUMINOSITY = 7;
    constexpr size_t STORAGE = 8;
  }  // namespace dimensions

  template<std::floating_point Val, typename... Dims>
  constexpr UnitValue<Val, Units<Dims...>> operator*(Val lhs, const Units<Dims...> &) {
    return {lhs};
  }

  template<std::integral Val, typename... Dims>
  constexpr UnitValue<Val, Units<Dims...>> operator*(Val lhs, const Units<Dims...> &) {
    return {lhs};
  }

  template<typename... Dims1, typename... Dims2>
  constexpr auto operator*(const Units<Dims1...> &, const Units<Dims2...> &) {
    return typename impl::WithoutZeroExponents<typename impl::ConcatUnits<Units<Dims1...>, Units<Dims2...>>::T>::T{};
  }
 
  static_assert(
    std::same_as<std::remove_cvref_t<decltype(Units<Unit<1>>{} * Units<Unit<1>>{})>, Units<Unit<1>, Unit<1>>>);

  template<typename... Dims1, typename... Dims2>
  constexpr auto operator/(const Units<Dims1...> &, const Units<Dims2...> &) {
    return typename impl::WithoutZeroExponents<
      typename impl::ConcatUnits<Units<Dims1...>, Units<typename impl::FlipUnit<Dims2>::T...>>::T>::T{};
  }

  template<std::floating_point Val, typename... Dims>
  constexpr auto operator/(Val lhs, const Units<Dims...> &) {
    return UnitValue<Val, typename impl::WithoutZeroExponents<Units<typename impl::FlipUnit<Dims...>::T>>::T>{lhs};
  }

  template<std::integral Val, typename... Dims>
  constexpr auto operator/(Val lhs, const Units<Dims...> &) {
    return UnitValue<Val, typename impl::WithoutZeroExponents<Units<typename impl::FlipUnit<Dims...>::T>>::T>{lhs};
  }
 
  static_assert(std::same_as<decltype(Units<Unit<1>>{} / Units<Unit<1>>{}), Units<>>);

  template<typename U1, typename Us1, typename U2, typename Us2>
  constexpr auto operator*(const UnitValue<U1, Us1> &lhs, const UnitValue<U2, Us2> &rhs) {
    using RetUnits = typename impl::ConcatUnits<std::remove_const_t<typename UnitValue<U1, Us1>::UnitsType>,
                                                std::remove_const_t<typename UnitValue<U2, Us2>::UnitsType>>::T;
    const auto r   = lhs.val * rhs.val;
    return UnitValue<std::remove_cvref_t<decltype(r)>, RetUnits>{r};
  }

  template<typename U1, typename Us1, typename U2, typename Us2>
  constexpr auto operator/(const UnitValue<U1, Us1> &lhs, const UnitValue<U2, Us2> &rhs) {
    using RetUnits = typename impl::ConcatUnits<std::remove_const_t<typename UnitValue<U1, Us1>::UnitsType>,
                                                std::remove_const_t<typename UnitValue<U2, Us2>::UnitsType>>::T;
    const auto r   = lhs.val * rhs.val;
    if constexpr (std::is_same_v<Units<>, RetUnits>) {
      return r;
    }
    return UnitValue<std::remove_cvref_t<decltype(r)>, RetUnits>{r};
  }

  template<std::floating_point I, typename U, typename Us>
  constexpr auto operator/(I value, UnitValue<U, Us> lhs) {
    using RetUnits = typename std::remove_const_t<decltype(1 / std::declval<Us>())>::UnitsType;
    return UnitValue<U, RetUnits>{static_cast<U>(value) / lhs.val};
  }

  template<std::floating_point I, typename U, typename Us>
  constexpr auto operator/(UnitValue<U, Us> lhs, I value) {
    using RetUnits = std::remove_const_t<Us>;
    return UnitValue<U, RetUnits>{lhs.val / static_cast<U>(value)};
  }

  template<std::integral I, typename U, typename Us>
  constexpr auto operator/(I value, const UnitValue<U, Us> &lhs) {
    using RetUnits = typename std::remove_const_t<decltype(1 / std::declval<Us>())>::UnitsType;
    return UnitValue<U, RetUnits>{static_cast<U>(value) / lhs.val};
  }

  template<std::integral I, typename U, typename Us>
  constexpr auto operator/(UnitValue<U, Us> lhs, I value) {
    using RetUnits = typename std::remove_const_t<decltype(1 / std::declval<Us>())>::UnitsType;
    return UnitValue<U, RetUnits>{lhs.val / value};
  }

  template<std::floating_point Val, typename U, typename Us>
  constexpr UnitValue<U, Us> operator*(const UnitValue<U, Us> &lhs, Val rhs) {
    return {static_cast<U>(lhs) * rhs.val};
  }

  template<std::floating_point Val, typename U, typename Us>
  constexpr UnitValue<Val, Us> operator*(Val lhs, const UnitValue<U, Us> &rhs) {
    return {lhs * static_cast<Val>(rhs.val)};
  }

  template<std::integral Val, typename U, typename Us>
  constexpr UnitValue<U, Us> operator*(const UnitValue<U, Us> &lhs, Val rhs) {
    return {static_cast<U>(lhs) * rhs.val};
  }

  template<std::integral Val, typename U, typename Us>
  constexpr UnitValue<Val, Us> operator*(Val lhs, const UnitValue<U, Us> &rhs) {
    return {lhs * static_cast<Val>(rhs.val)};
  }

  template<typename U, typename Us, typename... Dims>
  constexpr auto operator*(UnitValue<U, Us> lhs, const Units<Dims...> &u) {
    using RetUnits = std::remove_const_t<decltype(std::declval<typename UnitValue<U, Us>::UnitsType>() * u)>;
    return UnitValue<U, RetUnits>{lhs.val};
  }

  template<typename U, typename Us, typename... Dims>
  constexpr auto operator/(UnitValue<U, Us> lhs, const Units<Dims...> &u) {
    using RetUnits = std::remove_const_t<decltype(std::declval<typename UnitValue<U, Us>::UnitsType>() / u)>;
    return UnitValue<U, RetUnits>{lhs.val};
  }

  template<typename T>
  concept IsUnitValue = requires(const T &t, const typename T::UnitsType UT) {
    { t.template convert<typename T::UnitsType>() };
    { t.to(UT) };
    { t + t };
    { t - t };
    { t * t };
    { t / t };
    { 1 * t };
    { 1 / t };
    { t * 1 };
    { t / 1 };
    { 1. * t };
    { 1. / t };
    { t * 1. };
    { t / 1. };
  };
  static_assert(IsUnitValue<UnitValue<int, Units<Unit<1>>>>);

  template<typename U>
  struct UnitName;
 
#define MTCORE_DEF_UNIT_NAME_NO_ABBREV(NS, UNIT)                                                                       \
  template<>                                                                                                           \
  struct UnitName<std::remove_cvref_t<decltype(NS::UNIT)>> {                                                           \
    static constexpr std::string_view nameUs      = #UNIT;                                                             \
    static constexpr std::string_view name        = #UNIT;                                                             \
    static constexpr std::string_view abbrev      = #UNIT;                                                             \
    static constexpr std::string_view abbrevUs    = #UNIT;                                                             \
    static constexpr std::string_view abbrevAscii = #UNIT;                                                             \
    static constexpr std::string_view symbol      = "";                                                                \
  };
 
#define MTCORE_DEF_UNIT_NAME_SYM(NS, UNIT, ABBREV, SYM)                                                                \
  template<>                                                                                                           \
  struct UnitName<std::remove_cvref_t<decltype(NS::UNIT)>> {                                                           \
    static constexpr std::string_view nameUs      = #UNIT;                                                             \
    static constexpr std::string_view name        = #UNIT;                                                             \
    static constexpr std::string_view abbrev      = #ABBREV;                                                           \
    static constexpr std::string_view abbrevUs    = #ABBREV;                                                           \
    static constexpr std::string_view abbrevAscii = #ABBREV;                                                           \
    static constexpr std::string_view symbol      = SYM;                                                               \
  };
 
#define MTCORE_DEF_UNIT_NAME_STRS(NS, UNIT, NAME, US_NAME, ABBREV, ABBREV_ASCII, ABBREV_US, SYMBOL)                    \
  template<>                                                                                                           \
  struct UnitName<std::remove_cvref_t<decltype(NS::UNIT)>> {                                                           \
    static constexpr std::string_view nameUs      = US_NAME;                                                           \
    static constexpr std::string_view name        = NAME;                                                              \
    static constexpr std::string_view abbrev      = ABBREV;                                                            \
    static constexpr std::string_view abbrevUs    = ABBREV;                                                            \
    static constexpr std::string_view abbrevAscii = ABBREV_ASCII;                                                      \
    static constexpr std::string_view symbol      = SYMBOL;                                                            \
  };
 
#define MTCORE_DEF_UNIT_NAME(NS, UNIT, ABBREV)                                                                         \
  template<>                                                                                                           \
  struct UnitName<std::remove_cvref_t<decltype(NS::UNIT)>> {                                                           \
    static constexpr std::string_view nameUs      = #UNIT;                                                             \
    static constexpr std::string_view name        = #UNIT;                                                             \
    static constexpr std::string_view abbrev      = #ABBREV;                                                           \
    static constexpr std::string_view abbrevUs    = #ABBREV;                                                           \
    static constexpr std::string_view abbrevAscii = #ABBREV;                                                           \
    static constexpr std::string_view symbol      = "";                                                                \
  };
 
#define MTCORE_DEF_UNIT_NAME_DIFF_US(NS, UNIT, US_NAME, ABBREV)                                                        \
  template<>                                                                                                           \
  struct UnitName<std::remove_cvref_t<decltype(NS::UNIT)>> {                                                           \
    static constexpr std::string_view nameUs      = #US_NAME;                                                          \
    static constexpr std::string_view name        = #UNIT;                                                             \
    static constexpr std::string_view abbrev      = #ABBREV;                                                           \
    static constexpr std::string_view abbrevUs    = #ABBREV;                                                           \
    static constexpr std::string_view abbrevAscii = #ABBREV;                                                           \
    static constexpr std::string_view symbol      = "";                                                                \
  };
 
#define MTCORE_DEF_UNIT_NAME_UNIC_ABB(NS, UNIT, US_NAME, ABBREV, UNIC_ABB)                                             \
  template<>                                                                                                           \
  struct UnitName<std::remove_cvref_t<decltype(NS::UNIT)>> {                                                           \
    static constexpr std::string_view nameUs      = #US_NAME;                                                          \
    static constexpr std::string_view name        = #UNIT;                                                             \
    static constexpr std::string_view abbrev      = #UNIC_ABB;                                                         \
    static constexpr std::string_view abbrevUs    = #UNIC_ABB;                                                         \
    static constexpr std::string_view abbrevAscii = #ABBREV;                                                           \
    static constexpr std::string_view symbol      = "";                                                                \
  };
 
#define MTCORE_DEF_UNIT_NAME_SI_PREFIXES_SMALL(NS, UNIT, US_NAME, ABBREV)                                              \
  MTCORE_DEF_UNIT_NAME_DIFF_US(NS, deci##UNIT, deci##US_NAME, d##ABBREV)                                               \
  MTCORE_DEF_UNIT_NAME_DIFF_US(NS, centi##UNIT, centi##US_NAME, c##ABBREV)                                             \
  MTCORE_DEF_UNIT_NAME_DIFF_US(NS, milli##UNIT, milli##US_NAME, m##ABBREV)                                             \
  MTCORE_DEF_UNIT_NAME_UNIC_ABB(NS, micro##UNIT, micro##US_NAME, u##ABBREV, μ##ABBREV)                                 \
  MTCORE_DEF_UNIT_NAME_DIFF_US(NS, nano##UNIT, nano##US_NAME, n##ABBREV)                                               \
  MTCORE_DEF_UNIT_NAME_DIFF_US(NS, pico##UNIT, pico##US_NAME, p##ABBREV)                                               \
  MTCORE_DEF_UNIT_NAME_DIFF_US(NS, femto##UNIT, femto##US_NAME, f##ABBREV)
 
#define MTCORE_DEF_UNIT_NAME_SI_PREFIXES_LARGE(NS, UNIT, US_NAME, ABBREV)                                              \
  MTCORE_DEF_UNIT_NAME_DIFF_US(NS, deca##UNIT, deca##US_NAME, da##ABBREV)                                              \
  MTCORE_DEF_UNIT_NAME_DIFF_US(NS, hecto##UNIT, hecto##US_NAME, hm##ABBREV)                                            \
  MTCORE_DEF_UNIT_NAME_DIFF_US(NS, kilo##UNIT, kilo##US_NAME, km##ABBREV)                                              \
  MTCORE_DEF_UNIT_NAME_DIFF_US(NS, mega##UNIT, mega##US_NAME, M##ABBREV)                                               \
  MTCORE_DEF_UNIT_NAME_DIFF_US(NS, giga##UNIT, giga##US_NAME, G##ABBREV)                                               \
  MTCORE_DEF_UNIT_NAME_DIFF_US(NS, tera##UNIT, tera##US_NAME, T##ABBREV)                                               \
  MTCORE_DEF_UNIT_NAME_DIFF_US(NS, peta##UNIT, peta##US_NAME, P##ABBREV)
 
#define MTCORE_DEF_UNIT_NAME_SI(NS, UNIT, US_NAME, ABBREV)                                                             \
  MTCORE_DEF_UNIT_NAME_DIFF_US(NS, UNIT, US_NAME, ABBREV)                                                              \
  MTCORE_DEF_UNIT_NAME_SI_PREFIXES_SMALL(NS, UNIT, US_NAME, ABBREV)                                                    \
  MTCORE_DEF_UNIT_NAME_SI_PREFIXES_LARGE(NS, UNIT, US_NAME, ABBREV)
 
}  // namespace mtcore::units
 
#endif  // MTCORE_UNITS_BASE_HPP