rubystats 0.2.6 → 0.3.0

data/test/tc_beta.rb

@@ -96,5 +96,26 @@ class TestBeta < MiniTest::Unit::TestCase
     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 }
+
+    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

@@ -10,13 +10,27 @@ class TestBinomial < MiniTest::Unit::TestCase
 
     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_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

@@ -57,4 +57,14 @@ class TestExponential < MiniTest::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_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

@@ -28,6 +28,16 @@ class TestNormal < MiniTest::Unit::TestCase
 
     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

data/test/tc_poisson.rb

@@ -0,0 +1,35 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'minitest/autorun'
+require 'rubystats/poisson_distribution'
+
+class TestPoisson < MiniTest::Unit::TestCase
+  def test_simple
+    rate = 3.5
+    k = 6
+    
+    pois = Rubystats::PoissonDistribution.new(rate)
+    cdf = pois.cdf(k)
+    pmf = pois.pmf(k)
+    pdf = pois.pdf(k)
+    mean = pois.mean
+    inv_cdf = pois.icdf(cdf)
+
+    assert_equal pmf, pdf
+    assert_in_delta(0.0770984, pdf, 0.0000001 )
+    assert_in_delta(0.9347119, cdf, 0.0000001)
+    assert_equal(k,inv_cdf)
+    assert_equal(3.5,mean)
+  end
+  
+  def test_rng
+    rate = 3.5
+    pois = Rubystats::PoissonDistribution.new(rate)
+  
+    rngs = []
+    n = 1000
+    n.times { rngs << pois.rng.to_f }
+    avg = rngs.reduce(:+) / rngs.size    
+    
+    assert_in_delta(avg, pois.mean, 0.5)
+  end
+end

data/test/tc_studentt.rb

@@ -0,0 +1,43 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'minitest/autorun'
+require 'rubystats/student_t_distribution'
+
+class TestStudentT < MiniTest::Unit::TestCase
+  def test_pdf
+    t = Rubystats::StudentTDistribution.new(8)
+        
+    pdf = t.pdf(0.0)
+    assert_in_epsilon pdf, 0.386699, 0.000001, "pdf"
+  
+	pdf = t.pdf(1.0)
+    assert_in_epsilon pdf, 0.2276076, 0.000001, "pdf"  
+  end
+
+  def test_properties
+    t = Rubystats::StudentTDistribution.new(8)
+    assert_in_epsilon t.mean, 0.0, 0.01, "mean"
+    assert_in_epsilon t.variance, 1.333, 0.01, "variance"
+  end
+  
+  def test_rng
+    t = Rubystats::StudentTDistribution.new(8)
+    
+    total = 100000
+    values = Array.new(total).map{t.rng}
+
+    mean = values.inject(0.0) {|sum, v| sum + v} / values.size 
+    assert_in_delta mean, 0.0, 0.1, "rng mean"    
+	
+	var = values.inject(0.0) {|sum, v| sum + (v - mean)**2} / values.size 
+    assert_in_delta var, 8.0/(8.0-2.0), 0.1, "rng mean"    
+  end
+  
+  def test_integer_input
+    dfi, dff = 8, 8.0
+	xi,xf = 1, 1.0
+    dti = Rubystats::StudentTDistribution.new(dfi).pdf(xi)
+    dtf = Rubystats::StudentTDistribution.new(dff).pdf(xf)
+    assert_in_delta dti, dtf, 0.000001   
+  end
+  
+end

data/test/tc_unif.rb

@@ -0,0 +1,48 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'minitest/autorun'
+require 'rubystats/uniform_distribution'
+
+class TestUnif < MiniTest::Unit::TestCase
+  def test_cdf
+
+    unif = Rubystats::UniformDistribution.new(1,6)
+    cdf = unif.cdf(2.5)
+
+    assert_equal 0.3, cdf
+  end
+
+  def test_pdf
+    unif = Rubystats::UniformDistribution.new(1.0, 6.0)
+    
+    pdf = unif.pdf(2.5)
+    assert_equal 0.2, pdf
+
+    pdf_out_of_lower_bounds = unif.pdf(0.0)
+    assert_equal 0.0, pdf_out_of_lower_bounds
+ 
+    pdf_out_of_upper_bounds = unif.pdf(8.0)
+    assert_equal 0.0, pdf_out_of_upper_bounds
+  end
+  
+  def test_rng
+    lower, upper = 1,6
+    unif = Rubystats::UniformDistribution.new(lower,upper)
+    
+    total = 10000
+    values = Array.new(total).map{unif.rng}
+    
+    assert_equal values.min >= lower, true
+    assert_equal values.max <= upper, true
+  end
+  
+  def test_integer_input
+    loweri, upperi = 1, 6
+    lowerf, upperf = 1.0, 6.0
+    xi = 3
+    xf = 3.0
+    dunifi = Rubystats::NormalDistribution.new(loweri,upperi).pdf(xi)
+    duniff = Rubystats::NormalDistribution.new(lowerf,upperf).pdf(xf)
+    assert_in_delta dunifi, duniff, 0.00000001   
+  end
+  
+end

data/test/tc_weibull.rb

@@ -0,0 +1,51 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'minitest/autorun'
+require 'rubystats/weibull_distribution'
+
+class TestWeibull < MiniTest::Unit::TestCase
+  def test_simple
+    scale = 6.0
+    shape = 4.0
+    wbd = Rubystats::WeibullDistribution.new(scale,shape)
+    assert_in_delta(5.438415, wbd.mean, 0.000001)
+    assert_in_delta(2.327813, wbd.variance, 0.000001)
+    assert_in_delta(0.0243884, wbd.pdf(2.0), 0.000001)
+    assert_in_delta(0.2381909, wbd.pdf(5.0), 0.000001)
+    assert_in_delta(0.3826092, wbd.cdf(5.0), 0.000001)
+    # make sure the mean of RNG values is close to the expected mean
+    rngs = []
+    n = 10000
+    n.times {|i| rngs << wbd.rng }
+    avg = rngs.inject(0.0) {|sum,x|sum + x} / rngs.size
+    assert_in_delta(avg, 5.438415, 0.1)
+
+    x_vals = [0.5, 1, 1.5, 2, 2.5, 3, 3.5]
+    
+    p_vals = wbd.pdf(x_vals)
+    c_vals = wbd.cdf(x_vals)
+    
+    expected_pvals = [0.00038578, 0.00308404, 0.01037606, 0.02438840, 0.04679345, 0.07828442, 0.11786168]
+    expected_cvals = [0.00004822, 0.00077131, 0.00389863, 0.01226978, 0.02969111, 0.06058694, 0.10933684]
+
+    x_vals.size.times do |i|
+      assert_in_delta expected_pvals[i], p_vals[i], 0.000001
+      assert_in_delta expected_cvals[i], c_vals[i], 0.000001
+    end
+    
+    x_vals.each do |x|
+      cdf = wbd.cdf(x)
+      inv_cdf = wbd.icdf(cdf)
+      assert_in_delta(x, inv_cdf, 0.00000001)
+    end
+  end
+  
+  def test_integer_input
+    scalei,shapei = 6, 4
+    scalef,shapef = 6.0, 4.0
+    xi = 3
+    xf = 3.0
+    dwbi = Rubystats::WeibullDistribution.new(scalei,shapei).pdf(xi)
+    dwbf = Rubystats::WeibullDistribution.new(scalef,shapef).pdf(xf)
+    assert_in_delta dwbi, dwbf, 0.000001   
+  end
+end