/*************************************************************************
 * Copyright (C) 1995, 1996, 1997  Jun Sun, jsun@junsun.net.
 * 
 * 
 *************************************************************************/

/*------------------------------------------------------------------------
class hierarchy :
                        Random_Variate
                             / \
                            /   \
                  Dis_Rand_Var Cont_Rand_Var
                         /        \
                       /           \
               DUniform          CUniform
               Bernoulli         Exponential
               Binomial          Gamma
               Geometric         Weibull
               Negbin            Normal
               Poisson           Lognormal
*--------------------------------------------------------------------------*/

/*=========================================================================
PROGRAMMING NOTES :
	To make the whole system reproducible, you have to call
static member function Random_Variate.set_reproducible(seed).
===========================================================================*/


#ifndef _random_variates_h_
#define _random_variates_h_

#include "macro.h"
#include "LCG.h"
#include "cppstring.h"
/*
#include "macro.h"
*/

/* class definition */
extern const String	RANDOM_VARIATE_CLASS;
extern const String	DISCRETE_RANDOM_VARIATE_CLASS;
extern const String	DUNIFORM_CLASS;
extern const String	BERNOULLI_CLASS;
extern const String	BINOMIAL_CLASS;
extern const String	GEOMETRIC_CLASS;
extern const String	NEGBIN_CLASS;
extern const String	POISSON_CLASS;
extern const String	CONTINUOUS_RANDOM_VARIATE_CLASS;
extern const String	CUNIFORM_CLASS;
extern const String	EXPONENTIAL_CLASS;
extern const String	GAMMA_CLASS;
extern const String	WEIBULL_CLASS;
extern const String	NORMAL_CLASS;
extern const String	LOGNORMAL_CLASS;


class Random_Variate
{
protected:

LCG	* randp;		

void	mythrow(char *);	// error handler

public:

	Random_Variate();
virtual ~Random_Variate();

virtual const String& classOf() const { return RANDOM_VARIATE_CLASS; }

static void	set_reproducible(int);
// make the whole system reproducible after this function is called

virtual	double distribution(double)	
// distribution function is the only common function between 
// discrete distributions and continuous distributions
// It should be called in run time.  
{ mythrow("no distribution for general class Random_Variate");
  return -1.0;
}


};


//--------------- DISCRETE DISTRIBUTIONS ------------------
class Discrete_Random_Variate: public Random_Variate
{

public :

virtual const String& classOf() const { return DISCRETE_RANDOM_VARIATE_CLASS; }

virtual double mass(int)
// return the mass function 
{ mythrow("no mass function for general class Discret_Random_Variate");
  return -1.0;
}

virtual int sample()
// generate ramdom samples
{ mythrow("no sample function for general class Discret_Random_Variate");
  return -1;
}

virtual double distribution(double)
{ mythrow("no distribution for general class Discret_Random_Variate");
  return -1.0;
}

};


// DU(i,j)
class DUniform : public Discrete_Random_Variate
{
	int     _i,_j;

public :
        DUniform(int i, int j);
        DUniform(int *data, int num_data);      // estimated from samples
        virtual ~DUniform();

	virtual const String& classOf() const { return DUNIFORM_CLASS; }

        int i() {return _i; }
        int j() {return _j;}

        double  mass(int x);                    // prob(X=x)
        double  distribution(double x);         // prob(X<=x)
        int     sample();                       // a random sample
};


// Bernoulli(p)
class Bernoulli : public Discrete_Random_Variate
{
        double  _p;
public :
        Bernoulli(double p);
        Bernoulli(int *data, int num_data);     // estimated from samples
        virtual ~Bernoulli();

	virtual const String& classOf() const { return BERNOULLI_CLASS; }
 
        double p() {return _p; }

        double  mass(int x);                    // prob(X=x)
        double  distribution(double x);         // prob(X<=x)
        int     sample();                       // a random sample
};


// Bin(t,p)
class Binomial : public Discrete_Random_Variate
{
        int     _t;
        double  _p;
        Bernoulli       *bp;

public :
        Binomial(int t, double p);
        Binomial(int *data, int num_data);      // estimated from samples
        virtual ~Binomial();

	virtual const String& classOf() const { return BINOMIAL_CLASS; }
 
        int t() { return _t; }
        double p() {return _p; }

        double  mass(int x);                    // prob(X=x)
        double  distribution(double x);         // prob(X<=x)
        int     sample();

	static int binomial_test(int*,int);
	// test if an array of data can be binomial distribution
	// return value is TRUE or FALSE
};


// Geom(p)
class Geometric : public Discrete_Random_Variate
{
        double  _p;

public :
        Geometric(double p);
        Geometric(int *data, int num_data);     // estimated from samples
        virtual ~Geometric();

	virtual const String& classOf() const { return GEOMETRIC_CLASS; }

        double p() {return _p; }

        double  mass(int x);                    // prob(X=x)
        double  distribution(double x);         // prob(X<=x)
        int     sample();
};



// Negbin(s,p)
class Negbin : public Discrete_Random_Variate
{
        int     _s;
        double  _p;
	Geometric	*gp;

public :
        Negbin(int s, double p);
        Negbin(int *data, int num_data);        // estimated from samples
        virtual ~Negbin();

	virtual const String& classOf() const { return NEGBIN_CLASS; }
        
        int s() { return _s; }
        double p() {return _p; }

        double  mass(int x);                    // prob(X=x)
        double  distribution(double x);         // prob(X<=x)
	int	sample();

	static int negbin_test();
	// test if a set of sample data form a valid negbin
	// return TRUE if they do; FALSE otherwise
};



// Poisson(lamda)
class Poisson : public Discrete_Random_Variate
{
        double  _lamda;

public :
        Poisson(double lamda);
        Poisson(int *data, int num_data);      // estimated from samples
        virtual ~Poisson();

	virtual const String& classOf() const { return POISSON_CLASS; }
        
        double lamda() {return _lamda; }

        double  mass(int x);                    // prob(X=x)
        double  distribution(double x);         // prob(X<=x)
	int	sample();
};


//------------------ CONTINUOUS DISTRIBUTION --------------------------
class Continuous_Random_Variate : public Random_Variate
{
public :

virtual const String& classOf() const { return CONTINUOUS_RANDOM_VARIATE_CLASS; }

virtual double density(double)
{ mythrow("no density function for general class Continuous_Random_Variate");
  return -1.0;
}

virtual double distribution(double)
{ mythrow("no distribution for general class Continuous_Random_Variate");
  return -1.0;
}

virtual double sample()
{ mythrow("no sample for general class Continuous_Random_Variate");
  return -1.0;
}

virtual double inverse_distribution(double)
{ mythrow("no inverse_distribution for general class Continuous_Random_Variate");
  return -1.0;
}

virtual double probability(double, double)
{ mythrow("no probability for general class Continuous_Random_Variate");
  return -1.0;
}

};


// U(a,b)
class CUniform : public Continuous_Random_Variate
{
	double	_a,_b;

public :

	CUniform(double,double);
	CUniform(double *,int);
	virtual ~CUniform();

	virtual const String& classOf() const { return CUNIFORM_CLASS; }

        double  density(double x);              // density function
        double  distribution(double x);         // prob(X<x)
	double	sample();
        double  probability(double, double); // prob(x1<X<x2)
        double  inverse_distribution(double);    // prob(X<variable) = prob

	double a() { return _a; }
	double b() { return _b; }
};



// expo(beta)
class Exponential : public Continuous_Random_Variate
{
	double _beta;

public :

	Exponential(double);
	Exponential(double*,int);
	virtual ~Exponential();

	virtual const String& classOf() const { return EXPONENTIAL_CLASS; }

	double density(double);
	double distribution(double);
	double sample();
	double probability(double, double);
	double inverse_distribution(double);

	double beta() { return _beta; }
};


// gamma(alpha,beta)
class Gamma : public Continuous_Random_Variate
{
	double _alpha, _beta;
	Exponential	*expo;

public :

	Gamma(double,double);
	Gamma(double*, int);
	virtual ~Gamma();

	virtual const String& classOf() const { return GAMMA_CLASS; }

        double density(double);
        double distribution(double);
        double sample();
        double probability(double, double);
        double inverse_distribution(double);

	double alpha() { return _alpha; }
	double beta()  { return _beta;  }
};



// Weibull(alpha,beta)
/*
class Weibull : public Continuous_Random_Variate
{
        double _alpha, _beta;

public :

        Weibull(double,double);
        Weibull(double*, int);
        virtual ~Weibull();

	virtual const String& classOf() const { return WEIBULL_CLASS; }

        double density(double);
        double distribution(double);
        double sample();
        double probability(double, double);
        double inverse_distribution(double);

	double alpha() { return _alpha; }
	double beta() { return _beta; }
};

*/

// Normal(miu,sigma2)
class Normal : public Continuous_Random_Variate
{
	double _miu;
	double _sigma,_sigma2;

	int	valid_sample;
	double	temp_sample;

public :

	Normal();
	Normal(double,double);
	Normal(double*,int); 
	virtual ~Normal();

	virtual const String& classOf() const { return NORMAL_CLASS; }

        double density(double);
        double distribution(double);
        double sample();
        double probability(double, double);
        double inverse_distribution(double);

	double miu() { return _miu; }
	double sigma2() { return _sigma2; }
	double sigma() { return _sigma; }
};


// LN(miu,sigma2)
/*
class Lognormal : public Continuous_Random_Variate
{
        double _miu;
        double _sigma,_sigma2;

public :

        Lognormal(double,double);
        Lognormal(double,int);
        virtual ~Lognormal();

	virtual const String& classOf() const { return LOGNORMAL_CLASS; }

        double density(double);
        double distribution(double);
        double sample();
        double probability(double, double);
        double inverse_distribution(double);

        double miu() { return _miu; }
        double sigma2() { return _sigma2; }
        double sigma() { return _sigma; }
};
*/

//------------------- helper functions ------------------------------
extern double factorial(int);
extern double combination(int,int);	// x1 choose x2

#endif