chistogram.h

//==========================================================================
//  CHISTOGRAM.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================
 
/*--------------------------------------------------------------*
  Copyright (C) 1992-2017 Andras Varga
  Copyright (C) 2006-2017 OpenSim Ltd.
 
  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/
 
#ifndef __OMNETPP_CHISTOGRAM_H
#define __OMNETPP_CHISTOGRAM_H
 
#include <climits>
#include "cabstracthistogram.h"
 
namespace omnetpp {
 
class cIHistogramStrategy;
class cAutoRangeHistogramStrategy;
 
class SIM_API cHistogram : public cAbstractHistogram
{
  public:
    enum Mode {MODE_AUTO, MODE_INTEGERS, MODE_REALS, MODE_DOUBLES /*deprecated*/ = MODE_REALS};
 
  protected:
    cIHistogramStrategy *strategy = nullptr; // owned
 
    std::vector<double> binEdges;
    std::vector<double> binValues; // one less than bin edges
    double finiteUnderflowSumWeights = 0, finiteOverflowSumWeights = 0;
    double posInfSumWeights = 0, negInfSumWeights = 0;
 
  public:
    // INTERNAL, only for cIHistogramSetupStrategy implementations.
    // Directly collects the value into the existing bins, without delegating to the strategy object
    virtual void collectIntoHistogram(double value, double weight=1);
    void dump() const; // for debugging
    void assertSanity();
 
  private:
    void copy(const cHistogram& other);
    cAutoRangeHistogramStrategy *getOrCreateAutoRangeStrategy() const;
 
  public:
 
    explicit cHistogram(const char *name=nullptr, bool weighted=false);
 
    explicit cHistogram(const char *name, int numBinsHint, bool weighted=false);
 
    explicit cHistogram(const char *name, cIHistogramStrategy *strategy, bool weighted=false);
 
    cHistogram(const cHistogram& other): cAbstractHistogram(other) {copy(other);}
 
    cHistogram& operator=(const cHistogram& other);
 
    virtual ~cHistogram();
 
 
    virtual cHistogram *dup() const override {return new cHistogram(*this);}
 
    virtual void parsimPack(cCommBuffer *buffer) const override;
 
    virtual void parsimUnpack(cCommBuffer *buffer) override;
 
 
    virtual void collect(double value) override;
    using cAbstractHistogram::collect;
 
    virtual void collectWeighted(double value, double weight) override;
    using cAbstractHistogram::collectWeighted;
 
    virtual void clear() override;
 
    virtual void saveToFile(FILE *f) const override;
 
    virtual void loadFromFile(FILE *f) override;
 
    virtual void merge(const cStatistic *other) override;
 
 
    void setStrategy(cIHistogramStrategy *strategy);
 
    cIHistogramStrategy *getStrategy() const {return strategy;}
 
    virtual bool binsAlreadySetUp() const override;
 
    virtual void setUpBins() override;
 
    virtual void setBinEdges(const std::vector<double>& edges);
 
    virtual void createUniformBins(double lo, double hi, double step);
 
    virtual void prependBins(const std::vector<double>& edges);
 
    virtual void appendBins(const std::vector<double>& edges);
 
    virtual void extendBinsTo(double value, double step, int maxNumBins=INT_MAX); // TODO: remove default value for maxNumBins
 
    virtual void mergeBins(int groupSize);
 
    virtual std::vector<double> getBinEdges() const override {return binEdges;}
 
    virtual std::vector<double> getBinValues() const override {return binValues;}
 
    virtual int getNumBins() const override {return binValues.size();}
 
    virtual double getBinEdge(int k) const override {return binEdges.at(k);}
 
    virtual double getBinValue(int k) const override {return binValues.at(k);}
 
    virtual double getUnderflowSumWeights() const override {return finiteUnderflowSumWeights + negInfSumWeights;}
 
    virtual double getOverflowSumWeights() const override {return finiteOverflowSumWeights + posInfSumWeights;}
 
    virtual int64_t getNumUnderflows() const override;
 
    virtual int64_t getNumOverflows() const override;
 
    virtual int64_t getNumNegInfs() const override;
 
    virtual int64_t getNumPosInfs() const override;
 
    virtual double getNegInfSumWeights() const override {return negInfSumWeights;}
 
    virtual double getPosInfSumWeights() const override {return posInfSumWeights;}
 
    virtual void setMode(Mode mode);
 
    virtual void setRange(double lower, double upper);
 
    virtual void setNumPrecollectedValues(int numPrecollect);
 
    virtual void setRangeExtensionFactor(double rangeExtensionFactor);
 
    virtual void setAutoExtend(bool autoExtend);
 
    virtual void setNumBinsHint(int numCells);
 
    virtual void setBinSizeHint(double d);
};
 
}  // namespace omnetpp
 
#endif