Accumulator.h

#ifndef ACCUMULATOR_H
#define ACCUMULATOR_H
 
/*
 * Copyright (c) 2013      Christoph Niethammer <christoph.niethammer@gmail.com>
 */
 
#include <algorithm>
#include "utils/mardyn_assert.h"
#include <cmath>
#include <cstdlib>
 
 
template <typename T>
class Accumulator {
public:
    Accumulator(size_t windowLength = 100) : _windowLength(windowLength), _insertPosition(0), _size(0) {
        _data = new T[windowLength];
    }
    ~Accumulator(){
        delete[] _data;
    }
 
    T getAverage() {
        T sum = 0;
        for( size_t i = 0; i < _size; i++ ) {
            sum += _data[i];
        }
        return sum / _size;
    }
 
    T getStddev() {
        T avg = getAverage();
        T stddev = 0;
        for( size_t i = 0; i < _size; i++ ) {
            T diff = _data[i] - avg;
            stddev += diff*diff;
        }
        stddev /= getSize();
        stddev = sqrt(stddev);
        return stddev;
    }
 
    T getPercentile(double p) {
        T *sorted_data = new T[_size];
        std::copy(_data, _data + _size, sorted_data);
        std::sort(sorted_data, sorted_data + _size);
        T retValue = sorted_data[static_cast<size_t>(_size * p) - 1];
        delete[] sorted_data;
        return retValue;
    }
 
    T getInterPercentileRange(double pmin, double pmax) {
        T *sorted_data = new T[_size];
        std::copy(_data, _data + _size, sorted_data);
        std::sort(sorted_data, sorted_data + _size);
        T qmin = sorted_data[static_cast<size_t>(_size * pmin) - 1];
        T qmax = sorted_data[static_cast<size_t>(_size * pmax) - 1];
        T retValue = qmax - qmin;
        delete[] sorted_data;
        return retValue;
    }
 
    void addEntry(T value) {
        _data[_insertPosition] = value;
        _insertPosition = (_insertPosition + 1) % _windowLength;
        if (_size < _windowLength)
            _size += 1;
    }
 
    T getLastEntry() {
        return getEntry(1);
    }
 
    T getEntry(size_t id) {
        mardyn_assert(0 < id && id <= _windowLength);
        return _data[(_insertPosition + _windowLength - id) % _windowLength];
    }
 
    size_t getWindowLength() {
        return _windowLength;
    }
 
    size_t getSize() {
        return _size;
    }
 
private:
    size_t _windowLength;   
    size_t _insertPosition; 
    size_t _size;           
    T *_data;               
};
 
#endif /* ACCUMULATOR_H */