utils.hpp

Go to the documentation of this file.

#ifndef _UTILS_HPP_
#define _UTILS_HPP_

/* --------------------------------------------------------------- *\

   author:

      steven bergner
      mathias gumz

\* --------------------------------------------------------------- */


namespace math
{

struct Utility { };

template<typename Out, typename In, typename U1, typename U2>
struct Chain : public Utility
{
  Out operator()(In x, U1 u1, U2 u2) const { return u1(u2(x)); };
}; // struct Chain


template<typename T>
struct Clamp2Upper : public Utility
{
  Clamp2Upper(const T& _ub= Traits<T>::zero()) : ub(_ub) { };
  T operator() (const T& x) const { return std::min(x, ub); }
  T operator() (const T& x, const T& _ub) { return std::min(x, _ub); }
  private:
    T ub;
};

template<typename T>
struct Clamp2Lower : public Utility
{
  Clamp2Lower(const T& _lb= Traits<T>::zero()) : lb(_lb) { };
  T operator() (const T& x) const { return std::max(x, lb); }
  T operator() (const T& x, const T& _lb) { return std::max(x, _lb); }

  private:
    T lb;

};

template<typename T>
struct Clamp : public Utility
{
  Clamp(const T& lb= Traits<T>::zero(), const T& ub= Traits<T>::zero()) : clamp2lower(lb), clamp2upper(ub) { };
  T operator() (const T& x) const { return clamp2upper(clamp2lower(x)); };
  T operator() (const T& x, const T& lb, const T& ub)
  {
    Chain<T, T, Clamp2Lower<T>, Clamp2Upper<T> > clamp;
    return clamp(x, Clamp2Lower<T>(lb), Clamp2Upper<T>(ub));
  }

  private:
    Clamp2Lower<T> clamp2lower;
    Clamp2Upper<T> clamp2upper;

}; // struct Clamp


template<typename T>
struct Sum : public Utility
{
  typename T::ValType operator() (const T& x) const
  {
    return std::accumulate(x.begin(), x.end(), T::ValTrait::zero());
  }
};

template<typename T>
struct Average : public Utility
{
  typename T::ValType operator() (const T& x) const
  {
    return typename T::ValType(sum(x) / x.size());
  }

  private:
    Sum<T> sum;
};


template<typename T>
struct Variance : public Utility
{
  typename T::ValType operator() (const T& x) const
  { return T(a(x)).norm2(); }

  private:
    Average<T> a;
};

template<typename T>
struct StdDeviation : public Utility
{
  typename T::ValType operator() (const T& x) const
  {
    return sqrt(v(x));
  }
  private:
    Variance<T> v;
}; // struct StdDeviation

}; // namespace math

#endif // _UTILS_HPP_

---