Accumulator.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_statistics_Accumulator_hpp
#define anna_statistics_Accumulator_hpp

#include <anna/core/RuntimeException.hpp>
#include <anna/core/functions.hpp>

// Standard
#include <string>

namespace anna {
namespace xml {
class Node;
}
}


namespace anna {

namespace statistics {


class Operation {
public:

  enum Type {
    //Sum = 0, // is not very useful
    Average,
    StandardDeviation,
    BesselStandardDeviation, //This correction (the use of N - 1 instead of N) is known as Bessel's correction
    Minimum,
    Maximum
  };
};

typedef struct {

  unsigned long long Size;                           // Sample size
  double Sum;                                        // Accumulated sum
  double SquareSum;                                  // Accumulated sum of square values
  double Average;                                    // Current average
  //double SquareSumSampleDeviation;                   // Current total sum for square deviation items;
  double MinimumProcessed;                           // Minimum value processed
  double MaximumProcessed;                           // Maximum value processed
  anna::Millisecond MinimumEventTimestampMs;       // Timestamp (ms) for minimum event
  anna::Millisecond MaximumEventTimestampMs;       // Timestamp (ms) for maximum event
  anna::Millisecond LastResetEventTimestampMs;     // Timestamp (ms) for last statistics reset


  void reset() {
    Size = (unsigned long long)0;
    Sum = (double)0;
    SquareSum = (double)0;
    Average = (double)0;
    //SquareSumSampleDeviation = (double)0;
    MinimumProcessed = (double)0;
    MaximumProcessed = (double)0;
    MinimumEventTimestampMs = (anna::Millisecond)0;
    MaximumEventTimestampMs = (anna::Millisecond)0;
    LastResetEventTimestampMs = anna::Millisecond::getTime();
  }

} _concept_data_t;

typedef std::map <int, _concept_data_t> _concept_data_map_t;
typedef std::map <int, _concept_data_t>::const_iterator _concept_data_map_iter;




//------------------------------------------------------------------------------
//------------------------------------------------------------ class Accumulator
//------------------------------------------------------------------------------
class Accumulator {

  std::string a_name;

  void initialize(const int & conceptId) ;
  _concept_data_t * getConcept(const int & conceptId) const noexcept(false);
  // Gets the data structure for a existing concept Id.
  // Initializes and returns the new data structure for a new stored concept Id which is valid (exists for the engine).
  // Launch exception if concept id is not a valid concept registered at Engine.

  /*mutable */_concept_data_map_t a_concept_data_map;

  std::string floatFormat(const int & numberOfDecimals) const ;

  double getStandardDeviation(const _concept_data_t * conceptData) const noexcept(false);
  double getBesselStandardDeviation(const _concept_data_t * conceptData) const noexcept(false);


public:

  Accumulator(const std::string &name) : a_name(name) {};

  ~Accumulator() {;}


  void setName(const std::string &name) { a_name = name; }

  int addConcept(const std::string & description, const std::string & unit, const bool & integerNatureSample = true, const char *conceptNameFormat = "%s [%s]") ;

  void process(const int & conceptId, const double & value) noexcept(false);


  void reset(void) ;


  void reset(const int & conceptId) noexcept(false);


  const Accumulator & operator = (const Accumulator & accumulator);



  // Gets

  const std::string &getName() const { return a_name; }

  unsigned long long int sampleSize(const int & conceptId) const noexcept(false);


  double getValue(const int & conceptId, const Operation::Type & operation) const noexcept(false);


  std::string asString(const int & numberOfDecimals = 2) const ;


  anna::xml::Node* asXML(anna::xml::Node* parent, const int & numberOfDecimals = 2) const ;
};

}
}

#endif