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: Babak Fakhamzadeh, TU Delft, Mar-Jun 1996;
//  Rewritten by Andras Varga

#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, double *);

    typedef double (*DivFunc)(const cKSplit&, cKSplit::Grid&, double, 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
    double *critData;         // data array to pass to crit. function

    DivFunc divFunc;          // function to calc. lambda for cell division
    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, double *);
int critfunc_depth(const cKSplit&, cKSplit::Grid&, int, double *);

// cell division criteria
double divfunc_const(const cKSplit&, cKSplit::Grid&, double, double *);
double divfunc_babak(const cKSplit&, cKSplit::Grid&, double, double *);


}  // namespace omnetpp


#endif