cprecolldensityest.h

//==========================================================================
//  CPRECOLLDENSITYEST.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_CPRECOLLDENSITYEST_H
#define __OMNETPP_CPRECOLLDENSITYEST_H
 
#include "cabstracthistogram.h"
 
namespace omnetpp {
 
class SIM_API cPrecollectionBasedDensityEst : public cAbstractHistogram
{
  public:
    enum RangeMode {
        RANGE_AUTO,      // automatic range setup, using precollected values and range extension (the default)
        RANGE_AUTOLOWER, // like RANGE_AUTO, but upper limit is fixed
        RANGE_AUTOUPPER, // like RANGE_AUTO, but lower limit is fixed
        RANGE_FIXED,     // fixed range (lower, upper)
        RANGE_NOTSET     // not set, but it is OK (not used)
    };
 
  protected:
    // we can precollect observations to automatically determine the range before histogram bins are set up
    bool transformed = false;   // whether precollected values have been transformed into a histogram
    double *precollectedValues = nullptr;
    double *precollectedWeights = nullptr; // nullptr for unweighted
    int numPrecollected = 100;
 
    // range for distribution density collection
    RangeMode rangeMode = RANGE_AUTO;
    double rangeExtFactor = 2.0;    // we extend the range of precollected values by rangeExtFactor
    double rangeMin = 0, rangeMax = 0;
    double finiteMinValue = NAN, finiteMaxValue = NAN;
 
    // variables for counting out-of-range observations
    int64_t numFiniteUnderflows = 0;
    int64_t numFiniteOverflows = 0;
    int64_t numNegInfs = 0;
    int64_t numPosInfs = 0;
    double finiteUnderflowSumWeights = 0;
    double finiteOverflowSumWeights = 0;
    double negInfSumWeights = 0;
    double posInfSumWeights = 0;
 
  private:
    void copy(const cPrecollectionBasedDensityEst& other);
 
  protected:
    // part of merge(); to be implemented in subclasses
    virtual void doMergeBinValues(const cPrecollectionBasedDensityEst *other) = 0;
 
  public:
 
    cPrecollectionBasedDensityEst(const cPrecollectionBasedDensityEst& other) : cAbstractHistogram(other) {copy(other);}
 
    explicit cPrecollectionBasedDensityEst(const char *name=nullptr, bool weighted=false);
 
    virtual ~cPrecollectionBasedDensityEst();
 
    cPrecollectionBasedDensityEst& operator=(const cPrecollectionBasedDensityEst& res);
 
 
    /* No dup() because this is an abstract class. */
 
    virtual void parsimPack(cCommBuffer *buffer) const override;
 
    virtual void parsimUnpack(cCommBuffer *buffer) override;
 
 
    virtual void collect(double value) override;
    using cStatistic::collect;
 
    virtual void collectWeighted(double value, double weight) override;
    using cStatistic::collectWeighted;
 
    virtual void merge(const cStatistic *other) override;
 
    virtual void clear() override;
 
    virtual void saveToFile(FILE *) const override;
 
    virtual void loadFromFile(FILE *) override;
 
 
    virtual void setRange(double lower, double upper);
 
    virtual void setRangeAuto(int numPrecollect=100, double rangeExtensionFactor=2.0);
 
    virtual void setRangeAutoLower(double upper, int numPrecollect=100, double rangeExtensionFactor=2.0);
 
    virtual void setRangeAutoUpper(double lower, int numPrecollect=100, double rangeExtensionFactor=2.0);
 
    virtual void setNumPrecollectedValues(int numPrecollect);
 
    virtual int getNumPrecollectedValues() const {return numPrecollected;}
 
    virtual double getRangeExtensionFactor() const {return rangeExtFactor;}
 
  protected:
    virtual void setupRange();
 
    virtual void collectIntoHistogram(double value) = 0;
 
    virtual void collectWeightedIntoHistogram(double value, double weight) = 0;
 
  public:
    virtual bool binsAlreadySetUp() const override {return transformed;}
 
    virtual int64_t getNumUnderflows() const override {return numFiniteUnderflows + numNegInfs;}
 
    virtual int64_t getNumOverflows() const override {return numFiniteOverflows + numPosInfs;}
 
    virtual double getUnderflowSumWeights() const override {return finiteUnderflowSumWeights + negInfSumWeights;}
 
    virtual double getOverflowSumWeights() const override {return finiteOverflowSumWeights + posInfSumWeights;}
 
    virtual int64_t getNumNegInfs() const override {return numNegInfs;}
 
    virtual int64_t getNumPosInfs() const override {return numPosInfs;}
 
    virtual double getNegInfSumWeights() const override {return negInfSumWeights;}
 
    virtual double getPosInfSumWeights() const override {return posInfSumWeights;}
};
 
}  // namespace omnetpp
 
 
#endif