statsample 1.4.1 → 1.4.2

data/test/test_srs.rb

@@ -1,9 +1,9 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 
-class StatsampleSrsTestCase < MiniTest::Unit::TestCase
+class StatsampleSrsTestCase < Minitest::Test
   def test_std_error
-    assert_equal(384,Statsample::SRS.estimation_n0(0.05,0.5,0.95).to_i)
-    assert_equal(108,Statsample::SRS.estimation_n(0.05,0.5,150,0.95).to_i)
-    assert_in_delta(0.0289,Statsample::SRS.proportion_sd_kp_wor(0.5,100,150),0.001)
+    assert_equal(384, Statsample::SRS.estimation_n0(0.05, 0.5, 0.95).to_i)
+    assert_equal(108, Statsample::SRS.estimation_n(0.05, 0.5, 150, 0.95).to_i)
+    assert_in_delta(0.0289, Statsample::SRS.proportion_sd_kp_wor(0.5, 100, 150), 0.001)
   end
 end

data/test/test_statistics.rb

@@ -1,77 +1,79 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
-class StatsampleStatisicsTestCase < MiniTest::Unit::TestCase
-
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleStatisicsTestCase < Minitest::Test
   def initialize(*args)
     super
   end
+
   def test_p_using_cdf
-    assert_equal(0.25, Statsample::Test.p_using_cdf(0.25, tails=:left))
-    assert_equal(0.75, Statsample::Test.p_using_cdf(0.25, tails=:right))
-    assert_equal(0.50, Statsample::Test.p_using_cdf(0.25, tails=:both))
-    assert_equal(1, Statsample::Test.p_using_cdf(0.50, tails=:both))
-    assert_equal(0.05, Statsample::Test.p_using_cdf(0.025, tails=:both))
-    assert_in_delta(0.05, Statsample::Test.p_using_cdf(0.975, tails=:both),0.0001)
-    
+    assert_equal(0.25, Statsample::Test.p_using_cdf(0.25, tails = :left))
+    assert_equal(0.75, Statsample::Test.p_using_cdf(0.25, tails = :right))
+    assert_equal(0.50, Statsample::Test.p_using_cdf(0.25, tails = :both))
+    assert_equal(1, Statsample::Test.p_using_cdf(0.50, tails = :both))
+    assert_equal(0.05, Statsample::Test.p_using_cdf(0.025, tails = :both))
+    assert_in_delta(0.05, Statsample::Test.p_using_cdf(0.975, tails = :both), 0.0001)
   end
+
   def test_recode_repeated
-    a=%w{a b c c d d d e}
-    exp=["a","b","c_1","c_2","d_1","d_2","d_3","e"]
-    assert_equal(exp,a.recode_repeated)
+    a = %w(a b c c d d d e)
+    exp = %w(a b c_1 c_2 d_1 d_2 d_3 e)
+    assert_equal(exp, a.recode_repeated)
   end
-  def test_is_number
-    assert("10".is_number?)
-    assert("-10".is_number?)
-    assert("0.1".is_number?)
-    assert("-0.1".is_number?)
-    assert("10e3".is_number?)
-    assert("10e-3".is_number?)
-    assert(!"1212-1212-1".is_number?)
-    assert(!"a10".is_number?)
-    assert(!"".is_number?)
 
+  def test_is_number
+    assert('10'.is_number?)
+    assert('-10'.is_number?)
+    assert('0.1'.is_number?)
+    assert('-0.1'.is_number?)
+    assert('10e3'.is_number?)
+    assert('10e-3'.is_number?)
+    assert(!'1212-1212-1'.is_number?)
+    assert(!'a10'.is_number?)
+    assert(!''.is_number?)
   end
+
   def test_estimation_mean
-    v=([42]*23+[41]*4+[36]*1+[32]*1+[29]*1+[27]*2+[23]*1+[19]*1+[16]*2+[15]*2+[14,11,10,9,7]+ [6]*3+[5]*2+[4,3]).to_vector(:scale)
-    assert_equal(50,v.size)
-    assert_equal(1471,v.sum())
-    #limits=Statsample::SRS.mean_confidence_interval_z(v.mean(), v.sds(), v.size,676,0.80)
+    v = ([42] * 23 + [41] * 4 + [36] * 1 + [32] * 1 + [29] * 1 + [27] * 2 + [23] * 1 + [19] * 1 + [16] * 2 + [15] * 2 + [14, 11, 10, 9, 7] + [6] * 3 + [5] * 2 + [4, 3]).to_vector(:scale)
+    assert_equal(50, v.size)
+    assert_equal(1471, v.sum)
+    # limits=Statsample::SRS.mean_confidence_interval_z(v.mean(), v.sds(), v.size,676,0.80)
   end
+
   def test_estimation_proportion
     # total
-    pop=3042
-    sam=200
-    prop=0.19
+    pop = 3042
+    sam = 200
+    prop = 0.19
     assert_in_delta(81.8, Statsample::SRS.proportion_total_sd_ep_wor(prop, sam, pop), 0.1)
 
     # confidence limits
-    pop=500
-    sam=100
-    prop=0.37
-    a=0.95
-    l= Statsample::SRS.proportion_confidence_interval_z(prop, sam, pop, a)
-    assert_in_delta(0.28,l[0],0.01)
-    assert_in_delta(0.46,l[1],0.01)
+    pop = 500
+    sam = 100
+    prop = 0.37
+    a = 0.95
+    l = Statsample::SRS.proportion_confidence_interval_z(prop, sam, pop, a)
+    assert_in_delta(0.28, l[0], 0.01)
+    assert_in_delta(0.46, l[1], 0.01)
   end
+
   def test_ml
-    if(true)
-      #real=[1,1,1,1].to_vector(:scale)
+    if true
+      # real=[1,1,1,1].to_vector(:scale)
 
-      #pred=[0.0001,0.0001,0.0001,0.0001].to_vector(:scale)
+      # pred=[0.0001,0.0001,0.0001,0.0001].to_vector(:scale)
       # puts  Statsample::Bivariate.maximum_likehood_dichotomic(pred,real)
 
     end
   end
 
-
   def test_simple_linear_regression
-    a=[1,2,3,4,5,6].to_vector(:scale)
-    b=[6,2,4,10,12,8].to_vector(:scale)
-    reg = Statsample::Regression::Simple.new_from_vectors(a,b)
-    assert_in_delta((reg.ssr+reg.sse).to_f,reg.sst,0.001)
-    assert_in_delta(Statsample::Bivariate.pearson(a,b),reg.r,0.001)
-    assert_in_delta(2.4,reg.a,0.01)
-    assert_in_delta(1.314,reg.b,0.001)
-    assert_in_delta(0.657,reg.r,0.001)
-    assert_in_delta(0.432,reg.r2,0.001)
+    a = [1, 2, 3, 4, 5, 6].to_vector(:scale)
+    b = [6, 2, 4, 10, 12, 8].to_vector(:scale)
+    reg = Statsample::Regression::Simple.new_from_vectors(a, b)
+    assert_in_delta((reg.ssr + reg.sse).to_f, reg.sst, 0.001)
+    assert_in_delta(Statsample::Bivariate.pearson(a, b), reg.r, 0.001)
+    assert_in_delta(2.4, reg.a, 0.01)
+    assert_in_delta(1.314, reg.b, 0.001)
+    assert_in_delta(0.657, reg.r, 0.001)
+    assert_in_delta(0.432, reg.r2, 0.001)
   end
 end

data/test/test_stest.rb

@@ -1,56 +1,55 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 
-class StatsampleTestTestCase < MiniTest::Unit::TestCase
+class StatsampleTestTestCase < Minitest::Test
   def test_chi_square_matrix_with_expected
-    real=Matrix[[95,95],[45,155]]
-    expected=Matrix[[68,122],[72,128]]
+    real = Matrix[[95, 95], [45, 155]]
+    expected = Matrix[[68, 122], [72, 128]]
     assert_nothing_raised do
-      Statsample::Test.chi_square(real,expected)
+      Statsample::Test.chi_square(real, expected)
     end
-    chi=Statsample::Test.chi_square(real,expected).chi_square
-    assert_in_delta(32.53,chi,0.1)
-    
+    chi = Statsample::Test.chi_square(real, expected).chi_square
+    assert_in_delta(32.53, chi, 0.1)
   end
+
   def test_chi_square_matrix_only_observed
-    observed=Matrix[[20,30,40],[30,40,50],[60,70,80],[10,20,40]]
+    observed = Matrix[[20, 30, 40], [30, 40, 50], [60, 70, 80], [10, 20, 40]]
     assert_nothing_raised do
       Statsample::Test.chi_square(observed)
     end
-    chi=Statsample::Test.chi_square(observed)
+    chi = Statsample::Test.chi_square(observed)
     assert_in_delta(9.5602, chi.chi_square, 0.0001)
     assert_in_delta(0.1444, chi.probability, 0.0001)
 
     assert_equal(6, chi.df)
-    
   end
-  
+
   def test_u_mannwhitney
-    a=[1,2,3,4,5,6].to_scale
-    b=[0,5,7,9,10,11].to_scale
-    assert_equal(7.5, Statsample::Test.u_mannwhitney(a,b).u)
-    assert_equal(7.5, Statsample::Test.u_mannwhitney(b,a).u)
-    a=[1, 7,8,9,10,11].to_scale
-    b=[2,3,4,5,6,12].to_scale
-    assert_equal(11, Statsample::Test.u_mannwhitney(a,b).u)
+    a = [1, 2, 3, 4, 5, 6].to_scale
+    b = [0, 5, 7, 9, 10, 11].to_scale
+    assert_equal(7.5, Statsample::Test.u_mannwhitney(a, b).u)
+    assert_equal(7.5, Statsample::Test.u_mannwhitney(b, a).u)
+    a = [1, 7, 8, 9, 10, 11].to_scale
+    b = [2, 3, 4, 5, 6, 12].to_scale
+    assert_equal(11, Statsample::Test.u_mannwhitney(a, b).u)
   end
 
-
   def test_levene
-    a=[1,2,3,4,5,6,7,8,100,10].to_scale
-    b=[30,40,50,60,70,80,90,100,110,120].to_scale
-    levene=Statsample::Test::Levene.new([a,b])
+    a = [1, 2, 3, 4, 5, 6, 7, 8, 100, 10].to_scale
+    b = [30, 40, 50, 60, 70, 80, 90, 100, 110, 120].to_scale
+    levene = Statsample::Test::Levene.new([a, b])
     assert_levene(levene)
   end
+
   def test_levene_dataset
-    a=[1,2,3,4,5,6,7,8,100,10].to_scale
-    b=[30,40,50,60,70,80,90,100,110,120].to_scale
-    ds={'a'=>a,'b'=>b}.to_dataset
-    levene=Statsample::Test::Levene.new(ds)
+    a = [1, 2, 3, 4, 5, 6, 7, 8, 100, 10].to_scale
+    b = [30, 40, 50, 60, 70, 80, 90, 100, 110, 120].to_scale
+    ds = { 'a' => a, 'b' => b }.to_dataset
+    levene = Statsample::Test::Levene.new(ds)
     assert_levene(levene)
   end
+
   def assert_levene(levene)
     assert_in_delta(0.778, levene.f, 0.001)
     assert_in_delta(0.389, levene.probability, 0.001)
   end
- 
 end

data/test/test_stratified.rb

@@ -1,17 +1,17 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
-
-class StatsampleStratifiedTestCase < MiniTest::Unit::TestCase
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 
+class StatsampleStratifiedTestCase < Minitest::Test
   def initialize(*args)
     super
   end
+
   def test_mean
-    a=[10,20,30,40,50]
-    b=[110,120,130,140]
-    pop=a+b
-    av=a.to_vector(:scale)
-    bv=b.to_vector(:scale)
-    popv=pop.to_vector(:scale)
-    assert_equal(popv.mean,Statsample::StratifiedSample.mean(av,bv))
+    a = [10, 20, 30, 40, 50]
+    b = [110, 120, 130, 140]
+    pop = a + b
+    av = a.to_vector(:scale)
+    bv = b.to_vector(:scale)
+    popv = pop.to_vector(:scale)
+    assert_equal(popv.mean, Statsample::StratifiedSample.mean(av, bv))
   end
 end

data/test/test_test_f.rb

@@ -1,32 +1,32 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
-class StatsampleTestFTestCase < MiniTest::Unit::TestCase
-  context(Statsample::Test::F) do 
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleTestFTestCase < Minitest::Test
+  context(Statsample::Test::F) do
     setup do
-      @ssb=84
-      @ssw=68
-      @df_num=2
-      @df_den=15
-      @f=Statsample::Test::F.new(@ssb.quo(@df_num),@ssw.quo(@df_den), @df_num, @df_den)
+      @ssb = 84
+      @ssw = 68
+      @df_num = 2
+      @df_den = 15
+      @f = Statsample::Test::F.new(@ssb.quo(@df_num), @ssw.quo(@df_den), @df_num, @df_den)
     end
-    should "have #f equal to msb/msw" do
+    should 'have #f equal to msb/msw' do
       assert_equal((@ssb.quo(@df_num)).quo(@ssw.quo(@df_den)), @f.f)
     end
-    should "have df total equal to df_num+df_den" do
+    should 'have df total equal to df_num+df_den' do
       assert_equal(@df_num + @df_den, @f.df_total)
     end
-    should "have probability near 0.002" do 
+    should 'have probability near 0.002' do
       assert_in_delta(0.002, @f.probability, 0.0005)
     end
-    should "be coerced into float" do
+    should 'be coerced into float' do
       assert_equal(@f.to_f, @f.f)
     end
-    
-    context("method summary") do
+
+    context('method summary') do
       setup do
-        @summary=@f.summary
+        @summary = @f.summary
       end
-      should "have size > 0" do
-        assert(@summary.size>0)
+      should 'have size > 0' do
+        assert(@summary.size > 0)
       end
     end
   end

data/test/test_test_kolmogorovsmirnov.rb

@@ -1,28 +1,28 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
-class StatsampleTestKolmogorovSmirnovTestCase < MiniTest::Unit::TestCase
-  context(Statsample::Test::KolmogorovSmirnov) do 
-    should "calculate correctly D for two given samples" do
-      a=[1.1,2.5,5.6,9]
-      b=[1,2.3,5.8,10]
-      ks=Statsample::Test::KolmogorovSmirnov.new(a,b)
-      assert_equal(0.25,ks.d)
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleTestKolmogorovSmirnovTestCase < Minitest::Test
+  context(Statsample::Test::KolmogorovSmirnov) do
+    should 'calculate correctly D for two given samples' do
+      a = [1.1, 2.5, 5.6, 9]
+      b = [1, 2.3, 5.8, 10]
+      ks = Statsample::Test::KolmogorovSmirnov.new(a, b)
+      assert_equal(0.25, ks.d)
     end
-    should "calculate correctly D for a normal sample and Normal Distribution" do
-      a=[0.30022510,-0.36664035,0.08593404,1.29881130,-0.49878633,-0.63056010, 0.28397638, -0.04913700,0.03566644,-1.33414346]
-      ks=Statsample::Test::KolmogorovSmirnov.new(a,Distribution::Normal)
-      assert_in_delta(0.282, ks.d,0.001)
+    should 'calculate correctly D for a normal sample and Normal Distribution' do
+      a = [0.30022510, -0.36664035, 0.08593404, 1.29881130, -0.49878633, -0.63056010, 0.28397638, -0.04913700, 0.03566644, -1.33414346]
+      ks = Statsample::Test::KolmogorovSmirnov.new(a, Distribution::Normal)
+      assert_in_delta(0.282, ks.d, 0.001)
     end
-    should "calculate correctly D for a variable normal and Normal Distribution" do
-      rng=Distribution::Normal.rng
-      a=100.times.map {rng.call}
-      ks=Statsample::Test::KolmogorovSmirnov.new(a,Distribution::Normal)
-      assert(ks.d<0.15)
+    should 'calculate correctly D for a variable normal and Normal Distribution' do
+      rng = Distribution::Normal.rng
+      a = 100.times.map { rng.call }
+      ks = Statsample::Test::KolmogorovSmirnov.new(a, Distribution::Normal)
+      assert(ks.d < 0.15)
     end
-    
+
     context(Statsample::Test::KolmogorovSmirnov::EmpiricDistribution) do
-      should "Create a correct empirical distribution for an array" do
-        a=[10,9,8,7,6,5,4,3,2,1]
-        ed=Statsample::Test::KolmogorovSmirnov::EmpiricDistribution.new(a)
+      should 'Create a correct empirical distribution for an array' do
+        a = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
+        ed = Statsample::Test::KolmogorovSmirnov::EmpiricDistribution.new(a)
         assert_equal(0, ed.cdf(-2))
         assert_equal(0.5, ed.cdf(5))
         assert_equal(0.5, ed.cdf(5.5))

data/test/test_test_t.rb

@@ -1,62 +1,62 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
-class StatsampleTestTTestCase < MiniTest::Unit::TestCase
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleTestTTestCase < Minitest::Test
   include Statsample::Test
   include Math
-  context T do 
+  context T do
     setup do
-      @a=[30.02, 29.99, 30.11, 29.97, 30.01, 29.99].to_scale
-      @b=[29.89, 29.93, 29.72, 29.98, 30.02, 29.98].to_scale
-      @x1=@a.mean
-      @x2=@b.mean
-      @s1=@a.sd
-      @s2=@b.sd
-      @n1=@a.n
-      @n2=@b.n
-    end
-    should "calculate correctly standard t" do
-      t=Statsample::Test::T.new(@x1, @s1.quo(Math.sqrt(@a.n)), @a.n-1)
+      @a = [30.02, 29.99, 30.11, 29.97, 30.01, 29.99].to_scale
+      @b = [29.89, 29.93, 29.72, 29.98, 30.02, 29.98].to_scale
+      @x1 = @a.mean
+      @x2 = @b.mean
+      @s1 = @a.sd
+      @s2 = @b.sd
+      @n1 = @a.n
+      @n2 = @b.n
+    end
+    should 'calculate correctly standard t' do
+      t = Statsample::Test::T.new(@x1, @s1.quo(Math.sqrt(@a.n)), @a.n - 1)
       assert_equal((@x1).quo(@s1.quo(Math.sqrt(@a.n))), t.t)
-      assert_equal(@a.n-1, t.df)
-      assert(t.summary.size>0)
-    end
-    should "calculate correctly t for one sample" do
-      t1=[6, 4, 6, 7, 4,5,5,12,6,1].to_scale
-      t2=[9, 6, 5,10,10,8,7,10,6,5].to_scale
-      d=t1-t2
-      t=Statsample::Test::T::OneSample.new(d)
+      assert_equal(@a.n - 1, t.df)
+      assert(t.summary.size > 0)
+    end
+    should 'calculate correctly t for one sample' do
+      t1 = [6, 4, 6, 7, 4, 5, 5, 12, 6, 1].to_scale
+      t2 = [9, 6, 5, 10, 10, 8, 7, 10, 6, 5].to_scale
+      d = t1 - t2
+      t = Statsample::Test::T::OneSample.new(d)
       assert_in_delta(-2.631, t.t, 0.001)
-      assert_in_delta( 0.027, t.probability, 0.001)
-      assert_in_delta( 0.76012, t.se, 0.0001)
-      assert(t.summary.size>0)
-    end
-    should "calculate correctly t for two samples" do
-      assert_in_delta(1.959, T.two_sample_independent(@x1, @x2, @s1, @s2, @n1, @n2),0.001)
-      assert_in_delta(1.959, T.two_sample_independent(@x1, @x2, @s1, @s2, @n1, @n2,true),0.001)
-    end
-    should "calculate correctly df for equal and unequal variance" do
-      assert_equal(10,  T.df_equal_variance(@n1,@n2))
-      assert_in_delta(7.03,  T.df_not_equal_variance(@s1,@s2,@n1,@n2),0.001)    
-    end
-    should "calculate all values for T object" do
-      t=Statsample::Test.t_two_samples_independent(@a,@b)
-      assert(t.summary.size>0)
-      assert_in_delta(1.959, t.t_equal_variance,0.001)
-      assert_in_delta(1.959, t.t_not_equal_variance,0.001)
-      assert_in_delta(10, t.df_equal_variance,0.001)
-      assert_in_delta(7.03, t.df_not_equal_variance,0.001)
-      assert_in_delta(0.07856, t.probability_equal_variance,0.001)
-      assert_in_delta(0.09095, t.probability_not_equal_variance,0.001)
-    end
-    should "be the same using shorthand" do
-      v=100.times.map {rand(100)}.to_scale
+      assert_in_delta(0.027, t.probability, 0.001)
+      assert_in_delta(0.76012, t.se, 0.0001)
+      assert(t.summary.size > 0)
+    end
+    should 'calculate correctly t for two samples' do
+      assert_in_delta(1.959, T.two_sample_independent(@x1, @x2, @s1, @s2, @n1, @n2), 0.001)
+      assert_in_delta(1.959, T.two_sample_independent(@x1, @x2, @s1, @s2, @n1, @n2, true), 0.001)
+    end
+    should 'calculate correctly df for equal and unequal variance' do
+      assert_equal(10,  T.df_equal_variance(@n1, @n2))
+      assert_in_delta(7.03,  T.df_not_equal_variance(@s1, @s2, @n1, @n2), 0.001)
+    end
+    should 'calculate all values for T object' do
+      t = Statsample::Test.t_two_samples_independent(@a, @b)
+      assert(t.summary.size > 0)
+      assert_in_delta(1.959, t.t_equal_variance, 0.001)
+      assert_in_delta(1.959, t.t_not_equal_variance, 0.001)
+      assert_in_delta(10, t.df_equal_variance, 0.001)
+      assert_in_delta(7.03, t.df_not_equal_variance, 0.001)
+      assert_in_delta(0.07856, t.probability_equal_variance, 0.001)
+      assert_in_delta(0.09095, t.probability_not_equal_variance, 0.001)
+    end
+    should 'be the same using shorthand' do
+      v = 100.times.map { rand(100) }.to_scale
       assert_equal(Statsample::Test.t_one_sample(v).t, T::OneSample.new(v).t)
     end
-    should "calculate all values for one sample T test" do
-      u=@a.mean+(1-rand*2)
-      tos=T::OneSample.new(@a,{:u=>u})
-      assert_equal((@a.mean-u).quo(@a.sd.quo(sqrt(@a.n))), tos.t)
-      assert_equal(@a.n-1, tos.df)
-      assert(tos.summary.size>0)
+    should 'calculate all values for one sample T test' do
+      u = @a.mean + (1 - rand * 2)
+      tos = T::OneSample.new(@a, u: u)
+      assert_equal((@a.mean - u).quo(@a.sd.quo(sqrt(@a.n))), tos.t)
+      assert_equal(@a.n - 1, tos.df)
+      assert(tos.summary.size > 0)
     end
   end
 end