Interval.h

Go to the documentation of this file.

#pragma once
 
 
#include "common/Globals.h"
#include "math/MathUtils.h"
#include "objects/containers/StaticArray.h"
 
NAMESPACE_SPH_BEGIN
 
class Interval {
private:
    Float minBound;
    Float maxBound;
 
public:
    INLINE Interval()
        : minBound(INFTY)
        , maxBound(-INFTY) {}
 
    INLINE Interval(const Float& lower, const Float& upper)
        : minBound(lower)
        , maxBound(upper) {}
 
    INLINE void extend(const Float& value) {
        minBound = min(minBound, value);
        maxBound = max(maxBound, value);
    }
 
    INLINE void extend(const Interval& other) {
        minBound = min(minBound, other.minBound);
        maxBound = max(maxBound, other.maxBound);
    }
 
    INLINE bool contains(const Float& value) const {
        return minBound <= value && value <= maxBound;
    }
 
    INLINE Interval intersect(const Interval& other) const {
        Interval is;
        is.minBound = max(minBound, other.minBound);
        is.maxBound = min(maxBound, other.maxBound);
        return is;
    }
 
    INLINE Float clamp(const Float& value) const {
        SPH_ASSERT(minBound <= maxBound);
        return max(minBound, min(value, maxBound));
    }
 
    INLINE Float lower() const {
        return minBound;
    }
 
    INLINE Float upper() const {
        return maxBound;
    }
 
    INLINE Float center() const {
        return 0.5_f * (minBound + maxBound);
    }
 
    INLINE Float size() const {
        return maxBound - minBound;
    }
 
    INLINE bool operator==(const Interval& other) const {
        return minBound == other.minBound && maxBound == other.maxBound;
    }
 
    INLINE bool operator!=(const Interval& other) const {
        return !(*this == other);
    }
 
    INLINE bool empty() const {
        return minBound > maxBound;
    }
 
    static Interval unbounded() {
        return Interval(-INFTY, INFTY);
    }
 
    friend std::ostream& operator<<(std::ostream& stream, const Interval& range);
};
 
 
template <typename T>
INLINE T clamp(const T& v, const Interval& range) {
    return T(range.clamp(v));
}
 
template <typename T>
INLINE Pair<T> clampWithDerivative(const T&, const T&, const Interval&) {
    NOT_IMPLEMENTED;
}
 
template <>
INLINE Pair<Float> clampWithDerivative<Float>(const Float& v, const Float& dv, const Interval& range) {
    const bool zeroDeriv = (v >= range.upper() && dv > 0._f) || (v <= range.lower() && dv < 0._f);
    return { clamp(v, range), zeroDeriv ? 0._f : dv };
}
 
NAMESPACE_SPH_END