StatisticAccumulator.ct

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
//


/** \file
    \brief StatisticAccumulator non-inline template implementation  */

// Custom includes
#include <algorithm>
#include <limits>

#define prefix_
///////////////////////////////ct.p////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
// senf::StatisticAccumulator<T>

template <class T>
prefix_ senf::StatisticAccumulator<T>::StatisticAccumulator(T const & value)
    : sum_(0), sum_squared_(0), min_( std::numeric_limits<T>::max()), max_( std::numeric_limits<T>::lowest()), cnt_(0)
{
    accumulate(value);
}

template <class T>
prefix_ senf::StatisticAccumulator<T>::StatisticAccumulator()
    : sum_(0), sum_squared_(0), min_( std::numeric_limits<T>::max()), max_( std::numeric_limits<T>::lowest()), cnt_(0)
{}

template <class T>
prefix_ senf::StatisticAccumulator<T>::StatisticAccumulator(T const & sum, T const & sumSquared, T const & min, T const & max, unsigned count)
    : sum_(sum), sum_squared_(sumSquared), min_(min), max_(max), cnt_(count) 
{}

template <class T>
prefix_ senf::StatisticAccumulator<T>::StatisticAccumulator(senf::StatisticsData const & data)
    : sum_(T(data.avg) * data.cnt), sum_squared_(T(data.avg * data.avg) * data.cnt), min_(T(data.min)), max_(T(data.max)), cnt_(data.cnt)
{}


template <class T>
prefix_ float senf::StatisticAccumulator<T>::stddev()
    const
{
    if (cnt_ == 0)
        return NAN;
    if (cnt_ == 1)
        return 0.0f;
    float _avg (avg());
    // std::max avoid rounding errors, that might cause a sqrt(<0)
    return sqrtf(std::max(0.0f, (float(sum_squared_) / float( cnt_) - (_avg * _avg) )));
}

template <class T>
prefix_ void senf::StatisticAccumulator<T>::clear()
{
    cnt_ = 0;
    sum_squared_ = 0;
    sum_ = 0;
    min_ = std::numeric_limits<T>::max();
    max_ = std::numeric_limits<T>::lowest();  
}

template <class T>
prefix_ void senf::StatisticAccumulator<T>::data(StatisticsData & data_)
    const
{
    if (cnt_ == 0) {
        data_.min = data_.avg = data_.max = NAN;
        data_.stddev = NAN;
        data_.cnt = 0;
    } else {
        data_.min = (float) min_;
        data_.avg = avg();
        data_.max = (float) max_;
        data_.stddev = stddev();
        data_.cnt = cnt_;
    }
}

template <class T>
prefix_ senf::StatisticsData senf::StatisticAccumulator<T>::data()
    const
{
    StatisticsData tmp;
    data(tmp);
    return tmp;
}

template <class T>
prefix_ senf::StatisticAccumulator<T> senf::StatisticAccumulator<T>::operator+=(senf::StatisticAccumulator<T> const & other)
{
    if (other.cnt_ > 0) {
        if (cnt_ == 0) {
            this->sum_ = other.sum_;
            this->sum_squared_ = other.sum_squared_;
            this->cnt_ = other.cnt_;
            this->min_ = other.min_;
            this->max_ = other.max_;
        } else {
            this->sum_ += other.sum_;
            this->sum_squared_ += other.sum_squared_;
            this->cnt_ += other.cnt_;
            this->min_ = std::min(min_,other.min_);
            this->max_ = std::max(max_,other.max_);
        }
    }
    return *this;
}

template <class T>
prefix_ senf::StatisticAccumulator<T> senf::StatisticAccumulator<T>::operator*=(const float & scale)
{
    if (cnt_ > 0) {
        this->sum_ *= scale;
        this->sum_squared_ *= scale * scale;
        this->min_ *= scale;
        this->max_ *= scale;
    }

    return *this;
}

//
// EWMA
//

template <class T>
prefix_ senf::StatisticsEWMA<T>::StatisticsEWMA(float alpha, T const & value)
    : ewma_(value),
      alpha_(alpha),
      cnt_(0)
{
}

template <class T>
prefix_ void senf::StatisticsEWMA<T>::clear(T const & value)
{
    ewma_ = value;
    cnt_ = 0;
}


///////////////////////////////ct.e////////////////////////////////////////
#undef prefix_