cdetect.h

//=========================================================================
//  CDETECT.H - part of
//
//                  OMNeT++/OMNEST
//           Discrete System Simulation in C++
//
//         File designed and written by the Hollandiaba Team
//
//   Class declarations:
//     cTransientDetection :  virtual base class for transient detection
//     cAccuracyDetection  :  virtual base class for result accuracy detection
//
//     cTDExpandingWindows :  an algorithm for transient detection
//     cADByStddev         :  an algorithm for result accuracy detection
//
//   Bugfixes: Andras Varga, Oct.1996
//=========================================================================

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

#include "cownedobject.h"
#include "cstatistic.h"

NAMESPACE_BEGIN


class cStatistic;

typedef void (*PostTDFunc)(cTransientDetection *, void *);

typedef void (*PostADFunc)(cAccuracyDetection *, void *);


class SIM_API cTransientDetection : public cOwnedObject
{
  protected:
    cStatistic *back;    // ptr to cStatistic that uses this object
    PostTDFunc pdf;      // function to call after detection
    void *pdfdata;       // data for PostDetectFunct

  public:
    explicit cTransientDetection(const char *name=NULL) : cOwnedObject(name) {}

    virtual ~cTransientDetection()  {}

    virtual cTransientDetection *dup() const {copyNotSupported(); return NULL;}

    /* Note: no dup() because this is an abstract class. */


    virtual void collect(double val) = 0;

    virtual bool detected() const = 0;

    virtual void reset() = 0;

    virtual void stop() = 0;

    virtual void start() = 0;

    void setPostDetectFunction(PostTDFunc f, void *p) {pdf = f; pdfdata = p;}


    virtual void setHostObject(cStatistic *ptr)  {back = ptr;}

    virtual cStatistic *getHostObject() const  {return back;}
};


//----

class SIM_API cAccuracyDetection : public cOwnedObject
{
  protected:
    cStatistic *back;           // ptr to cStatistic that uses this object
    PostADFunc pdf;             // function to call after detection
    void *pdfdata;              // data for PostDetectFunc

  public:
    explicit cAccuracyDetection(const char *name=NULL) : cOwnedObject(name)  {}

    virtual ~cAccuracyDetection()  {}

    virtual cAccuracyDetection *dup() const {copyNotSupported(); return NULL;}


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


    virtual void collect(double val) = 0;

    virtual bool detected() const = 0;

    virtual void reset() = 0;

    virtual void stop() = 0;

    virtual void start() = 0;

    void setPostDetectFunction(PostADFunc f, void *p) {pdf=f; pdfdata=p;}


    virtual void setHostObject(cStatistic *ptr)  {back = ptr;}

    virtual cStatistic *getHostObject() const  {return back;}
};

//----

class SIM_API cTDExpandingWindows : public cTransientDetection
{
  private:
    bool go;                  // collect & detect
    bool transval;            // value of the last detection
    double accuracy;          // accuracy for detection
    int minwinds;             // minimum windows size
    double windexp;           // window expansion factor
    int repeats;              // repetitions necessary for detection
    int detreps;              // number of detections in a row
    int size;                 // number of collected values
    struct xy {double x; double y; xy *next;};
    xy *func;                 // structure of collected values

  private:
    // internal: computes new value of transval
    void detectTransient();

    void copy(const cTDExpandingWindows& other);

  public:

    cTDExpandingWindows(const cTDExpandingWindows& r);

    explicit cTDExpandingWindows(const char *name=NULL,
                        int reps=3, int minw=4, double wind=1.3, double acc=0.3,
                        PostTDFunc f=NULL,void *p=NULL);

    virtual ~cTDExpandingWindows();

    cTDExpandingWindows& operator=(const cTDExpandingWindows& res);


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


    virtual void collect(double val);

    virtual bool detected() const {return transval;}

    virtual void reset();

    virtual void stop()      {go = false;}

    virtual void start()     {go = true;}

    void setParameters(int reps=3, int minw=4,
                       double wind=1.3, double acc=0.3);
};


//----

class SIM_API cADByStddev : public cAccuracyDetection
{
  private:
    bool go;                    // start collecting if true
    bool resaccval;             // value of the last detection
    double accuracy;            // minimum needed for detection
    long int sctr;              // counter
    double ssum,sqrsum;         // sum, square sum;
    int repeats, detreps;       // repetitions necessary for detection

  private:
    void copy(const cADByStddev& other);

    // internal: compute new value of transval
    void detectAccuracy();

    // internal: compute the standard deviation
    double getStddev() const;

  public:

    cADByStddev(const cADByStddev& r);

    explicit cADByStddev(const char *name=NULL,
                         double acc=0.01, int reps=3,
                         PostADFunc f=NULL, void *p=NULL);

    virtual ~cADByStddev()  {}

    cADByStddev& operator=(const cADByStddev& res);


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


    virtual void collect(double val);

    virtual bool detected() const {return resaccval;}

    virtual void reset();

    virtual void stop()   {go=false;}

    virtual void start()  {go=true;}


    void setParameters(double acc=0.1, int reps=3)
        {accuracy=acc; repeats=detreps=reps;}
};

NAMESPACE_END


#endif