Range.h

Go to the documentation of this file.

#ifndef RANGE_TYPE_H_
#define RANGE_TYPE_H_
 
#include <cctype>
#include <iostream>
#include <limits>
#include <type_traits>
#include <utility>
 
#include "Utilities/MPUtils.h"
 
 
template <typename T>
struct Range final {
 
 
  T min;  
  T max;  
 
 
  Range() noexcept;
 
  Range(const T _min, const T _max) noexcept;
 
  Range(const std::pair<T, T>& _bounds) noexcept;
 
 
  T Length() const noexcept;
 
  T Center() const noexcept;
 
  template <typename U>
  bool Contains(const U& _val, const double _tolerance = 1e-8)
      const noexcept;
 
  template <typename U>
  T Clearance(const U& _val) const noexcept;
 
  template <typename U>
  T ClearancePoint(const U& _val) const noexcept;
 
  T Sample() const noexcept;
 
  bool operator==(const Range<T>& _other) const {
    return min == _other.min && max == _other.max;
  }
 
  bool operator<(const Range<T>& _other) const {
    if(min != _other.min)
      return min < _other.min;
 
    return max < _other.max;
  }
 
 
  void Resize(const T _min, const T _max) noexcept;
 
  void Translate(const T _t) noexcept;
 
  void SetCenter(const T _t) noexcept;
 
  void ExpandToInclude(const T _t) noexcept;
 
 
};
 
/*------------------------------- Construction -------------------------------*/
 
template <typename T>
inline
Range<T>::
Range() noexcept :
    min(T(0)), max(T(0)) { }
 
 
template <typename T>
inline
Range<T>::
Range(const T _min, const T _max) noexcept :
    min(_min), max(_max) { }
 
 
template <typename T>
inline
Range<T>::
Range(const std::pair<T, T>& _bounds) noexcept :
    min(_bounds.first), max(_bounds.second) { }
 
/*-------------------------------- Queries -----------------------------------*/
 
template <typename T>
inline
T
Range<T>::
Length() const noexcept {
  return max -  min;
}
 
 
template <typename T>
inline
T
Range<T>::
Center() const noexcept {
  return (max + min) / T(2);
}
 
 
template <typename T>
template <typename U>
inline
bool
Range<T>::
Contains(const U& _val, const double _tolerance) const noexcept {
  // James: Tolerance is causing issues with abs compilation.
  // There is also an imbalance with the amount of tolerance at either end of the 
  // range with this implementation.
  // An alternative is to just offer tolerance as a constant amount to extend the
  // range in either direction "min - _tolernace, max  + _tolerance".
 
  //return (min - std::abs(min) * _tolerance) <= _val
  //   and _val <= (max + std::abs(max) * _tolerance);
 
  return min <= _val and _val <= max;
 
}
 
 
template <typename T>
template <typename U>
inline
T
Range<T>::
Clearance(const U& _val) const noexcept {
  static_assert(!std::is_unsigned<T>::value, "Can't compute clearance for "
      "unsigned ranges as the return would be negative if the test value "
      "lies outside the range.");
  return std::min(_val - min, max - _val);
}
 
 
template <typename T>
template <typename U>
inline
T
Range<T>::
ClearancePoint(const U& _val) const noexcept {
  static_assert(!std::is_unsigned<T>::value, "Can't compute clearance for "
      "unsigned ranges as the return would be negative if the test value "
      "lies outside the range.");
  const T distToMin = std::abs(min - _val),
          distToMax = std::abs(max - _val);
  return distToMin < distToMax ? min : max;
}
 
 
template <typename T>
inline
T
Range<T>::
Sample() const noexcept {
  return min + (max - min) * DRand();
}
 
/*-------------------------------- Modifiers ---------------------------------*/
 
template <typename T>
inline
void
Range<T>::
Resize(const T _min, const T _max) noexcept {
  min = _min;
  max = _max;
}
 
 
template <typename T>
inline
void
Range<T>::
Translate(const T _t) noexcept {
  min += _t;
  max += _t;
}
 
 
template <typename T>
inline
void
Range<T>::
SetCenter(const T _t) noexcept {
  Translate(_t - Center());
}
 
 
template <typename T>
inline
void
Range<T>::
ExpandToInclude(const T _t) noexcept {
  min = std::min(min, _t);
  max = std::max(max, _t);
}
 
/*---------------------------------- I/O -------------------------------------*/
 
template <typename T>
std::ostream&
operator<<(std::ostream& _os, const Range<T>& _r) {
  return _os << _r.min << ":" << _r.max;
}
 
 
template <typename T>
std::istream&
operator>>(std::istream& _is, Range<T>& _r) {
  char delim;
  return _is >> _r.min >> std::skipws >> delim >> _r.max;
}
 
 
/*----------------------------------------------------------------------------*/
 
#endif