rubystats 0.2.3 → 0.4.1

data/lib/rubystats/weibull_distribution.rb

@@ -0,0 +1,56 @@
+require 'rubystats/probability_distribution'
+module Rubystats
+  class WeibullDistribution < Rubystats::ProbabilityDistribution
+    include Rubystats::NumericalConstants
+   
+    def initialize(scale=1.0, shape=1.0) 
+      if scale <= 0.0
+        raise ArgumentError.new("Scale parameter should be greater than zero.")
+      end
+      if shape <= 0.0
+        raise ArgumentError.new("Shape parameter should be greater than zero.")
+      end
+      @scale = scale.to_f 
+      @shape = shape.to_f 
+    end
+
+    private
+
+    def get_mean 
+      @scale * Math.gamma(1.0 + 1.0 / @shape) 
+    end
+
+    def get_variance 
+      @scale**2 * (Math.gamma(1.0 + 2.0 / @shape) - (Math.gamma(1.0 + 1.0 / @shape))**2)
+    end
+
+    # Private method to obtain single PDF value.
+    # x should be greater than or equal to 0.0  
+    # returns the probability that a stochastic variable x has the value X, i.e. P(x=X). 
+    def get_pdf(x) 
+      check_range(x, 0.0, MAX_VALUE)
+      (@shape / @scale) * (x / @scale)**(@shape-1.0) * Math.exp(-1.0 * ((x/@scale)**@shape))
+    end
+
+    # Private method to obtain single CDF value.
+    # param x should be greater than 0    
+    # return the probability that a stochastic variable x is less then X, i.e. P(x<X).
+    def get_cdf(x)
+      check_range(x,0.0,MAX_VALUE)
+      1.0 - Math.exp(-1.0 * ((x.to_f/@scale)**@shape))    
+    end
+
+    # Private method to obtain single inverse CDF value.
+    # return the value X for which P(x<X).
+    def get_icdf(p) 
+      check_range(p)
+      @scale * (-1.0 * Math.log(1.0 - p.to_f))**(1.0 / @shape)
+    end
+
+    # Private method to obtain single RNG value.
+    def get_rng   
+      self.icdf(Kernel.rand)
+    end
+
+  end
+end

data/lib/rubystats.rb

@@ -1,10 +1,44 @@
-module Rubystats
-  VERSION = '0.2.3'
-end
-
 require 'rubystats/normal_distribution'
 require 'rubystats/binomial_distribution'
+require 'rubystats/poisson_distribution'
 require 'rubystats/beta_distribution'
 require 'rubystats/fishers_exact_test'
 require 'rubystats/exponential_distribution'
-include Rubystats
+require 'rubystats/uniform_distribution'
+require 'rubystats/lognormal_distribution'
+require 'rubystats/student_t_distribution'
+require 'rubystats/weibull_distribution'
+require 'rubystats/cauchy_distribution'
+require 'rubystats/gamma_distribution'
+require 'rubystats/multivariate_normal_distribution'
+require 'rubystats/version'
+
+module Rubystats
+end
+
+NormalDistribution = Rubystats::NormalDistribution
+BinomialDistribution = Rubystats::BinomialDistribution
+PoissonDistribution = Rubystats::PoissonDistribution
+BetaDistribution = Rubystats::BetaDistribution
+FishersExactTest = Rubystats::FishersExactTest
+ExponentialDistribution = Rubystats::ExponentialDistribution
+UniformDistribution = Rubystats::UniformDistribution
+LognormalDistribution = Rubystats::LognormalDistribution
+StudentTDistribution = Rubystats::StudentTDistribution
+WeibullDistribution = Rubystats::WeibullDistribution
+CauchyDistribution = Rubystats::CauchyDistribution
+GammaDistribution = Rubystats::GammaDistribution
+MultivariateNormalDistribution = Rubystats::MultivariateNormalDistribution
+
+#short-hand notation
+Normal = Rubystats::NormalDistribution
+Binomial = Rubystats::BinomialDistribution
+Poisson = Rubystats::PoissonDistribution
+Beta = Rubystats::BetaDistribution
+Exponential = Rubystats::ExponentialDistribution
+Uniform = Rubystats::UniformDistribution
+Lognormal = Rubystats::LognormalDistribution
+Weibull = Rubystats::WeibullDistribution
+Cauchy = Rubystats::CauchyDistribution
+Gamma = Rubystats::GammaDistribution
+MultivariateNormal = Rubystats::MultivariateNormalDistribution

data/rubystats.gemspec

@@ -0,0 +1,28 @@
+$LOAD_PATH << File.expand_path("../lib", __FILE__)
+require 'rubystats/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'rubystats'
+  s.version     = Rubystats::VERSION
+  s.license     = "MIT"
+  s.summary     = ''
+  s.description = "Ruby Stats is a port of the statistics libraries from PHPMath. Probability distributions include binomial, beta, and normal distributions with PDF, CDF and inverse CDF as well as Fisher's Exact Test."
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- Appraisals {test,spec,features,gemfiles}/*`.split("\n")
+
+  s.require_paths = ['lib']
+  s.required_ruby_version = Gem::Requirement.new(">= 1.9.3")
+
+  s.authors = ['Ilya Scharrenbroich', 'Bryan Donovan - http://www.bryandonovan.com', 'Phillip Baker']
+
+  s.homepage = 'https://github.com/phillbaker/rubystats'
+
+  s.add_development_dependency("minitest", ">= 4.2", "< 5.0")
+  s.add_development_dependency("hoe", ">= 1.7.0")
+
+  # matrix was removed from default gems in Ruby 3.1, see
+  # https://github.com/ruby/ruby/pull/4530 and https://stdgems.org/
+  s.add_runtime_dependency("matrix")
+end
+

data/test/tc_beta.rb

@@ -1,51 +1,51 @@
 $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
-require 'test/unit'
+require 'minitest/autorun'
 require 'rubystats/beta_distribution'
 
-class TestBeta < Test::Unit::TestCase
-	def test_simple
-		p = 12
-		q = 59
-		beta = Rubystats::BetaDistribution.new(p,q)
-		assert_equal("0.169014084507042", beta.mean.to_s)
-		assert_equal("0.0441664031038187", beta.standard_deviation.to_s)
-		assert_equal("6.26075815849967", beta.pdf(0.2).to_s)
-		assert_equal("0.999999997766913", beta.cdf(0.50).to_s)
-		assert_equal("0.102003194113565", beta.icdf(0.05).to_s)
+class TestBeta < MiniTest::Unit::TestCase
+  def test_simple
+    p = 12
+    q = 59
+    beta = Rubystats::BetaDistribution.new(p,q)
+    assert_equal("0.16901408450704225", beta.mean.to_s)
+    assert_equal("0.04416640310381873", beta.standard_deviation.to_s)
+    assert_equal("6.260758158499666", beta.pdf(0.2).to_s)
+    assert_equal("0.9999999977669126", beta.cdf(0.50).to_s)
+    assert_equal("0.10200319411356515", beta.icdf(0.05).to_s)
+
+    x_vals = [0.1, 0.15, 0.2, 0.25, 0.3, 0.35]
+    p_vals = beta.pdf(x_vals)
+    c_vals = beta.cdf(x_vals)
+    expected_pvals = [ 2.83232625227534,
+      8.89978000366836,
+      6.26075815849967,
+      1.72572305993386,
+      0.234475706454223,
+      0.0173700433944934]
+    expected_cvals = [0.0440640755091473,
+      0.356009606171447,
+      0.768319101921981,
+      0.956058132801147,
+      0.995358286711105,
+      0.99971672771575]
 
-		x_vals = [0.1, 0.15, 0.2, 0.25, 0.3, 0.35]
-		p_vals = beta.pdf(x_vals)
-		c_vals = beta.cdf(x_vals)
-		expected_pvals = [ 2.83232625227534,
-			8.89978000366836,
-			6.26075815849967,
-			1.72572305993386,
-			0.234475706454223,
-			0.0173700433944934]
-		expected_cvals = [0.0440640755091473,
-			0.356009606171447,
-			0.768319101921981,
-			0.956058132801147,
-			0.995358286711105,
-			0.99971672771575]
-     
     0.upto(x_vals.size - 1) do |i|
       assert_in_delta expected_pvals[i], p_vals[i], 0.00000001
       assert_in_delta expected_cvals[i], c_vals[i], 0.00000001
       i += 1
     end
 
-		x_vals.each do |x|
-			cdf = beta.cdf(x)
-			inv_cdf = beta.icdf(cdf)
-			assert_in_delta(x, inv_cdf, 0.00000001)
-		end
-	end
+    x_vals.each do |x|
+      cdf = beta.cdf(x)
+      inv_cdf = beta.icdf(cdf)
+      assert_in_delta(x, inv_cdf, 0.00000001)
+    end
+  end
 
   def test_low_p_and_q_values
-		p = 1.5 
-		q = 1.0 
-		beta = Rubystats::BetaDistribution.new(p,q)
+    p = 1.5
+    q = 1.0
+    beta = Rubystats::BetaDistribution.new(p,q)
 
     #from PHPExcel/PHPMath output
     expected_icdf_vals = [
@@ -60,41 +60,62 @@ class TestBeta < Test::Unit::TestCase
     end
   end
 
-	def test_control_limits
-		trials = 50
-		alpha = 0.05
-		p = 10
-		lcl = get_lower_limit(trials, alpha, p)
-		ucl = get_upper_limit(trials, alpha, p)
-		assert_equal("0.112721613414076",lcl.to_s)
-		assert_equal("0.315596061420013",ucl.to_s)
+  def test_control_limits
+    trials = 50
+    alpha = 0.05
+    p = 10
+    lcl = get_lower_limit(trials, alpha, p)
+    ucl = get_upper_limit(trials, alpha, p)
+    assert_equal("0.1127216134140763",lcl.to_s)
+    assert_equal("0.3155960614200132",ucl.to_s)
+
+    trials = 210
+    alpha = 0.10
+    p = 47
+    lcl = get_lower_limit(trials, alpha, p)
+    ucl = get_upper_limit(trials, alpha, p)
+    assert_equal("0.18667948526990116",lcl.to_s)
+    assert_equal("0.2649576017835441",ucl.to_s)
+  end
 
-		trials = 210 
-		alpha = 0.10
-		p = 47 
-		lcl = get_lower_limit(trials, alpha, p)
-		ucl = get_upper_limit(trials, alpha, p)
-		assert_equal("0.186679485269901",lcl.to_s)
-		assert_equal("0.264957601783544",ucl.to_s)
-	end
+  def get_lower_limit(trials,alpha,p)
+    if p==0
+      lcl=0
+    else
+      q=trials-p+1
+      bin= Rubystats::BetaDistribution.new(p,q)
+      lcl=bin.icdf(alpha)
+    end
+    return lcl
+  end
 
-	def get_lower_limit(trials,alpha,p)
-		if p==0
-			lcl=0
-		else
-			q=trials-p+1
-			bin= Rubystats::BetaDistribution.new(p,q)
-			lcl=bin.icdf(alpha)
-		end
-		return lcl
-	end
+  def get_upper_limit(trials,alpha,p)
+    q=trials-p
+    p=p+1
+    bin= Rubystats::BetaDistribution.new(p,q)
+    ucl=bin.icdf(1-alpha)
+    return ucl
+  end
+  
+  def test_rng_distribution
+    p = 4.0
+    q = 12.0
+    beta = Rubystats::BetaDistribution.new(p,q)
+	
+    total = 10000
+    values = Array.new(total).map{ beta.rng }
 
-	def get_upper_limit(trials,alpha,p)
-		q=trials-p
-		p=p+1
-		bin= Rubystats::BetaDistribution.new(p,q)
-		ucl=bin.icdf(1-alpha)
-		return ucl
-	end
+    mean = values.inject(0.0) {|sum,v| sum + v} / values.size
+    assert_in_epsilon 0.25, mean.round(2), 0.01	
+  end
 
+  def test_integer_input
+    pi, qi = 2, 4
+    pf, qf = 2.0, 4.0
+    x = 0.25
+    dbetai = Rubystats::BetaDistribution.new(pi,qi).pdf(x)
+    dbetaf = Rubystats::BetaDistribution.new(pf,qf).pdf(x)
+    assert_in_delta dbetai, dbetaf, 0.00000001   
+  end
+  
 end

data/test/tc_binomial.rb

@@ -1,22 +1,36 @@
 $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
-require 'test/unit'
+require 'minitest/autorun'
 require 'rubystats/binomial_distribution'
 
-class TestBinomial < Test::Unit::TestCase
-	def test_simple
-		t = 100 
-		f = 7 
-		p = 0.05
+class TestBinomial < MiniTest::Unit::TestCase
+  def test_simple
+    t = 100
+    f = 7
+    p = 0.05
 
-		bin = Rubystats::BinomialDistribution.new(t,p)
-		cdf = bin.cdf(f)
-		pdf = bin.pdf(f)
-		mean = bin.mean
-		inv_cdf = bin.icdf(cdf)
+    bin = Rubystats::BinomialDistribution.new(t,p)
+    cdf = bin.cdf(f)
+    pmf = bin.pmf(f)
+    pdf = bin.pdf(f)
+    mean = bin.mean
+    inv_cdf = bin.icdf(cdf)
 
-		assert_in_delta(0.10602553736479, pdf, 0.00000000000001 )
-		assert_in_delta(0.87203952137960, cdf, 0.00000000000001)
-		assert_equal("5.0",mean.to_s)
-		assert_equal(f,inv_cdf)
-	end
+    assert_equal pmf, pdf
+    assert_in_delta(0.10602553736479, pdf, 0.00000000000001 )
+    assert_in_delta(0.87203952137960, cdf, 0.00000000000001)
+    assert_equal("5.0",mean.to_s)
+    assert_equal(f,inv_cdf)
+  end
+  
+  def test_rng
+    t, p = 100, 0.75
+    bin = Rubystats::BinomialDistribution.new(t,p)
+  
+    rngs = []
+    n = 1000
+    n.times { rngs << bin.rng.to_f }
+    avg = rngs.reduce(:+) / rngs.size    
+    
+    assert_in_delta(avg, bin.mean, 0.5)
+  end
 end

data/test/tc_cauchy.rb

@@ -0,0 +1,39 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'minitest/autorun'
+require 'rubystats/cauchy_distribution'
+
+class TestCauchy < MiniTest::Unit::TestCase
+  def test_simple
+    location = 0.0
+    scale = 0.5
+    cd = Rubystats::CauchyDistribution.new(location,scale)
+    assert_in_delta(0.6366198, cd.pdf(0.0), 0.000001)
+    assert_in_delta(0.5, cd.cdf(0.0), 0.00000001)
+    assert_in_delta(3.169765, cd.icdf(0.9502), 0.000001)
+   
+   # make sure the mean of RNG values is close to the expected mean
+    rngs = []
+    n = 10000
+    n.times {|i| rngs << cd.rng }
+    quantile = rngs.sort[(0.75*rngs.size).ceil] 
+    assert_in_delta(quantile, 0.5, 0.1)
+
+    x_vals = [-2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0]
+    
+    x_vals.each do |x|
+      cdf = cd.cdf(x)
+      inv_cdf = cd.icdf(cdf)
+      assert_in_delta(x, inv_cdf, 0.00000001)
+    end
+  end
+  
+  def test_integer_input
+    locationi, scalei = 3, 1
+    locationf, scalef = 3.0, 1.0
+    xi = 4
+    xf = 4.0
+    dcdi = Rubystats::CauchyDistribution.new(locationi,scalei).pdf(xi)
+    dcdf = Rubystats::CauchyDistribution.new(locationf,scalef).pdf(xf)
+    assert_in_delta dcdi, dcdf, 0.00000001   
+  end
+end

data/test/tc_exponential.rb

@@ -1,8 +1,8 @@
 $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
-require 'test/unit'
+require 'minitest/autorun'
 require 'rubystats/exponential_distribution'
 
-class TestExponential < Test::Unit::TestCase
+class TestExponential < MiniTest::Unit::TestCase
   def test_simple
     lmbda = 1
     expd = Rubystats::ExponentialDistribution.new(lmbda)
@@ -16,7 +16,7 @@ class TestExponential < Test::Unit::TestCase
     rngs = []
     rngsum = 0
     n = 5000
-    n.times do 
+    n.times do
       rng = expd.rng
       rngs << rng
       rngsum += rng
@@ -57,4 +57,14 @@ class TestExponential < Test::Unit::TestCase
       assert_in_delta(x, inv_cdf, 0.00000001)
     end
   end
+  
+  def test_integer_input
+    lambdai = 2
+    lambdaf = 2.0
+    xi = 3
+    xf = 3.0
+    dexpi = Rubystats::ExponentialDistribution.new(lambdai).pdf(xi)
+    dexpf = Rubystats::ExponentialDistribution.new(lambdaf).pdf(xf)
+    assert_in_delta dexpi, dexpf, 0.00000001   
+  end
 end

data/test/tc_fisher.rb

@@ -1,20 +1,20 @@
 $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
-require 'test/unit'
+require 'minitest/autorun'
 require 'rubystats/fishers_exact_test'
 
-class TestFisher < Test::Unit::TestCase
-	def test_simple
-		tested1 = 20
-		tested2 = 30
-		f1 = 10
-		f2 = 10
-		t1 = tested1 - f1
-		t2 = tested2 - f2
-		fet = Rubystats::FishersExactTest.new
-		fisher = fet.calculate(t1,t2,f1,f2)
+class TestFisher < MiniTest::Unit::TestCase
+  def test_simple
+    tested1 = 20
+    tested2 = 30
+    f1 = 10
+    f2 = 10
+    t1 = tested1 - f1
+    t2 = tested2 - f2
+    fet = Rubystats::FishersExactTest.new
+    fisher = fet.calculate(t1,t2,f1,f2)
 
-		assert_equal("0.188301375769922",fisher[:left].to_s)
-		assert_equal("0.929481131661052",fisher[:right].to_s)
-		assert_equal("0.257549242810992",fisher[:twotail].to_s)
-	end
+    assert_equal("0.18830137576992229",fisher[:left].to_s)
+    assert_equal("0.9294811316610517",fisher[:right].to_s)
+    assert_equal("0.2575492428109919",fisher[:twotail].to_s)
+  end
 end

data/test/tc_gamma.rb

@@ -0,0 +1,39 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'minitest/autorun'
+require 'rubystats/gamma_distribution'
+
+class TestGamma < MiniTest::Unit::TestCase
+  def test_simple
+    shape = 3.0
+    scale = 2.0
+    gamma = Rubystats::GammaDistribution.new(shape,scale)
+   
+    #check properties
+    assert_in_delta(6.0, gamma.mean, 0.000001)
+    assert_in_delta(12.0, gamma.variance, 0.000001)
+    
+    #check distributions
+    assert_in_delta(0.0, gamma.pdf(0.0), 0.000001)
+    assert_in_delta(0.1353353, gamma.pdf(4.0), 0.000001)
+    assert_in_delta(0.001134998, gamma.pdf(20.0), 0.000001)
+    assert_in_delta(0.5768099, gamma.cdf(6.0), 0.01)
+    assert_in_delta(0.986246, gamma.cdf(16.0), 0.01)
+    
+   # make sure the mean of RNG values is close to the expected mean
+    rngs = []
+    n = 10000
+    n.times {|i| rngs << gamma.rng }
+    quantile = rngs.sort[(0.75*rngs.size).ceil] 
+    assert_in_delta(quantile, 7.84080, 0.2)
+  end
+  
+  def test_integer_input
+    shapei, scalei = 3, 1
+    shapef, scalef = 3.0, 1.0
+    xi = 4
+    xf = 4.0
+    pdfi = Rubystats::GammaDistribution.new(shapei,scalei).pdf(xi)
+    pdff = Rubystats::GammaDistribution.new(shapef,scalef).pdf(xf)
+    assert_in_delta pdfi, pdff, 0.00000001   
+  end
+end

data/test/tc_lnorm.rb

@@ -0,0 +1,45 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'minitest/autorun'
+require 'rubystats/lognormal_distribution'
+
+class TestLognormal < MiniTest::Unit::TestCase
+  def test_cdf_pdf
+    lnorm = Rubystats::LognormalDistribution.new(2.0,0.2)
+    
+    cdf = lnorm.cdf(8.0)
+    assert_in_epsilon cdf, 0.654392, 0.0001, "cdf"
+  
+    pdf = lnorm.pdf(8.0)
+    assert_in_epsilon pdf, 0.2304252, 0.000001, "pdf"
+  
+  end
+
+  def test_properties
+    lnorm = Rubystats::LognormalDistribution.new(2.0,0.2)
+    assert_in_epsilon lnorm.mean, 7.538325, 0.000001, "mean"
+    assert_in_epsilon lnorm.variance, 2.319127, 0.000001, "variance"
+  end
+  
+  def test_rng
+    lnorm = Rubystats::LognormalDistribution.new(2.0,0.2)
+    
+    total = 100000
+    values = Array.new(total).map{lnorm.rng}
+
+    mean = values.inject(0.0) {|sum, v| sum + v} / values.size
+    
+    assert_in_delta mean, 7.538325, 0.1, "rng mean"
+    assert_equal values.min >= 0.0, true, "rng min value"
+  end
+  
+  def test_integer_input
+    meani, sdi = 2, 1
+    meanf, sdf = 2.0, 1.0
+    xi = 9
+    xf = 9.0
+    dlnormi = Rubystats::LognormalDistribution.new(meani,sdi).pdf(xi)
+    dlnormf = Rubystats::LognormalDistribution.new(meanf,sdf).pdf(xf)
+    assert_in_delta dlnormi, dlnormf, 0.000001   
+  end
+  
+end

data/test/tc_multivariate_normal.rb

@@ -0,0 +1,53 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'minitest/autorun'
+require 'rubystats/multivariate_normal_distribution'
+
+class TestMultivariateNormal < MiniTest::Unit::TestCase
+  def test_simple
+    mu = [1.3,-2.5]
+    sigma = [[1.0,0.3],[0.3,1.0]]    
+    
+    mvnorm = Rubystats::MultivariateNormalDistribution.new(mu,sigma)
+    
+    assert_in_delta(0.0001340771, mvnorm.pdf([1.0,1.0]), 0.000001)
+    assert_in_delta(0.131732, mvnorm.pdf([1.0,-2.0]), 0.000001)
+    
+   
+   # make sure the mean of RNG values is close to the expected mean
+    rngs = []
+    n = 5000
+    n.times {|i| rngs << mvnorm.rng }
+   
+    a,b = rngs.transpose
+   
+    #check means
+    mean_a = a.inject(0.0) {|sum,x| sum + x} / a.size
+    assert_in_delta(1.3, mean_a, 0.1)
+    
+    mean_b = b.inject(0.0) {|sum,x| sum + x} / b.size
+    assert_in_delta(1.3, mean_a, 0.1)
+    
+    #check variances
+    var_a = a.inject(0.0) {|sum,x| sum + (x - mean_a)**2 } / a.size
+    assert_in_delta(1.0, var_a, 0.1)
+    
+    var_b = b.inject(0.0) {|sum,x| sum + (x - mean_b)**2 } / b.size
+    assert_in_delta(1.0, var_b, 0.1)
+    
+    #check correlation
+    covariance = a.zip(b).map{|xa,xb| (xa-mean_a)*(xb-mean_b)}.inject(0.0){|sum,x| sum + x} / a.size
+    correlation = covariance / Math.sqrt(var_a * var_b)
+    assert_in_delta(0.3, correlation, 0.1)    
+    
+  end
+  
+  def test_integer_input
+    mui, sigmai = [1,2], [[1,0.3],[0.3,1]]
+    muf, sigmaf = [1.0,2.0], [[1.0,0.3],[0.3,1.0]]
+    xi = [1,1]
+    xf = [1.0,1.0]
+    dmvnormi = Rubystats::MultivariateNormalDistribution.new(mui,sigmai).pdf(xi)
+    dmvnormf = Rubystats::MultivariateNormalDistribution.new(muf,sigmaf).pdf(xf)
+    assert_in_delta dmvnormi, dmvnormf, 0.00000001   
+  end
+end

data/test/tc_norm.rb

@@ -1,14 +1,43 @@
-$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
-require 'test/unit'
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'minitest/autorun'
 require 'rubystats/normal_distribution'
 
-class TestNormal < Test::Unit::TestCase
-  def test_simple
+class TestNormal < MiniTest::Unit::TestCase
+  def test_cdf
 
     norm = Rubystats::NormalDistribution.new(10,2)
     cdf = norm.cdf(11)
 
-    assert_equal("0.691462461274013",cdf.to_s)
-    assert_not_nil(norm.rng)
+    assert_equal('0.691462461274013', '%.15f' % cdf)
+    refute_nil(norm.rng)
   end
+
+  def test_distribution
+    norm = Rubystats::NormalDistribution.new(10.0, 1.0)
+    assert_instance_of Float, norm.rng
+
+    total = 10000
+    values =Array.new(total).map{norm.rng.to_i}
+    histogram = Hash[*values.group_by{ |v| v }.flat_map{ |k, v| [k, v.size] }]
+
+    one_sigma = histogram[9] + histogram[10]
+    assert_in_epsilon 0.682689492137 , one_sigma.to_f / total, 0.02, 'the 1-sigma-environment should contain 68.3%'
+
+    two_sigma = one_sigma + histogram[8] + histogram[11]
+    assert_in_epsilon 0.954499736104 , two_sigma.to_f / total, 0.01, 'the 2-sigma-environment should contain 95.4%'
+
+    three_sigma = two_sigma + histogram[7] + histogram[12]
+    assert_in_epsilon 0.997300203937 , three_sigma.to_f / total, 0.005, 'the 3-sigma-environment should contain 99.7%'
+  end
+  
+  def test_integer_input
+    meani, sdi = 10, 2
+    meanf, sdf = 10.0, 2.0
+    xi = 11
+    xf = 11.0
+    dnormi = Rubystats::NormalDistribution.new(meani,sdi).pdf(xi)
+    dnormf = Rubystats::NormalDistribution.new(meanf,sdf).pdf(xf)
+    assert_in_delta dnormi, dnormf, 0.00000001   
+  end
+  
 end