// $Source: /usr/local/SimSoft/Sfx3D/src/gts/gtsvert.h,v $
// $Revision: 1.2 $
// $Author: baum $
// $Date: 2001/11/29 15:18:10 $
//
// Login name of the user who locked the revision
// $Locker:  $
// Tag name used to checkout the file
// $Name: Release-14 $
// State assigned to revision
// $State: Exp $
//
//
// $Log: gtsvert.h,v $
// Revision 1.2  2001/11/29 15:18:10  baum
// -Realzeitsteuerung eingebaut
// -Handsteuerung eingebaut
//

#ifndef _ZUFX_H
#define _ZUFX_H     1

#include "Strings.h"

class Verteilung {
public:
  static Verteilung* erzeugen (unsigned Art);
  virtual ~Verteilung ();
  Ustring bereinigeString (Ustring inp);

  virtual double NeueZahl () = 0;
  virtual void lesen     (InputFile& file) = 0;
  virtual void schreiben (ostream& ostrm) = 0;
  virtual void    setVerteilung (Ustring str) = 0;
  virtual Ustring getVerteilung () = 0;
  int round (double);
  unsigned getVerteilTyp ();

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

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

class RealExplizit : public Verteilung {
public :
  RealExplizit ();
  virtual ~RealExplizit ();
  virtual double NeueZahl ();
  virtual void lesen     (InputFile& file);
  virtual void schreiben (ostream& ostrm);
  virtual void    setVerteilung (Ustring str);
  virtual Ustring getVerteilung ();

protected :
  double ObjWert;

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

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

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

class RealGleich : public Verteilung {
public :
  RealGleich ();
  virtual ~RealGleich ();
  virtual double NeueZahl ();
  virtual void lesen     (InputFile& file);
  virtual void schreiben (ostream& ostrm);
  virtual void    setVerteilung (Ustring str);
  virtual Ustring getVerteilung ();

protected :
  double ObjMin, ObjMax;
  unsigned ObjStartzahl;

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

class IntGleich : public RealGleich {
public :
  IntGleich ();
  virtual ~IntGleich ();
  virtual double NeueZahl ();
  virtual void lesen     (InputFile& file);
  virtual void schreiben (ostream& ostrm);
  virtual void    setVerteilung (Ustring str);
  virtual Ustring getVerteilung ();

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

class RealExp : public Verteilung {
public :
  RealExp ();
  virtual ~RealExp ();
  virtual double NeueZahl ();
  virtual void lesen     (InputFile& file);
  virtual void schreiben (ostream& ostrm);
  virtual void    setVerteilung (Ustring str);
  virtual Ustring getVerteilung ();

protected :
  double ObjErwartungswert;
  unsigned ObjStartzahl;

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

class RealExpMitGrenze : public RealExp {
public :
  RealExpMitGrenze ();
  virtual ~RealExpMitGrenze ();
  virtual double NeueZahl ();
   virtual void lesen     (InputFile& file);
  virtual void schreiben (ostream& ostrm);
  virtual void    setVerteilung (Ustring str);
  virtual Ustring getVerteilung ();

protected :
  double ObjMin, ObjMax;

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

class RealExpMitGrenzeNeuziehen : public RealExpMitGrenze {
public :
  RealExpMitGrenzeNeuziehen ();
  virtual ~RealExpMitGrenzeNeuziehen ();
  virtual double NeueZahl ();

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

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

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

class IntExpMitGrenze : public IntExp {
public :
  IntExpMitGrenze ();
  virtual ~IntExpMitGrenze ();
  virtual double NeueZahl ();
  virtual void lesen     (InputFile& file);
  virtual void schreiben (ostream& ostrm);
  virtual void    setVerteilung (Ustring str);
  virtual Ustring getVerteilung ();

protected :
  int ObjMin, ObjMax;

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

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

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

class RealGauss : public Verteilung {
public :
  RealGauss ();
  virtual ~RealGauss ();
  virtual double NeueZahl ();
  virtual void lesen     (InputFile& file);
  virtual void schreiben (ostream& ostrm);
  virtual void    setVerteilung (Ustring str);
  virtual Ustring getVerteilung ();
  
protected :
  double ObjMittel, ObjAbweichung;
  unsigned ObjStartzahl;

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

class RealGaussMitGrenze : public RealGauss {
public :
  RealGaussMitGrenze ();
  virtual ~RealGaussMitGrenze ();
  virtual double NeueZahl ();
  virtual void lesen     (InputFile& file);
  virtual void schreiben (ostream& ostrm);
  virtual void    setVerteilung (Ustring str);
  virtual Ustring getVerteilung ();

protected :
  double ObjMin, ObjMax;

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

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

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

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

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


class IntGaussMitGrenze : public IntGauss {
public :
  IntGaussMitGrenze ();
  virtual ~IntGaussMitGrenze ();
  virtual double NeueZahl ();
  virtual void lesen     (InputFile& file);
  virtual void schreiben (ostream& ostrm);
  virtual void    setVerteilung (Ustring str);
  virtual Ustring getVerteilung ();

protected :
  int ObjMin, ObjMax;

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

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

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

class RealErlang : public Verteilung {
public :
  RealErlang ();
  virtual ~RealErlang ();
  virtual double NeueZahl ();
  virtual void lesen     (InputFile& file);
  virtual void schreiben (ostream& ostrm);
  virtual void    setVerteilung (Ustring str);
  virtual Ustring getVerteilung ();
  
protected :
  double ObjErwartungswert;
  int ObjK;
  unsigned ObjStartzahl;

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

class RealErlangMitGrenze : public RealErlang {
public :
  RealErlangMitGrenze ();
  virtual ~RealErlangMitGrenze ();
  virtual double NeueZahl ();
  virtual void lesen     (InputFile& file);
  virtual void schreiben (ostream& ostrm);
  virtual void    setVerteilung (Ustring str);
  virtual Ustring getVerteilung ();

protected :
  double ObjMin, ObjMax;

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

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

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

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

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

class IntErlangMitGrenze : public IntErlang {
public :
  IntErlangMitGrenze ();
  virtual ~IntErlangMitGrenze ();
  virtual double NeueZahl ();
  virtual void lesen     (InputFile& file);
  virtual void schreiben (ostream& ostrm);
  virtual void    setVerteilung (Ustring str);
  virtual Ustring getVerteilung ();

protected :
  int ObjMin, ObjMax;

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

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

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

class IntPoisson : public Verteilung {
public :
  IntPoisson ();
  virtual ~IntPoisson ();
  virtual double NeueZahl ();
  virtual void lesen     (InputFile& file);
  virtual void schreiben (ostream& ostrm);
  virtual void    setVerteilung (Ustring str);
  virtual Ustring getVerteilung ();

protected :
  int ObjMittel;
  unsigned ObjStartzahl;

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

class IntPoissonMitGrenze : public IntPoisson {
public :
  IntPoissonMitGrenze ();
  virtual ~IntPoissonMitGrenze ();
  virtual double NeueZahl ();
  virtual void lesen     (InputFile& file);
  virtual void schreiben (ostream& ostrm);
  virtual void    setVerteilung (Ustring str);
  virtual Ustring getVerteilung ();

protected :
  int ObjMin, ObjMax;

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

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

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

#endif /* ZUFX_H */
