cksplit.h

//==========================================================================
//  CKSPLIT.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//
//  Declaration of the following classes:
//    cKSplit : implements the k-split algorithm in 1 dimension
//
//  Author: Babak Fakhamzadeh, TU Delft, Mar-Jun 1996;
//  Rewritten by Andras Varga
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2008 Andras Varga
  Copyright (C) 2006-2008 OpenSim Ltd.

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

#ifndef __CKSPLIT_H
#define __CKSPLIT_H

#include "cdensityestbase.h"

NAMESPACE_BEGIN


class SIM_API cKSplit : public cDensityEstBase
{
  public:
    enum { K = 2 };

    struct Grid
    {
      int parent;      
      int reldepth;    
      long total;      
      int mother;      
      int 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 num_cells;            // number of cells

    Grid *gridv;              // grid vector
    int gridv_size;           // size of gridv[]+1
    int rootgrid, lastgrid;   // indices into gridv[]
    bool rangeext_enabled;    // 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 getBasepoint(), getCellValue() etc.
    mutable long iter_num_vals; // num_vals when iterator was created

  private:
    void copy(const cKSplit& other);

  protected:
    // internal:
    void resetGrids(int grid);

    // internal:
    void createRootGrid();

    // internal:
    void newRootGrids(double x);

    // internal:
    void insertIntoGrids(double x, int enable_splits);

    // internal:
    void splitCell(int grid, int cell);

    // internal:
    void distributeMotherObservations(int grid);

    // internal:
    void expandGridVector();

    // internal: helper for getBasepoint(), getCellValue()
    void iteratorToCell(int cell_nr) const;

    // abstract method in cDensityEstBase
    virtual void doMergeCellValues(const cDensityEstBase *other);

  public:

    cKSplit(const cKSplit& r);

    explicit cKSplit(const char *name=NULL);

    virtual ~cKSplit();

    cKSplit& operator=(const cKSplit& res);


    virtual cKSplit *dup() const  {return new cKSplit (*this);}

    virtual std::string detailedInfo() const;

    virtual void parsimPack(cCommBuffer *buffer);

    virtual void parsimUnpack(cCommBuffer *buffer);

  protected:
    virtual void collectTransformed(double val);

  public:

    virtual void transform();

    virtual int getNumCells() const;

    virtual double getBasepoint(int k) const;

    virtual double getCellValue(int k) const;

    virtual double getPDF(double x) const;

    virtual double getCDF(double x) const;

    virtual void merge(const cStatistic *other);

    virtual double random() const;

    virtual void saveToFile(FILE *) const;

    virtual void loadFromFile(FILE *);


    void setCritFunc(CritFunc _critfunc, double *_critdata);

    void setDivFunc(DivFunc _divfunc, double *_divdata);

    void rangeExtension(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[rootgrid];}
};


// 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_END


#endif