rubystats 0.1.2 → 0.2.0

data/lib/normal_distribution.rb

@@ -1,114 +0,0 @@
-require 'probability_distribution'
-require 'modules/special_math'
-# This class provides an object for encapsulating normal distributions
-# Ported to Ruby from PHPMath class by Bryan Donovan
-# Author:: Jaco van Kooten 
-# Author:: Paul Meagher
-# Author:: Bryan Donovan (mailto:bryandonovan@myrealbox.com)
-
-class NormalDistribution < ProbabilityDistribution
-	include SpecialMath
-
-	# Constructs a normal distribution (defaults to zero mean and
-	# unity variance).
-	def initialize(mu=0.0, sigma=1.0)
-		@mean = mu
-		if sigma <= 0.0
-			return "error"
-		end
-		@stdev = sigma
-		@variance = sigma**2
-		@pdf_denominator = Sqrt2pi * Math.sqrt(@variance)
-		@cdf_denominator = Sqrt2   * Math.sqrt(@variance)
-	end
-
-	# Returns the mean of the distribution
-	def get_mean 
-		return @mean
-	end
-
-	# Returns the standard deviation of the distribution
-	def get_standard_deviation
-		return @stdev
-	end
-
-	# Returns the variance of the distribution
-	def get_variance
-		return @variance
-	end
-
-	private
-
-	# Obtain single PDF value
-	# Returns the probability that a stochastic variable x has the value X,
-	# i.e. P(x=X)
-	def get_pdf(x)
-		Math.exp( -((x-@mean)**2) / (2 * @variance)) / @pdf_denominator
-	end
-
-	# Obtain single CDF value
-	# Returns the probability that a stochastic variable x is less than X,
-	# i.e. P(x<X)
-	def get_cdf(x)
-		complementary_error( -(x - @mean) / @cdf_denominator) / 2
-	end
-
-	# Obtain single inverse CDF value.
-	#	returns the value X for which P(x&lt;X).
-	def get_icdf(p)
-		check_range(p)
-		if p == 0.0
-			return -Max_value
-		end
-		if p == 1.0
-			return Max_value
-		end
-		if p == 0.5
-			return @mean
-		end
-
-		mean_save = @mean
-		var_save = @variance
-		pdf_D_save = @pdf_denominator
-		cdf_D_save = @cdf_denominator
-		@mean = 0.0
-		@variance = 1.0
-		@pdf_denominator = Math.sqrt(Two_pi)
-		@cdf_denominator = Sqrt2
-		x = find_root(p, 0.0, -100.0, 100.0)
-		#scale back
-		@mean = mean_save
-		@variance = var_save
-		@pdf_denominator = pdf_D_save
-		@cdf_denominator = cdf_D_save
-		return x * Math.sqrt(@variance) + @mean
-	end
-
-	# Uses the polar form of the Box-Muller transformation which
-	#	is both faster and more robust numerically than basic Box-Muller
-	# transform. To speed up repeated RNG computations, two random values
-	# are computed after the while loop and the second one is saved and
-	# directly used if the method is called again.
-	# see http://www.taygeta.com/random/gaussian.html
-	# returns single normal deviate
-	def get_rng
-		if @use_last
-			y1 = @last
-			@use_last = false
-		else
-			until w < 1.0 do
-				r1 = Kernel.rand
-				r2 = Kernel.rand
-				x1 = 2.0 * r1 - 1.0
-				x2 = 2.0 * r2 - 1.0
-				w  = x1 * x1 * x2 * x2
-			end
-			w = Math.sqrt((-2.0 * Math.log(w)) / w)
-			y1 = x1 * w
-			@last = x2 * w
-			@use_last = true
-		end
-		return @mean + y1 * Math.sqrt(@variance)
-	end
-end
-				

data/lib/probability_distribution.rb

@@ -1,132 +0,0 @@
-require 'modules/numerical_constants'
-require 'modules/extra_math'
-require 'modules/special_math'
-
-class ProbabilityDistribution
-	include NumericalConstants
-	include SpecialMath
-	include ExtraMath
-
-	def initialize
-	end
-
-	def mean
-		get_mean
-	end
-
-	def get_mean
-	end
-
-
-	def pdf(x) 
-		if x.class == Array
-			pdf_vals = []
-			for i in (0..x.length)
-				pdf_vals[i] = get_pdf(x[i])
-			end
-			return pdf_vals
-		else
-			return get_pdf(x)
-		end
-	end
-
-	def get_pdf(x)
-	end
-
-	def cdf(x)
-		if x.class == Array
-			cdf_vals = []
-			for i in (0...x.size)
-				cdf_vals[i] = get_cdf(x[i])
-			end
-			return cdf_vals
-		else
-			return get_cdf(x)
-		end
-	end
-
-	def get_cdf(x)
-	end
-
-	def icdf(p)
-		if p.class == Array
-			inv_vals = []
-			for i in (0..p.length)
-				inv_vals[i] = get_icdf(p[i])
-			end
-			return inv_vals
-		else
-			return get_icdf(p)
-		end
-	end
-
-	def get_icdf(p)
-	end
-
-	def rng(n=1)
-		if n < 1
-			return "Number of random numbers to return must be 1 or greater"
-		end
-		if (n > 1)
-			rnd_vals = []
-			for i in (0..n)
-				rnd_vals[i] = get_rng()
-			end
-			return rnd_vals
-		else
-			return get_rng()
-		end
-	end
-
-	def get_rng() 
-	end
-
-	def check_range(x, lo=0.0, hi=1.0)
-		if (x < lo) || (x > hi)
-			return "error"
-		end
-	end
-
-	def get_factorial(n)
-		if n <= 1
-			return 1
-		else 
-			return n * get_factorial(n-1)
-		end
-	end
-
-	def find_root (prob, guess, x_lo, x_hi) 
-		accuracy = 1.0e-10
-		max_iteration = 150
-		x 		= guess
-		x_new = guess
-		error = 0.0
-		pdf 	= 0.0
-		dx 		= 1000.0
-		i 		= 0
-		while ( dx.abs > accuracy && (i += 1) < max_iteration )
-			#Apply Newton-Raphson step
-			error = cdf(x) - prob
-			if error < 0.0
-				x_lo = x
-			else
-				x_hi = x
-			end
-			pdf = pdf(x)
-			if pdf != 0.0
-				dx = error / pdf
-				x_new = x -dx
-			end
-			# If the NR fails to converge (which for example may be the 
-			# case if the initial guess is to rough) we apply a bisection
-			# step to determine a more narrow interval around the root.
-			if  x_new < x_lo || x_new > x_hi || pdf == 0.0
-				x_new = (x_lo + x_hi) / 2.0
-				dx = x_new - x
-			end
-			x = x_new
-		end
-		return x
-	end
-end
-

data/tests/tc_norm.rb

@@ -1,13 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
-require 'test/unit'
-require 'normal_distribution'
-
-class TestNormal < Test::Unit::TestCase
-	def test_simple
-
-		norm = NormalDistribution.new(10,2)
-		cdf = norm.cdf(11)
-
-		assert_equal("0.691462461274013",cdf.to_s)
-	end
-end