random_variable 0.0.2.pre → 0.1.0

data/lib/ext/random_variable.c

@@ -59,13 +59,18 @@
 /******************************************************************************/
 /* class objects */
 /******************************************************************************/
-static VALUE rb_cRandomVariable;
+static VALUE rb_mRandomVariable;
+static VALUE rb_cGenericRV;
 static VALUE rb_cBernoulliRV;
+static VALUE rb_cBinomialRV;
 static VALUE rb_cPoissonRV;
 static VALUE rb_cNormalRV;
 static VALUE rb_cExponentialRV;
 static VALUE rb_cRayleighRV;
-
+static VALUE rb_cContinuousUniformRV;
+static VALUE rb_cDiscreteUniformRV;
+static VALUE rb_cBetaRV;
+static VALUE rb_cFRV;
 /******************************************************************************/
 /* Common Functions */
 /******************************************************************************/
@@ -77,7 +82,8 @@ static inline void check_not_nan(double x, const char *str)
 		rb_raise(rb_eArgError, "%s", str);
 }
 
-#define CHECK_NOT_NAN(x) check_not_nan((x),"not a number " #x " parameter")
+#define CHECK_NOT_NAN(x) check_not_nan((x), \
+			"not a number (NaN) " #x " parameter")
 
 static inline void check_not_infinite(double x, const char *str)
 {
@@ -88,14 +94,81 @@ static inline void check_not_infinite(double x, const char *str)
 
 #define CHECK_NOT_INFINITE(x) check_not_infinite((x),"infinite " #x " paramter")
 
-static inline void check_positive(double x, const char *str)
+
+static inline void dbl_check_positive(double x, const char *str)
 {
 	if (x > 0.0)
 		return;
 	rb_raise(rb_eArgError, "%s", str);
 }
 
-#define CHECK_POSITIVE(x) check_positive((x), "non-positive " #x " parameter")
+#define DBL_CHECK_POSITIVE(x) dbl_check_positive((x), \
+			"non-positive " #x " parameter")
+
+
+static inline void long_check_positive(long x, const char *str)
+{
+	if (x > 0)
+		return;
+	rb_raise(rb_eArgError, "%s", str);
+}
+
+#define LONG_CHECK_POSITIVE(x) long_check_positive((x), \
+			"non-positive " #x " parameter")
+
+static inline void dbl_check_non_neg(double x, const char *str)
+{
+	if (x >= 0.0)
+		return;
+	rb_raise(rb_eArgError, "%s", str);
+}
+
+#define DBL_CHECK_NON_NEG(x) long_check_positive((x), \
+			"negative " #x " parameter")
+
+static inline void long_check_non_neg(long x, const char *str)
+{
+	if (x >= 0)
+		return;
+	rb_raise(rb_eArgError, "%s", str);
+}
+
+#define LONG_CHECK_NON_NEG(x) long_check_non_neg((x), \
+			"negative " #x " parameter")
+
+static inline int
+dbl_check_cinterval(double x, double min, double max, 
+			const char *lower, const char *greater)
+{
+	if (x < min)
+		rb_raise(rb_eArgError, "%s", lower);
+	else if (x > max)			
+		rb_raise(rb_eArgError, "%s", greater);
+	return;
+}
+
+#define DBL_CHECK_CINTERVAL(x,min,max)				\
+	(dbl_check_cinterval((x), (min), (max), 		\
+	#x " parameter out of bounds (" #x " < " #min ")", 	\
+	#x " parameter out of bounds (" #x " > " #max ")")) 	
+
+#define CHECK_PROBABILITY(x) DBL_CHECK_CINTERVAL(x,0.0,1.0)
+
+static inline int
+dbl_check_ointerval(double x, double min, double max, 
+			const char *lower, const char *greater)
+{
+	if (x <= min)
+		rb_raise(rb_eArgError, "%s", lower);
+	else if (x >= max)			
+		rb_raise(rb_eArgError, "%s", greater);
+	return;
+}
+
+#define DBL_CHECK_OINTERVAL(x,min,max)				\
+	(dbl_check_ointerval((x), (min), (max), 		\
+	#x " parameter out of bounds (" #x " <= " #min ")", 	\
+	#x " parameter out of bounds (" #x " >= " #max ")")) 	
 
 static inline long get_times(VALUE times)
 {
@@ -186,6 +259,78 @@ VALUE BernoulliRV_outcomes(VALUE self, VALUE times)
 	return _RV_outcomes(rv, CAST(_BernoulliRV_outcome), times);	
 }
 
+/******************************************************************************/
+/* Binomial Random Variable */
+/******************************************************************************/
+typedef struct {
+	long n;
+	double p;
+} binomial_rv_t;
+
+binomial_rv_t *binomial_rv_create(long n, double p)
+{
+	binomial_rv_t *rv;
+
+	LONG_CHECK_NON_NEG(n);
+	
+
+	CHECK_NOT_NAN(p);
+	CHECK_NOT_INFINITE(p);
+	CHECK_PROBABILITY(p);
+
+	/* n & p parameters correct */	
+	rv = ALLOC(binomial_rv_t);
+	rv->n = n;
+	rv->p = p;
+	return rv;
+}
+
+VALUE BinomialRV_new(VALUE self, VALUE n, VALUE p)
+{
+	binomial_rv_t *rv;
+	VALUE rb_obj; 
+
+	Check_Type(n, T_FIXNUM);
+	rv = binomial_rv_create(NUM2LONG(n), NUM2DBL(p));
+	rb_obj = Data_Wrap_Struct(rb_cBinomialRV, NULL, xfree, rv);
+	return rb_obj;	
+}
+
+static inline binomial_rv_t *_BinomialRV(VALUE BinomialRV_obj)
+{
+	binomial_rv_t *rv;
+	Data_Get_Struct(BinomialRV_obj, binomial_rv_t, rv);
+	return rv;
+}
+
+VALUE BinomialRV_n(VALUE self)
+{
+	return LONG2NUM(_BinomialRV(self)->n);
+}
+
+VALUE BinomialRV_p(VALUE self)
+{
+	return rb_float_new(_BinomialRV(self)->p);
+}
+
+static inline VALUE _BinomialRV_outcome(binomial_rv_t *rv)
+{
+	return INT2FIX(ignbin(rv->n, rv->p));
+}
+
+VALUE BinomialRV_outcome(VALUE self)
+{
+	return _BinomialRV_outcome(_BinomialRV(self));	
+}
+
+VALUE BinomialRV_outcomes(VALUE self, VALUE times)
+{
+	binomial_rv_t *rv;
+	
+	rv = _BinomialRV(self);
+	return _RV_outcomes(rv, CAST(_BinomialRV_outcome), times);
+}	
+
 /******************************************************************************/
 /* Poisson Random Variable */
 /******************************************************************************/
@@ -193,6 +338,7 @@ typedef struct {
 	double lambda;
 } poisson_rv_t;
 
+/* avoid overflow */
 #define POISSON_LAMBDA_MAX (LONG_MAX - (long)(0.00001*LONG_MAX))
 
 static inline poisson_rv_t *poisson_rv_create(double lambda)
@@ -477,23 +623,350 @@ VALUE RayleighRV_outcomes(VALUE self, VALUE times)
 	return _RV_outcomes(rv, CAST(_RayleighRV_outcome), times);
 }
 
+/******************************************************************************/
+/* Continuous Uniform Random Variable */
+/******************************************************************************/
+typedef struct {
+	double a;
+	double b;
+} continuous_uniform_rv_t;
+
+static inline
+continuous_uniform_rv_t *continuous_uniform_rv_create(double a, double b)
+{
+	continuous_uniform_rv_t *rv;
+
+	check_not_nan(a, "not a number (NaN) a parameter");
+	check_not_infinite(a, "infinite a parameter");
+
+	check_not_nan(b, "not a number (NaN) b parameter");
+	check_not_infinite(b, "infinite b parameter");
+
+	if (a >= b) {
+		rb_raise(rb_eArgError, "a < b");
+		return NULL;
+	}
+
+	rv = ALLOC(continuous_uniform_rv_t);
+	
+	rv->a = a;
+	rv->b = b;
+	return rv;
+}
+
+VALUE ContinuousUniformRV_new(VALUE self, VALUE a, VALUE b)
+{
+	continuous_uniform_rv_t *rv;
+	VALUE ContinuousUniformRV_obj;
+
+	rv = continuous_uniform_rv_create(NUM2DBL(a), NUM2DBL(b));
+	ContinuousUniformRV_obj = 
+		Data_Wrap_Struct(rb_cContinuousUniformRV, NULL, xfree, rv);
+	return ContinuousUniformRV_obj;	
+}
+
+static inline 
+continuous_uniform_rv_t *_ContinuousUniformRV(VALUE ContinuousUniformRV_obj)
+{
+	continuous_uniform_rv_t *rv;
+	Data_Get_Struct(ContinuousUniformRV_obj, continuous_uniform_rv_t, rv);
+	return rv;
+}
+
+VALUE ContinuousUniformRV_a(VALUE self)
+{
+	return DBL2NUM(_ContinuousUniformRV(self)->a);
+}
+
+VALUE ContinuousUniformRV_b(VALUE self)
+{
+	return DBL2NUM(_ContinuousUniformRV(self)->b);
+}
+
+static inline VALUE _ContinuousUniformRV_outcome(continuous_uniform_rv_t *rv)
+{
+	return rb_float_new(genunf(rv->a, rv->b));
+}
+
+VALUE ContinuousUniformRV_outcome(VALUE self)
+{
+	return _ContinuousUniformRV_outcome(_ContinuousUniformRV(self));
+}
+
+VALUE ContinuousUniformRV_outcomes(VALUE self, VALUE times)
+{
+	continuous_uniform_rv_t *rv;
+	
+	rv = _ContinuousUniformRV(self);
+	return _RV_outcomes(rv, CAST(_ContinuousUniformRV_outcome), times);
+}
+
+/******************************************************************************/
+/* Discrete Uniform Random Variable */
+/******************************************************************************/
+typedef struct {
+	long a;
+	long b;
+} discrete_uniform_rv_t;
+
+static inline
+discrete_uniform_rv_t *discrete_uniform_rv_create(long a, long b)
+{
+	discrete_uniform_rv_t *rv;
+
+	if (a >= b) {
+		rb_raise(rb_eArgError, "not a < b");
+		return NULL;
+	}
+
+	rv = ALLOC(discrete_uniform_rv_t);
+	
+	rv->a = a;
+	rv->b = b;
+	return rv;
+}
+
+VALUE DiscreteUniformRV_new(VALUE self, VALUE a, VALUE b)
+{
+	discrete_uniform_rv_t *rv;
+	VALUE DiscreteUniformRV_obj;
+
+	/* Check both parameters are integers only */
+	VALUE a_is_integer, b_is_integer;
+	a_is_integer = rb_obj_is_kind_of(a, rb_cInteger);
+	b_is_integer = rb_obj_is_kind_of(b, rb_cInteger);
+	
+	if (!a_is_integer && b_is_integer)
+		rb_raise(rb_eArgError, "not integer a parameter");
+	else if (a_is_integer && !b_is_integer)
+		rb_raise(rb_eArgError, "not integer b parameter");
+	else if (!a_is_integer && !b_is_integer)
+		rb_raise(rb_eArgError, "not integer a and b  parameters");
+		
+
+	rv = discrete_uniform_rv_create(NUM2LONG(a), NUM2LONG(b));
+	DiscreteUniformRV_obj = 
+		Data_Wrap_Struct(rb_cDiscreteUniformRV, NULL, xfree, rv);
+	return DiscreteUniformRV_obj;	
+}
+
+static inline 
+discrete_uniform_rv_t *_DiscreteUniformRV(VALUE DiscreteUniformRV_obj)
+{
+	discrete_uniform_rv_t *rv;
+	Data_Get_Struct(DiscreteUniformRV_obj, discrete_uniform_rv_t, rv);
+	return rv;
+}
+
+VALUE DiscreteUniformRV_a(VALUE self)
+{
+	return LONG2NUM(_DiscreteUniformRV(self)->a);
+}
+
+VALUE DiscreteUniformRV_b(VALUE self)
+{
+	return LONG2NUM(_DiscreteUniformRV(self)->b);
+}
+
+static inline VALUE _DiscreteUniformRV_outcome(discrete_uniform_rv_t *rv)
+{
+	return rb_float_new(genunf(rv->a, rv->b));
+}
+
+VALUE DiscreteUniformRV_outcome(VALUE self)
+{
+	return _DiscreteUniformRV_outcome(_DiscreteUniformRV(self));
+}
+
+VALUE DiscreteUniformRV_outcomes(VALUE self, VALUE times)
+{
+	discrete_uniform_rv_t *rv;
+	
+	rv = _DiscreteUniformRV(self);
+	return _RV_outcomes(rv, CAST(_DiscreteUniformRV_outcome), times);
+}
+
+/******************************************************************************/
+/* Beta Random Variable */
+/******************************************************************************/
+typedef struct {
+	double alpha;
+	double beta;
+} beta_rv_t;
+
+static inline
+beta_rv_t *beta_rv_create(double alpha, double beta)
+{
+	beta_rv_t *rv;
+
+	CHECK_NOT_NAN(alpha);
+	CHECK_NOT_INFINITE(alpha);
+
+	CHECK_NOT_NAN(beta);
+	CHECK_NOT_INFINITE(beta);
+
+	DBL_CHECK_POSITIVE(alpha);
+	DBL_CHECK_POSITIVE(beta);
+
+	rv = ALLOC(beta_rv_t);
+	
+	rv->alpha = alpha;
+	rv->beta = beta;
+	return rv;
+}
+
+VALUE BetaRV_new(VALUE self, VALUE alpha, VALUE beta)
+{
+	beta_rv_t *rv;
+	VALUE BetaRV_obj;
+
+	rv = beta_rv_create(NUM2DBL(alpha), NUM2DBL(beta));
+	BetaRV_obj = 
+		Data_Wrap_Struct(rb_cBetaRV, NULL, xfree, rv);
+	return BetaRV_obj;	
+}
+
+static inline 
+beta_rv_t *_BetaRV(VALUE BetaRV_obj)
+{
+	beta_rv_t *rv;
+	Data_Get_Struct(BetaRV_obj, beta_rv_t, rv);
+	return rv;
+}
+
+VALUE BetaRV_alpha(VALUE self)
+{
+	return DBL2NUM(_BetaRV(self)->alpha);
+}
+
+VALUE BetaRV_beta(VALUE self)
+{
+	return DBL2NUM(_BetaRV(self)->beta);
+}
+
+static inline VALUE _BetaRV_outcome(beta_rv_t *rv)
+{
+	return rb_float_new(genbet(rv->alpha, rv->beta));
+}
+
+VALUE BetaRV_outcome(VALUE self)
+{
+	return _BetaRV_outcome(_BetaRV(self));
+}
+
+VALUE BetaRV_outcomes(VALUE self, VALUE times)
+{
+	beta_rv_t *rv;
+	
+	rv = _BetaRV(self);
+	return _RV_outcomes(rv, CAST(_BetaRV_outcome), times);
+}
+
+/******************************************************************************/
+/* F Random Variable */
+/******************************************************************************/
+typedef struct {
+	double d1;
+	double d2;
+} f_rv_t;
+
+static inline
+f_rv_t *f_rv_create(double d1, double d2)
+{
+	f_rv_t *rv;
+
+	CHECK_NOT_NAN(d1);
+	CHECK_NOT_INFINITE(d1);
+
+	CHECK_NOT_NAN(d2);
+	CHECK_NOT_INFINITE(d2);
+
+	DBL_CHECK_POSITIVE(d1);
+	DBL_CHECK_POSITIVE(d2);
+
+	rv = ALLOC(f_rv_t);
+	
+	rv->d1 = d1;
+	rv->d2 = d2;
+	return rv;
+}
+
+VALUE FRV_new(VALUE self, VALUE d1, VALUE d2)
+{
+	f_rv_t *rv;
+	VALUE FRV_obj;
+
+	rv = f_rv_create(NUM2DBL(d1), NUM2DBL(d2));
+	FRV_obj = 
+		Data_Wrap_Struct(rb_cFRV, NULL, xfree, rv);
+	return FRV_obj;	
+}
+
+static inline 
+f_rv_t *_FRV(VALUE FRV_obj)
+{
+	f_rv_t *rv;
+	Data_Get_Struct(FRV_obj, f_rv_t, rv);
+	return rv;
+}
+
+VALUE FRV_d1(VALUE self)
+{
+	return DBL2NUM(_FRV(self)->d1);
+}
+
+VALUE FRV_d2(VALUE self)
+{
+	return DBL2NUM(_FRV(self)->d2);
+}
+
+static inline VALUE _FRV_outcome(f_rv_t *rv)
+{
+	return rb_float_new(genf(rv->d1, rv->d2));
+}
+
+VALUE FRV_outcome(VALUE self)
+{
+	return _FRV_outcome(_FRV(self));
+}
+
+VALUE FRV_outcomes(VALUE self, VALUE times)
+{
+	f_rv_t *rv;
+	
+	rv = _FRV(self);
+	return _RV_outcomes(rv, CAST(_FRV_outcome), times);
+}
+
 /******************************************************************************/
 /* Extension Initialization */
 /******************************************************************************/
 void Init_random_variable(void)
 {
 	/* RandomVariable */
-	rb_cRandomVariable = rb_define_class("RandomVariable", rb_cObject);
+	rb_mRandomVariable = rb_define_module("RandomVariable");
 
-	/* BernoulliRV */
-	rb_cBernoulliRV = rb_define_class("BernoulliRV", rb_cRandomVariable);
+	/* Generic */
+	rb_cGenericRV = rb_define_class_under(rb_mRandomVariable, "Generic",
+						rb_cObject);
+
+	/* Bernoulli */
+	rb_cBernoulliRV = rb_define_class_under(rb_mRandomVariable,"Bernoulli", rb_cGenericRV);
 	rb_define_singleton_method(rb_cBernoulliRV, "new", BernoulliRV_new, 1);
 	rb_define_method(rb_cBernoulliRV, "p", BernoulliRV_p, 0);
 	rb_define_method(rb_cBernoulliRV, "outcome", BernoulliRV_outcome, 0);
 	rb_define_method(rb_cBernoulliRV, "outcomes", BernoulliRV_outcomes, 1);
 
-	/* PoissonRV */
-	rb_cPoissonRV = rb_define_class("PoissonRV", rb_cRandomVariable);
+	/* Binomial */
+	rb_cBinomialRV = rb_define_class_under(rb_mRandomVariable,"Binomial", rb_cGenericRV);
+	rb_define_singleton_method(rb_cBinomialRV, "new", BinomialRV_new, 2);
+	rb_define_method(rb_cBinomialRV, "n", BinomialRV_n, 0);
+	rb_define_method(rb_cBinomialRV, "p", BinomialRV_p, 0);
+	rb_define_method(rb_cBinomialRV, "outcome", BinomialRV_outcome, 0);
+	rb_define_method(rb_cBinomialRV, "outcomes", BinomialRV_outcomes, 1);
+
+	/* Poisson */
+	rb_cPoissonRV = rb_define_class_under(rb_mRandomVariable,"Poisson", rb_cGenericRV);
 	rb_define_singleton_method(rb_cPoissonRV, "new", PoissonRV_new, 1);
 	rb_define_singleton_method(rb_cPoissonRV, 
 			"lambda_max", PoissonRV_max_lambda, 0);
@@ -503,15 +976,14 @@ void Init_random_variable(void)
 	rb_define_method(rb_cPoissonRV, "outcome", PoissonRV_outcome, 0);	
 	rb_define_method(rb_cPoissonRV, "outcomes", PoissonRV_outcomes, 1);
 
-	/* NormalRV */
-	rb_cNormalRV = rb_define_class("NormalRV", rb_cRandomVariable);
+	/* Normal */
+	rb_cNormalRV = rb_define_class_under(rb_mRandomVariable,"Normal", rb_cGenericRV);
 	rb_define_singleton_method(rb_cNormalRV, "new", NormalRV_new, 2);
 	rb_define_method(rb_cNormalRV, "outcome", NormalRV_outcome, 0);	
 	rb_define_method(rb_cNormalRV, "outcomes", NormalRV_outcomes, 1);
 
-	/* ExponentialRV */
-	rb_cExponentialRV = rb_define_class("ExponentialRV", 
-						rb_cRandomVariable);
+	/* Exponential */
+	rb_cExponentialRV = rb_define_class_under(rb_mRandomVariable,"Exponential", rb_cGenericRV);
 	rb_define_singleton_method(rb_cExponentialRV, "new", 
 						ExponentialRV_new, 1);
 	rb_define_method(rb_cExponentialRV, "lambda", ExponentialRV_lambda, 0);
@@ -522,7 +994,7 @@ void Init_random_variable(void)
 						ExponentialRV_outcomes, 1);
 
 	/* Rayleigh */
-	rb_cRayleighRV = rb_define_class("Rayleigh", rb_cRandomVariable);
+	rb_cRayleighRV = rb_define_class_under(rb_mRandomVariable,"Rayleigh", rb_cGenericRV);
 	rb_define_singleton_method(rb_cRayleighRV, "new",
 						RayleighRV_new, 1);
 	rb_define_method(rb_cRayleighRV, "sigma", RayleighRV_sigma, 0);
@@ -530,6 +1002,62 @@ void Init_random_variable(void)
 						RayleighRV_outcome, 0);
 	rb_define_method(rb_cRayleighRV, "outcomes", 
 						RayleighRV_outcomes, 1);
+
+	/* Continuous Uniform */
+	rb_cContinuousUniformRV = 
+		rb_define_class_under(rb_mRandomVariable,"ContinuousUniform", rb_cGenericRV);
+	rb_define_singleton_method(rb_cContinuousUniformRV, "new",
+				ContinuousUniformRV_new, 2);
+	rb_define_method(rb_cContinuousUniformRV, 
+				"a", ContinuousUniformRV_a, 0);
+	rb_define_method(rb_cContinuousUniformRV, 
+				"b", ContinuousUniformRV_b, 0);
+	rb_define_method(rb_cContinuousUniformRV, "outcome", 
+				ContinuousUniformRV_outcome, 0);
+	rb_define_method(rb_cContinuousUniformRV, "outcomes", 
+				ContinuousUniformRV_outcomes, 1);
+
+	/* Discrete Uniform */
+	rb_cDiscreteUniformRV = 
+		rb_define_class_under(rb_mRandomVariable,"DiscreteUniform", rb_cGenericRV);
+	rb_define_singleton_method(rb_cDiscreteUniformRV, "new",
+				DiscreteUniformRV_new, 2);
+	rb_define_method(rb_cDiscreteUniformRV, 
+				"a", DiscreteUniformRV_a, 0);
+	rb_define_method(rb_cDiscreteUniformRV, 
+				"b", DiscreteUniformRV_b, 0);
+	rb_define_method(rb_cDiscreteUniformRV, "outcome", 
+				DiscreteUniformRV_outcome, 0);
+	rb_define_method(rb_cDiscreteUniformRV, "outcomes", 
+				DiscreteUniformRV_outcomes, 1);
+
+	/* Beta */
+	rb_cBetaRV = 
+		rb_define_class_under(rb_mRandomVariable,"Beta", rb_cGenericRV);
+	rb_define_singleton_method(rb_cBetaRV, "new",
+				BetaRV_new, 2);
+	rb_define_method(rb_cBetaRV, 
+				"alpha", BetaRV_alpha, 0);
+	rb_define_method(rb_cBetaRV, 
+				"beta", BetaRV_beta, 0);
+	rb_define_method(rb_cBetaRV, "outcome", 
+				BetaRV_outcome, 0);
+	rb_define_method(rb_cBetaRV, "outcomes", 
+				BetaRV_outcomes, 1);
+
+	/* F */
+	rb_cFRV = 
+		rb_define_class_under(rb_mRandomVariable,"F", rb_cGenericRV);
+	rb_define_singleton_method(rb_cFRV, "new",
+				FRV_new, 2);
+	rb_define_method(rb_cFRV, 
+				"d1", FRV_d1, 0);
+	rb_define_method(rb_cFRV, 
+				"d2", FRV_d2, 0);
+	rb_define_method(rb_cFRV, "outcome", 
+				FRV_outcome, 0);
+	rb_define_method(rb_cFRV, "outcomes", 
+				FRV_outcomes, 1);
 	
 	return;
 }

data/lib/ext/xrandlib.c

@@ -54,4 +54,47 @@ double genray(double sigma)
 	return sqrt( -2 * sigma * sigma * log(1.0 - ranf()) );
 }
 
+/* Arcsine */
+double gen_arcsine(void)
+{
+	return pow(sin(M_2_PI * ranf() ), 2);
+}
+
+/* Rectangular */
+double gen_rectangular(void)
+{
+	return (ranf() - 0.5);	
+}
+
+/* Irwin-Hall */
+double gen_irwin_hall(long n)
+{
+	long i;
+	double sum;
+	for (i = 0, sum = 0; i < n; i++)
+		sum += ranf();
+	return sum;	
+}
+
+/* Bates */
+double gen_bates(long n)
+{
+	return genirwinhall(n) / n;
+}
+
+/* Triangular */
+double gen_triangular(double a, double b, double c)
+{
+	double y = ranf();
+	if (y <= (c-a) / (b-a) )
+		return a + sqrt(y*(b-a)*(c-a));
+	return b - sqrt((1-y)*(b-a)*(b-c));
+}
+
+/* Truncated Normal */
+double gen_truncated_normal(double mu, double sigma, double a, double b)
+{
+	return 0.0;	
+}
+
 

data/lib/random_variable.rb

@@ -33,7 +33,19 @@
 
 require_relative 'ext/random_variable'
 
-class RandomVariable
+module RandomVariable 
+	def self.list
+		distros = []
+		self.constants.each do |c|
+			c = self.const_get(c)
+			if c.is_a? Class and c != self::Generic then
+				distros << c
+			end
+		end
+		distros
+	end
+	
+	class Generic	
 	klass = self
 
 	def initialize(&blk)
@@ -67,7 +79,9 @@ class RandomVariable
 		end
 		ary	
 	end
+	
 
+end
 end
 
 module Math

data/lib/test.rb

@@ -6,3 +6,4 @@ require 'test/unit'
 
 # unary tests...
 require 'test/test_poisson_rv'
+require 'test/test_rayleigh_rv'

metadata

@@ -1,17 +1,39 @@
 --- !ruby/object:Gem::Specification
 name: random_variable
 version: !ruby/object:Gem::Version
-  version: 0.0.2.pre
-  prerelease: 6
+  version: 0.1.0
+  prerelease: 
 platform: ruby
 authors:
 - Jorge Fco. Madronal Rinaldi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-27 00:00:00.000000000 Z
+date: 2012-11-17 00:00:00.000000000 Z
 dependencies: []
-description: Bernoulli, Normal, Poisson, Exponential
+description: ! 'Create and operate with Random Variables in Ruby
+
+  To date, the supported distributions are:
+
+  Bernoulli
+
+  Beta
+
+  Binomial
+
+  Continous Uniform
+
+  Discrete Uniform
+
+  Exponential
+
+  F
+
+  Normal
+
+  Poisson
+
+  Rayleigh'
 email: jorge.madronal.rinaldi@gmail.com
 executables: []
 extensions:
@@ -47,13 +69,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: For creating Random Variables in Ruby
+summary: Random Variables in Ruby
 test_files: []