MCSampleStatistics.hpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  AiBO+ is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#pragma once

#include "MCContainers.hpp"
#include "MCDefs.hpp"
#include "MCSamples.hpp"

#include <list>

#include <math.h>

template <typename T>
class MCIqr;

template <typename T>
class MCArithmeticSum : public MCSampleStatistic<T>
{
public:
  /*
   * Create an arithmetic sum statistic
   *
   * @param name Unique statistic name
   *
   */

  MCArithmeticSum(const std::string& name = "ArithmeticSum") : MCSampleStatistic<T>(name), Result(0.0)
  { }
  virtual ~MCArithmeticSum() {}

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCFloatInfinity();

    return (float)Result;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCArithmeticSum<T>* NewInstance = new MCArithmeticSum<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);
    Result += (float)value;
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);
    Result -= (float)value;
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    Result = 0.0;
  }

private:
  double Result;
};

template <typename T>
class MCAbsoluteSum : public MCArithmeticSum<T>
{
public:
  /*
   * Create an absolute sum statistic
   *
   * @param name Unique statistic name
   *
   */

  MCAbsoluteSum(const std::string& name = "AbsoluteSum") : MCArithmeticSum<T>(name), Result(0.0)
  { }
  virtual ~MCAbsoluteSum() { }

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCFloatInfinity();

    return (float)Result;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCAbsoluteSum<T>* NewInstance = new MCAbsoluteSum<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);
    Result += (double)MCAbs(value);
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);
    Result -= (double)MCAbs(value);
  }

private:
  double Result;
};

template <typename T>
class MCArithmeticMean : public MCSampleStatistic<T>
{
public:
  /*
   * Create an arithmetic mean statistic
   *
   * @param name Unique statistic name
   *
   */

  MCArithmeticMean(const std::string& name = "ArithmeticMean") : MCSampleStatistic<T>(name), Result(0.0)
  { }
  virtual ~MCArithmeticMean() {}

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCFloatInfinity();

    return (float)Result;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCArithmeticMean<T>* NewInstance = new MCArithmeticMean<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);
    Result += (float)value / MCSampleStatistic<T>::Size;
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);
    Result -= (float)value / MCSampleStatistic<T>::Size;
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    Result = 0;
  }

private:
  double Result;
};

template <typename T>
class MCNonZeroCount : public MCSampleStatistic<T>
{
public:
  /*
   * Create an non-zero count statistic
   *
   * @param name Unique statistic name
   *
   */

  MCNonZeroCount(const std::string& name = "NonZeroCount") : MCSampleStatistic<T>(name), Count(0)
  { }
  virtual ~MCNonZeroCount() { }

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCFloatInfinity();

    return (float)Count;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCNonZeroCount<T>* NewInstance = new MCNonZeroCount<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);

    Count += (value > 0);
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);

    Count -= (value > 0);
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    Count = 0;
  }

private:
  int Count;
};

template <typename T>
class MCArithmeticMeanHead : public MCSampleStatistic<T>
{
public:
  /*
   * Create an arithmetic mean head statistic
   *
   * @param name Unique statistic name
   *
   */

  MCArithmeticMeanHead(int degree, const std::string& name = "ArithmeticMeanHead") :
    MCSampleStatistic<T>(name), Degree(degree)
  { }
  virtual ~MCArithmeticMeanHead() { }

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCFloatInfinity();

    double Result = 0;

    Degree = MCBound(1, Degree, MCSampleStatistic<T>::Size);
    for (int i = 0; i < Degree; ++i)
    {
      Result += (double)SampleCache[i];
    }
    return (float)(Result / Degree);
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCArithmeticMeanHead<T>* NewInstance = new MCArithmeticMeanHead<T>(Degree, MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);
    if ((int) SampleCache.size() == MCSampleStatistic<T>::Size)
      SampleCache.erase(SampleCache.begin());

    SampleCache.push_back((float) value);
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(value);
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    SampleCache.clear();
  }

private:
  int Degree;
  std::vector<float> SampleCache;  
};

template <typename T>
class MCArithmeticMeanTail : public MCSampleStatistic<T>
{
public:
  /*
   * Create an arithmetic mean tail statistic
   *
   * @param name Unique statistic name
   *
   */

  MCArithmeticMeanTail(int degree, const std::string& name = "ArithmeticMeanTail") :
    MCSampleStatistic<T>(name), Degree(degree)
  { }
  virtual ~MCArithmeticMeanTail() { }

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCFloatInfinity();

    double Result = 0;

    Degree = MCBound(1, Degree, MCSampleStatistic<T>::Size);
    for (int i = MCSampleStatistic<T>::Size-Degree; i < MCSampleStatistic<T>::Size; ++i)
    {
      Result += (double)SampleCache[i];
    }
    return (float)(Result / Degree);
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCArithmeticMeanTail<T>* NewInstance = new MCArithmeticMeanTail<T>(Degree, MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);
    if ((int)SampleCache.size() == MCSampleStatistic<T>::Size)
      SampleCache.erase(SampleCache.begin());

    SampleCache.push_back((float) value);
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(value);
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    SampleCache.clear();
  }

private:
  int Degree;
  std::vector<float> SampleCache;
};

template <typename T>
class MCWeightedArithmeticMean : public MCSampleStatistic<T>
{
public:
  /*
   * Create a weighted arithmetic mean statistic
   *
   * @param name Unique statistic name
   *
   */

  MCWeightedArithmeticMean(const std::string& name = "WeightedArithmeticMean") :
    MCSampleStatistic<T>(name), Result(0.0), Weights(0.0)
  { }
  virtual ~MCWeightedArithmeticMean() {}

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCFloatInfinity();

    return (float)(Result / Weights);
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCWeightedArithmeticMean<T>* NewInstance = new MCWeightedArithmeticMean<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);
    Result += (float)value*weight;
    Weights += weight;
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);
    Result -= (float)value*weight;
    Weights -= weight;
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    Weights = 0.0;
    Result = 0.0;
  }

private:
  double Result;
  double Weights;
};

template <typename T>
class MCDecreasinglyWeightedMean : public MCSampleStatistic<T>
{
public:
  /*
   * Create a decreasingly weighted mean statistic
   *
   * @param name Unique statistic name
   *
   */

  MCDecreasinglyWeightedMean(const std::string& name = "DecreasinglyWeightedMean") :
    MCSampleStatistic<T>(name)
  { }
  virtual ~MCDecreasinglyWeightedMean() {}

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCFloatInfinity();

    double Sum = 0.0;
    double WeightSum = 0.0;
    double OneThirdWeight { 1.0 / 3.0 };
    double TwoThirdWeight { 2.0 / 3.0 };
    const unsigned int OneThirdCount { (unsigned int)MCSampleStatistic<T>::Size / 3 };
    const unsigned int TwoThirdCount { (unsigned int)MCSampleStatistic<T>::Size*2 / 3 };

    foreach_i(i, sample, SampleCache)
    {
      if (i < OneThirdCount)
      {
        Sum += (double)(*sample)*OneThirdWeight;
        WeightSum += OneThirdWeight;
      } else
      if (i >= OneThirdCount && i < TwoThirdCount)
      {
        Sum += (double)(*sample)*TwoThirdWeight;
        WeightSum += TwoThirdWeight;
      } else
      if (i >= TwoThirdCount)
      {
        Sum += (double)(*sample);
        WeightSum += 1.0;
      }
    }
    return (float)Sum / WeightSum;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCDecreasinglyWeightedMean<T>* NewInstance = new MCDecreasinglyWeightedMean<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);
    if ((int)SampleCache.size() == MCSampleStatistic<T>::Size)
      SampleCache.erase(SampleCache.begin());

    SampleCache.push_back((float)value);
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(value);
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    SampleCache.clear();
  }

private:
  std::vector<float> SampleCache;  
};

template <typename T>
class MCHarmonicMean : public MCSampleStatistic<T>
{
public:
  /*
   * Create a harmonic mean statistic
   *
   * @param name Unique statistic name
   *
   */

  MCHarmonicMean(const std::string& name = "HarmonicMean") : MCSampleStatistic<T>(name), Result(0)
  { }
  virtual ~MCHarmonicMean() { }

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCFloatInfinity();

    return (float)((double)MCSampleStatistic<T>::Size / Result);
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCHarmonicMean<T>* NewInstance = new MCHarmonicMean<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);
    if (value == (T)0)
      return false;

    Result += (double)1.0 / value;
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);

    Result -= (double)1.0 / value;
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    Result = 0;
  }

private:
  double Result;
};

template <typename T>
class MCGeometricMean : public MCSampleStatistic<T>
{
public:
  /*
   * Create a geometric mean statistic
   *
   * @param name Unique statistic name
   *
   */

  MCGeometricMean(const std::string& name = "GeometricMean") : MCSampleStatistic<T>(name)
  { }
  virtual ~MCGeometricMean() {}

  virtual float GetResult() override
  {
    float Result = 1.0;

    for (auto& sample : SampleCache)
    {
      Result *= sample;
    }
    return Result;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCGeometricMean<T>* NewInstance = new MCGeometricMean<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);
    if (value <= (T)0.0)
      return false;

    if ((int)SampleCache.size() == MCSampleStatistic<T>::Size)
      SampleCache.erase(SampleCache.begin());

    SampleCache.push_back((float)pow((float)value, (float)1.0 / MCSampleStatistic<T>::Size));
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(value);
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    SampleCache.clear();
  }

private:
  std::vector<float> SampleCache;
};

template <typename T>
class MCQuartile : public MCSampleStatistic<T>
{
public:
  /*
   * Create a quartile-based statistic
   *
   * @param degree Degree-th quartile
   * @param name Unique statistic name
   *
   */

  MCQuartile(int degree, const std::string& name) : MCSampleStatistic<T>(name),
    Degree(MCBound(1, degree, 3)), DegreeMultiplier(Degree / 4.0)
  { }
  virtual ~MCQuartile() {}

  virtual void SetSize(int size) override
  {
    MCSampleStatistic<T>::SetSize(size);
    DegreeMultiplier = Degree / 4.0;
  }

  virtual float GetResult() override
  {
    if (unlikely(MCSampleStatistic<T>::Samples < 2))
      return MCFloatInfinity();
    if (unlikely(MCSampleStatistic<T>::Samples == 2))
    {
      auto FirstIter = List.begin();
      auto SecondIter = FirstIter++;

      return (*FirstIter+*SecondIter) / 2;
    }
    List.sort();

    auto Iter = List.begin();
    unsigned int i = 0;
    unsigned int ExpectedIndex { (unsigned int)((float)MCSampleStatistic<T>::Samples*DegreeMultiplier) };

    if (MCSampleStatistic<T>::Samples % 2 == 1)
    {
      for (; Iter != List.end(); ++Iter)
      {
        if (i == ExpectedIndex)
        {
          return (float)*Iter;
        }
        i++;
      }
    } else {
      for (; Iter != List.end(); ++Iter)
      {
        if (i+1 == ExpectedIndex)
        {
          T TempValue = *Iter;

          ++Iter;
          if (unlikely(Iter == List.end()))
          {
            return (float)TempValue;
          }
          return (float)(TempValue+*Iter) / 2;
        }
        i++;
      }
    }
    return MCFloatInfinity();
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);
    List.push_back(value);
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);

    for (auto Iter = List.begin(); Iter != List.end(); ++Iter)
    {
      if ((*Iter) == value)
      {
        List.erase(Iter);
        return;
      }
    }
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    List.clear();
  }

private:
  std::list<T> List;
  int Degree;
  float DegreeMultiplier;
};

template <typename T>
class MCFirstQuartile : public MCQuartile<T>
{
  friend class MCIqr<T>;
public:
  /*
   * Create a first quartile statistic
   *
   * @param name Unique statistic name
   *
   */

  MCFirstQuartile(const std::string& name = "FirstQuartile") : MCQuartile<T>(1, name)
  { }
  virtual ~MCFirstQuartile() {}

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCFirstQuartile<T>* NewInstance = new MCFirstQuartile<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }
};

template <typename T>
class MCMedian : public MCQuartile<T>
{
public:
  /*
   * Create a median statistic
   *
   * @param name Unique statistic name
   *
   */

  MCMedian(const std::string& name = "Median") : MCQuartile<T>(2, name)
  { }
  virtual ~MCMedian() {}

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCMedian<T>* NewInstance = new MCMedian<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }
};

template <typename T>
class MCThirdQuartile : public MCQuartile<T>
{
  friend class MCIqr<T>;
public:
  /*
   * Create a third quartile statistic
   *
   * @param name Unique statistic name
   *
   */

  MCThirdQuartile(const std::string& name = "ThirdQuartile") : MCQuartile<T>(3, name)
  { }
  virtual ~MCThirdQuartile() {}

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCThirdQuartile<T>* NewInstance = new MCThirdQuartile<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }
};

template <typename T>
class MCIqr : public MCSampleStatistic<T>
{
public:
  /*
   * Create an interquartile range statistic
   *
   * @param name Unique statistic name
   *
   */

  MCIqr(const std::string& name = "InterquartileRange") : MCSampleStatistic<T>(name), Fq(), Tq()
  { }
  virtual ~MCIqr() {}

  virtual void SetSize(int size) override
  {
    MCSampleStatistic<T>::SetSize(size);
    Fq.SetSize(size);
    Tq.SetSize(size);
  }

  virtual float GetResult() override
  {
    return Fq.GetResult()-Tq.GetResult();
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCIqr<T>* NewInstance = new MCIqr<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    Fq.AddValue(value, weight, prev_value, prev_weight);
    Tq.AddValue(value, weight, prev_value, prev_weight);
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    Fq.RemoveValue(value, weight, next_value, next_weight);
    Tq.RemoveValue(value, weight, next_value, next_weight);
  }

private:
  MCFirstQuartile<T> Fq;
  MCThirdQuartile<T> Tq;
};

template <typename T>
class MCStandardDeviation : public MCArithmeticMean<T>
{
public:
  /*
   * Create a standard deviation statistic
   *
   * @param name Unique statistic name
   *
   */

  MCStandardDeviation(const std::string& name = "StandardDeviation") : MCArithmeticMean<T>(name)
  { }
  virtual ~MCStandardDeviation() {}

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCFloatInfinity();

    float Mean { MCArithmeticMean<T>::GetResult() };
    float FinalResult = 0.0;

    for (int i = 0; i < MCSampleStatistic<T>::Size; ++i)
    {
      FinalResult += (MCSampleStatistic<T>::Storage[i]-Mean)*(MCSampleStatistic<T>::Storage[i]-Mean);
    }
    FinalResult /= (MCSampleStatistic<T>::Size-1);
    FinalResult = sqrt(FinalResult);
    return FinalResult;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCStandardDeviation<T>* NewInstance = new MCStandardDeviation<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }
};

template <typename T>
class MCMinimum : public MCSampleStatistic<T>
{
public:
  /*
   * Create a minimum statistic
   *
   * @param name Unique statistic name
   *
   */

  MCMinimum(const std::string& name = "Minimum") : MCSampleStatistic<T>(name), Result(MCFloatInfinity())
  { }
  virtual ~MCMinimum() {}

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCFloatInfinity();

    return Result;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCMinimum<T>* NewInstance = new MCMinimum<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);
    if (unlikely(MCIsDoubleInfinity(Result)))
    {
      // Recalculate the minimum value if needed
      if (likely(MCSampleStatistic<T>::Valid))
      {
        Result = MCSampleStatistic<T>::Storage[0];
        for (int i = 1; i < MCSampleStatistic<T>::Size; ++i)
        {
          Result = MCMin((double)MCSampleStatistic<T>::Storage[i], Result);
        }
      } else
        // Initial setting of the minimal value
        Result = value;
    } else {
      Result = MCMin(Result, (double)value);
    }
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);
    // Invalidate the current minimum
    if (unlikely(value == Result))
    {
      Result = MCDoubleInfinity();
    }
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    Result = MCFloatInfinity();
  }

private:
  double Result;
};

template <typename T>
class MCMaximum : public MCSampleStatistic<T>
{
public:
  /*
   * Create a maximum statistic
   *
   * @param name Unique statistic name
   *
   */

  MCMaximum(const std::string& name = "Maximum") : MCSampleStatistic<T>(name), Result(MCFloatInfinity())
  { }
  virtual ~MCMaximum() {}

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCFloatInfinity();

    return Result;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCMaximum<T>* NewInstance = new MCMaximum<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);
    if (unlikely(MCIsDoubleInfinity(Result)))
    {
      // Recalculate the maximum value if needed
      if (likely(MCSampleStatistic<T>::Valid))
      {
        Result = MCSampleStatistic<T>::Storage[0];
        for (int i = 1; i < MCSampleStatistic<T>::Size; ++i)
        {
          Result = MCMax((double)MCSampleStatistic<T>::Storage[i], Result);
        }
      } else
        // Initial setting of the minimal value
        Result = value;
    } else {
      Result = MCMax(Result, (double)value);
    }
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);
    // Invalidate the current maximum
    if (unlikely(value == Result))
    {
      Result = MCDoubleInfinity();
    }
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    Result = MCDoubleInfinity();
  }

private:
  double Result;
};

template <typename T>
class MCSquareSum : public MCSampleStatistic<T>
{
public:
  /*
   * Create a square sum statistic
   *
   * @param name Unique statistic name
   *
   */

  MCSquareSum(const std::string& name = "SquareSum") : MCSampleStatistic<T>(name), Result(0.0)
  { }
  virtual ~MCSquareSum() {}

  virtual float GetResult() override
  {
    if (unlikely(MCSampleStatistic<T>::Samples == 0))
    {
      return MCFloatInfinity();
    }
    return Result;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCSquareSum<T>* NewInstance = new MCSquareSum<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);
    Result += (double)value*value;
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);
    Result -= (double)value*value;
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    Result = 0.0;
  }

protected:
  double Result;
};


template <typename T>
class MCLogarithmicSquareSum : public MCSquareSum<T>
{
public:
  /*
   * Create a logarithmic square sum statistic
   *
   * @param name Unique statistic name
   *
   */

  MCLogarithmicSquareSum(const std::string& name = "LogarithmicSquareSum") : MCSquareSum<T>(name)
  { }
  virtual ~MCLogarithmicSquareSum() { }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCLogarithmicSquareSum<T>* NewInstance = new MCLogarithmicSquareSum<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_value);
    MC_UNUSED(prev_weight);
    MCSquareSum<T>::Result += log((double)value*value);
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);
    MCSquareSum<T>::Result -= log((double)value*value);
  }
};

template <typename T>
class MCRootMeanSquare : public MCSquareSum<T>
{
public:
  /*
   * Create a root mean square statistic
   *
   * @param name Unique statistic name
   *
   */

  MCRootMeanSquare(const std::string& name = "RootMeanSquare") : MCSquareSum<T>(name)
  { }
  virtual ~MCRootMeanSquare() {}

  virtual float GetResult() override
  {
    if (unlikely(MCSampleStatistic<T>::Samples == 0))
    {
      return MCFloatInfinity();
    }
    return sqrt(MCSquareSum<T>::GetResult() / MCSampleStatistic<T>::Samples);
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCSquareSum<T>* NewInstance = new MCRootMeanSquare<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }
};

template <typename T>
class MCPower : public MCSquareSum<T>
{
public:
  /*
   * Create a power statistic for signals
   *
   * @param name Unique statistic name
   *
   */

  MCPower(const std::string& name = "Power") : MCSquareSum<T>(name)
  { }
  virtual ~MCPower() {}

  virtual float GetResult() override
  {
    if (unlikely(MCSampleStatistic<T>::Samples == 0))
    {
      return MCFloatInfinity();
    }
    return MCSquareSum<T>::GetResult() / MCSampleStatistic<T>::Samples;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCPower<T>* NewInstance = new MCPower<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }
};

template <typename T>
class MCRootCounter : public MCSampleStatistic<T>
{
public:
  /*
   * Create a root counter statistic
   *
   * @param name Unique statistic name
   *
   */

  MCRootCounter(const std::string& name = "RootCounter") : MCSampleStatistic<T>(name), Result(0)
  { }
  virtual ~MCRootCounter() {}

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCFloatInfinity();

    return (float)Result;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCRootCounter<T>* NewInstance = new MCRootCounter<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    if (MCIsFloatInfinity(prev_weight))
      return true;

    if ((value > (T)0 && prev_value < (T)0) ||
        (value < (T)0 && prev_value > (T)0) ||
        value == (T)0)
    {
      Result++;
    }
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(next_weight);
    if ((value > (T)0 && next_value < (T)0) ||
        (value < (T)0 && next_value > (T)0) ||
        value == (T)0)
    {
      Result--;
    }
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    Result = 0;
  }

private:
  int Result;
};

template <typename T>
class MCValueRangeCounter : public MCSampleStatistic<T>
{
public:
  /*
   * Create a value range counter statistic
   *
   * @param range_lower_limit Lower limit of the range
   * @param range_upper_limit Upper limit of the range
   * @param name Unique statistic name
   *
   * The statistic counts the values falling into a range in a series.
   *
   */

  MCValueRangeCounter(float range_lower_limit, float range_upper_limit,
                      const std::string& name = "ValueRangeCounter") :
    MCSampleStatistic<T>(name), Result(0), RangeLowerLimit(MCMin(range_lower_limit, range_upper_limit)),
    RangeUpperLimit(MCMax(range_lower_limit, range_upper_limit))
  { }
  virtual ~MCValueRangeCounter() {}

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCFloatInfinity();

    return (float)Result;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCValueRangeCounter<T>* NewInstance = new MCValueRangeCounter<T>(RangeLowerLimit, RangeUpperLimit,
                                                                     MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(prev_value);
    MC_UNUSED(weight);
    MC_UNUSED(prev_weight);
    if ((float)value > RangeLowerLimit && (float)value < RangeUpperLimit)
    {
      Result++;
    }
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(next_value);
    MC_UNUSED(next_weight);
    if ((float)value > RangeLowerLimit && (float)value < RangeUpperLimit)
    {
      Result--;
    }
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    Result = 0;
  }

private:
  int Result;
  float RangeLowerLimit;
  float RangeUpperLimit;
};

template <typename T>
class MCValueChangeCounter : public MCSampleStatistic<T>
{
public:
  /*
   * Create a value change counter statistic
   *
   * @param name Unique statistic name
   *
   * The statistic sums the absolute difference between neighbor values in a series.
   *
   */

  MCValueChangeCounter(const std::string& name = "ValueChangeCounter") : MCSampleStatistic<T>(name),
    Result(MCFloatInfinity())
  { }
  virtual ~MCValueChangeCounter() {}

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCDoubleInfinity();

    return (float)Result;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCValueChangeCounter<T>* NewInstance = new MCValueChangeCounter<T>(MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_weight);
    if (unlikely(MCIsDoubleInfinity(Result)))
    {
      Result = MCAbs(prev_value-value);
    } else {
      Result += MCAbs(prev_value-value);
    }
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(next_weight);
    Result -= MCAbs(next_value-value);
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    Result = MCDoubleInfinity();
  }

private:
  double Result;
};

template <typename T>
class MCValueTrendCounter : public MCSampleStatistic<T>
{
public:
  /*
   * Create a value trend counter statistic
   *
   * @param positive_trend Whether it counts the positive (increasing) trend
   * @param name Unique statistic name
   *
   * The statistic can count the increasing or decreasing trends of a value series,
   * but the intervals are skipped when the value stagnates (it does not change).
   *
   */

  MCValueTrendCounter(bool positive_trend, const std::string& name = "ValueTrendCounter") :
    MCSampleStatistic<T>(name), PositiveTrend(positive_trend), Result(0.0)
  { }
  virtual ~MCValueTrendCounter() {}

  virtual float GetResult() override
  {
    if (unlikely(!MCSampleStatistic<T>::Valid))
      return MCDoubleInfinity();

    return (float)Result;
  }

  virtual MCSampleStatistic<T>* Clone() override
  {
    MCValueTrendCounter<T>* NewInstance = new MCValueTrendCounter<T>(PositiveTrend, MCSampleStatistic<T>::Name);

    *NewInstance = *this;
    return NewInstance;
  }

  virtual bool Add(const T value, const float weight, const T prev_value,
                   const float prev_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(prev_weight);
    if (PositiveTrend && prev_value-value > 0)
      Result++;
    if (!PositiveTrend && prev_value-value < 0)
      Result++;
    return true;
  }

  virtual void Remove(const T value, const float weight, const T next_value,
                      const float next_weight) override
  {
    MC_UNUSED(weight);
    MC_UNUSED(next_weight);
    if (PositiveTrend && value-next_value > 0)
      Result--;
    if (!PositiveTrend && value-next_value < 0)
      Result--;
  }

  virtual void Reset() override
  {
    MCSampleStatistic<T>::Reset();
    Result = 0.0;
  }

private:
  bool PositiveTrend;
  double Result;
};

template <typename T>
float MCCalculateVectorStatistic(const std::vector<T>& vector, MCSampleStatistic<T>& statistic)
{
  if (vector.size() < 2)
  {
    MC_WARNING("Vector size must be at least 2 for statistics calculations (%d)", vector.size());
    return MCFloatInfinity();
  }
  MCSamples<T> VectorSamples(vector.size(), statistic);

  VectorSamples << vector;
  return statistic.GetResult();
}

template <typename T>
float MCCalculateTableStatistic(const std::vector<std::vector<T> >& table, MCSampleStatistic<T>& statistic)
{
  if (!MCIsConsistentTable(table))
  {
    MC_WARNING("The table is not consistent for statistics calculations");
    return MCFloatInfinity();
  }
  MCSamples<T> Samples(table.size()*table[0].size(), statistic);

  for (auto& row : table)
    Samples << row;

  return statistic.GetResult();
}

template <typename T>
float MCCalculateColumnStatInTable(const std::vector<std::vector<T> >& table, int column,
                                   MCSampleStatistic<T>& statistic)
{
  MCSamples<T> ColumnSamples(table.size(), statistic);
  int ColumnIndex = MCBound(0, column, (int)table.size()-1);

  for (auto& row : table)
  {
    ColumnSamples << row[ColumnIndex];
  }
  return statistic.GetResult();
}

template <typename T, typename U >
MC::FloatList MCCalculateColumnStatsInTable(const std::vector<std::vector<T> >& table)
{
  MC::FloatList Results;

  for (unsigned int i = 0; i < table[0].size(); ++i)
  {
    Results.push_back(MCCalculateColumnStatInTable(table, i, *new U));
  }
  return Results;
}

template <typename T>
float MCCalculateDiagonalStatInTable(const std::vector<std::vector<T> >& table,
                                     MCSampleStatistic<T>& statistic, bool topleft_to_rightbottom = true)
{
  if (table.empty())
    return 0.0;
  if (!MCIsConsistentTable(table) || table.size() != table[0].size())
  {
    MC_WARNING("Table is not consistent or squared to calculate statistics.");
    return 0.0;
  }
  MCSamples<T> DiagonalSamples(table.size(), statistic);

  for (unsigned int i = 0; i < table.size(); ++i)
  {
    const int Index = topleft_to_rightbottom ? i : (table.size()-i-1);

    DiagonalSamples << table[Index][Index];
  }
  return statistic.GetResult();
}