quantities.h

Go to the documentation of this file.

#ifndef LARDATAALG_UTILITIES_QUANTITIES_H
#define LARDATAALG_UTILITIES_QUANTITIES_H

// LArSoft libraries
#include "larcorealg/CoreUtils/MetaUtils.h"      // util::always_true_v<>
#include "larcorealg/CoreUtils/StdUtils.h"       // util::to_string(), ...
#include "lardataalg/Utilities/constexpr_math.h" // util::abs()

// Boost libraries
#include "boost/integer/common_factor_rt.hpp" // boost::integer::gcd()

// C/C++ standard libraries
#include <cctype>     // std::isblank()
#include <functional> // std::hash<>
#include <limits>
#include <map>
#include <ostream>
#include <ratio>
#include <regex>
#include <string>
#include <string_view>
#include <type_traits> // std::is_same<>, std::enable_if_t<>, ...

namespace util::quantities {

  namespace concepts {

    namespace details {

      //------------------------------------------------------------------------
      //---  Ratio metaprogramming
      //------------------------------------------------------------------------
      template <typename Ratio, typename Value>
      static constexpr auto applyRatioToValue(Value&& v)
      {
        return v * Ratio::num / Ratio::den;
      }

      template <typename R>
      struct invert_ratio;

      template <typename R>
      using invert_t = typename invert_ratio<R>::type;

      template <typename R>
      struct ratio_simplifier;

      template <typename R>
      using simplify_ratio = typename ratio_simplifier<R>::type;

      //------------------------------------------------------------------------
      //--- Unit-related
      //------------------------------------------------------------------------
      template <typename U>
      struct has_unit;

      template <typename U>
      constexpr bool has_unit_v = has_unit<U>();

      template <typename Q>
      struct is_quantity;

      template <typename Q>
      constexpr bool is_quantity_v = is_quantity<Q>();

      template <typename Q>
      struct has_quantity;

      template <typename Q>
      constexpr bool has_quantity_v = has_quantity<Q>();

      //------------------------------------------------------------------------
      template <typename T>
      struct quantity_value_type;

      template <typename T>
      using quantity_value_t = typename quantity_value_type<T>::type;

      template <typename T, typename Q>
      struct is_value_compatible_with;

      template <typename T, typename Q>
      constexpr bool is_value_compatible_with_v = is_value_compatible_with<T, Q>();

      template <typename T, typename U>
      struct has_value_compatible_with;

      template <typename T, typename U>
      constexpr bool has_value_compatible_with_v = has_value_compatible_with<T, U>();

      //------------------------------------------------------------------------
      //---  constexpr string concatenation
      //------------------------------------------------------------------------
      // giving up for now; Boost 1.68.0 offers some help, but we don;t use it
      // yet

      //------------------------------------------------------------------------
      template <typename Q>
      class numeric_limits;

      //------------------------------------------------------------------------

    } // namespace details

    using namespace std::string_view_literals;

    //------------------------------------------------------------------------
    template <typename ARatio, typename BRatio>
    using simplified_ratio_multiply = details::simplify_ratio<std::ratio_multiply<ARatio, BRatio>>;

    template <typename NumRatio, typename DenRatio>
    using simplified_ratio_divide = details::simplify_ratio<std::ratio_divide<NumRatio, DenRatio>>;

    //------------------------------------------------------------------------
    struct UnitBase {
      static constexpr std::string_view symbol = "?"sv;
      static constexpr std::string_view name = "unknown"sv;
    }; // struct UnitBase

    template <typename R>
    struct Prefix {
      using ratio = R; 

      static constexpr auto names(bool Long = false);

      static constexpr auto symbol() { return names(false); }

      static constexpr auto name() { return names(true); }

    }; // struct Prefix

    template <typename U, typename R = std::ratio<1>>
    struct ScaledUnit {

      using baseunit_t = U;            
      using unit_t = ScaledUnit<U, R>; 
      using ratio = R;                 
      using prefix_t = Prefix<ratio>;  

      // -- BEGIN Conversion to string -----------------------------------------

      static auto symbol() { return std::string(prefix().symbol()) + baseUnit().symbol.data(); }

      static auto name() { return std::string(prefix().name()) + baseUnit().name.data(); }

      // -- END Conversion to string -------------------------------------------

      // -- BEGIN Representation conversions -----------------------------------

      template <typename T>
      static constexpr T scale(T v)
      {
        return details::applyRatioToValue<details::invert_t<ratio>>(v);
      }

      template <typename T>
      static constexpr T unscale(T v)
      {
        return details::applyRatioToValue<ratio>(v);
      }

      template <typename TargetRatio, typename T>
      static constexpr T scaleTo(T v)
      {
        return details::applyRatioToValue<simplified_ratio_divide<ratio, TargetRatio>>(v);
      }

      template <typename TargetRatio, typename T>
      static constexpr T fromRepr(T v)
      {
        return details::applyRatioToValue<simplified_ratio_divide<TargetRatio, ratio>>(v);
      }

      // -- END Representation conversions -------------------------------------

      // -- BEGIN Type features ------------------------------------------------

      static constexpr prefix_t prefix() { return {}; }

      static constexpr baseunit_t baseUnit() { return {}; }

      static constexpr unit_t unit() { return {}; }

      template <typename OU>
      static constexpr bool sameBaseUnitAs()
      {
        return std::is_same<baseunit_t, typename OU::baseunit_t>();
      }

      template <typename OU>
      static constexpr bool sameUnitAs()
      {
        return std::is_same<unit_t, typename OU::unit_t>();
      }

      // -- END Type features --------------------------------------------------

    }; // ScaledUnit<>

    template <typename U, typename R>
    std::ostream& operator<<(std::ostream& out, ScaledUnit<U, R> const& unit)
    {
      using unit_t = ScaledUnit<U, R>;
      return out << unit_t::prefix_t::symbol() << unit_t::baseunit_t::symbol;
    }

    template <typename Unit, typename T = double>
    struct Quantity {

    public:
      using value_t = T;                    
      using unit_t = Unit;                  
      using quantity_t = Quantity<Unit, T>; 

      using baseunit_t = typename unit_t::baseunit_t;

      // NOTE: this is not `constexpr` because using it n a constexpr would
      //       yield an uninitialized constant
      explicit Quantity() = default;

      explicit constexpr Quantity(value_t v) : fValue(v) {}

      template <typename Q, typename std::enable_if_t<details::is_quantity_v<Q>>* = nullptr>
      constexpr Quantity(Q q)
        : fValue{unit_t::template fromRepr<typename Q::unit_t::ratio>(q.value())}
      {
        static_assert(sameBaseUnitAs<Q>(),
                      "Can't construct from quantity with different base unit");
      }

      constexpr value_t value() const { return fValue; }

      explicit constexpr operator value_t() const { return value(); }

      // -- BEGIN Asymmetric arithmetic operations -----------------------------

      template <typename OU, typename OT>
      constexpr quantity_t operator+(Quantity<OU, OT> const other) const;

      template <typename OU, typename OT>
      constexpr quantity_t operator-(Quantity<OU, OT> const other) const;

      template <typename OU, typename OT>
      constexpr quantity_t plus(Quantity<OU, OT> const other) const;

      template <typename OU, typename OT>
      constexpr quantity_t minus(Quantity<OU, OT> const other) const;

      template <typename OU, typename OT>
      constexpr value_t operator/(Quantity<OU, OT> q) const;

      template <typename OU, typename OT>
      quantity_t& operator+=(Quantity<OU, OT> const other);

      template <typename OU, typename OT>
      quantity_t& operator-=(Quantity<OU, OT> const other);

      template <typename OT>
      std::enable_if_t<std::is_arithmetic_v<OT>, quantity_t&> operator*=(OT factor)
      {
        fValue *= factor;
        return *this;
      }

      template <typename OT>
      std::enable_if_t<std::is_arithmetic_v<OT>, quantity_t&> operator/=(OT quot)
      {
        fValue /= quot;
        return *this;
      }

      constexpr quantity_t operator+() const { return quantity_t(value()); }

      constexpr quantity_t operator-() const { return quantity_t(-value()); }

      constexpr quantity_t abs() const { return quantity_t(util::abs(value())); }

      // -- END Asymmetric arithmetic operations -------------------------------

      // -- BEGIN Comparisons --------------------------------------------------

      template <typename OU, typename OT>
      constexpr bool operator==(Quantity<OU, OT> const other) const;

      template <typename OU, typename OT>
      constexpr bool operator!=(Quantity<OU, OT> const other) const;

      template <typename OU, typename OT>
      constexpr bool operator>=(Quantity<OU, OT> const other) const;

      template <typename OU, typename OT>
      constexpr bool operator>(Quantity<OU, OT> const other) const;

      template <typename OU, typename OT>
      constexpr bool operator<=(Quantity<OU, OT> const other) const;

      template <typename OU, typename OT>
      constexpr bool operator<(Quantity<OU, OT> const other) const;

      // -- END Asymmetric arithmetic operations -------------------------------

      // -- BEGIN Access to the scaled unit ------------------------------------

      static constexpr unit_t unit() { return {}; }

      static constexpr baseunit_t baseUnit() { return {}; }

      static auto unitName() { return unit_t::name(); }

      static auto unitSymbol() { return unit_t::symbol(); }

      template <typename OU>
      static constexpr bool sameBaseUnitAs()
      {
        return unit_t::template sameBaseUnitAs<OU>();
      }

      template <typename OU>
      static constexpr bool sameUnitAs()
      {
        return unit_t::template sameUnitAs<OU>();
      }

      template <typename U>
      static constexpr bool is_compatible_value_v = details::is_value_compatible_with_v<U, value_t>;

      template <typename U>
      static constexpr bool has_compatible_value_v =
        details::has_value_compatible_with_v<U, value_t>;

      template <typename U>
      static constexpr bool isCompatibleValue()
      {
        return quantity_t::is_compatible_value_v<U>;
      }

      template <typename U>
      static constexpr bool hasCompatibleValue()
      {
        return quantity_t::has_compatible_value_v<U>;
      }

      // -- END Access to the scaled unit --------------------------------------

      template <typename OQ>
      constexpr OQ convertInto() const
      {
        return OQ(*this);
      }

      template <typename U>
      static constexpr quantity_t castFrom(U value)
      {
        return quantity_t{static_cast<value_t>(value)};
      }

    private:
      value_t fValue{}; 

    }; // struct Quantity

    template <typename... Args>
    std::ostream& operator<<(std::ostream& out, Quantity<Args...> const q)
    {
      return out << q.value() << " " << q.unit();
    }

    // -- BEGIN Arithmetic operations ------------------------------------------


    template <typename U, typename T>
    constexpr Quantity<U, T> operator+(Quantity<U, T> const q, T shift) = delete;
    template <typename U, typename T>
    constexpr Quantity<U, T> operator+(T shift, Quantity<U, T> const q) = delete;
    template <typename U, typename T>
    constexpr Quantity<U, T> operator-(Quantity<U, T> const q, T shift) = delete;
    template <typename U, typename T>
    constexpr Quantity<U, T> operator-(T shift, Quantity<U, T> const q) = delete;

    template <typename U, typename T, typename OT>
    constexpr std::enable_if_t<Quantity<U, T>::template is_compatible_value_v<OT>, Quantity<U, T>>
    operator*(Quantity<U, T> const q, OT factor)
    {
      return Quantity<U, T>{q.value() * static_cast<T>(factor)};
    }
    template <typename U, typename T, typename OT>
    constexpr std::enable_if_t<Quantity<U, T>::template is_compatible_value_v<OT>, Quantity<U, T>>
    operator*(OT factor, Quantity<U, T> const q)
    {
      return q * factor;
    }

    template <typename AU, typename AT, typename BU, typename BT>
    constexpr auto operator*(Quantity<AU, AT>, Quantity<BU, BT>)
      -> decltype(std::declval<AT>() * std::declval<BT>()) = delete;

    // Division by a scalar.
    template <typename U, typename T, typename OT>
    constexpr std::enable_if_t<Quantity<U, T>::template is_compatible_value_v<OT>, Quantity<U, T>>
    operator/(Quantity<U, T> q, OT quot)
    {
      return Quantity<U, T>{q.value() / static_cast<T>(quot)};
    }

    // -- END Arithmetic operations --------------------------------------------

    // -------------------------------------------------------------------------
    template <typename Unit, typename Ratio, typename T>
    using scaled_quantity = Quantity<ScaledUnit<Unit, Ratio>, T>;

    // -------------------------------------------------------------------------
    template <typename Q, typename R, typename T = typename Q::value_t>
    using rescale = Quantity<ScaledUnit<typename Q::unit_t::baseunit_t, R>, T>;

    // -------------------------------------------------------------------------

    //
    // extensions STL-style
    // (can't be put in `std` since they are not specializations)
    //

    template <typename... Args>
    std::string to_string(ScaledUnit<Args...> const& unit)
    {
      return std::string(unit.prefix().symbol()) + unit.baseUnit().symbol.data();
    }

    template <typename... Args>
    std::string to_string(Quantity<Args...> const& q)
    {
      return util::to_string(q.value()) + ' ' + util::to_string(q.unit());
    }

    // -------------------------------------------------------------------------

  } // namespace concepts

  // ---------------------------------------------------------------------------
  namespace prefixes { // we expect other libraries to fill it

    // ratios imported from C++ standard library:
    using std::atto, std::femto, std::pico, std::nano, std::micro, std::milli, std::centi,
      std::deci, std::deca, std::hecto, std::kilo, std::mega, std::giga, std::tera, std::peta,
      std::exa;

  } // namespace prefixes

  // ---------------------------------------------------------------------------
  namespace units {} // we expect other libraries to fill it

  // -------------------------------------------------------------------------
  // @{
  template <typename Quantity>
  Quantity makeQuantity(std::string_view s, bool unitOptional = false);

  template <typename Quantity>
  Quantity makeQuantity(std::string const& s, bool unitOptional = false);

  template <typename Quantity>
  Quantity makeQuantity(char const* s, bool unitOptional = false);


  // --- BEGIN -- Specific exceptions ------------------------------------------

  struct MissingUnit : std::runtime_error {
    using std::runtime_error::runtime_error;
  };

  struct InvalidUnitPrefix : std::runtime_error {
    using std::runtime_error::runtime_error;
  };

  struct MismatchingUnit : std::runtime_error {
    using std::runtime_error::runtime_error;
  };

  struct ValueError : std::runtime_error {
    using std::runtime_error::runtime_error;
  };

  struct ExtraCharactersError : std::runtime_error {
    using std::runtime_error::runtime_error;
  };

  // --- END -- Specific exceptions --------------------------------------------

  // ---------------------------------------------------------------------------

} // namespace util::quantities

//------------------------------------------------------------------------------
//---  template implementation
//------------------------------------------------------------------------------
namespace util::quantities::concepts::details {

  //----------------------------------------------------------------------------
  template <std::intmax_t Num, std::intmax_t Den>
  struct invert_ratio<std::ratio<Num, Den>> {
    using type = std::ratio<Den, Num>;
  };

  //----------------------------------------------------------------------------
  template <std::intmax_t Num, std::intmax_t Den>
  struct ratio_simplifier<std::ratio<Num, Den>> {
    static constexpr auto gcd = boost::integer::gcd(Num, Den);
    using type = std::ratio<Num / gcd, Den / gcd>;
  }; // ratio_simplifier

  //----------------------------------------------------------------------------
  template <typename U, typename Enable = void>
  struct has_unit_impl : public std::false_type {};

  template <typename U>
  struct has_unit_impl<U, std::enable_if_t<util::always_true_v<typename U::unit_t>>>
    : public std::true_type {};

  template <typename U>
  struct has_unit : public has_unit_impl<U> {};

  //----------------------------------------------------------------------------
  template <typename Q>
  struct is_quantity : public std::false_type {};

  template <typename... Args>
  struct is_quantity<Quantity<Args...>> : public std::true_type {};

  //----------------------------------------------------------------------------
  template <typename Q, typename Enable = void>
  struct has_quantity_impl : public std::false_type {};

  template <typename Q>
  struct has_quantity_impl<Q, std::enable_if_t<util::always_true_v<typename Q::quantity_t>>>
    : public std::true_type {};

  template <typename Q>
  struct has_quantity : public has_quantity_impl<Q> {};

  //----------------------------------------------------------------------------
  template <typename T, typename = void>
  struct quantity_value_type_impl {
    using type = T;
  }; // quantity_value_type

  template <typename T>
  struct quantity_value_type_impl<
    T,
    std::enable_if_t<(has_unit_v<T> && util::always_true_v<typename T::value_t>)>> {
    using type = typename T::value_t;
  }; // quantity_value_type_impl<unit>

  template <typename T>
  struct quantity_value_type : quantity_value_type_impl<T> {};

  //----------------------------------------------------------------------------
  template <typename T, typename Q>
  struct is_value_compatible_with
    : std::bool_constant<std::is_convertible_v<T, quantity_value_t<Q>>> {};

  //----------------------------------------------------------------------------
  template <typename T, typename U>
  struct has_value_compatible_with : is_value_compatible_with<quantity_value_t<T>, U> {};

  //----------------------------------------------------------------------------
  template <typename Q>
  class numeric_limits : public std::numeric_limits<typename Q::value_t> {

    using quantity_t = Q;
    using value_traits_t = std::numeric_limits<typename quantity_t::value_t>;

  public:
    static constexpr quantity_t min() noexcept { return quantity_t{value_traits_t::min()}; }
    static constexpr quantity_t max() noexcept { return quantity_t{value_traits_t::max()}; }
    static constexpr quantity_t lowest() noexcept { return quantity_t{value_traits_t::lowest()}; }
    static constexpr quantity_t epsilon() noexcept { return quantity_t{value_traits_t::epsilon()}; }
    static constexpr quantity_t round_error() noexcept
    {
      return quantity_t{value_traits_t::round_error()};
    }
    static constexpr quantity_t infinity() noexcept
    {
      return quantity_t{value_traits_t::infinity()};
    }
    static constexpr quantity_t quiet_NaN() noexcept
    {
      return quantity_t{value_traits_t::quiet_NaN()};
    }
    static constexpr quantity_t signaling_NaN() noexcept
    {
      return quantity_t{value_traits_t::signaling_NaN()};
    }
    static constexpr quantity_t denorm_min() noexcept
    {
      return quantity_t{value_traits_t::denorm_min()};
    }

  }; // numeric_limits<Quantity>

  //----------------------------------------------------------------------------

} // namespace util::quantities::concepts::details

//------------------------------------------------------------------------------
//--- template implementation
//------------------------------------------------------------------------------
//--- util::quantities::concepts::Prefix
//------------------------------------------------------------------------------
template <typename R>
constexpr auto util::quantities::concepts::Prefix<R>::names(bool Long /* = false */)
{
  if constexpr (std::is_same<ratio, std::tera>()) return Long ? "tera"sv : "T"sv;
  if constexpr (std::is_same<ratio, std::giga>()) return Long ? "giga"sv : "G"sv;
  if constexpr (std::is_same<ratio, std::mega>()) return Long ? "mega"sv : "M"sv;
  if constexpr (std::is_same<ratio, std::kilo>()) return Long ? "kilo"sv : "k"sv;
  if constexpr (std::is_same<ratio, std::ratio<1>>()) return ""sv;
  if constexpr (std::is_same<ratio, std::deci>()) return Long ? "deci"sv : "d"sv;
  if constexpr (std::is_same<ratio, std::centi>()) return Long ? "centi"sv : "c"sv;
  if constexpr (std::is_same<ratio, std::milli>()) return Long ? "milli"sv : "m"sv;
  if constexpr (std::is_same<ratio, std::micro>()) return Long ? "micro"sv : "u"sv;
  if constexpr (std::is_same<ratio, std::nano>()) return Long ? "nano"sv : "n"sv;
  if constexpr (std::is_same<ratio, std::pico>()) return Long ? "pico"sv : "p"sv;
  if constexpr (std::is_same<ratio, std::femto>()) return Long ? "femto"sv : "f"sv;
  // TODO complete the long list of prefixes

  // backup; can't use `to_string()` because of `constexpr` requirement
  return Long ? "???"sv : "?"sv;
} // util::quantities::concepts::Prefix<R>::names()

//------------------------------------------------------------------------------
//---  util::quantities::concepts::Quantity
//------------------------------------------------------------------------------
template <typename U, typename T>
template <typename OU, typename OT>
constexpr auto util::quantities::concepts::Quantity<U, T>::operator+(
  Quantity<OU, OT> const other) const -> quantity_t
{
  static_assert(std::is_same<Quantity<OU, OT>, quantity_t>(),
                "Only quantities with exactly the same unit can be added.");
  return quantity_t(value() + other.value());
} // util::quantities::concepts::Quantity<>::operator+

//------------------------------------------------------------------------------
template <typename U, typename T>
template <typename OU, typename OT>
constexpr auto util::quantities::concepts::Quantity<U, T>::operator-(
  Quantity<OU, OT> const other) const -> quantity_t
{
  static_assert(std::is_same<Quantity<OU, OT>, quantity_t>(),
                "Only quantities with exactly the same unit can be subtracted.");
  return quantity_t(value() - other.value());
} // util::quantities::concepts::Quantity<>::operator+

//------------------------------------------------------------------------------
template <typename U, typename T>
template <typename OU, typename OT>
constexpr auto util::quantities::concepts::Quantity<U, T>::plus(Quantity<OU, OT> const other) const
  -> quantity_t
{
  static_assert(sameBaseUnitAs<OU>(), "Can't add quantities with different base unit");

  // if the two quantities have the same *scaled* unit, add
  if constexpr (sameUnitAs<OU>()) {
    return quantity_t(fValue + other.value());
    return *this;
  }
  else {
    // otherwise, they have same base unit but different scale: convert `other`
    return (*this + quantity_t(other));
  }
} // util::quantities::concepts::Quantity<>::operator+()

//------------------------------------------------------------------------------
template <typename U, typename T>
template <typename OU, typename OT>
constexpr auto util::quantities::concepts::Quantity<U, T>::minus(Quantity<OU, OT> const other) const
  -> quantity_t
{
  static_assert(sameBaseUnitAs<OU>(), "Can't subtract quantities with different base unit");

  // if the two quantities have the same *scaled* unit, add
  if constexpr (sameUnitAs<OU>()) {
    return quantity_t(fValue - other.value());
    return *this;
  }
  else {
    // otherwise, they have same base unit but different scale: convert `other`
    return (*this - quantity_t(other));
  }
} // util::quantities::concepts::Quantity<>::minus()

//------------------------------------------------------------------------------
template <typename U, typename T>
template <typename OU, typename OT>
constexpr auto util::quantities::concepts::Quantity<U, T>::operator/(Quantity<OU, OT> const q) const
  -> value_t
{
  static_assert(sameBaseUnitAs<OU>(), "Can't divide quantities with different base unit");

  // if the two quantities have the same *scaled* unit, divide
  if constexpr (sameUnitAs<OU>()) { return value() / q.value(); }
  else {
    // otherwise, they have same base unit but different scale: convert `other`
    return (*this) / quantity_t(q);
  }
} // util::quantities::concepts::Quantity<>::operator/(Quantity)

//------------------------------------------------------------------------------
template <typename U, typename T>
template <typename OU, typename OT>
auto util::quantities::concepts::Quantity<U, T>::operator+=(Quantity<OU, OT> const other)
  -> quantity_t&
{
  static_assert(sameBaseUnitAs<OU>(), "Can't add quantities with different base unit");

  // if the two quantities have the same *scaled* unit, add
  if constexpr (sameUnitAs<OU>()) {
    fValue += other.value();
    return *this;
  }
  else {
    // otherwise, they have same base unit but different scale: convert `other`
    return (*this += quantity_t(other));
  }
} // util::quantities::concepts::Quantity<>::operator+=()

//------------------------------------------------------------------------------
template <typename U, typename T>
template <typename OU, typename OT>
auto util::quantities::concepts::Quantity<U, T>::operator-=(Quantity<OU, OT> const other)
  -> quantity_t&
{
  static_assert(sameBaseUnitAs<OU>(), "Can't subtract quantities with different base unit");

  // if the two quantities have the same *scaled* unit, add
  if constexpr (sameUnitAs<OU>()) {
    fValue -= other.value();
    return *this;
  }
  else {
    // otherwise, they have same base unit but different scale: convert `other`
    return (*this -= quantity_t(other));
  }
} // util::quantities::concepts::Quantity<>::operator-=()

//------------------------------------------------------------------------------
template <typename U, typename T>
template <typename OU, typename OT>
constexpr bool util::quantities::concepts::Quantity<U, T>::operator==(
  Quantity<OU, OT> const other) const
{
  static_assert(sameBaseUnitAs<OU>(), "Can't compare quantities with different base unit");

  // if the two quantities have the same *scaled* unit, just compare the values
  if constexpr (sameUnitAs<OU>()) { return value() == other.value(); }
  else {
    // otherwise, they have same base unit but different scale: convert `other`
    return *this == quantity_t(other);
  }
} // util::quantities::concepts::Quantity<>::operator==()

//------------------------------------------------------------------------------
template <typename U, typename T>
template <typename OU, typename OT>
constexpr bool util::quantities::concepts::Quantity<U, T>::operator!=(
  Quantity<OU, OT> const other) const
{
  static_assert(sameBaseUnitAs<OU>(), "Can't compare quantities with different base unit");

  // if the two quantities have the same *scaled* unit, just compare the values
  if constexpr (sameUnitAs<OU>()) { return value() != other.value(); }
  else {
    // otherwise, they have same base unit but different scale: convert `other`
    return *this != quantity_t(other);
  }
} // util::quantities::concepts::Quantity<>::operator!=()

//------------------------------------------------------------------------------
template <typename U, typename T>
template <typename OU, typename OT>
constexpr bool util::quantities::concepts::Quantity<U, T>::operator<=(
  Quantity<OU, OT> const other) const
{
  static_assert(sameBaseUnitAs<OU>(), "Can't compare quantities with different base unit");

  // if the two quantities have the same *scaled* unit, just compare the values
  if constexpr (sameUnitAs<OU>()) { return value() <= other.value(); }
  else {
    // otherwise, they have same base unit but different scale: convert `other`
    return *this <= quantity_t(other);
  }
} // util::quantities::concepts::Quantity<>::operator<=()

//------------------------------------------------------------------------------
template <typename U, typename T>
template <typename OU, typename OT>
constexpr bool util::quantities::concepts::Quantity<U, T>::operator>=(
  Quantity<OU, OT> const other) const
{
  static_assert(sameBaseUnitAs<OU>(), "Can't compare quantities with different base unit");

  // if the two quantities have the same *scaled* unit, just compare the values
  if constexpr (sameUnitAs<OU>()) { return value() >= other.value(); }
  else {
    // otherwise, they have same base unit but different scale: convert `other`
    return *this >= quantity_t(other);
  }
} // util::quantities::concepts::Quantity<>::operator>=()

//------------------------------------------------------------------------------
template <typename U, typename T>
template <typename OU, typename OT>
constexpr bool util::quantities::concepts::Quantity<U, T>::operator<(
  Quantity<OU, OT> const other) const
{
  static_assert(sameBaseUnitAs<OU>(), "Can't compare quantities with different base unit");

  // if the two quantities have the same *scaled* unit, just compare the values
  if constexpr (sameUnitAs<OU>()) { return value() < other.value(); }
  else {
    // otherwise, they have same base unit but different scale: convert `other`
    return *this < quantity_t(other);
  }
} // util::quantities::concepts::Quantity<>::operator<()

//------------------------------------------------------------------------------
template <typename U, typename T>
template <typename OU, typename OT>
constexpr bool util::quantities::concepts::Quantity<U, T>::operator>(
  Quantity<OU, OT> const other) const
{
  static_assert(sameBaseUnitAs<OU>(), "Can't compare quantities with different base unit");

  // if the two quantities have the same *scaled* unit, just compare the values
  if constexpr (sameUnitAs<OU>()) { return value() > other.value(); }
  else {
    // otherwise, they have same base unit but different scale: convert `other`
    return *this > quantity_t(other);
  }
} // util::quantities::concepts::Quantity<>::operator>()

//------------------------------------------------------------------------------
namespace util::quantities::details {

  template <typename Quantity>
  std::pair<std::string, typename Quantity::value_t> readUnit(std::string const& str,
                                                              bool unitOptional = false);

} // util::quantities::details

//------------------------------------------------------------------------------
template <typename Quantity>
std::pair<std::string, typename Quantity::value_t> util::quantities::details::readUnit(
  std::string const& str,
  bool unitOptional /* = false */)
{
  using Quantity_t = Quantity;
  using value_t = typename Quantity_t::value_t;
  using unit_t = typename Quantity_t::unit_t;
  using baseunit_t = typename unit_t::baseunit_t;

  // --- BEGIN -- static initialization ----------------------------------------
  using namespace std::string_literals;

  using PrefixMap_t = std::map<std::string, value_t>;
  using PrefixValue_t = typename PrefixMap_t::value_type;
  static PrefixMap_t const factors{PrefixValue_t{"a"s, 1e-18},
                                   PrefixValue_t{"f"s, 1e-15},
                                   PrefixValue_t{"p"s, 1e-12},
                                   PrefixValue_t{"n"s, 1e-09},
                                   PrefixValue_t{"u"s, 1e-06},
                                   PrefixValue_t{"m"s, 1e-03},
                                   PrefixValue_t{"c"s, 1e-02},
                                   PrefixValue_t{"d"s, 1e-01},
                                   PrefixValue_t{""s, 1e+00},
                                   PrefixValue_t{"da"s, 1e+01},
                                   PrefixValue_t{"h"s, 1e+02},
                                   PrefixValue_t{"k"s, 1e+03},
                                   PrefixValue_t{"M"s, 1e+06},
                                   PrefixValue_t{"G"s, 1e+09},
                                   PrefixValue_t{"T"s, 1e+12},
                                   PrefixValue_t{"P"s, 1e+15},
                                   PrefixValue_t{"E"s, 1e+18}}; // factors
  static auto const composePrefixPattern = [](auto b, auto e) -> std::string {
    std::string pattern = "(";
    if (b != e) {
      pattern += b->first;
      while (++b != e) {
        pattern += '|';
        pattern += b->first;
      }
    }
    return pattern += ")";
  };
  static std::string const prefixPattern = composePrefixPattern(factors.begin(), factors.end());
  // --- END -- static initialization ------------------------------------------

  std::regex const unitPattern{"[[:blank:]]*(" + prefixPattern + "?" +
                               util::to_string(baseunit_t::symbol) + ")[[:blank:]]*$"};

  std::smatch unitMatch;
  if (!std::regex_search(str, unitMatch, unitPattern)) {
    if (!unitOptional) {
      throw MissingUnit("Unit is mandatory and must derive from '" +
                        util::to_string(baseunit_t::symbol) + "' (parsing: '" + str + "')");
    }
    return {str, value_t{1}};
  }

  //
  // we do have a unit:
  //

  // " 7 cm " => [0] full match (" cm ") [1] unit ("cm") [2] unit prefix ("c")
  auto const iFactor = factors.find(unitMatch.str(2U));
  if (iFactor == factors.end()) {
    throw InvalidUnitPrefix("Unit '" + unitMatch.str(1U) + "' has unsupported prefix '" +
                            unitMatch.str(2U) + "' (parsing '" + str + "')");
  }

  return {str.substr(0U, str.length() - unitMatch.length()),
          static_cast<value_t>(unit_t::scale(iFactor->second))};

} // util::quantities::details::readUnit()

//------------------------------------------------------------------------------
template <typename Quantity>
Quantity util::quantities::makeQuantity(std::string const& s, bool unitOptional /* = false */)
{
  //
  // all this function is horrible;
  // some redesign is needed...
  //
  using value_t = typename Quantity::value_t;

  auto const [num_s, factor] = details::readUnit<Quantity>(s, unitOptional);

  char* parseEnd = nullptr;
  auto const value = static_cast<value_t>(std::strtod(num_s.c_str(), &parseEnd));
  const char* send = num_s.c_str() + num_s.length();
  if (parseEnd == num_s.c_str()) {
    throw ValueError("Could not convert '" + num_s + "' into a number!");
  }
  while (parseEnd != send) {
    if (!std::isblank(static_cast<unsigned char>(*parseEnd))) {
      throw ExtraCharactersError("Spurious characters after value " + std::to_string(value) +
                                 " in '" + num_s + "' ('" + std::string(parseEnd, send - parseEnd) +
                                 "')\n");
    }
    ++parseEnd;
  } // while

  //
  // create and return the quantity
  //
  return Quantity{static_cast<value_t>(value * factor)};
} // util::quantities::makeQuantity(string_view)

//------------------------------------------------------------------------------
template <typename Quantity>
Quantity util::quantities::makeQuantity(std::string_view s, bool unitOptional /* = false */)
{
  return util::quantities::makeQuantity<Quantity>(std::string{s.begin(), s.end()}, unitOptional);
} // util::quantities::makeQuantity(string_view)

//------------------------------------------------------------------------------
template <typename Quantity>
Quantity util::quantities::makeQuantity(char const* s, bool unitOptional /* = false */)
{
  return util::quantities::makeQuantity<Quantity>(std::string_view{s}, unitOptional);
} // util::quantities::makeQuantity(string)

//------------------------------------------------------------------------------
//---  Standard library extensions
//------------------------------------------------------------------------------
namespace std {

  // ---------------------------------------------------------------------------
  template <typename... Args>
  struct hash<util::quantities::concepts::Quantity<Args...>> {
  private:
    using quantity_t = util::quantities::concepts::Quantity<Args...>;
    using value_t = typename quantity_t::value_t;

  public:
    constexpr auto operator()(quantity_t key) const
      noexcept(noexcept(std::hash<value_t>()(key.value())))
    {
      return std::hash<value_t>()(key.value());
    }
  };

  // ---------------------------------------------------------------------------
  template <typename Unit, typename T>
  class numeric_limits<util::quantities::concepts::Quantity<Unit, T>>
    : public util::quantities::concepts::details::numeric_limits<
        util::quantities::concepts::Quantity<Unit, T>> {};

  template <typename Unit, typename T>
  class numeric_limits<util::quantities::concepts::Quantity<Unit, T> const>
    : public util::quantities::concepts::details::numeric_limits<
        util::quantities::concepts::Quantity<Unit, T> const> {};

  template <typename Unit, typename T>
  class numeric_limits<util::quantities::concepts::Quantity<Unit, T> volatile>
    : public util::quantities::concepts::details::numeric_limits<
        util::quantities::concepts::Quantity<Unit, T> volatile> {};

  template <typename Unit, typename T>
  class numeric_limits<util::quantities::concepts::Quantity<Unit, T> const volatile>
    : public util::quantities::concepts::details::numeric_limits<
        util::quantities::concepts::Quantity<Unit, T> const volatile> {};

  // ---------------------------------------------------------------------------

} // namespace std

//------------------------------------------------------------------------------

#endif // LARDATAALG_UTILITIES_QUANTITIES_H