StatisticAccumulator.hh

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#ifndef HH_SENF_Utils_StatisticAccumulator_
#define HH_SENF_Utils_StatisticAccumulator_ 1

// Custom includes
#include <math.h>
#include <iosfwd>
#include <boost/operators.hpp>
#include <boost/property_tree/json_parser.hpp>

namespace senf {

     struct StatisticsData
        : public boost::less_than_comparable<StatisticsData>
     {
         StatisticsData();
         StatisticsData(float min_, float avg_, float max_, float stddev_, unsigned cnt_);
         StatisticsData(float singleValue);

         void clear();

         explicit operator bool() const;
         bool operator<(StatisticsData const & other) const;

         boost::property_tree::ptree asPTree() const;

         float min;
         float avg;
         float max;
         float stddev;
         unsigned cnt;
     };

     std::ostream & operator<<(std::ostream & os, StatisticsData const & _data);


    template <class T>
    class StatisticAccumulator
    {
    public:
        StatisticAccumulator(); 
        StatisticAccumulator(T const & value); 
        StatisticAccumulator(T const & sum, T const & sumSquared, T const & min, T const & max, unsigned count);
        StatisticAccumulator(senf::StatisticsData const & data);

        void clear();                   

        void accumulate(T const & value); 

        T     min() const;              

        T     max() const;              

        T     sum() const;              

        T     sum2() const;             

        float avg() const;              

        float rms() const;              

        float stddev() const;           

        unsigned count() const;         

         void data(StatisticsData & data_) const;

        StatisticsData data() const;    

        explicit operator bool() const; 

        StatisticAccumulator<T> operator +=(StatisticAccumulator<T> const & other);
        StatisticAccumulator<T> operator*=(const float & scale);
        
    private:
        T sum_;
        T sum_squared_;
        T min_;
        T max_;
        unsigned cnt_;
    };

    template <class T>
    class StatisticsEWMA
        : public boost::less_than_comparable<StatisticsEWMA<T>>
    {
    public:
        StatisticsEWMA(float alpha = 0.25f, T const & value = T());
        
        void clear(T const & value = T()); 

        void accumulate(T const & value);   
        void accumulateWithLoss(T const & value, unsigned numLost); 

        bool operator<(StatisticsEWMA<T> const & other) const;
        
        explicit operator bool() const;     

        unsigned count() const;             

        T const & ewma() const;

        float const & alpha() const;
        
    private:
        T ewma_;
        float alpha_;
        unsigned cnt_;
    };
  
}

#include "StatisticAccumulator.cci"
#include "StatisticAccumulator.ct"
#include "StatisticAccumulator.cti"
#endif