cksplit.h

//==========================================================================
//  CKSPLIT.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.
*--------------------------------------------------------------*/
 
//  Author: Andras Varga, based on code of Babak Fakhamzadeh, TU Delft, Mar-Jun 1996;
 
#ifndef __OMNETPP_CKSPLIT_H
#define __OMNETPP_CKSPLIT_H
 
#include "cprecolldensityest.h"
 
namespace omnetpp {
 
 
class SIM_API cKSplit : public cPrecollectionBasedDensityEst
{
  public:
    // K is the grid size of the algorithm. It must be 2, or a >=3 odd number.
    enum { K = 2 };
 
    struct Grid
    {
      int parent;      
      int reldepth;    
      double total;    
      double mother;   
      double cells[K]; 
    };
 
    typedef int (*CritFunc)(const cKSplit&, cKSplit::Grid&, int, const double *);
 
    typedef double (*DivFunc)(const cKSplit&, cKSplit::Grid&, double, const double *);
 
    class Iterator
    {
      private:
        cKSplit *ks;             // host object
        int cellnum;             // global index of current cell
        int grid, cell;          // root index in gridv[], cell index in grid.cell[]
        double gridmin;          // left edge of current grid
        double cellsize;         // cell width on current grid
 
        // internal
        void dive(int where);
 
      public:
        Iterator(const cKSplit& ksplit, bool atbeginning=true);
 
        void init(const cKSplit& ksplit, bool atbeginning=true);
 
        void operator++(int);
 
        void operator--(int);
 
        bool end() const  {return grid==0;}
 
        int getCellNumber() const  {return cellnum;}
 
        double getCellMin() const  {return gridmin+cell*cellsize;}
 
        double getCellMax() const  {return gridmin+(cell+1)*cellsize;}
 
        double getCellSize() const  {return cellsize;}
 
        double getCellValue() const;
    };
 
    friend class Iterator;
 
  protected:
    int numCells;             // number of cells
 
    Grid *gridv;              // grid vector
    int gridvSize;            // size of gridv[]+1
    int rootGridIndex, lastGridIndex;   // indices into gridv[]
    bool rangeExtEnabled;     // enable/disable range extension
 
    CritFunc critFunc;        // function that determines when to split a cell
    const double *critData;   // data array to pass to crit. function
 
    DivFunc divFunc;          // function to calc. lambda for cell division
    const double *divData;    // data array to pass to div. function
 
    mutable Iterator *iter;   // iterator used by getBinEdge(), getBinValue() etc.
    mutable long iterNumValues; // numValues when iterator was created
 
  private:
    void copy(const cKSplit& other);
 
  protected:
    // internal:
    void resetGrids(int grid);
 
    // internal:
    void createRootGrid();
 
    // internal:
    void newRootGrids(double value, double weight);
 
    // internal:
    void insertIntoGrids(double value, double weight, int enableSplits);
 
    // internal:
    void splitCell(int grid, int cell);
 
    // internal:
    void distributeMotherObservations(int grid);
 
    // internal:
    void expandGridVector();
 
    // internal: helper for getBinEdge(), getBinValue()
    void iteratorToCell(int cell_nr) const;
 
    // abstract method in cPrecollectionBasedDensityEst
    virtual void doMergeBinValues(const cPrecollectionBasedDensityEst *other) override;
 
  public:
 
    explicit cKSplit(const char *name=nullptr, bool weighted=false);
 
    cKSplit(const cKSplit& r);
 
    virtual ~cKSplit();
 
    cKSplit& operator=(const cKSplit& res);
 
 
    virtual cKSplit *dup() const override  {return new cKSplit (*this);}
 
    virtual void parsimPack(cCommBuffer *buffer) const override;
 
    virtual void parsimUnpack(cCommBuffer *buffer) override;
 
  protected:
    virtual void collectIntoHistogram(double val) override;
 
    virtual void collectWeightedIntoHistogram(double value, double weight) override;
 
  public:
 
    virtual void setUpBins() override;
 
    virtual int getNumBins() const override;
 
    virtual double getBinEdge(int k) const override;
 
    virtual double getBinValue(int k) const override;
 
    virtual void merge(const cStatistic *other) override;
 
    virtual void clear() override;
 
    virtual void saveToFile(FILE *) const override;
 
    virtual void loadFromFile(FILE *) override;
 
 
    void setCritFunc(CritFunc _critfunc, double *_critdata);
 
    void setDivFunc(DivFunc _divfunc, double *_divdata);
 
    void setRangeExtension(bool enabled);
 
 
    int getTreeDepth() const;
 
    int getTreeDepth(Grid& grid) const;
 
    double getRealCellValue(Grid& grid, int cell) const;
 
    void printGrids() const;
 
    Grid& getGrid(int k) const {return gridv[k];}
 
    Grid& getRootGrid() const {return gridv[rootGridIndex];}
};
 
 
// cell split criteria
int critfunc_const(const cKSplit&, cKSplit::Grid&, int, const double *);
int critfunc_depth(const cKSplit&, cKSplit::Grid&, int, const double *);
 
// cell division criteria
double divfunc_const(const cKSplit&, cKSplit::Grid&, double, const double *);
double divfunc_babak(const cKSplit&, cKSplit::Grid&, double, const double *);
 
 
}  // namespace omnetpp
 
 
#endif