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};
    _OPPDEPRECATED typedef Mode HistogramMode;

  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);

    const std::vector<double>& getBinEdges() const {return binEdges;} // one more than values

    const std::vector<double>& getBinValues() const {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);

    _OPPDEPRECATED virtual void setRangeAuto(int numPrecollect=100, double rangeExtensionFactor=2.0);

    _OPPDEPRECATED virtual void setRangeAutoLower(double upper, int numPrecollect=100, double rangeExtensionFactor=2.0);

    _OPPDEPRECATED virtual void setRangeAutoUpper(double lower, int numPrecollect=100, double rangeExtensionFactor=2.0);

    _OPPDEPRECATED virtual void setNumCells(int numCells) final {setNumBinsHint(numCells);}

    _OPPDEPRECATED virtual void setCellSize(double d) final {setBinSizeHint(d);}
};

}  // namespace omnetpp

#endif