rubystats 0.2.6 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -96,5 +96,26 @@ class TestBeta < MiniTest::Unit::TestCase
96
96
  ucl=bin.icdf(1-alpha)
97
97
  return ucl
98
98
  end
99
+
100
+ def test_rng_distribution
101
+ p = 4.0
102
+ q = 12.0
103
+ beta = Rubystats::BetaDistribution.new(p,q)
104
+
105
+ total = 10000
106
+ values = Array.new(total).map{ beta.rng }
107
+
108
+ mean = values.inject(0.0) {|sum,v| sum + v} / values.size
109
+ assert_in_epsilon 0.25, mean.round(2), 0.01
110
+ end
99
111
 
112
+ def test_integer_input
113
+ pi, qi = 2, 4
114
+ pf, qf = 2.0, 4.0
115
+ x = 0.25
116
+ dbetai = Rubystats::BetaDistribution.new(pi,qi).pdf(x)
117
+ dbetaf = Rubystats::BetaDistribution.new(pf,qf).pdf(x)
118
+ assert_in_delta dbetai, dbetaf, 0.00000001
119
+ end
120
+
100
121
  end
@@ -10,13 +10,27 @@ class TestBinomial < MiniTest::Unit::TestCase
10
10
 
11
11
  bin = Rubystats::BinomialDistribution.new(t,p)
12
12
  cdf = bin.cdf(f)
13
+ pmf = bin.pmf(f)
13
14
  pdf = bin.pdf(f)
14
15
  mean = bin.mean
15
16
  inv_cdf = bin.icdf(cdf)
16
17
 
18
+ assert_equal pmf, pdf
17
19
  assert_in_delta(0.10602553736479, pdf, 0.00000000000001 )
18
20
  assert_in_delta(0.87203952137960, cdf, 0.00000000000001)
19
21
  assert_equal("5.0",mean.to_s)
20
22
  assert_equal(f,inv_cdf)
21
23
  end
24
+
25
+ def test_rng
26
+ t, p = 100, 0.75
27
+ bin = Rubystats::BinomialDistribution.new(t,p)
28
+
29
+ rngs = []
30
+ n = 1000
31
+ n.times { rngs << bin.rng.to_f }
32
+ avg = rngs.reduce(:+) / rngs.size
33
+
34
+ assert_in_delta(avg, bin.mean, 0.5)
35
+ end
22
36
  end
@@ -0,0 +1,39 @@
1
+ $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
2
+ require 'minitest/autorun'
3
+ require 'rubystats/cauchy_distribution'
4
+
5
+ class TestCauchy < MiniTest::Unit::TestCase
6
+ def test_simple
7
+ location = 0.0
8
+ scale = 0.5
9
+ cd = Rubystats::CauchyDistribution.new(location,scale)
10
+ assert_in_delta(0.6366198, cd.pdf(0.0), 0.000001)
11
+ assert_in_delta(0.5, cd.cdf(0.0), 0.00000001)
12
+ assert_in_delta(3.169765, cd.icdf(0.9502), 0.000001)
13
+
14
+ # make sure the mean of RNG values is close to the expected mean
15
+ rngs = []
16
+ n = 10000
17
+ n.times {|i| rngs << cd.rng }
18
+ quantile = rngs.sort[(0.75*rngs.size).ceil]
19
+ assert_in_delta(quantile, 0.5, 0.1)
20
+
21
+ x_vals = [-2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0]
22
+
23
+ x_vals.each do |x|
24
+ cdf = cd.cdf(x)
25
+ inv_cdf = cd.icdf(cdf)
26
+ assert_in_delta(x, inv_cdf, 0.00000001)
27
+ end
28
+ end
29
+
30
+ def test_integer_input
31
+ locationi, scalei = 3, 1
32
+ locationf, scalef = 3.0, 1.0
33
+ xi = 4
34
+ xf = 4.0
35
+ dcdi = Rubystats::CauchyDistribution.new(locationi,scalei).pdf(xi)
36
+ dcdf = Rubystats::CauchyDistribution.new(locationf,scalef).pdf(xf)
37
+ assert_in_delta dcdi, dcdf, 0.00000001
38
+ end
39
+ end
@@ -57,4 +57,14 @@ class TestExponential < MiniTest::Unit::TestCase
57
57
  assert_in_delta(x, inv_cdf, 0.00000001)
58
58
  end
59
59
  end
60
+
61
+ def test_integer_input
62
+ lambdai = 2
63
+ lambdaf = 2.0
64
+ xi = 3
65
+ xf = 3.0
66
+ dexpi = Rubystats::ExponentialDistribution.new(lambdai).pdf(xi)
67
+ dexpf = Rubystats::ExponentialDistribution.new(lambdaf).pdf(xf)
68
+ assert_in_delta dexpi, dexpf, 0.00000001
69
+ end
60
70
  end
@@ -0,0 +1,39 @@
1
+ $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
2
+ require 'minitest/autorun'
3
+ require 'rubystats/gamma_distribution'
4
+
5
+ class TestGamma < MiniTest::Unit::TestCase
6
+ def test_simple
7
+ shape = 3.0
8
+ scale = 2.0
9
+ gamma = Rubystats::GammaDistribution.new(shape,scale)
10
+
11
+ #check properties
12
+ assert_in_delta(6.0, gamma.mean, 0.000001)
13
+ assert_in_delta(12.0, gamma.variance, 0.000001)
14
+
15
+ #check distributions
16
+ assert_in_delta(0.0, gamma.pdf(0.0), 0.000001)
17
+ assert_in_delta(0.1353353, gamma.pdf(4.0), 0.000001)
18
+ assert_in_delta(0.001134998, gamma.pdf(20.0), 0.000001)
19
+ assert_in_delta(0.5768099, gamma.cdf(6.0), 0.01)
20
+ assert_in_delta(0.986246, gamma.cdf(16.0), 0.01)
21
+
22
+ # make sure the mean of RNG values is close to the expected mean
23
+ rngs = []
24
+ n = 10000
25
+ n.times {|i| rngs << gamma.rng }
26
+ quantile = rngs.sort[(0.75*rngs.size).ceil]
27
+ assert_in_delta(quantile, 7.84080, 0.2)
28
+ end
29
+
30
+ def test_integer_input
31
+ shapei, scalei = 3, 1
32
+ shapef, scalef = 3.0, 1.0
33
+ xi = 4
34
+ xf = 4.0
35
+ pdfi = Rubystats::GammaDistribution.new(shapei,scalei).pdf(xi)
36
+ pdff = Rubystats::GammaDistribution.new(shapef,scalef).pdf(xf)
37
+ assert_in_delta pdfi, pdff, 0.00000001
38
+ end
39
+ end
@@ -0,0 +1,45 @@
1
+ $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
2
+ require 'minitest/autorun'
3
+ require 'rubystats/lognormal_distribution'
4
+
5
+ class TestLognormal < MiniTest::Unit::TestCase
6
+ def test_cdf_pdf
7
+ lnorm = Rubystats::LognormalDistribution.new(2.0,0.2)
8
+
9
+ cdf = lnorm.cdf(8.0)
10
+ assert_in_epsilon cdf, 0.654392, 0.0001, "cdf"
11
+
12
+ pdf = lnorm.pdf(8.0)
13
+ assert_in_epsilon pdf, 0.2304252, 0.000001, "pdf"
14
+
15
+ end
16
+
17
+ def test_properties
18
+ lnorm = Rubystats::LognormalDistribution.new(2.0,0.2)
19
+ assert_in_epsilon lnorm.mean, 7.538325, 0.000001, "mean"
20
+ assert_in_epsilon lnorm.variance, 2.319127, 0.000001, "variance"
21
+ end
22
+
23
+ def test_rng
24
+ lnorm = Rubystats::LognormalDistribution.new(2.0,0.2)
25
+
26
+ total = 100000
27
+ values = Array.new(total).map{lnorm.rng}
28
+
29
+ mean = values.inject(0.0) {|sum, v| sum + v} / values.size
30
+
31
+ assert_in_delta mean, 7.538325, 0.1, "rng mean"
32
+ assert_equal values.min >= 0.0, true, "rng min value"
33
+ end
34
+
35
+ def test_integer_input
36
+ meani, sdi = 2, 1
37
+ meanf, sdf = 2.0, 1.0
38
+ xi = 9
39
+ xf = 9.0
40
+ dlnormi = Rubystats::LognormalDistribution.new(meani,sdi).pdf(xi)
41
+ dlnormf = Rubystats::LognormalDistribution.new(meanf,sdf).pdf(xf)
42
+ assert_in_delta dlnormi, dlnormf, 0.000001
43
+ end
44
+
45
+ end
@@ -0,0 +1,53 @@
1
+ $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
2
+ require 'minitest/autorun'
3
+ require 'rubystats/multivariate_normal_distribution'
4
+
5
+ class TestMultivariateNormal < MiniTest::Unit::TestCase
6
+ def test_simple
7
+ mu = [1.3,-2.5]
8
+ sigma = [[1.0,0.3],[0.3,1.0]]
9
+
10
+ mvnorm = Rubystats::MultivariateNormalDistribution.new(mu,sigma)
11
+
12
+ assert_in_delta(0.0001340771, mvnorm.pdf([1.0,1.0]), 0.000001)
13
+ assert_in_delta(0.131732, mvnorm.pdf([1.0,-2.0]), 0.000001)
14
+
15
+
16
+ # make sure the mean of RNG values is close to the expected mean
17
+ rngs = []
18
+ n = 5000
19
+ n.times {|i| rngs << mvnorm.rng }
20
+
21
+ a,b = rngs.transpose
22
+
23
+ #check means
24
+ mean_a = a.inject(0.0) {|sum,x| sum + x} / a.size
25
+ assert_in_delta(1.3, mean_a, 0.1)
26
+
27
+ mean_b = b.inject(0.0) {|sum,x| sum + x} / b.size
28
+ assert_in_delta(1.3, mean_a, 0.1)
29
+
30
+ #check variances
31
+ var_a = a.inject(0.0) {|sum,x| sum + (x - mean_a)**2 } / a.size
32
+ assert_in_delta(1.0, var_a, 0.1)
33
+
34
+ var_b = b.inject(0.0) {|sum,x| sum + (x - mean_b)**2 } / b.size
35
+ assert_in_delta(1.0, var_b, 0.1)
36
+
37
+ #check correlation
38
+ covariance = a.zip(b).map{|xa,xb| (xa-mean_a)*(xb-mean_b)}.inject(0.0){|sum,x| sum + x} / a.size
39
+ correlation = covariance / Math.sqrt(var_a * var_b)
40
+ assert_in_delta(0.3, correlation, 0.1)
41
+
42
+ end
43
+
44
+ def test_integer_input
45
+ mui, sigmai = [1,2], [[1,0.3],[0.3,1]]
46
+ muf, sigmaf = [1.0,2.0], [[1.0,0.3],[0.3,1.0]]
47
+ xi = [1,1]
48
+ xf = [1.0,1.0]
49
+ dmvnormi = Rubystats::MultivariateNormalDistribution.new(mui,sigmai).pdf(xi)
50
+ dmvnormf = Rubystats::MultivariateNormalDistribution.new(muf,sigmaf).pdf(xf)
51
+ assert_in_delta dmvnormi, dmvnormf, 0.00000001
52
+ end
53
+ end
@@ -28,6 +28,16 @@ class TestNormal < MiniTest::Unit::TestCase
28
28
 
29
29
  three_sigma = two_sigma + histogram[7] + histogram[12]
30
30
  assert_in_epsilon 0.997300203937 , three_sigma.to_f / total, 0.005, 'the 3-sigma-environment should contain 99.7%'
31
-
32
31
  end
32
+
33
+ def test_integer_input
34
+ meani, sdi = 10, 2
35
+ meanf, sdf = 10.0, 2.0
36
+ xi = 11
37
+ xf = 11.0
38
+ dnormi = Rubystats::NormalDistribution.new(meani,sdi).pdf(xi)
39
+ dnormf = Rubystats::NormalDistribution.new(meanf,sdf).pdf(xf)
40
+ assert_in_delta dnormi, dnormf, 0.00000001
41
+ end
42
+
33
43
  end
@@ -0,0 +1,35 @@
1
+ $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
2
+ require 'minitest/autorun'
3
+ require 'rubystats/poisson_distribution'
4
+
5
+ class TestPoisson < MiniTest::Unit::TestCase
6
+ def test_simple
7
+ rate = 3.5
8
+ k = 6
9
+
10
+ pois = Rubystats::PoissonDistribution.new(rate)
11
+ cdf = pois.cdf(k)
12
+ pmf = pois.pmf(k)
13
+ pdf = pois.pdf(k)
14
+ mean = pois.mean
15
+ inv_cdf = pois.icdf(cdf)
16
+
17
+ assert_equal pmf, pdf
18
+ assert_in_delta(0.0770984, pdf, 0.0000001 )
19
+ assert_in_delta(0.9347119, cdf, 0.0000001)
20
+ assert_equal(k,inv_cdf)
21
+ assert_equal(3.5,mean)
22
+ end
23
+
24
+ def test_rng
25
+ rate = 3.5
26
+ pois = Rubystats::PoissonDistribution.new(rate)
27
+
28
+ rngs = []
29
+ n = 1000
30
+ n.times { rngs << pois.rng.to_f }
31
+ avg = rngs.reduce(:+) / rngs.size
32
+
33
+ assert_in_delta(avg, pois.mean, 0.5)
34
+ end
35
+ end
@@ -0,0 +1,43 @@
1
+ $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
2
+ require 'minitest/autorun'
3
+ require 'rubystats/student_t_distribution'
4
+
5
+ class TestStudentT < MiniTest::Unit::TestCase
6
+ def test_pdf
7
+ t = Rubystats::StudentTDistribution.new(8)
8
+
9
+ pdf = t.pdf(0.0)
10
+ assert_in_epsilon pdf, 0.386699, 0.000001, "pdf"
11
+
12
+ pdf = t.pdf(1.0)
13
+ assert_in_epsilon pdf, 0.2276076, 0.000001, "pdf"
14
+ end
15
+
16
+ def test_properties
17
+ t = Rubystats::StudentTDistribution.new(8)
18
+ assert_in_epsilon t.mean, 0.0, 0.01, "mean"
19
+ assert_in_epsilon t.variance, 1.333, 0.01, "variance"
20
+ end
21
+
22
+ def test_rng
23
+ t = Rubystats::StudentTDistribution.new(8)
24
+
25
+ total = 100000
26
+ values = Array.new(total).map{t.rng}
27
+
28
+ mean = values.inject(0.0) {|sum, v| sum + v} / values.size
29
+ assert_in_delta mean, 0.0, 0.1, "rng mean"
30
+
31
+ var = values.inject(0.0) {|sum, v| sum + (v - mean)**2} / values.size
32
+ assert_in_delta var, 8.0/(8.0-2.0), 0.1, "rng mean"
33
+ end
34
+
35
+ def test_integer_input
36
+ dfi, dff = 8, 8.0
37
+ xi,xf = 1, 1.0
38
+ dti = Rubystats::StudentTDistribution.new(dfi).pdf(xi)
39
+ dtf = Rubystats::StudentTDistribution.new(dff).pdf(xf)
40
+ assert_in_delta dti, dtf, 0.000001
41
+ end
42
+
43
+ end
@@ -0,0 +1,48 @@
1
+ $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
2
+ require 'minitest/autorun'
3
+ require 'rubystats/uniform_distribution'
4
+
5
+ class TestUnif < MiniTest::Unit::TestCase
6
+ def test_cdf
7
+
8
+ unif = Rubystats::UniformDistribution.new(1,6)
9
+ cdf = unif.cdf(2.5)
10
+
11
+ assert_equal 0.3, cdf
12
+ end
13
+
14
+ def test_pdf
15
+ unif = Rubystats::UniformDistribution.new(1.0, 6.0)
16
+
17
+ pdf = unif.pdf(2.5)
18
+ assert_equal 0.2, pdf
19
+
20
+ pdf_out_of_lower_bounds = unif.pdf(0.0)
21
+ assert_equal 0.0, pdf_out_of_lower_bounds
22
+
23
+ pdf_out_of_upper_bounds = unif.pdf(8.0)
24
+ assert_equal 0.0, pdf_out_of_upper_bounds
25
+ end
26
+
27
+ def test_rng
28
+ lower, upper = 1,6
29
+ unif = Rubystats::UniformDistribution.new(lower,upper)
30
+
31
+ total = 10000
32
+ values = Array.new(total).map{unif.rng}
33
+
34
+ assert_equal values.min >= lower, true
35
+ assert_equal values.max <= upper, true
36
+ end
37
+
38
+ def test_integer_input
39
+ loweri, upperi = 1, 6
40
+ lowerf, upperf = 1.0, 6.0
41
+ xi = 3
42
+ xf = 3.0
43
+ dunifi = Rubystats::NormalDistribution.new(loweri,upperi).pdf(xi)
44
+ duniff = Rubystats::NormalDistribution.new(lowerf,upperf).pdf(xf)
45
+ assert_in_delta dunifi, duniff, 0.00000001
46
+ end
47
+
48
+ end
@@ -0,0 +1,51 @@
1
+ $:.unshift File.join(File.dirname(__FILE__), "..", "lib")
2
+ require 'minitest/autorun'
3
+ require 'rubystats/weibull_distribution'
4
+
5
+ class TestWeibull < MiniTest::Unit::TestCase
6
+ def test_simple
7
+ scale = 6.0
8
+ shape = 4.0
9
+ wbd = Rubystats::WeibullDistribution.new(scale,shape)
10
+ assert_in_delta(5.438415, wbd.mean, 0.000001)
11
+ assert_in_delta(2.327813, wbd.variance, 0.000001)
12
+ assert_in_delta(0.0243884, wbd.pdf(2.0), 0.000001)
13
+ assert_in_delta(0.2381909, wbd.pdf(5.0), 0.000001)
14
+ assert_in_delta(0.3826092, wbd.cdf(5.0), 0.000001)
15
+ # make sure the mean of RNG values is close to the expected mean
16
+ rngs = []
17
+ n = 10000
18
+ n.times {|i| rngs << wbd.rng }
19
+ avg = rngs.inject(0.0) {|sum,x|sum + x} / rngs.size
20
+ assert_in_delta(avg, 5.438415, 0.1)
21
+
22
+ x_vals = [0.5, 1, 1.5, 2, 2.5, 3, 3.5]
23
+
24
+ p_vals = wbd.pdf(x_vals)
25
+ c_vals = wbd.cdf(x_vals)
26
+
27
+ expected_pvals = [0.00038578, 0.00308404, 0.01037606, 0.02438840, 0.04679345, 0.07828442, 0.11786168]
28
+ expected_cvals = [0.00004822, 0.00077131, 0.00389863, 0.01226978, 0.02969111, 0.06058694, 0.10933684]
29
+
30
+ x_vals.size.times do |i|
31
+ assert_in_delta expected_pvals[i], p_vals[i], 0.000001
32
+ assert_in_delta expected_cvals[i], c_vals[i], 0.000001
33
+ end
34
+
35
+ x_vals.each do |x|
36
+ cdf = wbd.cdf(x)
37
+ inv_cdf = wbd.icdf(cdf)
38
+ assert_in_delta(x, inv_cdf, 0.00000001)
39
+ end
40
+ end
41
+
42
+ def test_integer_input
43
+ scalei,shapei = 6, 4
44
+ scalef,shapef = 6.0, 4.0
45
+ xi = 3
46
+ xf = 3.0
47
+ dwbi = Rubystats::WeibullDistribution.new(scalei,shapei).pdf(xi)
48
+ dwbf = Rubystats::WeibullDistribution.new(scalef,shapef).pdf(xf)
49
+ assert_in_delta dwbi, dwbf, 0.000001
50
+ end
51
+ end