interval.h

#pragma once
 
#include <cgv/type/traits/min.h>
#include <cgv/type/traits/max.h>
#include <iostream>
#include <algorithm>
#include <vector>
 
namespace cgv {
    namespace math {
 
template <typename T>
class interval
{   
public:
    // the interval lower bound [x,_]
    T lower_bound;
    // the interval upper bound [_,x]
    T upper_bound;
 
    interval() : lower_bound(1), upper_bound(0) {}
    interval(bool) : lower_bound(type::traits::min_fct<T>::get_value()), upper_bound(type::traits::max_fct<T>::get_value()) {}
    interval(const interval<T>& I) : lower_bound(I.lower_bound), upper_bound(I.upper_bound) {}
    interval(const T& lb, const T& ub) : lower_bound(std::min(lb, ub)), upper_bound(std::max(lb, ub)) {}
    bool empty() const { return upper_bound < lower_bound; }
    void clear() { lower_bound = T(1); upper_bound = T(0); }
    bool contains(const T& v) const { return lower_bound <= v && v <= upper_bound; }
    T center() const { return (lower_bound + upper_bound) / T(2); }
    T size() const { return empty() ? T(0) : upper_bound - lower_bound; }
    interval<T>& intersect(const interval<T>& I) {
        lower_bound = std::max(lower_bound, I.lower_bound);
        upper_bound = std::min(upper_bound, I.upper_bound);
        return *this;
    }
    interval<T> intersection(const interval<T>& I) const { interval J(*this); return J.intersect(I); } 
    interval<T>& extend(const T& v) { 
        if(empty()) {
            lower_bound = v;
            upper_bound = v;
        } else {
            lower_bound = std::min(lower_bound, v);
            upper_bound = std::max(upper_bound, v);
        }
        return *this;
    }
    interval<T>& extend(const T vs[], size_t n) {
        for(size_t i = 0; i < n; ++i)
            extend(vs[i]);
        return *this;
    }
    interval<T>& extend(const std::vector<T>& vs) {
        for(size_t i = 0; i < vs.size(); ++i)
            extend(vs[i]);
        return *this;
    }
    interval<T>& extension(const T& v) { interval<T> I(*this); return I.extend(v); }
    interval<T>& extend(const interval<T>& I) {
        if (!I.empty()) {
            extend(I.lower_bound);
            extend(I.upper_bound);
        }
        return *this;
    }
    interval<T>& extension(const interval<T>& J) { interval<T> I(*this); return I.extend(J); }
 
    interval<T>& operator *= (const T& s) { lower_bound *= s; upper_bound *= s; return *this; } 
    interval<T> operator * (const T& s) const { interval I(*this); return I *= s; } 
    interval<T>& operator /= (const T& s) { return *this *= T(1) / s; } 
    interval<T> operator / (const T& s) const { return *this * (T(1) / s); } 
    interval<T>& operator += (const T& s) { lower_bound += s; upper_bound += s; return *this; } 
    interval<T> operator + (const T& s) const { interval I(*this); return I += s; } 
    interval<T>& operator -= (const T& s) { lower_bound -= s; upper_bound -= s; return *this; } 
    interval<T> operator - (const T& s) const { interval I(*this); return I -= s; } 
 
    interval<T>& operator *= (const interval<T>& I) { 
        if (empty() || I.empty())
            *this = interval<T>();
        else 
            extend(lower_bound * I.lower_bound, lower_bound * I.upper_bound,
                   upper_bound * I.lower_bound, upper_bound * I.upper_bound);
        return *this; 
    } 
    interval<T> operator * (const interval<T>& J) const { interval I(*this); return I *= J; } 
    interval<T>& operator /= (const interval<T>& I) { 
        if (empty() || I.empty())
            *this = interval<T>();
        else {
            if (I.contains(T(0)))
                *this = interval<T>(true);
            else
                extend(lower_bound / I.lower_bound, lower_bound/I.upper_bound,
                       upper_bound / I.lower_bound, upper_bound/I.upper_bound);
        }
        return *this;
    } 
    interval<T> operator / (const interval<T>& J) const { interval I(*this); return I /= J; } 
    interval<T> operator - () const { if (empty()) return *this; else return interval<T>(-upper_bound, -lower_bound); }
    interval<T>& operator += (const interval<T>& I) { 
        if (empty() || I.empty())
            *this = interval<T>();
        else {
            extend(lower_bound + I.lower_bound, lower_bound + I.upper_bound,
                   upper_bound + I.lower_bound, upper_bound + I.upper_bound);
        }
        return *this; 
    } 
    interval<T> operator + (const interval<T>& J) const { interval I(*this); return I += J; } 
    interval<T>& operator -= (const interval<T>& I) { return *this += -I; }
    interval<T> operator - (const interval<T>& J) const { interval I(*this); return I -= J; } 
 
    bool operator == (const interval<T>& I) const {
        return empty() && I.empty() ||
            lower_bound == I.lower_bound && upper_bound == I.upper_bound;
    }
    bool operator != (const interval<T>& I) const {
        return !(*this == I);
    }
    bool operator < (const interval<T>& I) const {
        return !empty() && !I.empty() && upper_bound < I.lower_bound;
    }
    bool operator > (const interval<T>& I) const {
        return !empty() && !I.empty() && lower_bound > I.upper_bound;
    }
 
};
 
template <typename T> inline interval<T> operator + (const T& s, const interval<T>& I) { return  I+s; }
template <typename T> inline interval<T> operator - (const T& s, const interval<T>& I) { return -I+s; }
template <typename T> inline interval<T> operator * (const T& s, const interval<T>& I) { return  I*s; }
template <typename T> inline interval<T> operator / (const T& s, const interval<T>& I) { return interval<T>(s,s)/I; }
 
template <typename T>
std::ostream& operator << (std::ostream& os, const interval<T>& I) {
    return os << '[' << I.lower_bound << ',' << I.upper_bound << ']';
}
 
    }
}