interval.h

Go to the documentation of this file.

 
#if !defined(ULTRA_INTERVAL_H)
#define      ULTRA_INTERVAL_H
 
#include "utility/assert.h"
 
#include <concepts>
#include <type_traits>
#include <utility>
 
namespace ultra
{
 
template<class A> concept ArithmeticScalar =
  std::is_arithmetic_v<A> && !std::same_as<A, bool>;
 

template<ArithmeticScalar T>
struct interval
{
  constexpr interval(T m, T s) noexcept : min(m), sup(s)
  {
    Expects(m < s);
  }
 
  template<std::floating_point T1, std::floating_point T2>
  requires std::floating_point<T>
  constexpr interval(T1 m, T2 s) : interval(static_cast<T>(m),
                                            static_cast<T>(s))
  {
    Expects(m < s);
  }
 
  template<std::integral T1, std::integral T2>
  requires std::integral<T>
  constexpr interval(T1 m, T2 s) : interval(static_cast<T>(m),
                                            static_cast<T>(s))
  {
    Expects(std::cmp_less(m, s));
    Expects(std::in_range<T>(m));
    Expects(std::in_range<T>(s));
  }
 
  template<std::floating_point T1, std::floating_point T2>
  requires std::floating_point<T>
  explicit constexpr interval(const std::pair<T1, T2> &p)
    : interval(static_cast<T>(p.first), static_cast<T>(p.second))
  {
    Expects(p.first < p.second);
  }
 
  template<std::integral T1, std::integral T2>
  requires std::integral<T>
  explicit constexpr interval(const std::pair<T1, T2> &p)
    : interval(static_cast<T>(p.first), static_cast<T>(p.second))
  {
    Expects(std::cmp_less(p.first, p.second));
    Expects(std::in_range<T>(p.first));
    Expects(std::in_range<T>(p.second));
  }
 
  [[nodiscard]] friend constexpr bool operator==(
    const interval &, const interval &) noexcept = default;
 
  [[nodiscard]] bool is_valid() const noexcept
  {
    return min < sup;
  }
 
  T min;
  T sup;
};  // class interval
 
}  // namespace ultra
 
#endif