statsample 1.4.1 → 1.4.2

data/test/test_bivariate.rb

@@ -1,163 +1,159 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
-class StatsampleBivariateTestCase < MiniTest::Test
-  should "method sum of squares should be correct" do
-    v1=[1,2,3,4,5,6].to_vector(:scale)
-    v2=[6,2,4,10,12,8].to_vector(:scale)
-    assert_equal(23.0, Statsample::Bivariate.sum_of_squares(v1,v2))
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleBivariateTestCase < Minitest::Test
+  should 'method sum of squares should be correct' do
+    v1 = [1, 2, 3, 4, 5, 6].to_vector(:scale)
+    v2 = [6, 2, 4, 10, 12, 8].to_vector(:scale)
+    assert_equal(23.0, Statsample::Bivariate.sum_of_squares(v1, v2))
   end
-  should_with_gsl "return same covariance with ruby and gls implementation" do
-    v1=20.times.collect {|a| rand()}.to_scale
-    v2=20.times.collect {|a| rand()}.to_scale
-    assert_in_delta(Statsample::Bivariate.covariance(v1,v2), Statsample::Bivariate.covariance_slow(v1,v2), 0.001)
+  should_with_gsl 'return same covariance with ruby and gls implementation' do
+    v1 = 20.times.collect { |_a| rand }.to_scale
+    v2 = 20.times.collect { |_a| rand }.to_scale
+    assert_in_delta(Statsample::Bivariate.covariance(v1, v2), Statsample::Bivariate.covariance_slow(v1, v2), 0.001)
   end
 
-  should_with_gsl "return same correlation with ruby and gls implementation" do
-    v1=20.times.collect {|a| rand()}.to_scale
-    v2=20.times.collect {|a| rand()}.to_scale
+  should_with_gsl 'return same correlation with ruby and gls implementation' do
+    v1 = 20.times.collect { |_a| rand }.to_scale
+    v2 = 20.times.collect { |_a| rand }.to_scale
 
-    assert_in_delta(GSL::Stats::correlation(v1.gsl, v2.gsl), Statsample::Bivariate.pearson_slow(v1,v2), 1e-10)
+    assert_in_delta(GSL::Stats.correlation(v1.gsl, v2.gsl), Statsample::Bivariate.pearson_slow(v1, v2), 1e-10)
   end
-  should "return correct pearson correlation" do
-    v1=[6,5,4,7,8,4,3,2].to_vector(:scale)
-    v2=[2,3,7,8,6,4,3,2].to_vector(:scale)
-    assert_in_delta(0.525,Statsample::Bivariate.pearson(v1,v2), 0.001)
-    assert_in_delta(0.525,Statsample::Bivariate.pearson_slow(v1,v2), 0.001)
+  should 'return correct pearson correlation' do
+    v1 = [6, 5, 4, 7, 8, 4, 3, 2].to_vector(:scale)
+    v2 = [2, 3, 7, 8, 6, 4, 3, 2].to_vector(:scale)
+    assert_in_delta(0.525, Statsample::Bivariate.pearson(v1, v2), 0.001)
+    assert_in_delta(0.525, Statsample::Bivariate.pearson_slow(v1, v2), 0.001)
 
-    v3=[6,2,  1000,1000,5,4,7,8,4,3,2,nil].to_vector(:scale)
-    v4=[2,nil,nil,nil,  3,7,8,6,4,3,2,500].to_vector(:scale)
-    assert_in_delta(0.525,Statsample::Bivariate.pearson(v3,v4),0.001)
+    v3 = [6, 2,  1000, 1000, 5, 4, 7, 8, 4, 3, 2, nil].to_vector(:scale)
+    v4 = [2, nil, nil, nil,  3, 7, 8, 6, 4, 3, 2, 500].to_vector(:scale)
+    assert_in_delta(0.525, Statsample::Bivariate.pearson(v3, v4), 0.001)
     # Test ruby method
-    v3a,v4a=Statsample.only_valid v3, v4
-    assert_in_delta(0.525, Statsample::Bivariate.pearson_slow(v3a,v4a),0.001)
+    v3a, v4a = Statsample.only_valid v3, v4
+    assert_in_delta(0.525, Statsample::Bivariate.pearson_slow(v3a, v4a), 0.001)
   end
-  should "return correct values for t_pearson and prop_pearson" do
-    v1=[6,5,4,7,8,4,3,2].to_vector(:scale)
-    v2=[2,3,7,8,6,4,3,2].to_vector(:scale)
-    r=Statsample::Bivariate::Pearson.new(v1,v2)
-    assert_in_delta(0.525,r.r, 0.001)
-    assert_in_delta(Statsample::Bivariate.t_pearson(v1,v2), r.t, 0.001)
-    assert_in_delta(Statsample::Bivariate.prop_pearson(r.t,8,:both), r.probability, 0.001)
-    assert(r.summary.size>0)
+  should 'return correct values for t_pearson and prop_pearson' do
+    v1 = [6, 5, 4, 7, 8, 4, 3, 2].to_vector(:scale)
+    v2 = [2, 3, 7, 8, 6, 4, 3, 2].to_vector(:scale)
+    r = Statsample::Bivariate::Pearson.new(v1, v2)
+    assert_in_delta(0.525, r.r, 0.001)
+    assert_in_delta(Statsample::Bivariate.t_pearson(v1, v2), r.t, 0.001)
+    assert_in_delta(Statsample::Bivariate.prop_pearson(r.t, 8, :both), r.probability, 0.001)
+    assert(r.summary.size > 0)
   end
-  should "return correct correlation_matrix with nils values" do
-    v1=[6,5,4,7,8,4,3,2].to_vector(:scale)
-    v2=[2,3,7,8,6,4,3,2].to_vector(:scale)
-    v3=[6,2,  1000,1000,5,4,7,8].to_vector(:scale)
-    v4=[2,nil,nil,nil,  3,7,8,6].to_vector(:scale)
-    ds={'v1'=>v1,'v2'=>v2,'v3'=>v3,'v4'=>v4}.to_dataset
-    c=Proc.new {|n1,n2|Statsample::Bivariate.pearson(n1,n2)}
-    expected=Matrix[ [c.call(v1,v1),c.call(v1,v2),c.call(v1,v3),c.call(v1,v4)], [c.call(v2,v1),c.call(v2,v2),c.call(v2,v3),c.call(v2,v4)], [c.call(v3,v1),c.call(v3,v2),c.call(v3,v3),c.call(v3,v4)],
-      [c.call(v4,v1),c.call(v4,v2),c.call(v4,v3),c.call(v4,v4)]
+  should 'return correct correlation_matrix with nils values' do
+    v1 = [6, 5, 4, 7, 8, 4, 3, 2].to_vector(:scale)
+    v2 = [2, 3, 7, 8, 6, 4, 3, 2].to_vector(:scale)
+    v3 = [6, 2,  1000, 1000, 5, 4, 7, 8].to_vector(:scale)
+    v4 = [2, nil, nil, nil,  3, 7, 8, 6].to_vector(:scale)
+    ds = { 'v1' => v1, 'v2' => v2, 'v3' => v3, 'v4' => v4 }.to_dataset
+    c = proc { |n1, n2| Statsample::Bivariate.pearson(n1, n2) }
+    expected = Matrix[[c.call(v1, v1), c.call(v1, v2), c.call(v1, v3), c.call(v1, v4)], [c.call(v2, v1), c.call(v2, v2), c.call(v2, v3), c.call(v2, v4)], [c.call(v3, v1), c.call(v3, v2), c.call(v3, v3), c.call(v3, v4)],
+                      [c.call(v4, v1), c.call(v4, v2), c.call(v4, v3), c.call(v4, v4)]
     ]
-    obt=Statsample::Bivariate.correlation_matrix(ds)
+    obt = Statsample::Bivariate.correlation_matrix(ds)
     for i in 0...expected.row_size
       for j in 0...expected.column_size
-        #puts expected[i,j].inspect
-        #puts obt[i,j].inspect
-        assert_in_delta(expected[i,j], obt[i,j],0.0001, "#{expected[i,j].class}!=#{obt[i,j].class}  ")
+        # puts expected[i,j].inspect
+        # puts obt[i,j].inspect
+        assert_in_delta(expected[i, j], obt[i, j], 0.0001, "#{expected[i, j].class}!=#{obt[i, j].class}  ")
       end
     end
-    #assert_equal(expected,obt)
+    # assert_equal(expected,obt)
   end
-  should_with_gsl "return same values for optimized and pairwise covariance matrix" do
-      cases=100
-      v1=Statsample::Vector.new_scale(cases) {rand()}
-      v2=Statsample::Vector.new_scale(cases) {rand()}
-      v3=Statsample::Vector.new_scale(cases) {rand()}
-      v4=Statsample::Vector.new_scale(cases) {rand()}
-      v5=Statsample::Vector.new_scale(cases) {rand()}
+  should_with_gsl 'return same values for optimized and pairwise covariance matrix' do
+    cases = 100
+    v1 = Statsample::Vector.new_scale(cases) { rand }
+    v2 = Statsample::Vector.new_scale(cases) { rand }
+    v3 = Statsample::Vector.new_scale(cases) { rand }
+    v4 = Statsample::Vector.new_scale(cases) { rand }
+    v5 = Statsample::Vector.new_scale(cases) { rand }
 
-      ds={'v1'=>v1,'v2'=>v2,'v3'=>v3,'v4'=>v4,'v5'=>v5}.to_dataset
-      
-      cor_opt=Statsample::Bivariate.covariance_matrix_optimized(ds)
-      
-      cor_pw =Statsample::Bivariate.covariance_matrix_pairwise(ds)
-      assert_equal_matrix(cor_opt,cor_pw,1e-15)
+    ds = { 'v1' => v1, 'v2' => v2, 'v3' => v3, 'v4' => v4, 'v5' => v5 }.to_dataset
+
+    cor_opt = Statsample::Bivariate.covariance_matrix_optimized(ds)
+
+    cor_pw = Statsample::Bivariate.covariance_matrix_pairwise(ds)
+    assert_equal_matrix(cor_opt, cor_pw, 1e-15)
   end
-  should_with_gsl "return same values for optimized and pairwise correlation matrix" do
-    
-    cases=100
-    v1=Statsample::Vector.new_scale(cases) {rand()}
-    v2=Statsample::Vector.new_scale(cases) {rand()}
-    v3=Statsample::Vector.new_scale(cases) {rand()}
-    v4=Statsample::Vector.new_scale(cases) {rand()}
-    v5=Statsample::Vector.new_scale(cases) {rand()}
+  should_with_gsl 'return same values for optimized and pairwise correlation matrix' do
+    cases = 100
+    v1 = Statsample::Vector.new_scale(cases) { rand }
+    v2 = Statsample::Vector.new_scale(cases) { rand }
+    v3 = Statsample::Vector.new_scale(cases) { rand }
+    v4 = Statsample::Vector.new_scale(cases) { rand }
+    v5 = Statsample::Vector.new_scale(cases) { rand }
+
+    ds = { 'v1' => v1, 'v2' => v2, 'v3' => v3, 'v4' => v4, 'v5' => v5 }.to_dataset
 
-    ds={'v1'=>v1,'v2'=>v2,'v3'=>v3,'v4'=>v4,'v5'=>v5}.to_dataset
-    
-    cor_opt=Statsample::Bivariate.correlation_matrix_optimized(ds)
-    
-    cor_pw =Statsample::Bivariate.correlation_matrix_pairwise(ds)
-    assert_equal_matrix(cor_opt,cor_pw,1e-15)
-    
+    cor_opt = Statsample::Bivariate.correlation_matrix_optimized(ds)
+
+    cor_pw = Statsample::Bivariate.correlation_matrix_pairwise(ds)
+    assert_equal_matrix(cor_opt, cor_pw, 1e-15)
   end
-  should "return correct correlation_matrix without nils values" do
-    v1=[6,5,4,7,8,4,3,2].to_vector(:scale)
-    v2=[2,3,7,8,6,4,3,2].to_vector(:scale)
-    v3=[6,2,  1000,1000,5,4,7,8].to_vector(:scale)
-    v4=[2,4,6,7,  3,7,8,6].to_vector(:scale)
-    ds={'v1'=>v1,'v2'=>v2,'v3'=>v3,'v4'=>v4}.to_dataset
-    c=Proc.new {|n1,n2|Statsample::Bivariate.pearson(n1,n2)}
-    expected=Matrix[ [c.call(v1,v1),c.call(v1,v2),c.call(v1,v3),c.call(v1,v4)], [c.call(v2,v1),c.call(v2,v2),c.call(v2,v3),c.call(v2,v4)], [c.call(v3,v1),c.call(v3,v2),c.call(v3,v3),c.call(v3,v4)],
-      [c.call(v4,v1),c.call(v4,v2),c.call(v4,v3),c.call(v4,v4)]
+  should 'return correct correlation_matrix without nils values' do
+    v1 = [6, 5, 4, 7, 8, 4, 3, 2].to_vector(:scale)
+    v2 = [2, 3, 7, 8, 6, 4, 3, 2].to_vector(:scale)
+    v3 = [6, 2,  1000, 1000, 5, 4, 7, 8].to_vector(:scale)
+    v4 = [2, 4, 6, 7,  3, 7, 8, 6].to_vector(:scale)
+    ds = { 'v1' => v1, 'v2' => v2, 'v3' => v3, 'v4' => v4 }.to_dataset
+    c = proc { |n1, n2| Statsample::Bivariate.pearson(n1, n2) }
+    expected = Matrix[[c.call(v1, v1), c.call(v1, v2), c.call(v1, v3), c.call(v1, v4)], [c.call(v2, v1), c.call(v2, v2), c.call(v2, v3), c.call(v2, v4)], [c.call(v3, v1), c.call(v3, v2), c.call(v3, v3), c.call(v3, v4)],
+                      [c.call(v4, v1), c.call(v4, v2), c.call(v4, v3), c.call(v4, v4)]
     ]
-    obt=Statsample::Bivariate.correlation_matrix(ds)
+    obt = Statsample::Bivariate.correlation_matrix(ds)
     for i in 0...expected.row_size
       for j in 0...expected.column_size
-        #puts expected[i,j].inspect
-        #puts obt[i,j].inspect
-        assert_in_delta(expected[i,j], obt[i,j],0.0001, "#{expected[i,j].class}!=#{obt[i,j].class}  ")
+        # puts expected[i,j].inspect
+        # puts obt[i,j].inspect
+        assert_in_delta(expected[i, j], obt[i, j], 0.0001, "#{expected[i, j].class}!=#{obt[i, j].class}  ")
       end
     end
-    #assert_equal(expected,obt)
+    # assert_equal(expected,obt)
   end
 
-  
-  should "return correct value for prop pearson" do
-    assert_in_delta(0.42, Statsample::Bivariate.prop_pearson(Statsample::Bivariate.t_r(0.084,94), 94),0.01)
-    assert_in_delta(0.65, Statsample::Bivariate.prop_pearson(Statsample::Bivariate.t_r(0.046,95), 95),0.01)
-    r=0.9
-    n=100
-    t=Statsample::Bivariate.t_r(r,n)
-    assert(Statsample::Bivariate.prop_pearson(t,n,:both)<0.05)
-    assert(Statsample::Bivariate.prop_pearson(t,n,:right)<0.05)
-    assert(Statsample::Bivariate.prop_pearson(t,n,:left)>0.05)
+  should 'return correct value for prop pearson' do
+    assert_in_delta(0.42, Statsample::Bivariate.prop_pearson(Statsample::Bivariate.t_r(0.084, 94), 94), 0.01)
+    assert_in_delta(0.65, Statsample::Bivariate.prop_pearson(Statsample::Bivariate.t_r(0.046, 95), 95), 0.01)
+    r = 0.9
+    n = 100
+    t = Statsample::Bivariate.t_r(r, n)
+    assert(Statsample::Bivariate.prop_pearson(t, n, :both) < 0.05)
+    assert(Statsample::Bivariate.prop_pearson(t, n, :right) < 0.05)
+    assert(Statsample::Bivariate.prop_pearson(t, n, :left) > 0.05)
 
-    r=-0.9
-    n=100
-    t=Statsample::Bivariate.t_r(r,n)
-    assert(Statsample::Bivariate.prop_pearson(t,n,:both)<0.05)
-    assert(Statsample::Bivariate.prop_pearson(t,n,:right)>0.05)
-    assert(Statsample::Bivariate.prop_pearson(t,n,:left)<0.05)
+    r = -0.9
+    n = 100
+    t = Statsample::Bivariate.t_r(r, n)
+    assert(Statsample::Bivariate.prop_pearson(t, n, :both) < 0.05)
+    assert(Statsample::Bivariate.prop_pearson(t, n, :right) > 0.05)
+    assert(Statsample::Bivariate.prop_pearson(t, n, :left) < 0.05)
   end
 
   should "return correct value for Spearman's rho" do
-    v1=[86,97,99,100,101,103,106,110,112,113].to_vector(:scale)
-    v2=[0,20,28,27,50,29,7,17,6,12].to_vector(:scale)
-    assert_in_delta(-0.175758,Statsample::Bivariate.spearman(v1,v2),0.0001)
-
+    v1 = [86, 97, 99, 100, 101, 103, 106, 110, 112, 113].to_vector(:scale)
+    v2 = [0, 20, 28, 27, 50, 29, 7, 17, 6, 12].to_vector(:scale)
+    assert_in_delta(-0.175758, Statsample::Bivariate.spearman(v1, v2), 0.0001)
   end
-  should "return correct value for point_biserial correlation" do
-    c=[1,3,5,6,7,100,200,300,400,300].to_vector(:scale)
-    d=[1,1,1,1,1,0,0,0,0,0].to_vector(:scale)
+  should 'return correct value for point_biserial correlation' do
+    c = [1, 3, 5, 6, 7, 100, 200, 300, 400, 300].to_vector(:scale)
+    d = [1, 1, 1, 1, 1, 0, 0, 0, 0, 0].to_vector(:scale)
     assert_raises TypeError do
-      Statsample::Bivariate.point_biserial(c,d)
+      Statsample::Bivariate.point_biserial(c, d)
     end
-    assert_in_delta(Statsample::Bivariate.point_biserial(d,c), Statsample::Bivariate.pearson(d,c), 0.0001)
+    assert_in_delta(Statsample::Bivariate.point_biserial(d, c), Statsample::Bivariate.pearson(d, c), 0.0001)
   end
-  should "return correct value for tau_a and tau_b" do
-    v1=[1,2,3,4,5,6,7,8,9,10,11].to_vector(:ordinal)
-    v2=[1,3,4,5,7,8,2,9,10,6,11].to_vector(:ordinal)
-    assert_in_delta(0.6727,Statsample::Bivariate.tau_a(v1,v2),0.001)
-    assert_in_delta(0.6727,Statsample::Bivariate.tau_b((Statsample::Crosstab.new(v1,v2).to_matrix)),0.001)
-    v1=[12,14,14,17,19,19,19,19,19,20,21,21,21,21,21,22,23,24,24,24,26,26,27].to_vector(:ordinal)
-    v2=[11,4,4,2,0,0,0,0,0,0,4,0,4,0,0,0,0,4,0,0,0,0,0].to_vector(:ordinal)
-    assert_in_delta(-0.376201540231705, Statsample::Bivariate.tau_b(Statsample::Crosstab.new(v1,v2).to_matrix),0.001)
+  should 'return correct value for tau_a and tau_b' do
+    v1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].to_vector(:ordinal)
+    v2 = [1, 3, 4, 5, 7, 8, 2, 9, 10, 6, 11].to_vector(:ordinal)
+    assert_in_delta(0.6727, Statsample::Bivariate.tau_a(v1, v2), 0.001)
+    assert_in_delta(0.6727, Statsample::Bivariate.tau_b((Statsample::Crosstab.new(v1, v2).to_matrix)), 0.001)
+    v1 = [12, 14, 14, 17, 19, 19, 19, 19, 19, 20, 21, 21, 21, 21, 21, 22, 23, 24, 24, 24, 26, 26, 27].to_vector(:ordinal)
+    v2 = [11, 4, 4, 2, 0, 0, 0, 0, 0, 0, 4, 0, 4, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0].to_vector(:ordinal)
+    assert_in_delta(-0.376201540231705, Statsample::Bivariate.tau_b(Statsample::Crosstab.new(v1, v2).to_matrix), 0.001)
   end
-  should "return correct value for gamma correlation" do
-    m=Matrix[[10,5,2],[10,15,20]]
-    assert_in_delta(0.636,Statsample::Bivariate.gamma(m),0.001)
-    m2=Matrix[[15,12,6,5],[12,8,10,8],[4,6,9,10]]
-    assert_in_delta(0.349,Statsample::Bivariate.gamma(m2),0.001)
+  should 'return correct value for gamma correlation' do
+    m = Matrix[[10, 5, 2], [10, 15, 20]]
+    assert_in_delta(0.636, Statsample::Bivariate.gamma(m), 0.001)
+    m2 = Matrix[[15, 12, 6, 5], [12, 8, 10, 8], [4, 6, 9, 10]]
+    assert_in_delta(0.349, Statsample::Bivariate.gamma(m2), 0.001)
   end
 end

data/test/test_codification.rb

@@ -1,76 +1,78 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
-class StatsampleCodificationTestCase < MiniTest::Unit::TestCase
-
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleCodificationTestCase < Minitest::Test
   def initialize(*args)
-    v1=%w{run walk,run walking running sleep sleeping,dreaming sleep,dream}.to_vector
-    @dict={'run'=>'r','walk'=>'w','walking'=>'w','running'=>'r','sleep'=>'s', 'sleeping'=>'s', 'dream'=>'d', 'dreaming'=>'d'}
-    @ds={"v1"=>v1}.to_dataset
+    v1 = %w(run walk,run walking running sleep sleeping,dreaming sleep,dream).to_vector
+    @dict = { 'run' => 'r', 'walk' => 'w', 'walking' => 'w', 'running' => 'r', 'sleep' => 's', 'sleeping' => 's', 'dream' => 'd', 'dreaming' => 'd' }
+    @ds = { 'v1' => v1 }.to_dataset
     super
   end
+
   def test_create_hash
-    expected_keys_v1=%w{run walk walking running sleep sleeping dream dreaming}.sort
-    hash=Statsample::Codification.create_hash(@ds,['v1'])
-    assert_equal(['v1'],hash.keys)
-    assert_equal(expected_keys_v1,hash['v1'].keys.sort)
-    assert_equal(expected_keys_v1,hash['v1'].values.sort)
+    expected_keys_v1 = %w(run walk walking running sleep sleeping dream dreaming).sort
+    hash = Statsample::Codification.create_hash(@ds, ['v1'])
+    assert_equal(['v1'], hash.keys)
+    assert_equal(expected_keys_v1, hash['v1'].keys.sort)
+    assert_equal(expected_keys_v1, hash['v1'].values.sort)
   end
+
   def test_create_excel
-    filename=Dir::tmpdir+"/test_excel"+Time.now().to_s+".xls"
-    #filename = Tempfile.new("test_codification_"+Time.now().to_s)
+    filename = Dir.tmpdir + '/test_excel' + Time.now.to_s + '.xls'
+    # filename = Tempfile.new("test_codification_"+Time.now().to_s)
     Statsample::Codification.create_excel(@ds, ['v1'], filename)
-    field=(["v1"]*8).to_vector
-    keys=%w{dream dreaming run running sleep sleeping walk walking}.to_vector
-    ds=Statsample::Excel.read(filename)
+    field = (['v1'] * 8).to_vector
+    keys = %w(dream dreaming run running sleep sleeping walk walking).to_vector
+    ds = Statsample::Excel.read(filename)
     assert_equal(field, ds['field'])
     assert_equal(keys, ds['original'])
     assert_equal(keys, ds['recoded'])
-    hash=Statsample::Codification.excel_to_recoded_hash(filename)
+    hash = Statsample::Codification.excel_to_recoded_hash(filename)
     assert_equal(keys.data, hash['v1'].keys.sort)
     assert_equal(keys.data, hash['v1'].values.sort)
-
   end
+
   def test_create_yaml
-    assert_raise  ArgumentError do
-      Statsample::Codification.create_yaml(@ds,[])
+    assert_raise ArgumentError do
+      Statsample::Codification.create_yaml(@ds, [])
     end
-    expected_keys_v1=%w{run walk walking running sleep sleeping dream dreaming}.sort
-    yaml_hash=Statsample::Codification.create_yaml(@ds,['v1'])
-    h=YAML::load(yaml_hash)
-    assert_equal(['v1'],h.keys)
-    assert_equal(expected_keys_v1,h['v1'].keys.sort)
-    tf = Tempfile.new("test_codification")
-    yaml_hash=Statsample::Codification.create_yaml(@ds,['v1'],tf, Statsample::SPLIT_TOKEN)
+    expected_keys_v1 = %w(run walk walking running sleep sleeping dream dreaming).sort
+    yaml_hash = Statsample::Codification.create_yaml(@ds, ['v1'])
+    h = YAML.load(yaml_hash)
+    assert_equal(['v1'], h.keys)
+    assert_equal(expected_keys_v1, h['v1'].keys.sort)
+    tf = Tempfile.new('test_codification')
+    yaml_hash = Statsample::Codification.create_yaml(@ds, ['v1'], tf, Statsample::SPLIT_TOKEN)
     tf.close
     tf.open
-    h=YAML::load(tf)
-    assert_equal(['v1'],h.keys)
-    assert_equal(expected_keys_v1,h['v1'].keys.sort)
+    h = YAML.load(tf)
+    assert_equal(['v1'], h.keys)
+    assert_equal(expected_keys_v1, h['v1'].keys.sort)
     tf.close(true)
   end
+
   def test_recodification
-    expected=[['r'],['w','r'],['w'],['r'],['s'],['s','d'], ['s','d']]
-    assert_equal(expected,Statsample::Codification.recode_vector(@ds['v1'],@dict))
-    v2=['run','walk,dreaming',nil,'walk,dream,dreaming,walking'].to_vector
-    expected=[['r'],['w','d'],nil,['w','d']]
-    assert_equal(expected,Statsample::Codification.recode_vector(v2,@dict))
+    expected = [['r'], %w(w r), ['w'], ['r'], ['s'], %w(s d), %w(s d)]
+    assert_equal(expected, Statsample::Codification.recode_vector(@ds['v1'], @dict))
+    v2 = ['run', 'walk,dreaming', nil, 'walk,dream,dreaming,walking'].to_vector
+    expected = [['r'], %w(w d), nil, %w(w d)]
+    assert_equal(expected, Statsample::Codification.recode_vector(v2, @dict))
   end
+
   def test_recode_dataset_simple
-    Statsample::Codification.recode_dataset_simple!(@ds,{'v1'=>@dict})
-    expected_vector=['r','w,r','w','r','s','s,d', 's,d'].to_vector
-    assert_not_equal(expected_vector,@ds['v1'])
-    assert_equal(expected_vector,@ds['v1_recoded'])
+    Statsample::Codification.recode_dataset_simple!(@ds, 'v1' => @dict)
+    expected_vector = ['r', 'w,r', 'w', 'r', 's', 's,d', 's,d'].to_vector
+    assert_not_equal(expected_vector, @ds['v1'])
+    assert_equal(expected_vector, @ds['v1_recoded'])
   end
-  def test_recode_dataset_split
-    Statsample::Codification.recode_dataset_split!(@ds,{'v1'=>@dict})
-    e={}
-    e['r']=[1,1,0,1,0,0,0].to_vector
-    e['w']=[0,1,1,0,0,0,0].to_vector
-    e['s']=[0,0,0,0,1,1,1].to_vector
-    e['d']=[0,0,0,0,0,1,1].to_vector
-    e.each{|k,expected|
-      assert_equal(expected,@ds['v1_'+k],"Error on key #{k}")
 
+  def test_recode_dataset_split
+    Statsample::Codification.recode_dataset_split!(@ds, 'v1' => @dict)
+    e = {}
+    e['r'] = [1, 1, 0, 1, 0, 0, 0].to_vector
+    e['w'] = [0, 1, 1, 0, 0, 0, 0].to_vector
+    e['s'] = [0, 0, 0, 0, 1, 1, 1].to_vector
+    e['d'] = [0, 0, 0, 0, 0, 1, 1].to_vector
+    e.each{|k, expected|
+      assert_equal(expected, @ds['v1_' + k], "Error on key #{k}")
     }
   end
-
 end

data/test/test_crosstab.rb

@@ -1,63 +1,67 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
-class StatsampleCrosstabTestCase < MiniTest::Unit::TestCase
-
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleCrosstabTestCase < Minitest::Test
   def initialize(*args)
-    @v1=%w{black blonde black black red black brown black blonde black red black blonde}.to_vector
-    @v2=%w{woman man man woman man man man woman man woman woman man man}.to_vector
-    @ct=Statsample::Crosstab.new(@v1,@v2)
+    @v1 = %w(black blonde black black red black brown black blonde black red black blonde).to_vector
+    @v2 = %w(woman man man woman man man man woman man woman woman man man).to_vector
+    @ct = Statsample::Crosstab.new(@v1, @v2)
     super
   end
+
   def test_crosstab_errors
-    e1=%w{black blonde black black red black brown black blonde black}
+    e1 = %w(black blonde black black red black brown black blonde black)
     assert_raise ArgumentError do
-      Statsample::Crosstab.new(e1,@v2)
+      Statsample::Crosstab.new(e1, @v2)
     end
-    e2=%w{black blonde black black red black brown black blonde black black}.to_vector
+    e2 = %w(black blonde black black red black brown black blonde black black).to_vector
 
     assert_raise ArgumentError do
-      Statsample::Crosstab.new(e2,@v2)
+      Statsample::Crosstab.new(e2, @v2)
     end
     assert_nothing_raised do
-      Statsample::Crosstab.new(@v1,@v2)
+      Statsample::Crosstab.new(@v1, @v2)
     end
   end
+
   def test_crosstab_basic
-    assert_equal(%w{black blonde brown red}, @ct.rows_names)
-    assert_equal(%w{man woman}, @ct.cols_names)
-    assert_equal({'black'=>7,'blonde'=>3,'red'=>2,'brown'=>1}, @ct.rows_total)
-    assert_equal({'man'=>8,'woman'=>5}, @ct.cols_total)
+    assert_equal(%w(black blonde brown red), @ct.rows_names)
+    assert_equal(%w(man woman), @ct.cols_names)
+    assert_equal({ 'black' => 7, 'blonde' => 3, 'red' => 2, 'brown' => 1 }, @ct.rows_total)
+    assert_equal({ 'man' => 8, 'woman' => 5 }, @ct.cols_total)
   end
+
   def test_crosstab_frequencies
-    fq=@ct.frequencies
-    assert_equal(8,fq.size)
-    sum=fq.inject(0) {|s,x| s+x[1]}
-    assert_equal(13,sum)
-    fr=@ct.frequencies_by_row
-    assert_equal(4,fr.size)
-    assert_equal(%w{black blonde brown red},fr.keys.sort)
-    fc=@ct.frequencies_by_col
-    assert_equal(2,fc.size)
-    assert_equal(%w{man woman},fc.keys.sort)
-    assert_equal(Matrix.rows([[3,4],[3,0],[1,0],[1,1]]),@ct.to_matrix)
+    fq = @ct.frequencies
+    assert_equal(8, fq.size)
+    sum = fq.inject(0) { |s, x| s + x[1] }
+    assert_equal(13, sum)
+    fr = @ct.frequencies_by_row
+    assert_equal(4, fr.size)
+    assert_equal(%w(black blonde brown red), fr.keys.sort)
+    fc = @ct.frequencies_by_col
+    assert_equal(2, fc.size)
+    assert_equal(%w(man woman), fc.keys.sort)
+    assert_equal(Matrix.rows([[3, 4], [3, 0], [1, 0], [1, 1]]), @ct.to_matrix)
   end
+
   def test_summary
-    @ct.percentage_row=true
-    @ct.percentage_column=true
-    @ct.percentage_total=true
-    assert(@ct.summary.size>0)
+    @ct.percentage_row = true
+    @ct.percentage_column = true
+    @ct.percentage_total = true
+    assert(@ct.summary.size > 0)
   end
+
   def test_expected
-    v1=%w{1 1 1 1 1 0 0 0 0 0}.to_vector
-    v2=%w{0 0 0 0 0 1 1 1 1 1}.to_vector
-    ct=Statsample::Crosstab.new(v1,v2)
-    assert_equal(Matrix[[2.5,2.5],[2.5,2.5]],ct.matrix_expected)
+    v1 = %w(1 1 1 1 1 0 0 0 0 0).to_vector
+    v2 = %w(0 0 0 0 0 1 1 1 1 1).to_vector
+    ct = Statsample::Crosstab.new(v1, v2)
+    assert_equal(Matrix[[2.5, 2.5], [2.5, 2.5]], ct.matrix_expected)
   end
+
   def test_crosstab_with_scale
-    v1=%w{1 1 1 1 1 0 0 0 0 0}.to_scale
-    v2=%w{0 0 0 0 0 1 1 1 1 1}.to_scale
-    ct=Statsample::Crosstab.new(v1,v2)
-    assert_equal(Matrix[[0,5],[5,0]],ct.to_matrix)
-    assert_nothing_raised { ct.summary }  
+    v1 = %w(1 1 1 1 1 0 0 0 0 0).to_scale
+    v2 = %w(0 0 0 0 0 1 1 1 1 1).to_scale
+    ct = Statsample::Crosstab.new(v1, v2)
+    assert_equal(Matrix[[0, 5], [5, 0]], ct.to_matrix)
+    assert_nothing_raised { ct.summary }
   end
-
 end