Average.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_core_util_Average_hpp
#define anna_core_util_Average_hpp

#include <anna/core/util/Millisecond.hpp>
#include <anna/core//util/DelayMeter.hpp>
#include <anna/core/functions.hpp>

namespace anna {

template <class T> class Average {
public:
  Average(const char* name, const char* measure = NULL) :
    a_name(name), a_accumulator(0), a_n(0), a_measure(measure) {;}

  bool isEmpty() const   { return (a_n == 0); }

  bool isZero() const { return a_n == 0 || a_accumulator == 0; }

  int size() const { return a_n; }

  T getAccumulator() const { return a_accumulator; }

  T value() const { return (isEmpty() == true) ? T(0) : (a_accumulator / a_n);  }

  void clear() {  a_accumulator = 0; a_n = 0; }

  void setValue(const T& value, const unsigned int _n) {
    a_accumulator = value;
    a_n = _n;
  }

  operator T() const { return value(); }

  Average<T>& operator = (const T value)
  {
    a_accumulator = value;
    a_n = 1;
    return *this;
  }

  Average<T>& operator = (const Average<T>& other)
  {
    a_accumulator = other.a_accumulator;
    a_n = other.a_n;
    return *this;
  }

  Average<T>& operator += (const T& v)
  {
    const T backup(a_accumulator);

    if((a_accumulator += v) < backup) {
      a_accumulator = v;
      a_n = 1;
    } else
      a_n ++;

    return *this;
  }

  Average<T>& operator -= (const T v)
  {
    if(a_accumulator > v && a_n > 1) {
      a_accumulator -= v;
      a_n --;
    } else {
      a_accumulator = 0;
      a_n = 0;
    }

    return *this;
  }

  std::string asString() const
  {
    std::string msg(a_name);
    msg += " { Accumulate: ";
    msg += functions::asString(a_accumulator);

    if(a_measure != NULL)
      msg += " " + std::string(a_measure);

    msg += functions::asString(" | N: %u | avg: ", a_n);
    msg += functions::asString(value());

    if(a_measure != NULL)
      msg += " " + std::string(a_measure);

    return msg += " }";
  }

private:
  const char* a_name;
  const char* a_measure;
  T a_accumulator;
  unsigned int a_n;
};

}

#endif