chistogram.h

//==========================================================================
//  CHISTOGRAM.H - part of
//
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//
//  Declaration of the following classes:
//    cHistogramBase        : common base class for histogram classes
//      cHistogram          : equi-distant histogram
//        cLongHistogram    : long int distribution
//        cDoubleHistogram  : double distribution
//
//==========================================================================

/*--------------------------------------------------------------*
  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 __CHISTOGRAM_H
#define __CHISTOGRAM_H

#include "cdensityestbase.h"

NAMESPACE_BEGIN


class SIM_API cHistogramBase : public cDensityEstBase
{
  protected:
    int num_cells;        // nr. of categories
    unsigned *cellv;      // array of counters

  private:
    void copy(const cHistogramBase& other);

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

  public:

    cHistogramBase(const cHistogramBase& r) : cDensityEstBase(r) {cellv=NULL;copy(r);}

    cHistogramBase(const char *name, int numcells);

    virtual ~cHistogramBase();

    cHistogramBase& operator=(const cHistogramBase& res);


    /* No dup() because this is an abstract class. */

    virtual void parsimPack(cCommBuffer *buffer);

    virtual void parsimUnpack(cCommBuffer *buffer);


    virtual void clearResult();

    virtual void transform();

    virtual int getNumCells() const;

    virtual void saveToFile(FILE *) const;

    virtual void loadFromFile(FILE *);

    virtual void setNumCells(int numcells);
};


class SIM_API cHistogram : public cHistogramBase
{
  public:
    enum Mode {MODE_AUTO, MODE_INTEGERS, MODE_DOUBLES};

  protected:
    Mode mode;
    double cellsize;  // cell/category sizes; <=0 if unset

  private:
    void copy(const cHistogram& other);

  protected:
    virtual void setupRangeInteger();
    virtual void setupRangeDouble();
    virtual void getAttributesToRecord(opp_string_map& attributes);

  public:

    cHistogram(const cHistogram& r) : cHistogramBase(r) {copy(r);}

    explicit cHistogram(const char *name=NULL, int numcells=-1, Mode mode=MODE_AUTO);

    cHistogram& operator=(const cHistogram& res);


    /* No dup() because this is an abstract class. */

    virtual void parsimPack(cCommBuffer *buffer);

    virtual void parsimUnpack(cCommBuffer *buffer);

  protected:
    virtual void collectTransformed(double value);

    virtual void setupRange();

  public:

    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 double random() const;

    virtual void saveToFile(FILE *) const;

    virtual void loadFromFile(FILE *);

    virtual void setMode(Mode mode);

    virtual Mode getMode() const {return mode;}

    virtual void setCellSize(double d);

    virtual double getCellSize() const {return cellsize;}

};


class SIM_API cLongHistogram : public cHistogram
{
  private:
    void copy(const cLongHistogram& other) {}

  public:
    cLongHistogram(const cLongHistogram& r) : cHistogram(r) {copy(r);}

    explicit cLongHistogram(const char *name=NULL, int numcells=-1) :
        cHistogram(name, numcells, MODE_INTEGERS) {}

    virtual ~cLongHistogram() {}

    cLongHistogram& operator=(const cLongHistogram& other);


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

  public:

    virtual void collect(double value) {cHistogram::collect(floor(value));}

    virtual void collect(SimTime value) {collect(value.dbl());}
};


class SIM_API cDoubleHistogram : public cHistogram
{
  private:
    void copy(const cDoubleHistogram& other) {}

  public:

    cDoubleHistogram(const cDoubleHistogram& r) : cHistogram(r) {copy(r);}

    explicit cDoubleHistogram(const char *name=NULL, int numcells=-1) :
        cHistogram(name, numcells, MODE_DOUBLES) {}

    virtual ~cDoubleHistogram() {}

    cDoubleHistogram& operator=(const cDoubleHistogram& other);


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

NAMESPACE_END


#endif