Tools/CIC/utl/Accumulator.h

Go to the documentation of this file.

// \author Darko Veberic
// \date 2014

#ifndef _cic_utl_Accumulator_h_
#define _cic_utl_Accumulator_h_

#include <utl/Math.h>
#include <vector>
#include <functional>
#include <algorithm>


namespace utl {
namespace Accumulator {

  class Count {
  public:
    Count(const unsigned int init = 0) : fCount(init) { }
    void operator()() { ++fCount; }
    unsigned int operator++() { operator()(); return fCount; }
    unsigned int GetCount() const { return fCount; }
    void Clear(const unsigned init = 0) { fCount = init; }
  private:
    unsigned int fCount;
  };


  template<typename T, class Container = std::vector<T>>
  class Collect : public std::unary_function<T, void> {
  public:
    void operator()(const T& x) { fCollection.push_back(x); }

    Container& GetCollection() { return fCollection; }

    const Container& GetCollection() const { return fCollection; }

    template<class Order>
    void Sort(Order ord)
    { std::sort(fCollection.begin(), fCollection.end(), ord); }

    void Clear() { fCollection.clear(); }

  private:
    Container fCollection;
  };


  template<typename T>
  class Min : public std::unary_function<T, void> {
  public:
    typedef T Type;
    Min(const T first) : fMin(first) { }
    void operator()(const T x) { if (fMin > x) fMin = x; }
    T GetMin() const { return fMin; }
    void Clear(const T x) { fMin = x; }
  protected:
    Min() : fMin(T()) { }
    void Clear() { fMin = T(); }
  private:
    T fMin;
  };


  template<typename T>
  class Max : public std::unary_function<T, void> {
  public:
    typedef T Type;
    Max(const T first) : fMax(first) { }
    void operator()(const T x) { if (fMax < x) fMax = x; }
    T GetMax() const { return fMax; }
    void Clear(const T x) { fMax = x; }
  protected:
    Max() : fMax(T()) { }
    void Clear() { fMax = T(); }
  private:
    T fMax;
  };


  template<typename T>
  class MinMax : public Min<T>, public Max<T> {
  public:
    typedef T Type;
    MinMax(const T first) : Min<T>(first), Max<T>(first) { }
    MinMax(const T firstMin, const T firstMax) : Min<T>(firstMin), Max<T>(firstMax) { }
    MinMax(const MinMax& mm) = default;
    void operator()(const T x) { Min<T>::operator()(x); Max<T>::operator()(x); }
    std::pair<T, T> GetMinMax() const { return std::make_pair(this->GetMin(), this->GetMax()); }
    void Clear(const T x) { Clear(x, x); }
    void Clear(const T min, const T max) { Min<T>::Clear(min); Max<T>::Clear(max); }
  protected:
    MinMax() : Min<T>(), Max<T>() { }
    void Clear() { Min<T>::Clear(); Max<T>::Clear(); }
  };


  template<typename T>
  class Covariance : public Count {
  public:
    explicit Covariance(const unsigned int nVar)
      : Count(), fSumX(nVar), fSumXY(Sqr(nVar)) { }

    void
    operator()(const std::vector<T>& values)
    {
      Count::operator()();
      for (unsigned int i = 0, n = fSumX.size(); i < n; ++i) {
        fSumX[i] += values[i];
        for (unsigned int j = 0; j <= i; ++j)
          fSumXY[n*i + j] += values[i] * values[j];
      }
    }

    std::vector<double>
    GetMeans()
      const
    {
      std::vector<double> m(fSumX.size());
      for (unsigned int i = 0; i < fSumX.size(); ++i)
        m[i] = double(fSumX[i]) / GetCount();
      return m;
    }

    std::vector<double>
    GetVars()
      const
    {
      const unsigned int n = fSumX.size();
      std::vector<double> v(n);
      for (unsigned int i = 0; i < n; ++i)
        v[i] = (fSumXY[(n+1)*i] - double(Sqr(fSumX[i]))/GetCount()) / (GetCount() - 1);
      return v;
    }

    std::vector<double>
    GetStds()
      const
    {
      std::vector<double> s = GetVars();
      for (double& x : s)
        x = std::sqrt(x);
      return s;
    }

    double
    GetCovariance(unsigned int i, unsigned int j)
      const
    {
      if (j > i)
        std::swap(i, j);
      const unsigned int n = fSumX.size();
      return (fSumXY[n*i + j] - double(fSumX[i]*fSumX[j])/GetCount()) / (GetCount() - 1);
    }

    std::vector<std::vector<double>>
    GetCovariance()
      const
    {
      const unsigned int n = fSumX.size();
      std::vector<std::vector<double>> c(n, std::vector<double>(n));
      for (unsigned int i = 0; i < n; ++i)
        for (unsigned int j = 0; j < n; ++j)
          c[i][j] = GetCovariance(i, j);
      return c;
    }

  private:
    std::vector<T> fSumX;
    std::vector<T> fSumXY;
  };


  class Sum : public std::unary_function<double, void> {
  public:
    Sum() : fSumX(0) { }
    void operator()(const double x) { fSumX += x; }
    double GetMean(const int n) const { return fSumX / n; }
    double GetSum() const { return fSumX; }
    void Clear() { fSumX = 0; }
  private:
    double fSumX;
  };


  class Mean : public Count, public Sum {
  public:
    void operator()(const double x) { Count::operator()(); Sum::operator()(x); }
    double GetMean() const { return Sum::GetMean(GetCount()); }
    void Clear() { Count::Clear(); Sum::Clear(); }
  };


  class VarN : public Sum {
  public:
    void operator()(const double x) { Sum::operator()(x); fX2(Sqr(x)); }
    double GetVar(const int n) const
    { return (fX2.GetSum() - Sqr(GetSum())/n) / (n - 1); }
    double GetSumOfSquares() const { return fX2.GetSum(); }
    void Clear() { Sum::Clear(); fX2.Clear(); }
  protected:
    Sum fX2;
  };


  class StdN : public VarN {
  public:
    void operator()(const double x) { VarN::operator()(x); }
    double GetStd(const int n) const { return std::sqrt(GetVar(n)); }
  };


  class Var : public Mean {
  public:
    void operator()(const double x) { Mean::operator()(x); fVar(x); }
    double GetVar() const { return fVar.GetVar(GetCount()); }
    double GetSumOfSquares() const { return fVar.GetSumOfSquares(); }
    void Clear() { Mean::Clear(); fVar.Clear(); }
  protected:
    VarN fVar;
  };


  class Std : public Var {
  public:
    void operator()(const double x) { Var::operator()(x); }
    double GetStd() const { return std::sqrt(GetVar()); }
  };

}
}


#endif