chistogramstrategy.h

//==========================================================================
//  CHISTOGRAMSTRATEGY.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_CHISTOGRAMSTRATEGY_H
#define __OMNETPP_CHISTOGRAMSTRATEGY_H

#include <omnetpp/chistogram.h>

namespace omnetpp {

class SIM_API cIHistogramStrategy : public cObject
{
    friend class cHistogram;
  public:
    typedef enum cHistogram::Mode Mode;

  protected:
    cHistogram *hist = nullptr; // backreference to "owner"

  public:
    cIHistogramStrategy() {}
    cIHistogramStrategy(const cIHistogramStrategy& other) {}
    cIHistogramStrategy& operator=(const cIHistogramStrategy& other) {hist=nullptr; return *this;}

    void setHistogram(cHistogram *hist);

    cHistogram *getHistogram() const {return hist;}

    virtual void collect(double value) = 0;

    virtual void collectWeighted(double value, double weight) = 0;

    virtual void setUpBins() = 0;

    virtual void clear() = 0;
};

class SIM_API cFixedRangeHistogramStrategy : public cIHistogramStrategy
{
  protected:
    double lo = NAN;
    double hi = NAN;
    int numBins = -1;
    Mode mode = cHistogram::MODE_REALS; // may not be AUTO

  private:
    void copy(const cFixedRangeHistogramStrategy& other);

  public:
    cFixedRangeHistogramStrategy() {} // must be configured using setter methods
    cFixedRangeHistogramStrategy(double lo, double hi, int numBins, Mode mode=cHistogram::MODE_REALS) :
        lo(lo), hi(hi), numBins(numBins), mode(mode) {}
    cFixedRangeHistogramStrategy(const cFixedRangeHistogramStrategy& other): cIHistogramStrategy(other) {copy(other);}
    cFixedRangeHistogramStrategy& operator=(const cFixedRangeHistogramStrategy& other);
    virtual cFixedRangeHistogramStrategy *dup() const override {return new cFixedRangeHistogramStrategy(*this);}

    void setRange(double lo, double hi) {this->lo = lo; this->hi = hi;}
    double getUpperLimit() const {return hi;}
    void setUpperLimit(double hi) {this->hi = hi;}
    double getLowerLimit() const {return lo;}
    void setLowerLimit(double lo) {this->lo = lo;}
    Mode getMode() const {return mode;}
    void setMode(Mode mode) {this->mode = mode;}
    double getBinSize() const {return numBins;}
    void setBinSize(double binSize) {this->numBins = binSize;}

    virtual void collect(double value) override;
    virtual void collectWeighted(double value, double weight) override;
    virtual void setUpBins() override;
    virtual void clear() override {}
};

class SIM_API cPrecollectionBasedHistogramStrategy : public cIHistogramStrategy
{
  protected:
    bool inPrecollection = true;
    size_t numToPrecollect = 1000;
    size_t numToCollate = 10;
    double lastRange = NAN;
    int rangeUnchangedCounter = 0;
    int rangeUnchangedThreshold = 50;
    double finiteMinValue = NAN, finiteMaxValue = NAN; // have to keep track separate from cStdDev, ignoring infs
    std::vector<double> values;
    std::vector<double> weights; // same size as values[]

  protected:
    virtual void moveValuesIntoHistogram();
    virtual bool precollect(double value, double weight=1.0); // true: precollection over
    virtual void createBins() = 0;

  private:
    void copy(const cPrecollectionBasedHistogramStrategy& other);

  public:
    cPrecollectionBasedHistogramStrategy() {}
    cPrecollectionBasedHistogramStrategy(const cPrecollectionBasedHistogramStrategy& other): cIHistogramStrategy(other) {copy(other);}
    cPrecollectionBasedHistogramStrategy& operator=(const cPrecollectionBasedHistogramStrategy& other);

    int getNumToPrecollect() const {return numToPrecollect;}
    void setNumToPrecollect(int numToPrecollect) {this->numToPrecollect = numToPrecollect;}
    int getNumToCollate() const {return numToCollate;}
    void setNumToCollate(int numToCollate) {this->numToCollate = numToCollate;}
    int getRangeUnchangedThreshold() const {return rangeUnchangedThreshold;}
    void setRangeUnchangedThreshold(int threshold) {this->rangeUnchangedThreshold = threshold;}

    virtual void setUpBins() override;
    virtual void clear() override;
};

class SIM_API cDefaultHistogramStrategy : public cPrecollectionBasedHistogramStrategy
{
  private:
    static const int DEFAULT_NUM_BINS = 60; // a number with many divisors
    double rangeExtensionFactor = 1.5;
    double binSize = NAN;
    int numBinsHint = -1;
    int targetNumBins = DEFAULT_NUM_BINS;
    Mode mode = cHistogram::MODE_AUTO;
    bool autoExtend = true;
    bool binMerging = true;
    int maxNumBins = 1000;

  protected:
    virtual void createBins() override;
    virtual void extendBinsTo(double value);
    virtual void reduceNumBinsTo(int numBins);
    virtual void mergeAllBinsIntoOne(double newApproxBinSize);

  private:
    void copy(const cDefaultHistogramStrategy& other);

  public:
    explicit cDefaultHistogramStrategy(int numBinsHint=-1, Mode mode=cHistogram::MODE_AUTO) : numBinsHint(numBinsHint), mode(mode) {}
    cDefaultHistogramStrategy(const cDefaultHistogramStrategy& other): cPrecollectionBasedHistogramStrategy(other) {copy(other);}
    cDefaultHistogramStrategy& operator=(const cDefaultHistogramStrategy& other);
    virtual cDefaultHistogramStrategy *dup() const override {return new cDefaultHistogramStrategy(*this);}

    int getNumBinsHint() const {return numBinsHint;}
    void setNumBinsHint(int numBins) {this->numBinsHint = numBins;}

    virtual void collect(double value) override;
    virtual void collectWeighted(double value, double weight) override;
    virtual void clear() override {cPrecollectionBasedHistogramStrategy::clear();}
};

class SIM_API cAutoRangeHistogramStrategy : public cPrecollectionBasedHistogramStrategy
{
  private:
    static const int DEFAULT_NUM_BINS = 60; // a number with many divisors
    double lo = NAN;  // range lower limit; use NaN for unspecified
    double hi = NAN;  // range upper limit; use NaN for unspecified
    double rangeExtensionFactor = 1.5;
    int numBinsHint = -1;
    int targetNumBins = DEFAULT_NUM_BINS;
    double requestedBinSize = NAN; // user-given
    double binSize = NAN; // actual (computed)
    Mode mode = cHistogram::MODE_AUTO;
    bool binSizeRounding = true;
    bool autoExtend = true;
    bool binMerging = true;
    int maxNumBins = 1000;

  protected:
    virtual void createBins() override;
    virtual void extendBinsTo(double value);
    virtual void reduceNumBinsTo(int numBins);
    virtual void mergeAllBinsIntoOne(double newApproxBinSize);

  private:
    void copy(const cAutoRangeHistogramStrategy& other);

  public:
    explicit cAutoRangeHistogramStrategy(Mode mode=cHistogram::MODE_AUTO) : mode(mode) {}
    explicit cAutoRangeHistogramStrategy(int numBins, Mode mode=cHistogram::MODE_AUTO) : numBinsHint(numBins), mode(mode) {}
    cAutoRangeHistogramStrategy(const cAutoRangeHistogramStrategy& other): cPrecollectionBasedHistogramStrategy(other) {copy(other);}
    cAutoRangeHistogramStrategy& operator=(const cAutoRangeHistogramStrategy& other);
    virtual cAutoRangeHistogramStrategy *dup() const override {return new cAutoRangeHistogramStrategy(*this);}

    void setRangeHint(double lo, double hi) {this->lo = lo; this->hi = hi;}  
    double getUpperLimitHint() const {return hi;}
    void setUpperLimitHint(double hi) {this->hi = hi;}
    double getLowerLimitHint() const {return lo;}
    void setLowerLimitHint(double lo) {this->lo = lo;}
    double getRangeExtensionFactor() const {return rangeExtensionFactor;}
    void setRangeExtensionFactor(double rangeExtensionFactor) {this->rangeExtensionFactor = rangeExtensionFactor;}
    Mode getMode() const {return mode;}
    void setMode(Mode mode) {this->mode = mode;}
    double getBinSizeHint() const {return requestedBinSize;}
    void setBinSizeHint(double binSize) {this->requestedBinSize = binSize;}
    bool getBinSizeRounding() const {return binSizeRounding;}
    void setBinSizeRounding(bool binSizeRounding) {this->binSizeRounding = binSizeRounding;}
    int getNumBinsHint() const {return numBinsHint;}
    void setNumBinsHint(int numBins) {this->numBinsHint = numBins;}
    void setAutoExtend(bool enable) {this->autoExtend = enable;}
    bool getAutoExtend() const {return autoExtend;}
    void setBinMerging(bool enable) {this->binMerging = enable;}
    bool getBinMerging() const {return binMerging;}
    int getMaxNumBins() const {return maxNumBins;}
    void setMaxNumBins(int numBins) {this->maxNumBins = numBins;}

    virtual void collect(double value) override;
    virtual void collectWeighted(double value, double weight) override;
    virtual void clear() override;
};

}  // namespace omnetpp


#endif