// $Source: /usr/local/SimSoft/SoftShop/NewSimC/Zufall.h,v $
// $Revision: 1.14 $
// $Author: baum $
// $Date: 2001/11/29 15:52:23 $
//
// Login name of the user who locked the revision
// $Locker:  $
// Tag name used to checkout the file
// $Name: Release-20 $
// State assigned to revision
// $State: Exp $
//
//
// $Log: Zufall.h,v $
// Revision 1.14  2001/11/29 15:52:23  baum
// -In Kalender.cpp und Kalender.h Handsteuerung eingebaut
//

#ifndef _ZUFALL_H
#define _ZUFALL_H     1

#include "Token.h"

#ifdef _ZUFALL_CPP
#  undef _impexp
#  define _impexp __declspec(dllexport)
#elif defined BUILD_NEWSIMC_DLL
#  undef _impexp
#  define _impexp 
#else
#  undef _impexp
#  define _impexp __declspec(dllimport)
#endif

#if defined __GNUC__ || defined __hpux
#  undef _impexp
#  define _impexp
#endif

class _impexp Verteilung {
public:
  static Verteilung* erzeugen (unsigned Art);
  virtual ~Verteilung ();
  virtual double NeueZahl () = 0;
  virtual void lesen (InputFile& file) = 0;
  int round (double);

protected:
  Verteilung () {};
  double ranreal (unsigned& startzahl); 

private:
  Verteilung (const Verteilung&);
  Verteilung& operator = (const Verteilung&);
};

class _impexp RealExplizit : public Verteilung {
public :
  RealExplizit ();
  virtual ~RealExplizit ();
  virtual double NeueZahl ();
  virtual void lesen (InputFile& file);

protected :
  double ObjWert;

private:
  RealExplizit (const RealExplizit&);
  RealExplizit& operator = (const RealExplizit&);
};

class _impexp IntExplizit : public RealExplizit {
public :
  IntExplizit ();
  virtual ~IntExplizit ();
  virtual double NeueZahl ();

private:
  IntExplizit (const IntExplizit&);
  IntExplizit& operator = (const IntExplizit&);
};

class _impexp RealGleich : public Verteilung {
public :
  RealGleich ();
  virtual ~RealGleich ();
  virtual double NeueZahl ();
  virtual void lesen (InputFile& file);

protected :
  double ObjMin, ObjMax;
  unsigned ObjStartzahl;

private:
  RealGleich (const RealGleich&);
  RealGleich& operator = (const RealGleich&);
};

class _impexp IntGleich : public RealGleich {
public :
  IntGleich ();
  virtual ~IntGleich ();
  virtual double NeueZahl ();
  virtual void lesen (InputFile& file);

private:
  IntGleich (const IntGleich&);
  IntGleich& operator = (const IntGleich&);
};

class _impexp RealExp : public Verteilung {
public :
  RealExp ();
  virtual ~RealExp ();
  virtual double NeueZahl ();
  virtual void lesen (InputFile& file);

protected :
  double ObjErwartungswert;
  unsigned ObjStartzahl;

private:
  RealExp (const RealExp&);
  RealExp& operator = (const RealExp&);
};

class _impexp RealExpMitGrenze : public RealExp {
public :
  RealExpMitGrenze ();
  virtual ~RealExpMitGrenze ();
  virtual double NeueZahl ();
  virtual void lesen (InputFile& file);

protected :
  double ObjMin, ObjMax;

private:
  RealExpMitGrenze (const RealExpMitGrenze&);
  RealExpMitGrenze& operator = (const RealExpMitGrenze&);
};

class _impexp RealExpMitGrenzeNeuziehen : public RealExpMitGrenze {
public :
  RealExpMitGrenzeNeuziehen ();
  /**< Neuer Konstruktor um aus der C-Schnittstelle neue Prozesse zu erzeugen **/
  RealExpMitGrenzeNeuziehen (float min, float mittel, float max, int startzahl);
  virtual ~RealExpMitGrenzeNeuziehen ();
  virtual double NeueZahl ();

private:
  RealExpMitGrenzeNeuziehen (const RealExpMitGrenzeNeuziehen&);
  RealExpMitGrenzeNeuziehen& operator=(const RealExpMitGrenzeNeuziehen&);
};

class _impexp IntExp : public RealExp {
public :
  IntExp ();
  virtual ~IntExp ();
  virtual double NeueZahl ();

private:
  IntExp (const IntExp&);
  IntExp& operator = (const IntExp&);
};

class _impexp IntExpMitGrenze : public IntExp {
public :
  IntExpMitGrenze ();
  virtual ~IntExpMitGrenze ();
  virtual double NeueZahl ();
  virtual void lesen (InputFile& file);

protected :
  int ObjMin, ObjMax;

private:
  IntExpMitGrenze (const IntExpMitGrenze&);
  IntExpMitGrenze& operator = (const IntExpMitGrenze&);
};

class _impexp IntExpMitGrenzeNeuziehen : public IntExpMitGrenze {
public :
  IntExpMitGrenzeNeuziehen ();
  virtual ~IntExpMitGrenzeNeuziehen ();
  virtual double NeueZahl ();

private:
  IntExpMitGrenzeNeuziehen (const IntExpMitGrenzeNeuziehen&);
  IntExpMitGrenzeNeuziehen& operator = (const IntExpMitGrenzeNeuziehen&);
};

class _impexp RealGauss : public Verteilung {
public :
  RealGauss ();
  virtual ~RealGauss ();
  virtual double NeueZahl ();
  virtual void lesen (InputFile& file);
  
protected :
  double ObjMittel, ObjAbweichung;
  unsigned ObjStartzahl;

private:
  RealGauss (const RealGauss&);
  RealGauss& operator = (const RealGauss&);
};

class _impexp RealGaussMitGrenze : public RealGauss {
public :
  RealGaussMitGrenze ();
  virtual ~RealGaussMitGrenze ();
  virtual double NeueZahl ();
  virtual void lesen (InputFile& file);

protected :
  double ObjMin, ObjMax;

private:
  RealGaussMitGrenze (const RealGaussMitGrenze&);
  RealGaussMitGrenze& operator = (const RealGaussMitGrenze&);
};

class _impexp RealGaussMitGrenzeNeuziehen : public RealGaussMitGrenze {
public :
  RealGaussMitGrenzeNeuziehen ();
  virtual ~RealGaussMitGrenzeNeuziehen ();
  virtual double NeueZahl ();

private:
  RealGaussMitGrenzeNeuziehen (const RealGaussMitGrenzeNeuziehen&);
  RealGaussMitGrenzeNeuziehen& operator = 
                                 (const RealGaussMitGrenzeNeuziehen&);
};

class _impexp IntGauss : public RealGauss {
public :
  IntGauss ();
  virtual ~IntGauss ();
  virtual double NeueZahl ();

private:
  IntGauss (const IntGauss&);
  IntGauss& operator = (const IntGauss&);
};


class _impexp IntGaussMitGrenze : public IntGauss {
public :
  IntGaussMitGrenze ();
  virtual ~IntGaussMitGrenze ();
  virtual double NeueZahl ();
  virtual void lesen (InputFile& file);

protected :
  int ObjMin, ObjMax;

private:
  IntGaussMitGrenze (const IntGaussMitGrenze&);
  IntGaussMitGrenze& operator = (const IntGaussMitGrenze&);
};

class _impexp IntGaussMitGrenzeNeuziehen : public IntGaussMitGrenze {
public :
  IntGaussMitGrenzeNeuziehen ();
  virtual ~IntGaussMitGrenzeNeuziehen ();
  virtual double NeueZahl ();

private:
  IntGaussMitGrenzeNeuziehen (const IntGaussMitGrenzeNeuziehen&);
  IntGaussMitGrenzeNeuziehen& operator = 
                                (const IntGaussMitGrenzeNeuziehen&);
};

class _impexp RealErlang : public Verteilung {
public :
  RealErlang ();
  virtual ~RealErlang ();
  virtual double NeueZahl ();
  virtual void lesen (InputFile& file);
  
protected :
  double ObjErwartungswert;
  int ObjK;
  unsigned ObjStartzahl;

private:
  RealErlang (const RealErlang&);
  RealErlang& operator = (const RealErlang&);
};

class _impexp RealErlangMitGrenze : public RealErlang {
public :
  RealErlangMitGrenze ();
  virtual ~RealErlangMitGrenze ();
  virtual double NeueZahl ();
  virtual void lesen (InputFile& file);

protected :
  double ObjMin, ObjMax;

private:
  RealErlangMitGrenze (const RealErlangMitGrenze&);
  RealErlangMitGrenze& operator = (const RealErlangMitGrenze&);
};

class _impexp RealErlangMitGrenzeNeuziehen : public RealErlangMitGrenze {
public :
  RealErlangMitGrenzeNeuziehen ();
  virtual ~RealErlangMitGrenzeNeuziehen ();
  virtual double NeueZahl ();

private:
  RealErlangMitGrenzeNeuziehen (const RealErlangMitGrenzeNeuziehen&);
  RealErlangMitGrenzeNeuziehen& operator = 
                                  (const RealErlangMitGrenzeNeuziehen&);
};

class _impexp IntErlang : public RealErlang {
public :
  IntErlang ();
  virtual ~IntErlang ();
  virtual double NeueZahl ();

private:
  IntErlang (const IntErlang&);
  IntErlang& operator = (const IntErlang&);
};

class _impexp IntErlangMitGrenze : public IntErlang {
public :
  IntErlangMitGrenze ();
  virtual ~IntErlangMitGrenze ();
  virtual double NeueZahl ();
  virtual void lesen (InputFile& file);

protected :
  int ObjMin, ObjMax;

private:
  IntErlangMitGrenze (const IntErlangMitGrenze&);
  IntErlangMitGrenze& operator = (const IntErlangMitGrenze&);
};

class _impexp IntErlangMitGrenzeNeuziehen : public IntErlangMitGrenze {
public :
  IntErlangMitGrenzeNeuziehen ();
  virtual ~IntErlangMitGrenzeNeuziehen ();
  virtual double NeueZahl ();

private:
  IntErlangMitGrenzeNeuziehen (const IntErlangMitGrenzeNeuziehen&);
  IntErlangMitGrenzeNeuziehen& operator = 
                                 (const IntErlangMitGrenzeNeuziehen&);
};

class _impexp IntPoisson : public Verteilung {
public :
  IntPoisson ();
  virtual ~IntPoisson ();
  virtual double NeueZahl ();
  virtual void lesen (InputFile& file);

protected :
  int ObjMittel;
  unsigned ObjStartzahl;

private:
  IntPoisson (const IntPoisson&);
  IntPoisson& operator = (const IntPoisson&);
};

class _impexp IntPoissonMitGrenze : public IntPoisson {
public :
  IntPoissonMitGrenze ();
  virtual ~IntPoissonMitGrenze ();
  virtual double NeueZahl ();
  virtual void lesen (InputFile& file);

protected :
  int ObjMin, ObjMax;

private:
  IntPoissonMitGrenze (const IntPoissonMitGrenze&);
  IntPoissonMitGrenze& operator = (const IntPoissonMitGrenze&);
};

class _impexp IntPoissonMitGrenzeNeuziehen : public IntPoissonMitGrenze {
public :
  IntPoissonMitGrenzeNeuziehen ();
  virtual ~IntPoissonMitGrenzeNeuziehen ();
  virtual double NeueZahl ();

private:
  IntPoissonMitGrenzeNeuziehen (const IntPoissonMitGrenzeNeuziehen&);
  IntPoissonMitGrenzeNeuziehen& operator = 
                                  (const IntPoissonMitGrenzeNeuziehen&);
};

#endif //!ZUFALL_H
