unit.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef SI_DISABLE_IMPLICIT_RATIO_CONVERSION
#define SI_ENABLE_IMPLICIT_RATIO_CONVERSION false
#else
#define SI_ENABLE_IMPLICIT_RATIO_CONVERSION true
#endif
 
#include "detail.h"
#include "eps_equal.h"
#include "unit_cast.h"
 
#include <ratio>
#include <type_traits>
 
namespace SI::detail {
 
template <typename _unit_lhs, typename _unit_rhs> struct unit_with_common_ratio;
 
 
template <char _symbol, typename _exponent, typename _type,
          typename _ratio = std::ratio<1>>
struct unit_t {
  static_assert(std::is_arithmetic_v<_type>, "Type is an arithmetic value");
  static_assert(detail::is_ratio_v<_exponent>, "_exponent is a ratio type");
  static_assert(detail::is_ratio_v<_ratio>, "_ratio is a std::ratio");
  using ratio = _ratio;
  using internal_type = _type;
  using exponent = _exponent;
  using symbol = std::integral_constant<char, _symbol>;
 
  explicit constexpr unit_t(_type v) : value_{v} {}
  constexpr unit_t() = default;
  constexpr unit_t(const unit_t &) = default;
  constexpr unit_t(unit_t &&) = default;
 
  template <typename _type_rhs>
  constexpr unit_t(const unit_t<_symbol, _exponent, _type_rhs, _ratio> &rhs)
      : value_(rhs.value()) {
    static_assert(std::is_convertible<_type_rhs, _type>::value,
                  "Internal representation is convertible");
  }
 
  ~unit_t() = default;
 
  template <typename _rhs_type, typename _rhs_ratio>
  constexpr unit_t(const unit_t<_symbol, _exponent, _rhs_type, _rhs_ratio> &rhs)
      : value_{
            unit_cast<unit_t<_symbol, _exponent, _type, _ratio>>(rhs).value()} {
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
    static_assert(
        SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
            std::ratio_equal_v<ratio, _rhs_ratio>,
        "Implicit ratio conversion disabled, convert before assigning");
  }
 
  template <typename _rhs_ratio>
  constexpr unit_t(unit_t<_symbol, _exponent, _type, _rhs_ratio> &&rhs)
      : value_{
            std::move(unit_cast<unit_t<_symbol, _exponent, _type, _ratio>>(rhs)
                          .value())} {
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
    static_assert(
        SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
            std::ratio_equal_v<ratio, _rhs_ratio>,
        "Implicit ratio conversion disabled, convert before assigning");
  }
 
  constexpr _type value() const { return value_; }
 
  template <typename _unit_rhs> constexpr _unit_rhs as() const {
    static_assert(is_unit_t_v<_unit_rhs>, "only supported for SI::unit_t");
    static_assert(std::ratio_equal_v<typename _unit_rhs::exponent, _exponent>,
                  "Exponents must match");
    static_assert(_unit_rhs::symbol::value == _symbol,
                  "target unit must be of the same type must match");
 
    return unit_cast<_unit_rhs>(*this);
  }
 
  template <template <typename _type_rhs> typename _unit_rhs>
  constexpr _unit_rhs<_type> as() const {
    static_assert(is_unit_t_v<_unit_rhs<_type>>,
                  "only supported for SI::unit_t");
    static_assert(
        std::ratio_equal_v<typename _unit_rhs<_type>::exponent, _exponent>,
        "Exponents must match");
    static_assert(_unit_rhs<_type>::symbol::value == _symbol,
                  "target unit must be of the same type must match");
 
    return unit_cast<_unit_rhs<_type>>(*this);
  }
 
  void setValue(_type v) { value_ = v; }
 
  constexpr unit_t &operator=(const unit_t &rhs) = default;
 
  constexpr unit_t &operator=(unit_t &&rhs) = default;
 
  template <
      typename _rhs_ratio,
      std::enable_if_t<!std::ratio_equal_v<_rhs_ratio, _ratio>> * = nullptr>
  constexpr unit_t &
  operator=(const unit_t<_symbol, _exponent, _type, _rhs_ratio> &rhs) {
 
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
    static_assert(
        SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
            std::ratio_equal_v<ratio, _rhs_ratio>,
        "Implicit ratio conversion disabled, convert before assigning");
 
    *this = unit_cast<unit_t<_symbol, _exponent, _type, _ratio>>(rhs);
    return *this;
  }
 
  template <
      typename _rhs_ratio,
      std::enable_if_t<!std::ratio_equal_v<_rhs_ratio, _ratio>> * = nullptr>
  constexpr unit_t &
  operator=(unit_t<_symbol, _exponent, _type, _rhs_ratio> &&rhs) {
 
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
    static_assert(
        SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
            std::ratio_equal_v<ratio, _rhs_ratio>,
        "Implicit ratio conversion disabled, convert before assigning");
 
    *this =
        std::move(unit_cast<unit_t<_symbol, _exponent, _type, _ratio>>(rhs));
    return *this;
  }
 
  template <typename _rhs_type, typename _rhs_ratio>
  constexpr bool operator==(
      const unit_t<_symbol, _exponent, _rhs_type, _rhs_ratio> &rhs) const {
 
    static_assert(
        SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
            std::ratio_equal_v<ratio, _rhs_ratio>,
        "Implicit ratio conversion disabled, convert before comparing");
 
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
    static_assert(std::is_integral_v<_type> || std::is_floating_point_v<_type>,
                  "Is integral or floating point");
    using gcd_unit = typename unit_with_common_ratio<
        typename std::remove_reference<decltype(rhs)>::type,
        typename std::remove_reference<decltype(*this)>::type>::type;
 
    if constexpr (std::is_integral_v<_type>) {
 
      return unit_cast<gcd_unit>(rhs).value() ==
             unit_cast<gcd_unit>(*this).value();
    } else {
      return detail::eps_equals(unit_cast<gcd_unit>(rhs).value(),
                                unit_cast<gcd_unit>(*this).value());
    }
  }
 
  template <typename _rhs_type, typename _rhs_ratio>
  constexpr bool operator!=(
      const unit_t<_symbol, _exponent, _rhs_type, _rhs_ratio> &rhs) const {
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
    return !(*this == rhs);
  }
 
  template <typename _rhs_type, typename _rhs_ratio>
  constexpr bool operator<(
      const unit_t<_symbol, _exponent, _rhs_type, _rhs_ratio> &rhs) const {
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
    static_assert(
        SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
            std::ratio_equal_v<ratio, _rhs_ratio>,
        "Implicit ratio conversion disabled, convert before comparing");
 
    using gcd_unit = typename unit_with_common_ratio<
        typename std::remove_reference<decltype(rhs)>::type,
        typename std::remove_reference<decltype(*this)>::type>::type;
    return unit_cast<gcd_unit>(*this).value() <
           unit_cast<gcd_unit>(rhs).value();
  }
 
  template <typename _rhs_type, typename _rhs_ratio>
  constexpr bool operator<=(
      const unit_t<_symbol, _exponent, _rhs_type, _rhs_ratio> &rhs) const {
    return !(*this > rhs);
  }
 
  template <typename _rhs_type, typename _rhs_ratio>
  constexpr bool operator>(
      const unit_t<_symbol, _exponent, _rhs_type, _rhs_ratio> &rhs) const {
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
    static_assert(
        SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
            std::ratio_equal_v<ratio, _rhs_ratio>,
        "Implicit ratio conversion disabled, convert before comparing");
 
    using gcd_unit = typename unit_with_common_ratio<
        typename std::remove_reference<decltype(rhs)>::type,
        typename std::remove_reference<decltype(*this)>::type>::type;
 
    return unit_cast<gcd_unit>(*this).value() >
           unit_cast<gcd_unit>(rhs).value();
  }
 
  template <typename _rhs_type, typename _rhs_ratio>
  constexpr bool operator>=(
      const unit_t<_symbol, _exponent, _rhs_type, _rhs_ratio> &rhs) const {
    return !(*this < rhs);
  }
 
  constexpr unit_t operator*(const _type f) const { return unit_t{value_ * f}; }
 
  template <typename _rhs_exponent, typename _rhs_type>
  constexpr auto operator*(
      const unit_t<_symbol, _rhs_exponent, _rhs_type, _ratio> &rhs) const {
 
    static_assert(detail::is_ratio_v<_rhs_exponent>,
                  "rhs exponent is a ratio type");
    return unit_t<_symbol, std::ratio_add<_rhs_exponent, _exponent>, _type,
                  std::ratio_multiply<ratio, _ratio>>{value() * rhs.value()};
  }
 
  template <typename _rhs_exponent, typename _rhs_ratio, typename _rhs_type>
  constexpr auto operator*(
      const unit_t<_symbol, _rhs_exponent, _rhs_type, _rhs_ratio> &rhs) const {
    static_assert(detail::is_ratio_v<_rhs_exponent>,
                  "rhs exponent is a ratio type");
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
 
    static_assert(
        SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
            std::ratio_equal_v<ratio, _rhs_ratio>,
        "Implicit ratio conversion disabled, convert before comparing");
 
    return unit_t<_symbol, std::ratio_add<_exponent, _rhs_exponent>, _type,
                  std::ratio_multiply<ratio, _rhs_ratio>>{value_ * rhs.value()};
  }
 
  constexpr unit_t &operator*=(const _type scalar) {
    value_ *= scalar;
    return *this;
  }
 
  constexpr unit_t operator/(const _type f) const { return unit_t{value_ / f}; }
 
  template <typename _rhs_exponent, typename _rhs_type,
            std::enable_if_t<std::ratio_not_equal_v<_rhs_exponent, _exponent>>
                * = nullptr>
  constexpr auto operator/(
      const unit_t<_symbol, _rhs_exponent, _rhs_type, _ratio> &rhs) const {
    static_assert(detail::is_ratio_v<_rhs_exponent>,
                  "rhs exponent is a ratio type");
    using rhs_t = typename std::remove_reference<decltype(rhs)>::type;
 
    return unit_t<_symbol,
                  std::ratio_subtract<_exponent, typename rhs_t::exponent>,
                  _type, std::ratio_divide<ratio, _ratio>>{value_ /
                                                           rhs.value()};
  }
 
  template <typename _rhs_exponent, typename _rhs_type, typename _rhs_ratio,
            std::enable_if_t<std::ratio_not_equal_v<_rhs_exponent, _exponent>>
                * = nullptr>
  constexpr auto operator/(
      const unit_t<_symbol, _rhs_exponent, _rhs_type, _rhs_ratio> &rhs) const {
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
    static_assert(detail::is_ratio_v<_rhs_exponent>,
                  "rhs exponent is a ratio type");
    static_assert(
        SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
            std::ratio_equal_v<ratio, _rhs_ratio>,
        "Implicit ratio conversion disabled, convert before dividing");
 
    return unit_t<_symbol, std::ratio_subtract<exponent, _rhs_exponent>, _type,
                  std::ratio_divide<ratio, _rhs_ratio>>{value_ / rhs.value()};
  }
 
  template <typename _rhs_type>
  constexpr _type
  operator/(const unit_t<_symbol, _exponent, _rhs_type, _ratio> &rhs) {
    return value() / rhs.value();
  }
 
  template <
      typename _rhs_exponent, typename _rhs_type, typename _rhs_ratio,
      std::enable_if_t<std::ratio_equal_v<_rhs_exponent, exponent>> * = nullptr>
  constexpr _type operator/(
      const unit_t<_symbol, _rhs_exponent, _rhs_type, _rhs_ratio> &rhs) const {
    static_assert(SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
                      std::ratio_equal_v<_rhs_ratio, _ratio>,
                  "Implicit ratio conversion disabled, convert to same ratio "
                  "before dividing");
 
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
 
    static_assert(detail::is_ratio_v<_rhs_exponent>,
                  "rhs exponent is a ratio type");
 
    using gcd_unit = typename unit_with_common_ratio<
        typename std::remove_reference<decltype(*this)>::type,
        typename std::remove_reference<decltype(rhs)>::type>::type;
 
    return unit_cast<gcd_unit>(*this) / unit_cast<gcd_unit>(rhs);
  }
 
  constexpr unit_t &operator/=(const _type scalar) {
    value_ /= scalar;
    return *this;
  }
 
  template <typename _rhs_type, typename _rhs_ratio>
  constexpr unit_t operator+(
      const unit_t<_symbol, _exponent, _rhs_type, _rhs_ratio> &rhs) const {
 
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
    static_assert(
        SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
            std::ratio_equal_v<ratio, _rhs_ratio>,
        "Implicit ratio conversion disabled, convert before adding values");
 
    return unit_t{
        value() +
        unit_cast<unit_t<_symbol, _exponent, _type, _ratio>>(rhs).value()};
  }
 
  constexpr unit_t &operator+=(const unit_t &rhs) {
    value_ += rhs.value();
    return *this;
  }
 
  template <
      typename _rhs_type, typename _rhs_ratio,
      std::enable_if_t<!std::ratio_equal_v<_rhs_ratio, _ratio>> * = nullptr>
  constexpr unit_t &
  operator+=(const unit_t<_symbol, _exponent, _rhs_type, _rhs_ratio> &rhs) {
 
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
    static_assert(
        SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
            std::ratio_equal_v<ratio, _rhs_ratio>,
        "Implicit ratio conversion disabled, convert before adding values");
 
    value_ += unit_cast<unit_t<_symbol, _exponent, _type, _ratio>>(rhs).value();
 
    return *this;
  }
 
  template <typename _rhs_type, typename _rhs_ratio>
  constexpr unit_t operator-(
      const unit_t<_symbol, _exponent, _rhs_type, _rhs_ratio> &rhs) const {
 
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
    static_assert(
        SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
            std::ratio_equal_v<ratio, _rhs_ratio>,
        "Implicit ratio conversion disabled, convert before subtracting");
 
    return unit_t{
        value() +
        -unit_cast<unit_t<_symbol, _exponent, _type, _ratio>>(rhs).value()};
  }
 
  constexpr unit_t &operator-=(const unit_t &rhs) {
    value_ -= rhs.value();
    return *this;
  }
 
  template <typename _rhs_type, typename _rhs_ratio,
            std::enable_if<!std::ratio_equal_v<_rhs_ratio, _ratio>> * = nullptr>
  constexpr unit_t &
  operator-=(const unit_t<_symbol, _exponent, _type, _rhs_ratio> &rhs) {
 
    static_assert(detail::is_ratio_v<_rhs_ratio>, "_rhs_ratio is a std::ratio");
    static_assert(
        SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
            std::ratio_equal_v<ratio, _rhs_ratio>,
        "Implicit ratio conversion disabled, convert before adding values");
 
    value_ -= unit_cast<unit_t<_symbol, _exponent, _type, _ratio>>(rhs).value();
 
    return *this;
  }
 
  constexpr unit_t operator-() const { return unit_t{-value_}; }
 
  unit_t &operator++() {
    ++value_;
    return *this;
  }
  unit_t operator++(int) {
    auto ret_val(*this);
    ++(*this);
 
    return ret_val;
  }
 
  unit_t &operator--() {
    --value_;
    return *this;
  }
 
  unit_t operator--(int) {
    auto ret_val(*this);
    --(*this);
 
    return ret_val;
  }
 
private:
  _type value_;
};
 
template <typename _type, char _symbol, typename _exponent, typename _rhs_type,
          typename _ratio,
          std::enable_if_t<std::is_integral_v<_type>> * = nullptr>
constexpr auto
operator/(const _type &lhs,
          const unit_t<_symbol, _exponent, _rhs_type, _ratio> &rhs) {
  static_assert(SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
                    std::ratio_equal<std::ratio<1>, _ratio>::value,
                "Implicit ratio conversion disabled, convert to ratio<1> "
                "before dividing");
  static_assert(detail::is_ratio_v<_exponent>, "Exponent is a ratio type");
  return unit_t<_symbol, std::ratio_multiply<std::ratio<-1>, _exponent>, _type,
                _ratio>{lhs / rhs.value()};
}
 
template <typename _type, char _symbol, typename _exponent, typename _rhs_type,
          typename _ratio,
          std::enable_if_t<std::is_floating_point_v<_type>> * = nullptr>
constexpr auto
operator/(const _type &lhs,
          const unit_t<_symbol, _exponent, _rhs_type, _ratio> &rhs) {
  static_assert(SI_ENABLE_IMPLICIT_RATIO_CONVERSION ||
                    std::ratio_equal_v<_ratio, std::ratio<1>>,
                "Implicit ratio conversion disabled, convert to ratio<1> "
                "before dividing");
  static_assert(detail::is_ratio_v<_exponent>, "Exponent is a ratio type");
  return unit_t<_symbol, std::ratio_multiply<std::ratio<-1>, _exponent>, _type,
                _ratio>{lhs / rhs.value()};
}
 
} // namespace SI::detail