gz/math/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 ignition
{
  namespace math
  {
    // Inline bracket to help doxygen filtering.
    inline namespace IGNITION_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>;
    }
  }
}
 
#endif