intervals.h

Go to the documentation of this file.

#ifndef LARDATAALG_UTILITIES_INTERVALS_H
#define LARDATAALG_UTILITIES_INTERVALS_H

// LArSoft libraries
#include "lardataalg/Utilities/quantities.h"

// C/C++ standard libraries
#include <ostream>
#include <type_traits> // std::enable_if_t<>, ...

namespace util::quantities {

  struct NoCategory;

  namespace concepts {

    namespace details {

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

      template <typename Cat, typename = void>
      struct category_of_type;

      template <typename Cat>
      using category_of = typename category_of_type<Cat>::type;

      //------------------------------------------------------------------------
      template <typename Cat>
      struct WithCategory;

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

    } // namespace details

    //--------------------------------------------------------------------------
    struct CategoryBase {
      static std::string name() = delete;
    }; // struct CategoryBase

    //--------------------------------------------------------------------------
    //--- traits
    //--------------------------------------------------------------------------
    template <typename IV>
    struct is_interval;

    template <typename IV>
    constexpr bool is_interval_v = is_interval<IV>();

    //--------------------------------------------------------------------------
    template <typename PT>
    struct is_point;

    template <typename PT>
    constexpr bool is_point_v = is_point<PT>();

    //--------------------------------------------------------------------------
    template <typename T>
    using is_interval_or_point = std::disjunction<is_interval<T>, is_point<T>>;

    template <typename T>
    constexpr bool is_interval_or_point_v = is_interval_or_point<T>();

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

    template <typename T>
    using interval_of = typename T::interval_t;

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

    template <typename Q, typename Cat = NoCategory>
    struct Interval : private Q, public details::WithCategory<Cat> {

      using category_base_t = details::WithCategory<Cat>;

      using traits_t = typename category_base_t::traits_t;

      template <typename OC, typename Type = void>
      using enable_if_compatible_t =
        std::enable_if_t<category_base_t::template category_compatible_with<OC>(), Type>;

    public:
      using interval_t = Interval<Q, Cat>; 

      // --- BEGIN -- Types from the base quantity -----------------------------

      using quantity_t = Q; 

      using category_t = typename category_base_t::category_t;

      template <typename R>
      using scaled_quantity_t = rescale<quantity_t, R>;

      using value_t = typename quantity_t::value_t;

      using unit_t = typename quantity_t::unit_t;

      using baseunit_t = typename quantity_t::baseunit_t;

      template <typename OQ, typename OI>
      using other_interval_t = Interval<OQ, category_t>;

      // --- END -- Types from the base quantity -------------------------------

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

      explicit constexpr Interval(value_t v) : Interval(quantity_t{v}) {}

      template <typename... Args>
      constexpr Interval(Quantity<Args...> const& q) : quantity_t(quantity_t{q})
      {}

      template <typename IV, typename std::enable_if_t<is_interval_v<IV>>* = nullptr>
      constexpr Interval(IV iv) : Interval(quantity_t{iv.quantity()})
      {}

      constexpr quantity_t const& quantity() const { return *this; }

      using quantity_t::value;

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

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

      using quantity_t::baseUnit;
      using quantity_t::unit;
      using quantity_t::unitName;
      using quantity_t::unitSymbol;

      /*
       * due to C++ (up to 17 at least) syntax limitations, we can't import
       * a dependent template (in this case, `Q::baseUnit<U>`, which depends
       * on a template parameter `Q`) as such: C++ will import it if we use the
       * "standard" syntax `using quantity_t::sameUnitAs;`, but without
       * knowning it as a template; the correct syntax to express this would be
       * `using quantity_t::template sameUnitAs;`, which is not allowed in C++.
       * So we have to redefine the thing entirely.
       */

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

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

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

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

      constexpr interval_t operator+(interval_t const other) const
      {
        return interval_t{quantity() + other.quantity()};
      }

      constexpr interval_t operator-(interval_t const other) const
      {
        return interval_t{quantity() - other.quantity()};
      }

      template <typename OQ, typename OC>
      constexpr enable_if_compatible_t<Interval<OQ, OC>, value_t> operator/(
        Interval<OQ, OC> const denom) const
      {
        return quantity() / denom.quantity();
      }

      template <typename R>
      interval_t& operator+=(scaled_quantity_t<R> const other)
      {
        quantity_t::operator+=(other);
        return *this;
      }

      template <typename OQ, typename OC>
      enable_if_compatible_t<Interval<OQ, OC>, interval_t&> operator+=(Interval<OQ, OC> const other)
      {
        return operator+=(other.quantity());
      }

      template <typename R>
      interval_t& operator-=(scaled_quantity_t<R> const other)
      {
        quantity_t::operator-=(other);
        return *this;
      }

      template <typename OQ, typename OC>
      enable_if_compatible_t<Interval<OQ, OC>, interval_t&> operator-=(Interval<OQ, OC> const other)
      {
        return operator-=(other.quantity());
      }

      template <typename T>
      interval_t& operator*=(T factor)
      {
        quantity_t::operator*=(factor);
        return *this;
      }

      template <typename T>
      interval_t& operator/=(T factor)
      {
        quantity_t::operator/=(factor);
        return *this;
      }

      constexpr interval_t operator+() const { return interval_t(quantity()); }

      constexpr interval_t operator-() const { return interval_t(-quantity()); }

      constexpr interval_t abs() const { return interval_t(quantity().abs()); }

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

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

      template <typename OQ, typename OC>
      constexpr enable_if_compatible_t<Interval<OQ, OC>, bool> operator==(
        Interval<OQ, OC> const other) const
      {
        return quantity_t::operator==(other.quantity());
      }

      template <typename OQ, typename OC>
      constexpr enable_if_compatible_t<Interval<OQ, OC>, bool> operator!=(
        Interval<OQ, OC> const other) const
      {
        return quantity_t::operator!=(other.quantity());
      }

      template <typename OQ, typename OC>
      constexpr enable_if_compatible_t<Interval<OQ, OC>, bool> operator>=(
        Interval<OQ, OC> const other) const
      {
        return quantity_t::operator>=(other.quantity());
      }

      template <typename OQ, typename OC>
      constexpr enable_if_compatible_t<Interval<OQ, OC>, bool> operator>(
        Interval<OQ, OC> const other) const
      {
        return quantity_t::operator>(other.quantity());
      }

      template <typename OQ, typename OC>
      constexpr enable_if_compatible_t<Interval<OQ, OC>, bool> operator<=(
        Interval<OQ, OC> const other) const
      {
        return quantity_t::operator<=(other.quantity());
      }

      template <typename OQ, typename OC>
      constexpr enable_if_compatible_t<Interval<OQ, OC>, bool> operator<(
        Interval<OQ, OC> const other) const
      {
        return quantity_t::operator<(other.quantity());
      }

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

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

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

    }; // struct Interval

    template <typename... Args>
    std::ostream& operator<<(std::ostream& out, Interval<Args...> const iv)
    {
      return out << iv.quantity();
    }

    // -- BEGIN Comparison operations ------------------------------------------

    template <typename Q, typename Cat, typename... Args>
    constexpr bool operator==(Interval<Q, Cat> const a, Quantity<Args...> const b) noexcept
    {
      return a.quantity() == b;
    }

    template <typename Q, typename Cat, typename... Args>
    constexpr bool operator==(Quantity<Args...> const a, Interval<Q, Cat> const b) noexcept
    {
      return b == a;
    }

    template <typename Q, typename Cat, typename... Args>
    constexpr bool operator!=(Interval<Q, Cat> const a, Quantity<Args...> const b) noexcept
    {
      return a.quantity() != b;
    }

    template <typename Q, typename Cat, typename... Args>
    constexpr bool operator!=(Quantity<Args...> const a, Interval<Q, Cat> const b) noexcept
    {
      return b != a;
    }

    template <typename Q, typename Cat, typename... Args>
    constexpr bool operator<=(Interval<Q, Cat> const a, Quantity<Args...> const b) noexcept
    {
      return a.quantity() <= b;
    }

    template <typename Q, typename Cat, typename... Args>
    constexpr bool operator<=(Quantity<Args...> const a, Interval<Q, Cat> const b) noexcept
    {
      return b >= a;
    }

    template <typename Q, typename Cat, typename... Args>
    constexpr bool operator<(Interval<Q, Cat> const a, Quantity<Args...> const b) noexcept
    {
      return a.quantity() < b;
    }

    template <typename Q, typename Cat, typename... Args>
    constexpr bool operator<(Quantity<Args...> const a, Interval<Q, Cat> const b) noexcept
    {
      return b > a;
    }

    template <typename Q, typename Cat, typename... Args>
    constexpr bool operator>=(Interval<Q, Cat> const a, Quantity<Args...> const b) noexcept
    {
      return a.quantity() >= b;
    }

    template <typename Q, typename Cat, typename... Args>
    constexpr bool operator>=(Quantity<Args...> const a, Interval<Q, Cat> const b) noexcept
    {
      return b <= a;
    }

    template <typename Q, typename Cat, typename... Args>
    constexpr bool operator>(Interval<Q, Cat> const a, Quantity<Args...> const b) noexcept
    {
      return a.quantity() > b;
    }

    template <typename Q, typename Cat, typename... Args>
    constexpr bool operator>(Quantity<Args...> const a, Interval<Q, Cat> const b) noexcept
    {
      return b < a;
    }

    // -- END Comparison operations --------------------------------------------

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

    template <typename Q, typename Cat, typename T>
    constexpr std::enable_if_t<std::is_arithmetic_v<T>, Interval<Q, Cat>> operator*(
      Interval<Q, Cat> const iv,
      T const factor)
    {
      return Interval<Q, Cat>{iv.quantity() * factor};
    }
    template <typename Q, typename Cat, typename T>
    constexpr std::enable_if_t<std::is_arithmetic_v<T>, Interval<Q, Cat>> operator*(
      T const factor,
      Interval<Q, Cat> const iv)
    {
      return iv * factor;
    }

    template <typename AQ, typename AC, typename BQ, typename BC>
    constexpr auto operator*(Interval<AQ, AC> const, Interval<BQ, BC> const)
      //       -> decltype(std::declval<AQ>() * std::declval<AQ>())
      = delete;

    // Division by a scalar.
    template <typename Q, typename Cat, typename T>
    constexpr std::enable_if_t<std::is_arithmetic_v<T>, Interval<Q, Cat>> operator/(
      Interval<Q, Cat> const iv,
      T const quot)
    {
      return Interval<Q, Cat>{iv.quantity() / quot};
    }

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

    // -------------------------------------------------------------------------
    template <typename IV, typename R, typename T = typename IV::value_t>
    using rescale_interval =
      Interval<rescale<typename IV::quantity_t, R, T>, typename IV::category_t>;

    // -------------------------------------------------------------------------
    template <typename Q, typename Cat>
    std::string to_string(Interval<Q, Cat> const& iv)
    {
      return util::to_string(iv.quantity());
    }

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

    template <typename Q, typename Cat = NoCategory, typename IV = Interval<Q, Cat>>
    struct Point : private Q, public details::WithCategory<Cat> {

      using category_base_t = details::WithCategory<Cat>;

      using traits_t = typename category_base_t::traits_t;

      template <typename OC, typename Type = void>
      using enable_if_compatible_t =
        std::enable_if_t<category_base_t::template category_compatible_with<OC>(), Type>;

    public:
      using point_t = Point<Q, Cat, IV>; 

      // --- BEGIN -- Types from the base quantity -----------------------------

      using quantity_t = Q; 

      using category_t = typename category_base_t::category_t;

      using interval_t = IV;

      template <typename R>
      using scaled_quantity_t = rescale<quantity_t, R>;

      using value_t = typename quantity_t::value_t;

      using unit_t = typename quantity_t::unit_t;

      using baseunit_t = typename quantity_t::baseunit_t;

      template <typename OQ, typename OI>
      using other_point_t = Point<OQ, category_t, OI>;

      // --- END -- Types from the base quantity -------------------------------

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

      explicit constexpr Point(value_t v) : Point(quantity_t{v}) {}

      template <typename... Args>
      constexpr Point(Quantity<Args...> const q) : quantity_t(quantity_t{q})
      {}

      template <typename PT, typename std::enable_if_t<is_point_v<PT>>* = nullptr>
      constexpr Point(PT const p) : Point(quantity_t{p.quantity()})
      {}

      constexpr quantity_t const& quantity() const { return *this; }

      using quantity_t::value;

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

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

      template <typename R>
      constexpr point_t operator+(scaled_quantity_t<R> const delta) const
      {
        return point_t(quantity().plus(delta));
      }

      template <typename OQ, typename OC>
      constexpr enable_if_compatible_t<Interval<OQ, OC>, point_t> operator+(
        Interval<OQ, OC> const delta) const
      {
        return operator+(delta.quantity());
      }

      template <typename R>
      constexpr point_t operator-(scaled_quantity_t<R> const delta) const
      {
        return point_t(quantity().minus(delta));
      }

      template <typename OQ, typename OC>
      constexpr enable_if_compatible_t<Interval<OQ, OC>, point_t> operator-(
        Interval<OQ, OC> const delta) const
      {
        return operator-(delta.quantity());
      }

      template <typename R>
      point_t& operator+=(scaled_quantity_t<R> const other)
      {
        quantity_t::operator+=(other);
        return *this;
      }

      template <typename OQ, typename OC>
      enable_if_compatible_t<Interval<OQ, OC>, point_t&> operator+=(Interval<OQ, OC> const other)
      {
        return operator+=(other.quantity());
      }

      template <typename R>
      point_t& operator-=(scaled_quantity_t<R> const other)
      {
        quantity_t::operator-=(other);
        return *this;
      }

      template <typename OQ, typename OC>
      enable_if_compatible_t<Interval<OQ, OC>, point_t&> operator-=(Interval<OQ, OC> const other)
      {
        return operator-=(other.quantity());
      }

      constexpr point_t operator+() const { return point_t(quantity()); }

      constexpr point_t operator-() const { return point_t(-quantity()); }

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

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

      template <typename OQ, typename OI>
      constexpr enable_if_compatible_t<other_point_t<OQ, OI>, bool> operator==(
        other_point_t<OQ, OI> const other) const
      {
        return quantity_t::operator==(other.quantity());
      }

      template <typename OQ, typename OI>
      constexpr enable_if_compatible_t<other_point_t<OQ, OI>, bool> operator!=(
        other_point_t<OQ, OI> const other) const
      {
        return quantity_t::operator!=(other.quantity());
      }

      template <typename OQ, typename OI>
      constexpr enable_if_compatible_t<other_point_t<OQ, OI>, bool> operator>=(
        other_point_t<OQ, OI> const other) const
      {
        return quantity_t::operator>=(other.quantity());
      }

      template <typename OQ, typename OI>
      constexpr enable_if_compatible_t<other_point_t<OQ, OI>, bool> operator>(
        other_point_t<OQ, OI> const other) const
      {
        return quantity_t::operator>(other.quantity());
      }

      template <typename OQ, typename OI>
      constexpr enable_if_compatible_t<other_point_t<OQ, OI>, bool> operator<=(
        other_point_t<OQ, OI> const other) const
      {
        return quantity_t::operator<=(other.quantity());
      }

      template <typename OQ, typename OI>
      constexpr enable_if_compatible_t<other_point_t<OQ, OI>, bool> operator<(
        other_point_t<OQ, OI> const other) const
      {
        return quantity_t::operator<(other.quantity());
      }

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

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

      using quantity_t::baseUnit;
      using quantity_t::unit;
      using quantity_t::unitName;
      using quantity_t::unitSymbol;

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

      template <typename PT>
      constexpr std::enable_if_t<is_point_v<PT>, PT> convertInto() const
      {
        return PT(*this);
      }

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

    }; // struct Point

    template <typename... Args>
    std::ostream& operator<<(std::ostream& out, Point<Args...> const p)
    {
      return out << p.quantity();
    }

    // -- BEGIN Comparison operations ------------------------------------------

    template <typename Q, typename Cat, typename IV, typename... Args>
    constexpr bool operator==(Point<Q, Cat, IV> const a, Quantity<Args...> const b) noexcept
    {
      return a.quantity() == b;
    }

    template <typename Q, typename Cat, typename IV, typename... Args>
    constexpr bool operator==(Quantity<Args...> const a, Point<Q, Cat, IV> const b) noexcept
    {
      return b == a;
    }

    template <typename Q, typename Cat, typename IV, typename... Args>
    constexpr bool operator!=(Point<Q, Cat, IV> const a, Quantity<Args...> const b) noexcept
    {
      return a.quantity() != b;
    }

    template <typename Q, typename Cat, typename IV, typename... Args>
    constexpr bool operator!=(Quantity<Args...> const a, Point<Q, Cat, IV> const b) noexcept
    {
      return b != a;
    }

    template <typename Q, typename Cat, typename IV, typename... Args>
    constexpr bool operator<=(Point<Q, Cat, IV> const a, Quantity<Args...> const b) noexcept
    {
      return a.quantity() <= b;
    }

    template <typename Q, typename Cat, typename IV, typename... Args>
    constexpr bool operator<=(Quantity<Args...> const a, Point<Q, Cat, IV> const b) noexcept
    {
      return b >= a;
    }

    template <typename Q, typename Cat, typename IV, typename... Args>
    constexpr bool operator<(Point<Q, Cat, IV> const a, Quantity<Args...> const b) noexcept
    {
      return a.quantity() < b;
    }

    template <typename Q, typename Cat, typename IV, typename... Args>
    constexpr bool operator<(Quantity<Args...> const a, Point<Q, Cat, IV> const b) noexcept
    {
      return b > a;
    }

    template <typename Q, typename Cat, typename IV, typename... Args>
    constexpr bool operator>=(Point<Q, Cat, IV> const a, Quantity<Args...> const b) noexcept
    {
      return a.quantity() >= b;
    }

    template <typename Q, typename Cat, typename IV, typename... Args>
    constexpr bool operator>=(Quantity<Args...> const a, Point<Q, Cat, IV> const b) noexcept
    {
      return b <= a;
    }

    template <typename Q, typename Cat, typename IV, typename... Args>
    constexpr bool operator>(Point<Q, Cat, IV> const a, Quantity<Args...> const b) noexcept
    {
      return a.quantity() > b;
    }

    template <typename Q, typename Cat, typename IV, typename... Args>
    constexpr bool operator>(Quantity<Args...> const a, Point<Q, Cat, IV> const b) noexcept
    {
      return b < a;
    }

    // -- END Comparison operations --------------------------------------------

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

    template <typename Q, typename Cat, typename IV, typename OQ, typename OC>
    constexpr Point<Q, Cat, IV> operator+(Interval<OQ, OC> const delta, Point<Q, Cat, IV> const p) =
      delete; // use `point + interval`, not `interval + point`

    template <typename Q, typename Cat, typename IV, typename OQ, typename OC>
    constexpr Point<Q, Cat, IV> operator-(Interval<OQ, OC> const delta, Point<Q, Cat, IV> const p) =
      delete; // use `point + interval`, not `interval + point`

    // two different points but with the same interval type
    template <typename Q, typename Cat, typename IV, typename OQ, typename OCat>
    constexpr typename Point<Q, Cat, IV>::template enable_if_compatible_t<Point<OQ, OCat, IV>, IV>
    operator-(Point<Q, Cat, IV> const a, Point<OQ, OCat, IV> const b)
    {
      return IV(a.quantity() - b.quantity());
    }

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

    // -------------------------------------------------------------------------
    template <typename PT, typename R, typename T = typename PT::value_t>
    using rescale_point = Point<rescale<typename PT::quantity_t, R, T>, typename PT::category_t>;

    // -------------------------------------------------------------------------
    template <typename Q, typename Cat, typename IV>
    std::string to_string(Point<Q, Cat, IV> const& p)
    {
      return util::to_string(p.quantity());
    }

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

  } // namespace concepts

  // ---------------------------------------------------------------------------
  struct NoCategory : concepts::CategoryBase {

    static std::string name() { return "generic"; }

  }; // struct NoCategory

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

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

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


  // @{
  template <typename PT>
  PT makePoint(std::string_view s, bool unitOptional = false);

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

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


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

} // namespace util::quantities

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

  //----------------------------------------------------------------------------
  template <typename, typename = std::void_t<>>
  struct has_category : std::false_type {};

  template <typename Obj>
  struct has_category<Obj, std::void_t<typename Obj::category_t>> : std::true_type {};

  template <typename Obj>
  constexpr bool has_category_v = has_category<Obj>();

  //----------------------------------------------------------------------------
  template <typename, typename = std::void_t<>>
  struct category_has_name : std::false_type {};

  template <typename Cat>
  struct category_has_name<Cat, std::void_t<decltype(Cat::name())>> : std::true_type {};

  template <typename Cat>
  struct category_traits {

    using category_t = Cat; 

    static constexpr bool has_name = category_has_name<category_t>();

    template <typename OC>
    static constexpr bool compatible_with()
    {
      return util::is_any_of_v<OC, NoCategory, category_t>;
    }

  }; // struct category_traits<>

  //----------------------------------------------------------------------------
  template <typename Cat, typename /* = void */>
  struct category_of_type {
    using type = Cat;
  };

  template <typename Cat>
  struct category_of_type<Cat, std::void_t<typename Cat::category_t>> {
    using type = typename Cat::category_t;
  };

  //----------------------------------------------------------------------------
  template <typename Cat>
  struct WithCategory {

    using category_t = Cat; 

    using traits_t = category_traits<category_t>;

    static constexpr category_t category();

    // @{
    template <typename OC>
    static constexpr bool same_category_as();

    template <typename OC>
    static constexpr bool same_category_as(OC const&);
    // @}

    // @{
    template <typename OC>
    static constexpr bool category_compatible_with();

    template <typename OC>
    static constexpr bool category_compatible_with(OC const&);
    // @}

    static constexpr bool hasCategoryName();

    static std::string categoryName();

  }; // struct WithCategory<>

  //----------------------------------------------------------------------------
  //--- WithCategory
  //----------------------------------------------------------------------------
  template <typename Cat>
  constexpr auto WithCategory<Cat>::category() -> category_t
  {
    return {};
  }

  //----------------------------------------------------------------------------
  template <typename Cat>
  template <typename OC>
  constexpr bool WithCategory<Cat>::same_category_as()
  {
    return details::has_category_v<OC> && std::is_same_v<typename OC::category_t, category_t>;
  } // WithCategory<>::same_category_as()

  template <typename Cat>
  template <typename OC>
  constexpr bool WithCategory<Cat>::same_category_as(OC const&)
  {
    return same_category_as<OC>();
  }

  //----------------------------------------------------------------------------
  template <typename Cat>
  template <typename OC>
  constexpr bool WithCategory<Cat>::category_compatible_with()
  {
    return traits_t::template compatible_with<category_of<OC>>();
  }

  template <typename Cat>
  template <typename OC>
  constexpr bool WithCategory<Cat>::category_compatible_with(OC const&)
  {
    return category_compatible_with<OC>();
  }

  //----------------------------------------------------------------------------
  template <typename Cat>
  constexpr bool WithCategory<Cat>::hasCategoryName()
  {
    return details::category_traits<Cat>::has_name;
  }

  //----------------------------------------------------------------------------
  template <typename Cat>
  std::string WithCategory<Cat>::categoryName()
  {
    return Cat::name();
  }

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

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

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

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

  template <typename... Args>
  struct is_interval<Interval<Args...>> : public std::true_type {};

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

  template <typename... Args>
  struct is_point<Point<Args...>> : public std::true_type {};

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

} // namespace util::quantities::concepts

//------------------------------------------------------------------------------
//---  Template implementation
//------------------------------------------------------------------------------
template <typename IV>
IV util::quantities::makeInterval(std::string_view s, bool unitOptional /* = false */)
{
  using quantity_t = typename IV::quantity_t;
  return {util::quantities::makeQuantity<quantity_t>(s, unitOptional)};
} // util::quantities::makeInterval(string_view)

//------------------------------------------------------------------------------
template <typename IV>
IV util::quantities::makeInterval(std::string const& s, bool unitOptional /* = false */)
{
  using quantity_t = typename IV::quantity_t;
  return {util::quantities::makeQuantity<quantity_t>(s, unitOptional)};
} // util::quantities::makeInterval(string)

//------------------------------------------------------------------------------
template <typename IV>
IV util::quantities::makeInterval(char const* s, bool unitOptional /* = false */)
{
  using quantity_t = typename IV::quantity_t;
  return {util::quantities::makeQuantity<quantity_t>(s, unitOptional)};
} // util::quantities::makeInterval(C-string)

//------------------------------------------------------------------------------
template <typename PT>
PT util::quantities::makePoint(std::string_view s, bool unitOptional /* = false */)
{
  using quantity_t = typename PT::quantity_t;
  return {util::quantities::makeQuantity<quantity_t>(s, unitOptional)};
} // util::quantities::makePoint(string_view)

//------------------------------------------------------------------------------
template <typename PT>
PT util::quantities::makePoint(std::string const& s, bool unitOptional /* = false */)
{
  using quantity_t = typename PT::quantity_t;
  return {util::quantities::makeQuantity<quantity_t>(s, unitOptional)};
} // util::quantities::makePoint(string)

//------------------------------------------------------------------------------
template <typename PT>
PT util::quantities::makePoint(char const* s, bool unitOptional /* = false */)
{
  using quantity_t = typename PT::quantity_t;
  return {util::quantities::makeQuantity<quantity_t>(s, unitOptional)};
} // util::quantities::makePoint(C-string)

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

  // ---------------------------------------------------------------------------
  template <typename Q, typename Cat>
  struct hash<util::quantities::concepts::Interval<Q, Cat>> {
    constexpr auto operator()(util::quantities::concepts::Interval<Q, Cat> key) const
      noexcept(noexcept(std::hash(key.quantity())))
    {
      return std::hash(key.quantity());
    }
  }; // hash<Interval>

  template <typename Q, typename Cat, typename IV>
  struct hash<util::quantities::concepts::Point<Q, Cat, IV>> {
    constexpr auto operator()(util::quantities::concepts::Point<Q, Cat, IV> key) const
      noexcept(noexcept(std::hash(key.quantity())))
    {
      return std::hash(key.quantity());
    }
  }; // hash<Interval>

  // ---------------------------------------------------------------------------
  template <typename Q, typename Cat>
  class numeric_limits<util::quantities::concepts::Interval<Q, Cat>>
    : public util::quantities::concepts::details::numeric_limits<
        util::quantities::concepts::Interval<Q, Cat>> {};

  template <typename Q, typename Cat>
  class numeric_limits<util::quantities::concepts::Interval<Q, Cat> const>
    : public util::quantities::concepts::details::numeric_limits<
        util::quantities::concepts::Interval<Q, Cat> const> {};

  template <typename Q, typename Cat>
  class numeric_limits<util::quantities::concepts::Interval<Q, Cat> volatile>
    : public util::quantities::concepts::details::numeric_limits<
        util::quantities::concepts::Interval<Q, Cat> volatile> {};

  template <typename Q, typename Cat>
  class numeric_limits<util::quantities::concepts::Interval<Q, Cat> const volatile>
    : public util::quantities::concepts::details::numeric_limits<
        util::quantities::concepts::Interval<Q, Cat> const volatile> {};

  template <typename Q, typename Cat, typename IV>
  class numeric_limits<util::quantities::concepts::Point<Q, Cat, IV>>
    : public util::quantities::concepts::details::numeric_limits<
        util::quantities::concepts::Point<Q, Cat, IV>> {};

  template <typename Q, typename Cat, typename IV>
  class numeric_limits<util::quantities::concepts::Point<Q, Cat, IV> const>
    : public util::quantities::concepts::details::numeric_limits<
        util::quantities::concepts::Point<Q, Cat, IV> const> {};

  template <typename Q, typename Cat, typename IV>
  class numeric_limits<util::quantities::concepts::Point<Q, Cat, IV> volatile>
    : public util::quantities::concepts::details::numeric_limits<
        util::quantities::concepts::Point<Q, Cat, IV> volatile> {};

  template <typename Q, typename Cat, typename IV>
  class numeric_limits<util::quantities::concepts::Point<Q, Cat, IV> const volatile>
    : public util::quantities::concepts::details::numeric_limits<
        util::quantities::concepts::Point<Q, Cat, IV> const volatile> {};

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

} // namespace std

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

#endif // LARDATAALG_UTILITIES_INTERVALS_H