interval.hpp

Go to the documentation of this file.

#pragma once
#include <boost/numeric/interval.hpp>
#include <iostream>
#include <type_traits>

 
namespace sigma {

template<typename ValueType>
class Interval {
public:
    using value_t = ValueType;

    Interval() : m_interval_(0.0, 0.0) {}

    Interval(value_t value) : m_interval_(value, value) {}

    Interval(value_t lower, value_t upper) : m_interval_(lower, upper) {}

    value_t lower() const { return m_interval_.lower(); }

    value_t upper() const { return m_interval_.upper(); }

    bool contains(value_t value) const {
        return value >= lower() && value <= upper();
    }

    value_t median() const { return boost::numeric::median(m_interval_); }

    value_t radius() const {
        return boost::numeric::width(m_interval_) / value_t{2};
    }
 
    // -- Arithmetic in-place operators ----------------------------------------

    Interval& operator+=(const Interval& rhs) {
        m_interval_ += rhs.m_interval_;
        return *this;
    }

    Interval& operator+=(value_t rhs) {
        m_interval_ += rhs;
        return *this;
    }

    Interval& operator-=(const Interval& rhs) {
        m_interval_ -= rhs.m_interval_;
        return *this;
    }

    Interval& operator-=(value_t rhs) {
        m_interval_ -= rhs;
        return *this;
    }

    Interval& operator*=(const Interval& rhs) {
        m_interval_ *= rhs.m_interval_;
        return *this;
    }

    Interval& operator*=(value_t rhs) {
        m_interval_ *= rhs;
        return *this;
    }

    Interval& operator/=(const Interval& rhs) {
        m_interval_ /= rhs.m_interval_;
        return *this;
    }

    Interval& operator/=(value_t rhs) {
        m_interval_ /= rhs;
        return *this;
    }
 
private:
    boost::numeric::interval<value_t> m_interval_;
 
}; // class Interval
 
// -- Utility functions --------------------------------------------------------

template<typename ValueType>
std::ostream& operator<<(std::ostream& os, const Interval<ValueType>& i) {
    os << i.median() << "+/-" << i.radius();
    return os;
}

template<typename T1, typename T2>
bool operator==(const Interval<T1>& lhs, const Interval<T2>& rhs) {
    if constexpr(!std::is_same_v<T1, T2>) return false;
    return lhs.lower() == rhs.lower() && lhs.upper() == rhs.upper();
}

template<typename T1, typename T2>
bool operator!=(const Interval<T1>& lhs, const Interval<T2>& rhs) {
    return !(lhs == rhs);
}

template<typename T1, typename T2>
bool operator<(const Interval<T1>& lhs, const Interval<T2>& rhs) {
    return lhs.upper() < rhs.lower();
}

template<typename T1, typename T2>
bool operator>(const Interval<T1>& lhs, const Interval<T2>& rhs) {
    return rhs < lhs;
}

template<typename T1, typename T2>
bool operator<=(const Interval<T1>& lhs, const Interval<T2>& rhs) {
    return (lhs == rhs) || (lhs < rhs);
}

template<typename T1, typename T2>
bool operator>=(const Interval<T1>& lhs, const Interval<T2>& rhs) {
    return (lhs == rhs) || (lhs > rhs);
}
 
// -- Arithmetic free functions ------------------------------------------------

template<typename T>
Interval<T> operator-(const Interval<T>& a) {
    return Interval<T>(-a.upper(), -a.lower());
}

template<typename T>
Interval<T> operator+(Interval<T> lhs, const Interval<T>& rhs) {
    return lhs += rhs;
}

template<typename T>
Interval<T> operator+(Interval<T> lhs, T rhs) {
    return lhs += rhs;
}

template<typename T>
Interval<T> operator+(T lhs, const Interval<T>& rhs) {
    return rhs + lhs;
}

template<typename T>
Interval<T> operator-(Interval<T> lhs, const Interval<T>& rhs) {
    return lhs -= rhs;
}

template<typename T>
Interval<T> operator-(Interval<T> lhs, T rhs) {
    return lhs -= rhs;
}

template<typename T>
Interval<T> operator-(T lhs, const Interval<T>& rhs) {
    return Interval<T>(lhs, lhs) -= rhs;
}

template<typename T>
Interval<T> operator*(Interval<T> lhs, const Interval<T>& rhs) {
    return lhs *= rhs;
}

template<typename T>
Interval<T> operator*(Interval<T> lhs, T rhs) {
    return lhs *= rhs;
}

template<typename T>
Interval<T> operator*(T lhs, const Interval<T>& rhs) {
    return rhs * lhs;
}

template<typename T>
Interval<T> operator/(Interval<T> lhs, const Interval<T>& rhs) {
    return lhs /= rhs;
}

template<typename T>
Interval<T> operator/(Interval<T> lhs, T rhs) {
    return lhs /= rhs;
}

template<typename T>
Interval<T> operator/(T lhs, const Interval<T>& rhs) {
    return Interval<T>(lhs, lhs) /= rhs;
}

using IFloat = Interval<float>;

using IDouble = Interval<double>;
 
} // namespace sigma