RangeOperation.hpp

Go to the documentation of this file.

// ----------------- BEGIN LICENSE BLOCK ---------------------------------
//
// Copyright (C) 2018-2021 Intel Corporation
//
// SPDX-License-Identifier: MIT
//
// ----------------- END LICENSE BLOCK -----------------------------------
 
#pragma once
 
#include "ad/physics/AccelerationRangeValidInputRange.hpp"
#include "ad/physics/MetricRangeValidInputRange.hpp"
#include "ad/physics/ParametricRangeValidInputRange.hpp"
#include "ad/physics/SpeedRangeValidInputRange.hpp"
 
namespace ad {
namespace physics {
template <typename RangeType> bool isRangeValid(RangeType const &range)
{
  return withinValidInputRange(range);
}
 
template <typename RangeType> bool isRangeEmpty(RangeType const &range)
{
  return isRangeValid(range) && (range.minimum == range.maximum);
}
 
template <typename RangeType, typename RangeBaseType>
bool isWithinRange(RangeType const &range, RangeBaseType const &value)
{
  return (range.minimum <= value) && (value <= range.maximum);
}
 
template <typename RangeType> bool isRangeContained(RangeType const &left, RangeType const &right)
{
  return (left.minimum <= right.minimum) && (right.maximum <= left.maximum);
}
 
template <typename RangeType> bool doRangesOverlap(RangeType const &left, RangeType const &right)
{
  return isWithinRange(left, right.minimum) || isWithinRange(left, right.maximum) || isWithinRange(right, left.minimum)
    || isWithinRange(right, left.maximum) || isRangeContained(left, right) || isRangeContained(right, left);
}
 
template <typename RangeType> bool areRangesDisjunct(RangeType const &left, RangeType const &right)
{
  return !doRangesOverlaps(left, right);
}
 
template <typename RangeType> bool doesRangePredate(RangeType const &left, RangeType const &right)
{
  return left.maximum == right.minimum;
}
 
template <typename RangeType> bool doesRangeSucceed(RangeType const &left, RangeType const &right)
{
  return left.minimum == right.maximum;
}
 
template <typename RangeType> bool extendRangeWith(RangeType &left, RangeType const &right)
{
  if (doesRangePredate(left, right))
  {
    left.maximum = right.maximum;
    return true;
  }
  else if (doesRangeSucceed(left, right))
  {
    left.minimum = right.minimum;
    return true;
  }
  else
  {
    return false;
  }
}
 
template <typename RangeType> RangeType getUnionRange(RangeType const &left, RangeType const &right)
{
  RangeType result;
  result.minimum = std::min(left.minimum, right.minimum);
  result.maximum = std::max(left.maximum, right.maximum);
  return result;
}
 
template <typename RangeType, typename RangeBaseType>
RangeType getUnionRange(RangeType const &left, RangeBaseType const &value)
{
  RangeType result;
  result.minimum = std::min(left.minimum, value);
  result.maximum = std::max(left.maximum, value);
  return result;
}
 
template <typename RangeType> bool unionRangeWith(RangeType &left, RangeType const &right)
{
  left = getUnionRange(left, right);
  return isRangeValid(left);
}
 
template <typename RangeType, typename RangeBaseType> bool unionRangeWith(RangeType &left, RangeBaseType const &value)
{
  left = getUnionRange(left, value);
  return isRangeValid(left);
}
 
template <typename RangeType> RangeType getIntersectionRange(RangeType const &left, RangeType const &right)
{
  RangeType result;
  if (doRangesOverlap(left, right))
  {
    result.minimum = std::max(left.minimum, right.minimum);
    result.maximum = std::min(left.maximum, right.maximum);
  }
  return result;
}
 
template <typename RangeType> bool intersectRangeWith(RangeType &left, RangeType const &right)
{
  left = getIntersectionRange(left, right);
  return isRangeValid(left);
}
 
} // namespace physics
} // namespace ad
 
inline bool operator>(ad::physics::ParametricRange const &left, ad::physics::ParametricRange const &right)
{
  return left.minimum > right.maximum;
}
 
inline bool operator>=(ad::physics::ParametricRange const &left, ad::physics::ParametricRange const &right)
{
  return left.minimum >= right.maximum;
}
 
inline bool operator<(ad::physics::ParametricRange const &left, ad::physics::ParametricRange const &right)
{
  return left.maximum < right.minimum;
}
 
inline bool operator<=(ad::physics::ParametricRange const &left, ad::physics::ParametricRange const &right)
{
  return left.maximum <= right.minimum;
}
 
inline bool operator>(ad::physics::MetricRange const &left, ad::physics::MetricRange const &right)
{
  return left.minimum > right.maximum;
}
 
inline bool operator>=(ad::physics::MetricRange const &left, ad::physics::MetricRange const &right)
{
  return left.minimum >= right.maximum;
}
 
inline bool operator<(ad::physics::MetricRange const &left, ad::physics::MetricRange const &right)
{
  return left.maximum < right.minimum;
}
 
inline bool operator<=(ad::physics::MetricRange const &left, ad::physics::MetricRange const &right)
{
  return left.maximum <= right.minimum;
}
 
inline bool operator>(ad::physics::AccelerationRange const &left, ad::physics::AccelerationRange const &right)
{
  return left.minimum > right.maximum;
}
 
inline bool operator>=(ad::physics::AccelerationRange const &left, ad::physics::AccelerationRange const &right)
{
  return left.minimum >= right.maximum;
}
 
inline bool operator<(ad::physics::AccelerationRange const &left, ad::physics::AccelerationRange const &right)
{
  return left.maximum < right.minimum;
}
 
inline bool operator<=(ad::physics::AccelerationRange const &left, ad::physics::AccelerationRange const &right)
{
  return left.maximum <= right.minimum;
}
 
inline bool operator>(ad::physics::SpeedRange const &left, ad::physics::SpeedRange const &right)
{
  return left.minimum > right.maximum;
}
 
inline bool operator>=(ad::physics::SpeedRange const &left, ad::physics::SpeedRange const &right)
{
  return left.minimum >= right.maximum;
}
 
inline bool operator<(ad::physics::SpeedRange const &left, ad::physics::SpeedRange const &right)
{
  return left.maximum < right.minimum;
}
 
inline bool operator<=(ad::physics::SpeedRange const &left, ad::physics::SpeedRange const &right)
{
  return left.maximum <= right.minimum;
}