Utilities/Statistics/Accumulator.h

Go to the documentation of this file.

#ifndef _utl_Accumulator_h_
#define _utl_Accumulator_h_

#include <vector>
#include <deque>
#include <utl/Math.h>

#include <boost/shared_ptr.hpp>

#include <algorithm>


namespace utl {
  namespace Accumulator {

    template<typename T>
    class Min {
    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 SetFirst(const T x) { fMin = x; }
      void Clear() { fMin = T(); }
    private:
      T fMin;
    };


    template<typename T>
    class Max {
    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) { }
      void operator()(const T x) { Min<T>::operator()(x); Max<T>::operator()(x); }
      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() { }
      void Clear() { Min<T>::Clear(); Max<T>::Clear(); }
    };


    class AverageN {
    public:
      void operator()(const double x) { fX += x; }
      double GetAverage(const int n) const { return fX / n; }
      double GetSum() const { return fX; }
      void Clear() { fX = 0; }
    protected:
      double fX = 0;
    };


    class Average {
    public:
      void operator()(const double x) { fAvg(x); ++fN; }
      double GetAverage() const { return fAvg.GetAverage(fN); }
      int GetN() const { return fN; }
      void Clear() { fAvg.Clear(); fN = 0; }
      explicit operator bool() const { return fN; }
    private:
      AverageN fAvg;
      int fN = 0;
    };


    template<typename T>
    class MinMaxAverage : public Min<T>, public Max<T>, public Average {
    public:
      typedef T Type;
      MinMaxAverage(const T first) : Min<T>(first), Max<T>(first) { Average::operator()(first); }
      void operator()(const T x) { Min<T>::operator()(x); Max<T>::operator()(x); Average::operator()(x); }
      void Clear(const T x) { Min<T>::Clear(x); Max<T>::Clear(x); Average::Clear(); Average::operator()(x); }
    protected:
      MinMaxAverage() { }
      void Clear() { Min<T>::Clear(); Max<T>::Clear(); Average::Clear(); }
    };


    //


    class Validator {
    public:
      bool IsValid() const { return fIsValid; }
      void Validate(const bool state = true) { fIsValid = state; }
      void Clear() { fIsValid = false; }
    private:
      bool fIsValid = false;
    };

    template<typename AccumulatorT>
    class Safe : public AccumulatorT, public Validator {
    public:
      void
      operator()(const typename AccumulatorT::Type x)
      {
        if (*this)
          AccumulatorT::operator()(x);
        else {
          AccumulatorT::Clear(x);
          Validate();
        }
      }

      explicit operator bool() const { return IsValid(); }

      void Clear() { AccumulatorT::Clear(); Validator::Clear(); }
    };


    //


    class SampleVarianceN : public AverageN {
    public:
      void operator()(const double x) { AverageN::operator()(x); fX2 += Sqr(x); }
      double GetVariance(const int n) const { return (fX2 - Sqr(fX)/n) / (n - 1); }
      double GetAverageError(const int n) const { return std::sqrt(GetVariance(n)/n); }
      double GetSumOfSquares() const { return fX2; }
      void Clear() { AverageN::Clear(); fX2 = 0; }
    protected:
      double fX2 = 0;
    };


    //


    class SampleStandardDeviationN : public SampleVarianceN {
    public:
      void operator()(const double x) { SampleVarianceN::operator()(x); }
      double GetStandardDeviation(const int n) const { return std::sqrt(GetVariance(n)); }
    };


    //


    class SampleVariance : public Average {
    public:
      void operator()(const double x) { Average::operator()(x); fVariance(x); }
      double GetVariance() const { return fVariance.GetVariance(Average::GetN()); }
      double GetAverageError() const { return fVariance.GetAverageError(GetN()); }
      double GetSumOfSquares() const { return fVariance.GetSumOfSquares(); }
      void Clear() { Average::Clear(); fVariance.Clear(); }
    protected:
      SampleVarianceN fVariance;
    };


    class SampleStandardDeviation : public SampleVariance {
    public:
      void operator()(const double x) { SampleVariance::operator()(x); }
      double GetStandardDeviation() const { return std::sqrt(GetVariance()); }
    };


    //


    class CorrelationCoefficient {
    public:
      unsigned int GetN() const { return fX.GetN(); }
      double GetAverageX() const { return fX.GetAverage(); }
      double GetAverageY() const { return fY.GetAverage(GetN()); }
      double GetAverageXY() const { return fXY.GetAverage(GetN()); }
      double GetStandardDeviationX() const { return fX.GetStandardDeviation(); }
      double GetStandardDeviationY() const { return fY.GetStandardDeviation(GetN()); }
      double GetCorrelationCoefficient() const
      { return GetN() * (GetAverageXY() - GetAverageX()*GetAverageY()) /
          ((GetN() - 1) * GetStandardDeviationX() * GetStandardDeviationY()); }
      void Clear() { fX.Clear(); fY.Clear(); fXY.Clear(); }
      void operator()(const double x, const double y) { fX(x); fY(y); fXY(x*y); }
    private:
      SampleStandardDeviation fX;
      SampleStandardDeviationN fY;
      AverageN fXY;
    };

  }

}


#endif