random_variable 1.1.0 → 1.2.0

data/lib/distros.rb

@@ -38,6 +38,14 @@ module RandomVariable
 		end
 	end
 
+	class ChiSquared < Generic
+		# create a <i>Chi-Squared Random Variable</i> with +k+ degrees
+		# of freedom
+		def self.new(k)
+			intern_new(k)
+		end
+	end
+
 	class ContinuousUniform < Generic
 		# create a new <i>Continuous Uniform Random Variable</i> with 
 		# parameters +a+ and +b+
@@ -71,13 +79,21 @@ module RandomVariable
 	end
 
 	class Normal < Generic
-		# create a new <i>Normal Random Variable</i> with parameters
-		# +mu+ and +sigma+
+		# create a new <i>Normal (aka Gaussian) Random Variable</i> 
+		# with parameters +mu+ and +sigma+
 		def self.new(mu = 0.0, sigma = 1.0)
 			intern_new(mu, sigma)
 		end
 	end
 
+	class Pareto < Generic
+		# create a new <i>Pareto Random Variable</i> where +a+ is the
+		# shape and +m+ is the location
+		def self.new(a, m = 1.0)
+			intern_new(a, m)
+		end
+	end
+
 	class Poisson < Generic
 		# create a new <i>Poisson Random Variable</i> with a mean of
 		# +mean+
@@ -86,6 +102,13 @@ module RandomVariable
 		end
 	end
 
+	class Rademacher < Generic
+		# create a new <i>Rademacher Random Variable</i>
+		def self.new
+			intern_new
+		end
+	end
+
 	class Rayleigh < Generic
 		# create a new <i>Rayleigh Random Variable</i> with parameter
 		# +sigma+
@@ -93,4 +116,11 @@ module RandomVariable
 			intern_new(sigma)
 		end
 	end
+
+	class Rectangular < Generic
+		# create a <i>Rectangular Random Variable</i>
+		def self.new
+			intern_new
+		end
+	end
 end

data/lib/ext/randlib.c

@@ -1060,6 +1060,11 @@ S170:
 }
 
 long ignnbn(long n,double p)
+/* 
+	return the number of failures
+	n -> number of successful events
+	p -> probability of event
+ */
 /*
 **********************************************************************
  

data/lib/ext/random_variable.c

@@ -68,13 +68,18 @@ typedef enum {
 	rv_type_bernoulli,
 	rv_type_beta,
 	rv_type_binomial,
+	rv_type_chi_squared,
 	rv_type_continuous_uniform,
 	rv_type_discrete_uniform,
 	rv_type_exponential,
 	rv_type_f,
+	rv_type_negative_binomial,
 	rv_type_normal,
+	rv_type_pareto,
 	rv_type_poisson,
+	rv_type_rademacher,
 	rv_type_rayleigh,
+	rv_type_rectangular,
 
 	/* end of random variable types */	
 
@@ -92,13 +97,18 @@ typedef struct {
 		struct { double p; } bernoulli;
 		struct { double alpha, beta; } beta;
 		struct { long n; double p; } binomial;
+		struct { long k; } chi_squared;
 		struct { double a,b; } continuous_uniform;
 		struct { long a,b; } discrete_uniform;
 		struct { double mean; } exponential;
 		struct { double d1, d2; } f;
+		struct { long r; double p; } negative_binomial;
 		struct { double mu, sigma; } normal;
+		struct { double a, m; } pareto;
 		struct { double mean; } poisson;
+		struct { /* no params */ } rademacher;
 		struct { double sigma; } rayleigh;
+		struct { /* no params */ } rectangular;
 	} RANDVAR_DATA;	/* union */
 } randvar_t;
 #define RANDVAR_ALLOC()		ALLOC(randvar_t)
@@ -118,6 +128,13 @@ typedef struct {
 		rv->RANDVAR_DATA . name . param = param;		\
 	}
 
+#define CREATE_RANDVAR_OUTCOME_FUNC0(name, func, type)			\
+	static inline type 						\
+	randvar_##name ##_ ##outcome(randvar_t *rv)			\
+	{								\
+		return func();						\
+	}
+
 #define CREATE_RANDVAR_OUTCOME_FUNC1(name, func, type, param)		\
 	static inline type 						\
 	randvar_##name ##_ ##outcome(randvar_t *rv)			\
@@ -160,6 +177,11 @@ CREATE_RANDVAR_ACCESSOR(binomial, n, long)
 CREATE_RANDVAR_ACCESSOR(binomial, p, double)
 CREATE_RANDVAR_OUTCOME_FUNC2(binomial, ignbin, long, n, p)
 CREATE_RANDVAR_RB_OUTCOME(binomial, LONG2NUM)
+/* chi-squared */
+RV_NR_PARAMS(chi_squared, 1)
+CREATE_RANDVAR_ACCESSOR(chi_squared, k, long)
+CREATE_RANDVAR_OUTCOME_FUNC1(chi_squared, gen_chi_squared, double, k)
+CREATE_RANDVAR_RB_OUTCOME(chi_squared, DBL2NUM)
 /* continuous uniform */
 RV_NR_PARAMS(continuous_uniform, 2)
 CREATE_RANDVAR_ACCESSOR(continuous_uniform, a, double)
@@ -170,7 +192,7 @@ CREATE_RANDVAR_RB_OUTCOME(continuous_uniform, DBL2NUM)
 RV_NR_PARAMS(discrete_uniform, 2)
 CREATE_RANDVAR_ACCESSOR(discrete_uniform, a, long)
 CREATE_RANDVAR_ACCESSOR(discrete_uniform, b, long)
-CREATE_RANDVAR_OUTCOME_FUNC2(discrete_uniform, ignuin, long, a, b)
+CREATE_RANDVAR_OUTCOME_FUNC2(discrete_uniform, gen_discrete_uniform, long, a, b)
 CREATE_RANDVAR_RB_OUTCOME(discrete_uniform, LONG2NUM)
 /* exponential */
 RV_NR_PARAMS(exponential, 1)
@@ -183,22 +205,42 @@ CREATE_RANDVAR_ACCESSOR(f, d1, double)
 CREATE_RANDVAR_ACCESSOR(f, d2, double)
 CREATE_RANDVAR_OUTCOME_FUNC2(f, genf, double, d1, d2)
 CREATE_RANDVAR_RB_OUTCOME(f, DBL2NUM)
+/* negative binomial */
+RV_NR_PARAMS(negative_binomial, 2)
+CREATE_RANDVAR_ACCESSOR(negative_binomial, r, long)
+CREATE_RANDVAR_ACCESSOR(negative_binomial, p, double)
+CREATE_RANDVAR_OUTCOME_FUNC2(negative_binomial, ignnbn, long, r, p)
+CREATE_RANDVAR_RB_OUTCOME(negative_binomial, LONG2NUM)
 /* normal */
 RV_NR_PARAMS(normal, 2)
 CREATE_RANDVAR_ACCESSOR(normal, mu, double)
 CREATE_RANDVAR_ACCESSOR(normal, sigma, double)
 CREATE_RANDVAR_OUTCOME_FUNC2(normal, gennor, double, mu, sigma)
 CREATE_RANDVAR_RB_OUTCOME(normal, DBL2NUM)
+/* pareto */
+RV_NR_PARAMS(pareto, 2)
+CREATE_RANDVAR_ACCESSOR(pareto, a, double)
+CREATE_RANDVAR_ACCESSOR(pareto, m, double)
+CREATE_RANDVAR_OUTCOME_FUNC2(pareto, gen_pareto, double, a, m)
+CREATE_RANDVAR_RB_OUTCOME(pareto, DBL2NUM)
 /* poisson */
 RV_NR_PARAMS(poisson, 1)
 CREATE_RANDVAR_ACCESSOR(poisson, mean, double)
 CREATE_RANDVAR_OUTCOME_FUNC1(poisson, ignpoi, long, mean)
 CREATE_RANDVAR_RB_OUTCOME(poisson, LONG2NUM)
+/* rademacher */
+RV_NR_PARAMS(rademacher, 0)
+CREATE_RANDVAR_OUTCOME_FUNC0(rademacher, gen_rademacher, int)
+CREATE_RANDVAR_RB_OUTCOME(rademacher, INT2FIX)
 /* rayleigh */
 RV_NR_PARAMS(rayleigh, 1)
 CREATE_RANDVAR_ACCESSOR(rayleigh, sigma, double)
 CREATE_RANDVAR_OUTCOME_FUNC1(rayleigh, gen_rayleigh, double, sigma)
 CREATE_RANDVAR_RB_OUTCOME(rayleigh, DBL2NUM)
+/* rectangular */
+RV_NR_PARAMS(rectangular, 0)
+CREATE_RANDVAR_OUTCOME_FUNC0(rectangular, gen_rectangular, double)
+CREATE_RANDVAR_RB_OUTCOME(rectangular, DBL2NUM)
 
 /******************************************************************************/
 /* class and module objects */
@@ -267,6 +309,15 @@ static type_t type(VALUE rb_obj)
 						#x " parameter "	\
 						"is not a "		\
 						"probability");		\
+			} while (0)
+	
+#define CHECK_PROBABILITY_EXCL(x) 					\
+			do {						\
+				if (x >= 1.0 || x <= 0.0)		\
+					rb_raise(rb_eArgError,		\
+						#x " parameter "	\
+						"must be "		\
+						"0 < " #x " < 1");	\
 			} while (0)	
 
 #define VAR_DECLARATIONS	va_list ap;				\
@@ -275,6 +326,15 @@ static type_t type(VALUE rb_obj)
 				VALUE klass = 0;
 #define SET_KLASS(name)							\
 		(klass = rb_cRandomVariables[rv_type_ ##name])
+
+#define ASSERT_KLASS_IS_SET						\
+		do {							\
+			if (0 == klass) 				\
+				rb_bug("forgot to set klass variable "	\
+					"in %s()", __func__);		\
+		} while (0)						
+
+
 #define GET_NEXT_ARG(ap)	va_arg((ap), VALUE)
 #define CREATE_WRAPPING(rv)	Data_Wrap_Struct(klass, NULL, xfree, (rv))
 
@@ -294,6 +354,7 @@ static type_t type(VALUE rb_obj)
 			{		
 
 #define CASE_END							\
+			ASSERT_KLASS_IS_SET;				\
 			break;						\
 			}	
 /******************************************************************************/
@@ -375,6 +436,25 @@ VALUE rb_create_instance(VALUE rb_obj, ...)
 			SET_PARAM(binomial, p);
 		CASE_END
 
+		CASE(chi_squared)
+			VALUE rb_k;
+			long k;
+
+			SET_KLASS(chi_squared);
+
+			rb_k = GET_NEXT_ARG(ap);
+			CHECK_RB_INTEGER(rb_k, "k");
+
+			k = NUM2LONG(rb_k);
+			
+			/* k > 0 */
+			CHECK_POSITIVE(k);
+
+			/* k parameter correct */
+			RANDVAR_INIT(chi_squared);
+			SET_PARAM(chi_squared, k);	
+		CASE_END
+
 		CASE(continuous_uniform)
 			VALUE rb_a, rb_b;
 			double a,b;
@@ -460,6 +540,34 @@ VALUE rb_create_instance(VALUE rb_obj, ...)
 			SET_PARAM(f, d2);
 		CASE_END
 
+		CASE(negative_binomial)
+			VALUE rb_r, rb_p;
+			long r;
+			double p;
+
+			SET_KLASS(negative_binomial);
+
+			rb_r = GET_NEXT_ARG(ap);
+			rb_p = GET_NEXT_ARG(ap);
+
+			CHECK_RB_INTEGER(rb_r, "r");
+			
+			r = NUM2LONG(rb_r);
+			p = NUM2DBL(rb_p);
+
+			/* r > 0 */
+			CHECK_POSITIVE(r);
+			/* 0 < p < 0 */
+			CHECK_PROBABILITY_EXCL(p);
+
+			/* r and p parameters correct */
+			RANDVAR_INIT(negative_binomial);
+			SET_PARAM(negative_binomial, r);
+			SET_PARAM(negative_binomial, p);
+
+			
+		CASE_END		
+
 		CASE(normal)
 			VALUE rb_mu, rb_sigma;
 			double mu, sigma;
@@ -478,6 +586,30 @@ VALUE rb_create_instance(VALUE rb_obj, ...)
 			RANDVAR_INIT(normal);
 			SET_PARAM(normal, mu);
 			SET_PARAM(normal, sigma);
+		CASE_END
+
+		CASE(pareto)
+			VALUE rb_a, rb_m;
+			double a, m;
+			
+			SET_KLASS(pareto);
+
+			rb_a = GET_NEXT_ARG(ap);
+			rb_m = GET_NEXT_ARG(ap);
+
+			a = NUM2DBL(rb_a);
+			m = NUM2DBL(rb_m);
+
+			/* a > 0 */
+			CHECK_POSITIVE(a);
+
+			/* m > 0 */
+			CHECK_POSITIVE(m);
+
+			/* a and m parameters correct */
+			RANDVAR_INIT(pareto);
+			SET_PARAM(pareto, a);
+			SET_PARAM(pareto, m);
 		CASE_END		
 
 		CASE(poisson)
@@ -489,11 +621,17 @@ VALUE rb_create_instance(VALUE rb_obj, ...)
 			rb_mean = GET_NEXT_ARG(ap);
 			mean = NUM2DBL(rb_mean); 
 			/* mean > 0 */
-			CHECK_POSITIVE(mean);;
+			CHECK_POSITIVE(mean);
 			
 			/* mean parameter correct */
 			RANDVAR_INIT(poisson);
-			SET_PARAM(poisson, mean);;
+			SET_PARAM(poisson, mean);
+		CASE_END
+
+		CASE(rademacher)
+			SET_KLASS(rademacher);
+
+			RANDVAR_INIT(rademacher);
 		CASE_END
 	
 		CASE(rayleigh)
@@ -512,6 +650,12 @@ VALUE rb_create_instance(VALUE rb_obj, ...)
 			SET_PARAM(rayleigh, sigma);				
 		CASE_END
 
+		CASE(rectangular)
+			SET_KLASS(rectangular);
+
+			RANDVAR_INIT(rectangular);
+		CASE_END
+
 		default:
 			rb_rv = Qnil;
 				
@@ -607,11 +751,12 @@ static VALUE rb_seed_set(VALUE self, VALUE rb_seed)
 			(VALUE (*) (ANYARGS)) rb_create_instance,	\
 			rv_ ##name ##_nr_params);			\
 									\
-		rb_define_method(*rb_objp, "outcome" , rb_outcome,  0);	\
-		rb_define_alias(*rb_objp, "sample", "outcome");		\
+		rb_define_private_method(*rb_objp, 			\
+			"intern_outcome", rb_outcome, 0);		\
+									\
+		rb_define_private_method(*rb_objp,			\
+			"intern_outcomes", rb_outcomes, 1);		\
 									\
-		rb_define_method(*rb_objp, "outcomes", rb_outcomes, 1);	\
-		rb_define_alias(*rb_objp, "samples", "outcomes");	\
 		outcome_func[rv_type_ ##name] = 			\
 				randvar_ ##name ##_rb_outcome;		\
 	} while (0)
@@ -637,13 +782,18 @@ void Init_random_variable(void)
 	CREATE_RANDOM_VARIABLE_CLASS("Bernoulli", bernoulli);
 	CREATE_RANDOM_VARIABLE_CLASS("Beta", beta);
 	CREATE_RANDOM_VARIABLE_CLASS("Binomial", binomial);
+	CREATE_RANDOM_VARIABLE_CLASS("ChiSquared", chi_squared);
 	CREATE_RANDOM_VARIABLE_CLASS("ContinuousUniform", continuous_uniform);
 	CREATE_RANDOM_VARIABLE_CLASS("DiscreteUniform", discrete_uniform);
 	CREATE_RANDOM_VARIABLE_CLASS("Exponential", exponential);
 	CREATE_RANDOM_VARIABLE_CLASS("F", f);
+	CREATE_RANDOM_VARIABLE_CLASS("NegativeBinomial", negative_binomial);
 	CREATE_RANDOM_VARIABLE_CLASS("Normal", normal);
+	CREATE_RANDOM_VARIABLE_CLASS("Pareto", pareto);
 	CREATE_RANDOM_VARIABLE_CLASS("Poisson", poisson);
+	CREATE_RANDOM_VARIABLE_CLASS("Rademacher", rademacher);
 	CREATE_RANDOM_VARIABLE_CLASS("Rayleigh", rayleigh);
+	CREATE_RANDOM_VARIABLE_CLASS("Rectangular", rectangular);
 
 	/* initialize the random number generator */
 	rv_init_gen();

data/lib/ext/xrandlib.c

@@ -40,6 +40,19 @@
 #include "xrandlib.h"
 #include "randlib.h"
 
+/* Arcsine */
+double gen_arcsine(void)
+{
+	return pow(sin(M_2_PI * ranf() ), 2);
+}
+
+/* Bates */
+double gen_bates(long n)
+{
+	return genirwinhall(n) / n;
+}
+
+/* Bernoulli */
 int gen_bernoulli(double p)
 {
 	if (ranf() > p)
@@ -47,22 +60,35 @@ int gen_bernoulli(double p)
 	return 1;
 }
 
-/* Rayleigh */
-double gen_rayleigh(double sigma)
-{
-	return sigma * sqrt(-2 * log(1.0 - ranf()));
-}
-
-/* Arcsine */
-double gen_arcsine(void)
+/* Chi-Squared */
+double gen_chi_squared(long k)
 {
-	return pow(sin(M_2_PI * ranf() ), 2);
+	return genchi((double) k);
 }
 
-/* Rectangular */
-double gen_rectangular(void)
+/* Discrete Uniform */
+long gen_discrete_uniform(long a, long b)
 {
-	return (ranf() - 0.5);	
+	/* assumptions:
+		1) a != b
+		2) a < b
+	*/
+	double step;
+	long step_nr;
+	double y, y0;
+
+	step = 1.0 / (b - a + 1);
+	y = step;
+	y0 = ranf();
+	step_nr = 0;
+
+	do {
+		if (y0 <= y)
+			break;
+		y += step;
+		++step_nr;	
+	} while (1);
+	return a + step_nr;	
 }
 
 /* Irwin-Hall */
@@ -75,10 +101,30 @@ double gen_irwin_hall(long n)
 	return sum;	
 }
 
-/* Bates */
-double gen_bates(long n)
+/* Rademacher */
+int gen_rademacher(void)
 {
-	return genirwinhall(n) / n;
+	if (ranf() <= 0.5)
+		return -1;
+	return 1;	
+}
+
+/* Rayleigh */
+double gen_rayleigh(double sigma)
+{
+	return sigma * sqrt(-2 * log(1.0 - ranf()));
+}
+
+/* Pareto */
+double gen_pareto(double a, double m)
+{
+	return m * pow(1 - ranf(), 1.0 / a);
+}
+
+/* Rectangular */
+double gen_rectangular(void)
+{
+	return (ranf() - 0.5);	
 }
 
 /* Triangular */

data/lib/ext/xrandlib.h

@@ -17,8 +17,13 @@
 #ifndef _XRANDLIB_H_
 #define _XRANDLIB_H_
 
-extern int gen_bernoulli(double);
-extern double gen_exponential(double);
-extern double gen_rayleigh(double);
+extern int 	gen_bernoulli(double);
+extern double 	gen_chi_squared(long);
+extern long	gen_discrete_uniform(long a, long b);
+extern double 	gen_exponential(double);
+extern double	gen_pareto(double, double);
+extern int 	gen_rademacher(void);
+extern double 	gen_rayleigh(double);
+extern double	gen_rectangular(void);
 
 #endif /* _XRANDLIB_H_ */

data/lib/random_variable.rb

@@ -32,6 +32,7 @@
 =end
 
 require_relative 'ext/random_variable'
+require_relative 'sampleable'
 
 module RandomVariable 
 	# obtain the current seed in use
@@ -63,14 +64,34 @@ module RandomVariable
 		distros
 	end
 	
-	class Generic	
+	class Generic
+		include Sampleable
+
 		klass = self
 
 		def initialize(&blk)
 			@blk = blk
+			
+			class << self
+				def outcome
+					@blk.call
+				end
+				alias :sample :outcome
+
+				def outcomes(nr_samples)
+					ary = []
+					nr_samples.times do
+						ary << @blk.call
+					end
+					class << ary
+						include RandomVariable::Samples
+					end
+					ary
+				end
+				alias :samples :outcomes
+			end
 		end
 
-
 		operators = %w(+ - * / % **)
 
 		operators.each do |op|
@@ -85,22 +106,6 @@ module RandomVariable
 			end
 		end
 
-		# obtain a single outcome from the random variable
-		def outcome
-			@blk.call
-		end
-		alias :sample :outcome
-
-		# obtain +number+ outcomes from the random variable
-		def outcomes(number)
-			ary = []
-			number.times do
-				ary << @blk.call
-			end
-			ary	
-		end
-		alias :samples :outcomes
-	
 	end
 end
 

data/lib/sampleable.rb

@@ -0,0 +1,32 @@
+################################################################################
+#                                                                              #
+# File:     sampleable.rb                                                      #
+#                                                                              #
+################################################################################
+#                                                                              #
+# Author:   Jorge F.M. Rinaldi                                                 #
+# Contact:  jorge.madronal.rinaldi@gmail.com                                   #
+#                                                                              #
+################################################################################
+#                                                                              #
+# Date:     2012/12/02                                                         #
+#                                                                              #
+################################################################################
+
+require_relative 'samples'
+
+module RandomVariable::Sampleable
+	def outcome
+		intern_outcome
+	end
+	alias :sample :outcome
+
+	def outcomes(nr_samples)
+		samples_ary = intern_outcomes(nr_samples)
+		class << samples_ary
+			include RandomVariable::Samples
+		end
+		samples_ary
+	end
+	alias :samples :outcomes
+end

data/lib/samples.rb

@@ -0,0 +1,61 @@
+################################################################################
+#                                                                              #
+# File:     samples.rb                                                         #
+#                                                                              #
+################################################################################
+#                                                                              #
+# Author:   Jorge F.M. Rinaldi                                                 #
+# Contact:  jorge.madronal.rinaldi@gmail.com                                   #
+#                                                                              #
+################################################################################
+#                                                                              #
+# Date:     2012/12/02                                                         #
+#                                                                              #
+################################################################################
+
+module RandomVariable::Samples
+	def iterate_samples
+		self.each_with_index do |sample, i|
+			if block_given? then
+				yield(sample, i)
+			end	
+		end
+	end
+	
+	def max
+		cur_max = self[0]
+		self.iterate_samples do |sample|
+			cur_max = sample if sample > cur_max
+		end
+		cur_max
+	end
+	
+	def min
+		cur_min = self[0]
+		self.iterate_samples do |sample|
+			cur_min = sample if sample < cur_min
+		end
+		cur_min
+	end
+
+	def mean
+		return nil if 0 == self.size
+		acc = 0.0
+		self.iterate_samples do |sample|
+			acc += sample
+		end
+		acc / self.size
+	end
+
+	def median
+		return nil if 0 == self.size
+		return self[0] if 1 == self.size
+		ary = self.sort
+		i = ary.len / 2
+		if ary.len.even? then
+			return (ary[i] + ary[i-1]) / 2.0
+		else
+			return ary[i]
+		end
+	end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: random_variable
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-02 00:00:00.000000000 Z
+date: 2012-12-15 00:00:00.000000000 Z
 dependencies: []
-description: Create and operate with random variables in Ruby
+description: Probability distributions such as the Binomial, Beta, Chi-Squared, Normal,
+  Pareto, Poisson, etc.
 email: jorge.madronal.rinaldi@gmail.com
 executables: []
 extensions:
@@ -20,6 +21,8 @@ extra_rdoc_files: []
 files:
 - lib/random_variable.rb
 - lib/ext/extconf.rb
+- lib/samples.rb
+- lib/sampleable.rb
 - lib/distros.rb
 - LICENSE
 - COPYING
@@ -56,5 +59,5 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Random Variables in Ruby
+summary: Random Variables in Ruby for a wide variety of probability distributions
 test_files: []