distrib.h

#ifndef DISTRIB_H
#define DISTRIB_H

#include <math.h>

class Distrib
{
private:
  static unsigned long int seed_; 
  static signed long int x_;      
  static signed long int y_;      
  static signed long int z_;      
  static inline signed long int Trunc(double x) {
        return (x >=0) ? (int(floor(x))) : (int(ceil(x)));
  };
  
protected:      
  Distrib (void);
  double Pick(void);
  
public:
  virtual ~Distrib (void);

  virtual double  GetVal (void) = 0;
  static void InitRng (unsigned long int seed=0);
};


class Constant : public Distrib {
private:
  double val_;
public:
  Constant(double value);
  double GetVal(void);
};

class Unif01 : public Distrib {
public:
  Unif01(void);
  double GetVal(void);
};

class Uniform : public Distrib {
private:
  double a_;
  double b_;
public:
  Uniform(double a, double b);
  double GetVal(void);
};


class Exponential : public Distrib {
private:
  double mean_;
public:
  Exponential (double m);
  double GetVal(void);
};

class Normal : public Distrib {
private:
  double mean_;
  double sDev_;
public:
  Normal (double m, double sDev);
  double GetVal(void);
};

class ErlangK: public Distrib {
private:
  double k_;
  double mean_;
public:
  ErlangK (unsigned int k, double m);
  double GetVal(void);
};

class Pareto: public Distrib {
private:
  double scale_;
  double alpha_;
public:
  Pareto (double scale, double alpha);
  double GetVal(void);
};

class HyperExponential: public Distrib {
private:
  double mean_;
  double sDev_;
  double p_;
public:
  HyperExponential(double m, double sDev);
  double GetVal(void);
};


class DiscreteEmpirical: public Distrib {
 private:
  typedef struct {
        double Fx;
        double val;
  } valT_;
  valT_ *accumP_;
  int n_;
 public:
  DiscreteEmpirical (const double P[],const double V[], int n);
  virtual ~DiscreteEmpirical (void);    
  double GetVal (void);
};

#endif

---