range_impl.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_MATH_RANGE_IMPL_HPP
#define MLPACK_CORE_MATH_RANGE_IMPL_HPP

#include "range.hpp"
#include <float.h>
#include <sstream>

namespace mlpack {
namespace math {

template<typename T>
inline RangeType<T>::RangeType() :
    lo(std::numeric_limits<T>::max()),
    hi(-std::numeric_limits<T>::max()) { /* nothing else to do */ }

template<typename T>
inline RangeType<T>::RangeType(const T point) :
    lo(point), hi(point) { /* nothing else to do */ }

template<typename T>
inline RangeType<T>::RangeType(const T lo, const T hi) :
    lo(lo), hi(hi) { /* nothing else to do */ }

template<typename T>
inline T RangeType<T>::Width() const
{
  if (lo < hi)
    return (hi - lo);
  else
    return 0.0;
}

template<typename T>
inline T RangeType<T>::Mid() const
{
  return (hi + lo) / 2;
}

template<typename T>
inline RangeType<T>& RangeType<T>::operator|=(const RangeType<T>& rhs)
{
  if (rhs.lo < lo)
    lo = rhs.lo;
  if (rhs.hi > hi)
    hi = rhs.hi;

  return *this;
}

template<typename T>
inline RangeType<T> RangeType<T>::operator|(const RangeType<T>& rhs) const
{
  return RangeType<T>((rhs.lo < lo) ? rhs.lo : lo,
                      (rhs.hi > hi) ? rhs.hi : hi);
}

template<typename T>
inline RangeType<T>& RangeType<T>::operator&=(const RangeType<T>& rhs)
{
  if (rhs.lo > lo)
    lo = rhs.lo;
  if (rhs.hi < hi)
    hi = rhs.hi;

  return *this;
}

template<typename T>
inline RangeType<T> RangeType<T>::operator&(const RangeType<T>& rhs) const
{
  return RangeType<T>((rhs.lo > lo) ? rhs.lo : lo,
                      (rhs.hi < hi) ? rhs.hi : hi);
}

template<typename T>
inline RangeType<T>& RangeType<T>::operator*=(const T d)
{
  lo *= d;
  hi *= d;

  // Now if we've negated, we need to flip things around so the bound is valid.
  if (lo > hi)
  {
    double tmp = hi;
    hi = lo;
    lo = tmp;
  }

  return *this;
}

template<typename T>
inline RangeType<T> RangeType<T>::operator*(const T d) const
{
  double nlo = lo * d;
  double nhi = hi * d;

  if (nlo <= nhi)
    return RangeType<T>(nlo, nhi);
  else
    return RangeType<T>(nhi, nlo);
}

// Symmetric case.
template<typename T>
inline RangeType<T> operator*(const T d, const RangeType<T>& r)
{
  double nlo = r.lo * d;
  double nhi = r.hi * d;

  if (nlo <= nhi)
    return RangeType<T>(nlo, nhi);
  else
    return RangeType<T>(nhi, nlo);
}

template<typename T>
inline bool RangeType<T>::operator==(const RangeType<T>& rhs) const
{
  return (lo == rhs.lo) && (hi == rhs.hi);
}

template<typename T>
inline bool RangeType<T>::operator!=(const RangeType<T>& rhs) const
{
  return (lo != rhs.lo) || (hi != rhs.hi);
}

template<typename T>
inline bool RangeType<T>::operator<(const RangeType<T>& rhs) const
{
  return hi < rhs.lo;
}

template<typename T>
inline bool RangeType<T>::operator>(const RangeType<T>& rhs) const
{
  return lo > rhs.hi;
}

template<typename T>
inline bool RangeType<T>::Contains(const T d) const
{
  return d >= lo && d <= hi;
}

template<typename T>
inline bool RangeType<T>::Contains(const RangeType<T>& r) const
{
  return lo <= r.hi && hi >= r.lo;
}

template<typename T>
template<typename Archive>
void RangeType<T>::serialize(Archive& ar, const uint32_t /* version */)
{
  ar(CEREAL_NVP(hi));
  ar(CEREAL_NVP(lo));
}

} // namespace math
} // namespace mlpack

#endif