interval.hpp

Go to the documentation of this file.

 
#pragma once
 
// #include <algorithm> // import std::min, std::max
#include <utility>  // import std::move
 
#include "generic.hpp"
 
namespace recti {
 
    template <typename T = int> class Interval {
      private:
        T _lb;  //> lower bound
        T _ub;  //> upper bound
 
      public:
        using value_type = T;
 
        constexpr Interval() : _lb{T()}, _ub{T()} {}
 
        constexpr Interval(T lower, T upper) noexcept
            : _lb{std::move(lower)}, _ub{std::move(upper)} {}
 
        explicit constexpr Interval(const T& value) : _lb{value}, _ub{value} {}
 
        constexpr auto operator=(const T& value) -> Interval& {
            this->_lb = this->_ub = value;
            return *this;
        }
 
        constexpr auto lb() const -> const T& { return this->_lb; }
 
        constexpr auto ub() const -> const T& { return this->_ub; }
 
        constexpr auto measure() const -> T { return this->ub() - this->lb(); }
 
        constexpr auto is_invalid() const -> bool { return this->lb() > this->ub(); }
 
 
        template <typename U>  //
        constexpr auto operator==(const Interval<U>& rhs) const -> bool {
            return this->lb() == rhs.lb() && this->ub() == rhs.ub();
        }
 
        template <typename U>  //
        constexpr auto operator!=(const Interval<U>& rhs) const -> bool {
            return !(*this == rhs);
        }
 
        template <typename U>  //
        constexpr auto operator<=>(const U& rhs) const -> std::weak_ordering {
            if (this->ub() < rhs) return std::weak_ordering::less;
            if (this->lb() > rhs) return std::weak_ordering::greater;
            return std::weak_ordering::equivalent;
        }
 
        friend constexpr auto operator<=>(const T& lhs, const Interval& rhs) -> std::weak_ordering {
            if (lhs < rhs.lb()) return std::weak_ordering::less;
            if (lhs > rhs.ub()) return std::weak_ordering::greater;
            return std::weak_ordering::equivalent;
        }
 
 
 
        constexpr auto operator-() const -> Interval { return {-this->_ub, -this->_lb}; }
 
        template <typename U> constexpr auto operator+=(const U& value) -> Interval& {
            this->_lb += value;
            this->_ub += value;
            return *this;
        }
 
        template <typename U> friend constexpr auto operator+(Interval rhs, const U& value)
            -> Interval {
            return rhs += value;
        }
 
        friend constexpr auto operator+(const T& value, Interval rhs) -> Interval {
            return rhs += value;
        }
 
        template <typename U> constexpr auto operator-=(const U& value) -> Interval& {
            this->_lb -= value;
            this->_ub -= value;
            return *this;
        }
 
        template <typename U> friend constexpr auto operator-(const Interval& rhs, const U& value)
            -> Interval {
            auto lower = rhs.lb() - value;
            auto upper = rhs.ub() - value;
            return Interval<decltype(lower)>{std::move(lower), std::move(upper)};
        }
 
        constexpr auto enlarge_with(const T& value) const {
            return Interval{this->_lb - value, this->_ub + value};
        }
 
 
        template <typename U>  // cppcheck-suppress internalAstError
        constexpr auto overlaps(const U& other_interval) const -> bool {
            return !(*this < other_interval || other_interval < *this);
        }
 
        template <typename U>  // cppcheck-suppress internalAstError
        constexpr auto contains(const U& other_interval) const -> bool {
            if constexpr (requires { other_interval.lb(); }) {
                return this->lb() <= other_interval.lb() && other_interval.ub() <= this->ub();
            } else /* constexpr */ {  // assume scalar
                return this->lb() <= other_interval && other_interval <= this->ub();
            }
        }
 
        template <typename U>  //
        constexpr auto intersect_with(const U& other_interval) const {
            if constexpr (requires { other_interval.lb(); }) {
                return Interval<T>{
                    this->lb() > other_interval.lb() ? this->lb() : T(other_interval.lb()),
                    this->ub() < other_interval.ub() ? this->ub() : T(other_interval.ub())};
            } else /* constexpr */ {  // assume scalar
                return Interval<T>{this->lb() > other_interval ? this->lb() : T(other_interval),
                                   this->ub() < other_interval ? this->ub() : T(other_interval)};
            }
        }
 
        template <typename U>  //
        constexpr auto hull_with(const U& other_interval) const {
            if constexpr (requires { other_interval.lb(); }) {
                return Interval<T>{
                    this->lb() < other_interval.lb() ? this->lb() : T(other_interval.lb()),
                    this->ub() > other_interval.ub() ? this->ub() : T(other_interval.ub())};
            } else /* constexpr */ {  // assume scalar
                return Interval<T>{this->lb() < other_interval ? this->lb() : T(other_interval),
                                   this->ub() > other_interval ? this->ub() : T(other_interval)};
            }
        }
 
        template <typename U> constexpr auto min_dist_with(const U& other_interval) const -> T {
            if (*this < other_interval) {
                return min_dist(this->_ub, other_interval);
            }
            if (other_interval < *this) {
                return min_dist(this->_lb, other_interval);
            }
            return T(0);
        }
 
        constexpr auto nearest_to(const T& reference_value) const -> T {
            if (*this < reference_value) {
                return nearest(this->_ub, reference_value);
            }
            if (reference_value < *this) {
                return nearest(this->_lb, reference_value);
            }
            return reference_value;
        }
 
        template <typename U> constexpr auto min_dist_change_with(U& other_interval) -> T {
            if (*this < other_interval) {
                this->_lb = this->_ub;
                return min_dist_change(this->_ub, other_interval);
            }
            if (other_interval < *this) {
                this->_ub = this->_lb;
                return min_dist_change(this->_lb, other_interval);
            }
 
            if constexpr (requires { other_interval.lb(); }) {
                *this = other_interval = this->intersect_with(other_interval);
            } else /* constexpr */ {  // assume scalar
                this->_ub = this->_lb = other_interval;
            }
            return T(0);
        }
 
        constexpr auto get_center() const -> T { return this->_lb + (this->_ub - this->_lb) / 2; }
 
        constexpr auto lower_corner() const -> T { return this->_lb; }
 
        constexpr auto upper_corner() const -> T { return this->_ub; }
 
        template <class Stream> friend auto operator<<(Stream& out, const Interval& intvl)
            -> Stream& {
            out << "[" << intvl.lb() << ", " << intvl.ub() << "]";
            return out;
        }
    };
 
    template <typename U1, typename U2>  //
    constexpr auto hull(const U1& left, const U2& right) {
        if constexpr (requires { left.hull_with(right); }) {
            return left.hull_with(right);
        } else if constexpr (requires { right.hull_with(left); }) {
            return right.hull_with(left);
        } else /* constexpr */ {
            return left < right ? Interval<U1>(left, right) : Interval<U2>(right, left);
        }
    }
 
    template <typename U1, typename U2>  //
    constexpr auto enlarge(const U1& left, const U2& right) {
        if constexpr (requires { left.enlarge_with(right); }) {
            return left.enlarge_with(right);
        } else if constexpr (std::is_arithmetic_v<U1>) {
            return Interval<U1>{left - right, left + right};
        } else {
            // No default behavior for non-arithmetic types without enlarge_with
            // This will cause a compile error if enlarge is called with such types,
            // which is the desired behavior.
            return left;
        }
    }
}  // namespace recti