ImathInterval.h

//
// SPDX-License-Identifier: BSD-3-Clause
// Copyright Contributors to the OpenEXR Project.
//
 
//
// An interval class
//
 
#ifndef INCLUDED_ATOMSMATHINTERVAL_H
#define INCLUDED_ATOMSMATHINTERVAL_H
 
#include <AtomsMath/ImathNamespace.h>
#include <AtomsMath/ImathVec.h>
 
ATOMSMATH_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
template <class T> class Interval
{
  public:
 
    
    T min;
 
    T max;
 
    
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Interval() noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Interval (const T& point) noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Interval (const T& minT, const T& maxT) noexcept;
 
 
 
    ATOMSMATH_HOSTDEVICE constexpr bool operator== (const Interval<T>& src) const noexcept;
    ATOMSMATH_HOSTDEVICE constexpr bool operator!= (const Interval<T>& src) const noexcept;
 
 
 
    ATOMSMATH_HOSTDEVICE void makeEmpty() noexcept;
 
    ATOMSMATH_HOSTDEVICE void extendBy (const T& point) noexcept;
 
    ATOMSMATH_HOSTDEVICE void extendBy (const Interval<T>& interval) noexcept;
 
    ATOMSMATH_HOSTDEVICE void makeInfinite() noexcept;
 
 
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 T size() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 T center() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool intersects (const T& point) const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool intersects (const Interval<T>& interval) const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool isEmpty() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool hasVolume() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool isInfinite() const noexcept;
 
};
 
template <class T> std::ostream& operator<< (std::ostream& s, const Interval<T>& v);
 
typedef Interval<float> Intervalf;
 
typedef Interval<double> Intervald;
 
typedef Interval<short> Intervals;
 
typedef Interval<int> Intervali;
 
template <class T> inline ATOMSMATH_CONSTEXPR14 Interval<T>::Interval() noexcept
{
    makeEmpty();
}
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Interval<T>::Interval (const T& point) noexcept
{
    min = point;
    max = point;
}
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Interval<T>::Interval (const T& minV, const T& maxV) noexcept
{
    min = minV;
    max = maxV;
}
 
template <class T>
constexpr inline bool
Interval<T>::operator== (const Interval<T>& src) const noexcept
{
    return (min == src.min && max == src.max);
}
 
template <class T>
constexpr inline bool
Interval<T>::operator!= (const Interval<T>& src) const noexcept
{
    return (min != src.min || max != src.max);
}
 
template <class T>
inline void
Interval<T>::makeEmpty() noexcept
{
    min = std::numeric_limits<T>::max();
    max = std::numeric_limits<T>::lowest();
}
 
template <class T>
inline void
Interval<T>::makeInfinite() noexcept
{
    min = std::numeric_limits<T>::lowest();
    max = std::numeric_limits<T>::max();
}
 
 
template <class T>
inline void
Interval<T>::extendBy (const T& point) noexcept
{
    if (point < min)
        min = point;
 
    if (point > max)
        max = point;
}
 
template <class T>
inline void
Interval<T>::extendBy (const Interval<T>& interval) noexcept
{
    if (interval.min < min)
        min = interval.min;
 
    if (interval.max > max)
        max = interval.max;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Interval<T>::intersects (const T& point) const noexcept
{
    return point >= min && point <= max;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Interval<T>::intersects (const Interval<T>& interval) const noexcept
{
    return interval.max >= min && interval.min <= max;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline T
Interval<T>::size() const noexcept
{
    if (isEmpty())
        return T(0);
    
    return max - min;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline T
Interval<T>::center() const noexcept
{
    return (max + min) / 2;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Interval<T>::isEmpty() const noexcept
{
    return max < min;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Interval<T>::hasVolume() const noexcept
{
    return max > min;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Interval<T>::isInfinite() const noexcept
{
    if (min != std::numeric_limits<T>::lowest() || max != std::numeric_limits<T>::max())
        return false;
 
    return true;
}
 
template <class T>
std::ostream&
operator<< (std::ostream& s, const Interval<T>& v)
{
    return s << '(' << v.min << ' ' << v.max << ')';
}
 
ATOMSMATH_INTERNAL_NAMESPACE_HEADER_EXIT
 
#endif // INCLUDED_ATOMSMATHINTERVAL_H