Interval.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Louis Langholtz https://github.com/louis-langholtz/PlayRho
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#ifndef PLAYRHO_COMMON_INTERVAL_HPP
#define PLAYRHO_COMMON_INTERVAL_HPP
 
#include <PlayRho/Common/BoundedValue.hpp>
#include <algorithm>
#include <limits>
#include <iostream>
 
namespace playrho {
 
template <typename T>
class Interval
{
public:
    
    using value_type = T;
    
    using limits = std::numeric_limits<value_type>;
    
    static PLAYRHO_CONSTEXPR inline value_type GetLowest() noexcept
    {
        return (limits::has_infinity)? -limits::infinity(): limits::lowest();
    }
    
    static PLAYRHO_CONSTEXPR inline value_type GetHighest() noexcept
    {
        return (limits::has_infinity)? limits::infinity(): limits::max();
    }
 
    PLAYRHO_CONSTEXPR inline Interval() = default;
    
    PLAYRHO_CONSTEXPR inline Interval(const Interval& other) = default;
 
    PLAYRHO_CONSTEXPR inline Interval(Interval&& other) = default;
    
    PLAYRHO_CONSTEXPR inline explicit Interval(const value_type& v) noexcept:
        Interval(pair_type{v, v})
    {
        // Intentionally empty.
    }
    
    PLAYRHO_CONSTEXPR inline Interval(const value_type& a, const value_type& b) noexcept:
        Interval(std::minmax(a, b))
    {
        // Intentionally empty.
    }
    
    PLAYRHO_CONSTEXPR inline Interval(const std::initializer_list<T> ilist) noexcept:
        Interval(std::minmax(ilist))
    {
        // Intentionally empty.
    }
    
    ~Interval() noexcept = default;
    
    Interval& operator= (const Interval& other) = default;
 
    Interval& operator= (Interval&& other) = default;
    
    PLAYRHO_CONSTEXPR inline Interval& Move(const value_type& v) noexcept
    {
        m_min += v;
        m_max += v;
        return *this;
    }
 
    PLAYRHO_CONSTEXPR inline value_type GetMin() const noexcept
    {
        return m_min;
    }
 
    PLAYRHO_CONSTEXPR inline value_type GetMax() const noexcept
    {
        return m_max;
    }
    
    PLAYRHO_CONSTEXPR inline Interval& Include(const value_type& v) noexcept
    {
        m_min = std::min(v, GetMin());
        m_max = std::max(v, GetMax());
        return *this;
    }
    
    PLAYRHO_CONSTEXPR inline Interval& Include(const Interval& v) noexcept
    {
        m_min = std::min(v.GetMin(), GetMin());
        m_max = std::max(v.GetMax(), GetMax());
        return *this;
    }
    
    PLAYRHO_CONSTEXPR inline Interval& Intersect(const Interval& v) noexcept
    {
        const auto min = std::max(v.GetMin(), GetMin());
        const auto max = std::min(v.GetMax(), GetMax());
        *this = (min <= max)? Interval{pair_type{min, max}}: Interval{};
        return *this;
    }
    
    PLAYRHO_CONSTEXPR inline Interval& Expand(const value_type& v) noexcept
    {
        if (v < value_type{})
        {
            m_min += v;
        }
        else
        {
            m_max += v;
        }
        return *this;
    }
    
    PLAYRHO_CONSTEXPR inline Interval& ExpandEqually(const NonNegative<value_type>& v) noexcept
    {
        const auto amount = value_type{v};
        m_min -= amount;
        m_max += amount;
        return *this;
    }
    
private:
    using pair_type = std::pair<value_type, value_type>;
    
    PLAYRHO_CONSTEXPR inline explicit Interval(pair_type pair) noexcept:
        m_min{std::get<0>(pair)}, m_max{std::get<1>(pair)}
    {
        // Intentionally empty.
    }
 
    value_type m_min = GetHighest(); 
    value_type m_max = GetLowest(); 
};
 
template <typename T>
PLAYRHO_CONSTEXPR inline T GetSize(const Interval<T>& v) noexcept
{
    return v.GetMax() - v.GetMin();
}
 
template <typename T>
PLAYRHO_CONSTEXPR inline T GetCenter(const Interval<T>& v) noexcept
{
    // Rounding may cause issues...
    return (v.GetMin() + v.GetMax()) / 2;
}
 
template <typename T>
PLAYRHO_CONSTEXPR inline bool IsIntersecting(const Interval<T>& a, const Interval<T>& b) noexcept
{
    const auto maxOfMins = std::max(a.GetMin(), b.GetMin());
    const auto minOfMaxs = std::min(a.GetMax(), b.GetMax());
    return minOfMaxs >= maxOfMins;
}
 
template <typename T>
PLAYRHO_CONSTEXPR inline Interval<T> GetIntersection(Interval<T> a, const Interval<T>& b) noexcept
{
    return a.Intersect(b);
}
 
template <typename T>
PLAYRHO_CONSTEXPR inline bool IsEntirelyBefore(const Interval<T>& a, const Interval<T>& b)
{
    return a.GetMax() < b.GetMin();
}
 
template <typename T>
PLAYRHO_CONSTEXPR inline bool IsEntirelyAfter(const Interval<T>& a, const Interval<T>& b)
{
    return a.GetMin() > b.GetMax();
}
 
template <typename T>
PLAYRHO_CONSTEXPR inline bool IsEntirelyEnclosing(const Interval<T>& a, const Interval<T>& b)
{
    return a.GetMin() <= b.GetMin() && a.GetMax() >= b.GetMax();
}
 
template <typename T>
PLAYRHO_CONSTEXPR inline bool operator== (const Interval<T>& a, const Interval<T>& b) noexcept
{
    return (a.GetMin() == b.GetMin()) && (a.GetMax() == b.GetMax());
}
 
template <typename T>
PLAYRHO_CONSTEXPR inline bool operator!= (const Interval<T>& a, const Interval<T>& b) noexcept
{
    return !(a == b);
}
 
template <typename T>
PLAYRHO_CONSTEXPR inline bool operator< (const Interval<T>& lhs, const Interval<T>& rhs) noexcept
{
    return (lhs.GetMin() < rhs.GetMin()) ||
        (lhs.GetMin() == rhs.GetMin() && lhs.GetMax() < rhs.GetMax());
}
 
template <typename T>
PLAYRHO_CONSTEXPR inline bool operator<= (const Interval<T>& lhs, const Interval<T>& rhs) noexcept
{
    return (lhs.GetMin() < rhs.GetMin()) ||
        (lhs.GetMin() == rhs.GetMin() && lhs.GetMax() <= rhs.GetMax());
}
 
template <typename T>
PLAYRHO_CONSTEXPR inline bool operator> (const Interval<T>& lhs, const Interval<T>& rhs) noexcept
{
    return (lhs.GetMin() > rhs.GetMin()) ||
        (lhs.GetMin() == rhs.GetMin() && lhs.GetMax() > rhs.GetMax());
}
 
template <typename T>
PLAYRHO_CONSTEXPR inline bool operator>= (const Interval<T>& lhs, const Interval<T>& rhs) noexcept
{
    return (lhs.GetMin() > rhs.GetMin()) ||
        (lhs.GetMin() == rhs.GetMin() && lhs.GetMax() >= rhs.GetMax());
}
 
template <typename T>
::std::ostream& operator<< (::std::ostream& os, const Interval<T>& value)
{
    return os << '{' << value.GetMin() << "..." << value.GetMax() << '}';
}
 
} // namespace playrho
 
#endif // PLAYRHO_COMMON_INTERVAL_HPP