Interval.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2022 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
#ifndef GZ_MATH_INTERVAL_HH_
#define GZ_MATH_INTERVAL_HH_
 
#include <cmath>
#include <limits>
#include <ostream>
#include <type_traits>
#include <utility>
 
#include <gz/math/config.hh>
 
namespace gz::math
{
  // Inline bracket to help doxygen filtering.
  inline namespace GZ_MATH_VERSION_NAMESPACE {
  //
  template <typename T>
  class Interval
  {
    public: static const Interval<T> &Unbounded;
 
    public: Interval() = default;
 
    public: constexpr Interval(
        T _leftValue, bool _leftClosed,
        T _rightValue, bool _rightClosed)
    : leftValue(std::move(_leftValue)),
      rightValue(std::move(_rightValue)),
      leftClosed(_leftClosed),
      rightClosed(_rightClosed)
    {
    }
 
    public: static constexpr Interval<T>
    Open(T _leftValue, T _rightValue)
    {
      return Interval<T>(
        std::move(_leftValue), false,
        std::move(_rightValue), false);
    }
 
    public: static constexpr Interval<T>
    LeftClosed(T _leftValue, T _rightValue)
    {
      return Interval<T>(
        std::move(_leftValue), true,
        std::move(_rightValue), false);
    }
 
    public: static constexpr Interval<T>
    RightClosed(T _leftValue, T _rightValue)
    {
      return Interval<T>(
        std::move(_leftValue), false,
        std::move(_rightValue), true);
    }
 
    public: static constexpr Interval<T>
    Closed(T _leftValue, T _rightValue)
    {
      return Interval<T>{
        std::move(_leftValue), true,
        std::move(_rightValue), true};
    }
 
    public: const T &LeftValue() const { return this->leftValue; }
 
    public: bool IsLeftClosed() const { return this->leftClosed; }
 
    public: const T &RightValue() const { return this->rightValue; }
 
    public: bool IsRightClosed() const { return this->rightClosed; }
 
    public: bool Empty() const
    {
      if (this->leftClosed && this->rightClosed)
      {
        return this->rightValue < this->leftValue;
      }
      return this->rightValue <= this->leftValue;
    }
 
    public: bool Contains(const T &_value) const
    {
      if (this->leftClosed && this->rightClosed)
      {
        return this->leftValue <= _value && _value <= this->rightValue;
      }
      if (this->leftClosed)
      {
        return this->leftValue <= _value && _value < this->rightValue;
      }
      if (this->rightClosed)
      {
        return this->leftValue < _value && _value <= this->rightValue;
      }
      return this->leftValue < _value && _value < this->rightValue;
    }
 
    public: bool Contains(const Interval<T> &_other) const
    {
      if (this->Empty() || _other.Empty())
      {
        return false;
      }
      if (!this->leftClosed && _other.leftClosed)
      {
        if (_other.leftValue <= this->leftValue)
        {
          return false;
        }
      }
      else
      {
        if (_other.leftValue < this->leftValue)
        {
          return false;
        }
      }
      if (!this->rightClosed && _other.rightClosed)
      {
        if (this->rightValue <= _other.rightValue)
        {
          return false;
        }
      }
      else
      {
        if (this->rightValue < _other.rightValue)
        {
          return false;
        }
      }
      return true;
    }
 
    public: bool Intersects(const Interval<T> &_other) const
    {
      if (this->Empty() || _other.Empty())
      {
        return false;
      }
      if (this->rightClosed && _other.leftClosed)
      {
        if (this->rightValue < _other.leftValue)
        {
          return false;
        }
      }
      else
      {
        if (this->rightValue <= _other.leftValue)
        {
          return false;
        }
      }
      if (_other.rightClosed && this->leftClosed)
      {
        if (_other.rightValue < this->leftValue)
        {
          return false;
        }
      }
      else
      {
        if (_other.rightValue <= this->leftValue)
        {
          return false;
        }
      }
      return true;
    }
 
    public: bool operator==(const Interval<T> &_other) const
    {
      return this->Contains(_other) && _other.Contains(*this);
    }
 
    public: bool operator!=(const Interval<T> &_other) const
    {
      return !this->Contains(_other) || !_other.Contains(*this);
    }
 
    public: friend std::ostream &operator<<(
      std::ostream &_out, const gz::math::Interval<T> &_interval)
    {
      return _out << (_interval.leftClosed ? "[" : "(")
                  << _interval.leftValue << ", " << _interval.rightValue
                  << (_interval.rightClosed ? "]" : ")");
    }
 
    private: T leftValue{0};
    private: T rightValue{0};
    private: bool leftClosed{false};
    private: bool rightClosed{false};
  };
 
  namespace detail {
     template<typename T>
     constexpr Interval<T> gUnboundedInterval =
         Interval<T>::Open(-std::numeric_limits<T>::infinity(),
                           std::numeric_limits<T>::infinity());
  }  // namespace detail
  template<typename T>
  const Interval<T> &Interval<T>::Unbounded = detail::gUnboundedInterval<T>;
 
  using Intervalf = Interval<float>;
  using Intervald = Interval<double>;
  }  // namespace GZ_MATH_VERSION_NAMESPACE
}  // namespace gz::math
#endif  // GZ_MATH_INTERVAL_HH_