statsample 1.4.1 → 1.4.2

data/test/test_regression.rb

@@ -1,215 +1,210 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 
-class StatsampleRegressionTestCase < MiniTest::Unit::TestCase
-  context "Example with missing data" do
-    setup do 
-      @x=[0.285714285714286, 0.114285714285714, 0.314285714285714, 0.2, 0.2, 0.228571428571429, 0.2, 0.4, 0.714285714285714, 0.285714285714286, 0.285714285714286, 0.228571428571429, 0.485714285714286, 0.457142857142857, 0.257142857142857, 0.228571428571429, 0.285714285714286, 0.285714285714286, 0.285714285714286, 0.142857142857143, 0.285714285714286, 0.514285714285714, 0.485714285714286, 0.228571428571429, 0.285714285714286, 0.342857142857143, 0.285714285714286, 0.0857142857142857].to_scale
+class StatsampleRegressionTestCase < Minitest::Test
+  context 'Example with missing data' do
+    setup do
+      @x = [0.285714285714286, 0.114285714285714, 0.314285714285714, 0.2, 0.2, 0.228571428571429, 0.2, 0.4, 0.714285714285714, 0.285714285714286, 0.285714285714286, 0.228571428571429, 0.485714285714286, 0.457142857142857, 0.257142857142857, 0.228571428571429, 0.285714285714286, 0.285714285714286, 0.285714285714286, 0.142857142857143, 0.285714285714286, 0.514285714285714, 0.485714285714286, 0.228571428571429, 0.285714285714286, 0.342857142857143, 0.285714285714286, 0.0857142857142857].to_scale
 
-      @y=[nil, 0.233333333333333, nil, 0.266666666666667, 0.366666666666667, nil, 0.333333333333333, 0.3, 0.666666666666667, 0.0333333333333333, 0.333333333333333, nil, nil, 0.533333333333333, 0.433333333333333, 0.4, 0.4, 0.5, 0.4, 0.266666666666667, 0.166666666666667, 0.666666666666667, 0.433333333333333, 0.166666666666667, nil, 0.4, 0.366666666666667, nil].to_scale      
-      @ds={'x'=>@x,'y'=>@y}.to_dataset
-      @lr=Statsample::Regression::Multiple::RubyEngine.new(@ds,'y')
+      @y = [nil, 0.233333333333333, nil, 0.266666666666667, 0.366666666666667, nil, 0.333333333333333, 0.3, 0.666666666666667, 0.0333333333333333, 0.333333333333333, nil, nil, 0.533333333333333, 0.433333333333333, 0.4, 0.4, 0.5, 0.4, 0.266666666666667, 0.166666666666667, 0.666666666666667, 0.433333333333333, 0.166666666666667, nil, 0.4, 0.366666666666667, nil].to_scale
+      @ds = { 'x' => @x, 'y' => @y }.to_dataset
+      @lr = Statsample::Regression::Multiple::RubyEngine.new(@ds, 'y')
+    end
+    should 'have correct values' do
+      assert_in_delta(0.455, @lr.r2, 0.001)
+      assert_in_delta(0.427, @lr.r2_adjusted, 0.001)
+      assert_in_delta(0.1165, @lr.se_estimate, 0.001)
+      assert_in_delta(15.925, @lr.f, 0.0001)
+      assert_in_delta(0.675, @lr.standarized_coeffs['x'], 0.001)
+      assert_in_delta(0.778, @lr.coeffs['x'], 0.001, 'coeff x')
+      assert_in_delta(0.132, @lr.constant, 0.001, 'constant')
+      assert_in_delta(0.195, @lr.coeffs_se['x'], 0.001, 'coeff x se')
+      assert_in_delta(0.064, @lr.constant_se, 0.001, 'constant se')
     end
-    should "have correct values" do
-      assert_in_delta(0.455,@lr.r2,0.001)
-      assert_in_delta(0.427,@lr.r2_adjusted, 0.001)
-      assert_in_delta(0.1165,@lr.se_estimate,0.001)
-      assert_in_delta(15.925,@lr.f,0.0001)
-      assert_in_delta(0.675, @lr.standarized_coeffs['x'],0.001)
-      assert_in_delta(0.778, @lr.coeffs['x'],0.001, "coeff x")
-      assert_in_delta(0.132, @lr.constant,0.001,"constant")
-      assert_in_delta(0.195, @lr.coeffs_se['x'],0.001,"coeff x se")
-      assert_in_delta(0.064, @lr.constant_se,0.001,"constant se")
-  end
   end
-  should "return an error if data is linearly dependent" do 
-    samples=100
-    
-    a,b=rand,rand
-    
-    x1=samples.times.map { rand}.to_scale
-    x2=samples.times.map {rand}.to_scale
-    x3=samples.times.map {|i| x1[i]*(1+a)+x2[i]*(1+b)}.to_scale
-    y=samples.times.map {|i| x1[i]+x2[i]+x3[i]+rand}.to_scale
-
-    ds={'x1'=>x1,'x2'=>x2,'x3'=>x3,'y'=>y}.to_dataset
+  should 'return an error if data is linearly dependent' do
+    samples = 100
+
+    a, b = rand, rand
+
+    x1 = samples.times.map { rand }.to_scale
+    x2 = samples.times.map { rand }.to_scale
+    x3 = samples.times.map { |i| x1[i] * (1 + a) + x2[i] * (1 + b) }.to_scale
+    y = samples.times.map { |i| x1[i] + x2[i] + x3[i] + rand }.to_scale
+
+    ds = { 'x1' => x1, 'x2' => x2, 'x3' => x3, 'y' => y }.to_dataset
 
     assert_raise(Statsample::Regression::LinearDependency) {
-        Statsample::Regression::Multiple::RubyEngine.new(ds,'y')
+      Statsample::Regression::Multiple::RubyEngine.new(ds, 'y')
     }
   end
   def test_parameters
-    @x=[13,20,10,33,15].to_vector(:scale)
-    @y=[23,18,35,10,27	].to_vector(:scale)
-    reg=Statsample::Regression::Simple.new_from_vectors(@x,@y)
+    @x = [13, 20, 10, 33, 15].to_vector(:scale)
+    @y = [23, 18, 35, 10, 27].to_vector(:scale)
+    reg = Statsample::Regression::Simple.new_from_vectors(@x, @y)
     _test_simple_regression(reg)
-    ds={'x'=>@x,'y'=>@y}.to_dataset
-    reg=Statsample::Regression::Simple.new_from_dataset(ds,'x','y')
+    ds = { 'x' => @x, 'y' => @y }.to_dataset
+    reg = Statsample::Regression::Simple.new_from_dataset(ds, 'x', 'y')
     _test_simple_regression(reg)
-    reg=Statsample::Regression.simple(@x,@y)
+    reg = Statsample::Regression.simple(@x, @y)
     _test_simple_regression(reg)
-
   end
+
   def _test_simple_regression(reg)
-  
-    assert_in_delta(40.009, reg.a,0.001)
-    assert_in_delta(-0.957, reg.b,0.001)
-    assert_in_delta(4.248,reg.standard_error,0.002)
+    assert_in_delta(40.009, reg.a, 0.001)
+    assert_in_delta(-0.957, reg.b, 0.001)
+    assert_in_delta(4.248, reg.standard_error, 0.002)
     assert(reg.summary)
   end
-  
+
   def test_summaries
-    a=10.times.map{rand(100)}.to_scale
-    b=10.times.map{rand(100)}.to_scale
-    y=10.times.map{rand(100)}.to_scale
-    ds={'a'=>a,'b'=>b,'y'=>y}.to_dataset
-    lr=Statsample::Regression::Multiple::RubyEngine.new(ds,'y')
-    assert(lr.summary.size>0)
+    a = 10.times.map { rand(100) }.to_scale
+    b = 10.times.map { rand(100) }.to_scale
+    y = 10.times.map { rand(100) }.to_scale
+    ds = { 'a' => a, 'b' => b, 'y' => y }.to_dataset
+    lr = Statsample::Regression::Multiple::RubyEngine.new(ds, 'y')
+    assert(lr.summary.size > 0)
   end
+
   def test_multiple_dependent
-    complete=Matrix[
-      [1,0.53,0.62,0.19,-0.09,0.08,0.02,-0.12,0.08],
-      [0.53,1,0.61,0.23,0.1,0.18,0.02,-0.1,0.15],
-      [0.62,0.61,1,0.03,0.1,0.12,0.03,-0.06,0.12],
-      [0.19,0.23,0.03,1,-0.02,0.02,0,-0.02,-0.02],
-      [-0.09,0.1,0.1,-0.02,1,0.05,0.06,0.18,0.02],
-      [0.08,0.18,0.12,0.02,0.05,1,0.22,-0.07,0.36],
-      [0.02,0.02,0.03,0,0.06,0.22,1,-0.01,-0.05],
-      [-0.12,-0.1,-0.06,-0.02,0.18,-0.07,-0.01,1,-0.03],
-    [0.08,0.15,0.12,-0.02,0.02,0.36,-0.05,-0.03,1]]
+    complete = Matrix[
+      [1, 0.53, 0.62, 0.19, -0.09, 0.08, 0.02, -0.12, 0.08],
+      [0.53, 1, 0.61, 0.23, 0.1, 0.18, 0.02, -0.1, 0.15],
+      [0.62, 0.61, 1, 0.03, 0.1, 0.12, 0.03, -0.06, 0.12],
+      [0.19, 0.23, 0.03, 1, -0.02, 0.02, 0, -0.02, -0.02],
+      [-0.09, 0.1, 0.1, -0.02, 1, 0.05, 0.06, 0.18, 0.02],
+      [0.08, 0.18, 0.12, 0.02, 0.05, 1, 0.22, -0.07, 0.36],
+      [0.02, 0.02, 0.03, 0, 0.06, 0.22, 1, -0.01, -0.05],
+      [-0.12, -0.1, -0.06, -0.02, 0.18, -0.07, -0.01, 1, -0.03],
+      [0.08, 0.15, 0.12, -0.02, 0.02, 0.36, -0.05, -0.03, 1]]
     complete.extend Statsample::CovariateMatrix
-    complete.fields=%w{adhd cd odd sex age monly mwork mage poverty}
+    complete.fields = %w(adhd cd odd sex age monly mwork mage poverty)
 
-    lr=Statsample::Regression::Multiple::MultipleDependent.new(complete, %w{adhd cd odd})
-
-
-    assert_in_delta(0.197, lr.r2yx,0.001)
-    assert_in_delta(0.197, lr.r2yx_covariance,0.001)
-    assert_in_delta(0.07, lr.p2yx,0.001)
+    lr = Statsample::Regression::Multiple::MultipleDependent.new(complete, %w(adhd cd odd))
 
+    assert_in_delta(0.197, lr.r2yx, 0.001)
+    assert_in_delta(0.197, lr.r2yx_covariance, 0.001)
+    assert_in_delta(0.07, lr.p2yx, 0.001)
   end
-  
+
   def test_multiple_regression_pairwise_2
-    @a=[1,3,2,4,3,5,4,6,5,7,3,nil,3,nil,3].to_vector(:scale)
-    @b=[3,3,4,4,5,5,6,6,4,4,2,2,nil,6,2].to_vector(:scale)
-    @c=[11,22,30,40,50,65,78,79,99,100,nil,3,7,nil,7].to_vector(:scale)
-    @y=[3,4,5,6,7,8,9,10,20,30,30,40,nil,50,nil].to_vector(:scale)
-    ds={'a'=>@a,'b'=>@b,'c'=>@c,'y'=>@y}.to_dataset
-    lr=Statsample::Regression::Multiple::RubyEngine.new(ds,'y')
-    assert_in_delta(2407.436,lr.sst,0.001)
-    assert_in_delta(0.752,lr.r,0.001, "pairwise r")
-    assert_in_delta(0.565,lr.r2,0.001)
-    assert_in_delta(1361.130,lr.ssr,0.001)
-    assert_in_delta(1046.306,lr.sse,0.001)
-    assert_in_delta(3.035,lr.f,0.001)
+    @a = [1, 3, 2, 4, 3, 5, 4, 6, 5, 7, 3, nil, 3, nil, 3].to_vector(:scale)
+    @b = [3, 3, 4, 4, 5, 5, 6, 6, 4, 4, 2, 2, nil, 6, 2].to_vector(:scale)
+    @c = [11, 22, 30, 40, 50, 65, 78, 79, 99, 100, nil, 3, 7, nil, 7].to_vector(:scale)
+    @y = [3, 4, 5, 6, 7, 8, 9, 10, 20, 30, 30, 40, nil, 50, nil].to_vector(:scale)
+    ds = { 'a' => @a, 'b' => @b, 'c' => @c, 'y' => @y }.to_dataset
+    lr = Statsample::Regression::Multiple::RubyEngine.new(ds, 'y')
+    assert_in_delta(2407.436, lr.sst, 0.001)
+    assert_in_delta(0.752, lr.r, 0.001, 'pairwise r')
+    assert_in_delta(0.565, lr.r2, 0.001)
+    assert_in_delta(1361.130, lr.ssr, 0.001)
+    assert_in_delta(1046.306, lr.sse, 0.001)
+    assert_in_delta(3.035, lr.f, 0.001)
   end
 
-
   def test_multiple_regression_gsl
     if Statsample.has_gsl?
-      @a=[1,3,2,4,3,5,4,6,5,7].to_vector(:scale)
-      @b=[3,3,4,4,5,5,6,6,4,4].to_vector(:scale)
-      @c=[11,22,30,40,50,65,78,79,99,100].to_vector(:scale)
-      @y=[3,4,5,6,7,8,9,10,20,30].to_vector(:scale)
-      ds={'a'=>@a,'b'=>@b,'c'=>@c,'y'=>@y}.to_dataset
-      lr=Statsample::Regression::Multiple::GslEngine.new(ds,'y')
-      assert(lr.summary.size>0)
-      model_test(lr,'gsl')
-      predicted=[1.7857, 6.0989, 3.2433, 7.2908, 4.9667, 10.3428, 8.8158, 10.4717, 23.6639, 25.3198]
-      c_predicted=lr.predicted
+      @a = [1, 3, 2, 4, 3, 5, 4, 6, 5, 7].to_vector(:scale)
+      @b = [3, 3, 4, 4, 5, 5, 6, 6, 4, 4].to_vector(:scale)
+      @c = [11, 22, 30, 40, 50, 65, 78, 79, 99, 100].to_vector(:scale)
+      @y = [3, 4, 5, 6, 7, 8, 9, 10, 20, 30].to_vector(:scale)
+      ds = { 'a' => @a, 'b' => @b, 'c' => @c, 'y' => @y }.to_dataset
+      lr = Statsample::Regression::Multiple::GslEngine.new(ds, 'y')
+      assert(lr.summary.size > 0)
+      model_test(lr, 'gsl')
+      predicted = [1.7857, 6.0989, 3.2433, 7.2908, 4.9667, 10.3428, 8.8158, 10.4717, 23.6639, 25.3198]
+      c_predicted = lr.predicted
       predicted.each_index{|i|
-        assert_in_delta(predicted[i],c_predicted[i],0.001)
+        assert_in_delta(predicted[i], c_predicted[i], 0.001)
       }
-      residuals=[1.2142, -2.0989, 1.7566, -1.29085, 2.033, -2.3428, 0.18414, -0.47177, -3.66395, 4.6801]
-      c_residuals=lr.residuals
+      residuals = [1.2142, -2.0989, 1.7566, -1.29085, 2.033, -2.3428, 0.18414, -0.47177, -3.66395, 4.6801]
+      c_residuals = lr.residuals
       residuals.each_index{|i|
-        assert_in_delta(residuals[i],c_residuals[i],0.001)
+        assert_in_delta(residuals[i], c_residuals[i], 0.001)
       }
     else
-      skip "Regression::Multiple::GslEngine not tested (no Gsl)"
+      skip 'Regression::Multiple::GslEngine not tested (no Gsl)'
     end
   end
 
-
-
-  def model_test_matrix(lr,name='undefined')
-
-    stan_coeffs={'a'=>0.151,'b'=>-0.547,'c'=>0.997}
-    unstan_coeffs={'a'=>0.695, 'b'=>-4.286, 'c'=>0.266}
+  def model_test_matrix(lr, name = 'undefined')
+    stan_coeffs = { 'a' => 0.151, 'b' => -0.547, 'c' => 0.997 }
+    unstan_coeffs = { 'a' => 0.695, 'b' => -4.286, 'c' => 0.266 }
 
     unstan_coeffs.each_key{|k|
-      assert_in_delta(unstan_coeffs[k], lr.coeffs[k],0.001,"b coeffs - #{name}")
+      assert_in_delta(unstan_coeffs[k], lr.coeffs[k], 0.001, "b coeffs - #{name}")
     }
 
     stan_coeffs.each_key{|k|
-      assert_in_delta(stan_coeffs[k], lr.standarized_coeffs[k],0.001, "beta coeffs - #{name}")
+      assert_in_delta(stan_coeffs[k], lr.standarized_coeffs[k], 0.001, "beta coeffs - #{name}")
     }
 
-    assert_in_delta(11.027,lr.constant,0.001)
+    assert_in_delta(11.027, lr.constant, 0.001)
 
-    assert_in_delta(0.955,lr.r,0.001)
-    assert_in_delta(0.913,lr.r2,0.001)
+    assert_in_delta(0.955, lr.r, 0.001)
+    assert_in_delta(0.913, lr.r2, 0.001)
 
-    assert_in_delta(20.908, lr.f,0.001)
+    assert_in_delta(20.908, lr.f, 0.001)
     assert_in_delta(0.001, lr.probability, 0.001)
-    assert_in_delta(0.226,lr.tolerance("a"),0.001)
-
-    coeffs_se={"a"=>1.171,"b"=>1.129,"c"=>0.072}
+    assert_in_delta(0.226, lr.tolerance('a'), 0.001)
 
+    coeffs_se = { 'a' => 1.171, 'b' => 1.129, 'c' => 0.072 }
 
-
-    ccoeffs_se=lr.coeffs_se
+    ccoeffs_se = lr.coeffs_se
     coeffs_se.each_key{|k|
-      assert_in_delta(coeffs_se[k],ccoeffs_se[k],0.001)
+      assert_in_delta(coeffs_se[k], ccoeffs_se[k], 0.001)
     }
-    coeffs_t={"a"=>0.594,"b"=>-3.796,"c"=>3.703}
-    ccoeffs_t=lr.coeffs_t
+    coeffs_t = { 'a' => 0.594, 'b' => -3.796, 'c' => 3.703 }
+    ccoeffs_t = lr.coeffs_t
     coeffs_t.each_key{|k|
-      assert_in_delta(coeffs_t[k], ccoeffs_t[k],0.001)
+      assert_in_delta(coeffs_t[k], ccoeffs_t[k], 0.001)
     }
 
-    assert_in_delta(639.6,lr.sst,0.001)
-    assert_in_delta(583.76,lr.ssr,0.001)
-    assert_in_delta(55.840,lr.sse,0.001)
-	assert(lr.summary.size>0, "#{name} without summary")
+    assert_in_delta(639.6, lr.sst, 0.001)
+    assert_in_delta(583.76, lr.ssr, 0.001)
+    assert_in_delta(55.840, lr.sse, 0.001)
+    assert(lr.summary.size > 0, "#{name} without summary")
   end
-  def model_test(lr,name='undefined')
-    model_test_matrix(lr,name)
-    assert_in_delta(4.559, lr.constant_se,0.001)
-    assert_in_delta(2.419, lr.constant_t,0.001)
 
-    assert_in_delta(1.785,lr.process([1,3,11]),0.001)
+  def model_test(lr, name = 'undefined')
+    model_test_matrix(lr, name)
+    assert_in_delta(4.559, lr.constant_se, 0.001)
+    assert_in_delta(2.419, lr.constant_t, 0.001)
+
+    assert_in_delta(1.785, lr.process([1, 3, 11]), 0.001)
   end
+
   def test_regression_matrix
-    @a=[1,3,2,4,3,5,4,6,5,7].to_vector(:scale)
-    @b=[3,3,4,4,5,5,6,6,4,4].to_vector(:scale)
-    @c=[11,22,30,40,50,65,78,79,99,100].to_vector(:scale)
-    @y=[3,4,5,6,7,8,9,10,20,30].to_vector(:scale)
-    ds={'a'=>@a,'b'=>@b,'c'=>@c,'y'=>@y}.to_dataset
-    cor=Statsample::Bivariate.correlation_matrix(ds)
-    
-    lr=Statsample::Regression::Multiple::MatrixEngine.new(cor,'y', :y_mean=>@y.mean, :x_mean=>{'a'=>ds['a'].mean, 'b'=>ds['b'].mean, 'c'=>ds['c'].mean}, :cases=>@a.size, :y_sd=>@y.sd , :x_sd=>{'a' => @a.sd, 'b' => @b.sd, 'c' => @c.sd})
+    @a = [1, 3, 2, 4, 3, 5, 4, 6, 5, 7].to_vector(:scale)
+    @b = [3, 3, 4, 4, 5, 5, 6, 6, 4, 4].to_vector(:scale)
+    @c = [11, 22, 30, 40, 50, 65, 78, 79, 99, 100].to_vector(:scale)
+    @y = [3, 4, 5, 6, 7, 8, 9, 10, 20, 30].to_vector(:scale)
+    ds = { 'a' => @a, 'b' => @b, 'c' => @c, 'y' => @y }.to_dataset
+    cor = Statsample::Bivariate.correlation_matrix(ds)
+
+    lr = Statsample::Regression::Multiple::MatrixEngine.new(cor, 'y', y_mean: @y.mean, x_mean: { 'a' => ds['a'].mean, 'b' => ds['b'].mean, 'c' => ds['c'].mean }, cases: @a.size, y_sd: @y.sd, x_sd: { 'a' => @a.sd, 'b' => @b.sd, 'c' => @c.sd })
     assert_nil(lr.constant_se)
     assert_nil(lr.constant_t)
-    model_test_matrix(lr, "correlation matrix")
+    model_test_matrix(lr, 'correlation matrix')
 
-    covariance=Statsample::Bivariate.covariance_matrix(ds)
-    lr=Statsample::Regression::Multiple::MatrixEngine.new(covariance,'y', :y_mean=>@y.mean, :x_mean=>{'a'=>ds['a'].mean, 'b'=>ds['b'].mean, 'c'=>ds['c'].mean}, :cases=>@a.size)
-    assert(lr.summary.size>0)
+    covariance = Statsample::Bivariate.covariance_matrix(ds)
+    lr = Statsample::Regression::Multiple::MatrixEngine.new(covariance, 'y', y_mean: @y.mean, x_mean: { 'a' => ds['a'].mean, 'b' => ds['b'].mean, 'c' => ds['c'].mean }, cases: @a.size)
+    assert(lr.summary.size > 0)
 
-    model_test(lr , "covariance matrix")
+    model_test(lr, 'covariance matrix')
   end
+
   def test_regression_rubyengine
-    @a=[nil,1,3,2,4,3,5,4,6,5,7].to_vector(:scale)
-    @b=[nil,3,3,4,4,5,5,6,6,4,4].to_vector(:scale)
-    @c=[nil,11,22,30,40,50,65,78,79,99,100].to_vector(:scale)
-    @y=[nil,3,4,5,6,7,8,9,10,20,30].to_vector(:scale)
-    ds={'a'=>@a,'b'=>@b,'c'=>@c,'y'=>@y}.to_dataset
-    lr=Statsample::Regression::Multiple::RubyEngine.new(ds,'y')
+    @a = [nil, 1, 3, 2, 4, 3, 5, 4, 6, 5, 7].to_vector(:scale)
+    @b = [nil, 3, 3, 4, 4, 5, 5, 6, 6, 4, 4].to_vector(:scale)
+    @c = [nil, 11, 22, 30, 40, 50, 65, 78, 79, 99, 100].to_vector(:scale)
+    @y = [nil, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30].to_vector(:scale)
+    ds = { 'a' => @a, 'b' => @b, 'c' => @c, 'y' => @y }.to_dataset
+    lr = Statsample::Regression::Multiple::RubyEngine.new(ds, 'y')
     assert_equal(11, lr.total_cases)
     assert_equal(10, lr.valid_cases)
     model_test(lr, 'rubyengine with missing data')
 
-    predicted=[nil,1.7857, 6.0989, 3.2433, 7.2908, 4.9667, 10.3428, 8.8158, 10.4717, 23.6639, 25.3198]
+    predicted = [nil, 1.7857, 6.0989, 3.2433, 7.2908, 4.9667, 10.3428, 8.8158, 10.4717, 23.6639, 25.3198]
     c_predicted = lr.predicted
     predicted.each_index do |i|
       if c_predicted[i].nil?
@@ -218,15 +213,14 @@ class StatsampleRegressionTestCase < MiniTest::Unit::TestCase
         assert_in_delta(predicted[i], c_predicted[i], 0.001)
       end
     end
-    residuals=[nil,1.2142, -2.0989, 1.7566, -1.29085, 2.033, -2.3428, 0.18414, -0.47177, -3.66395, 4.6801]
-    c_residuals=lr.residuals
+    residuals = [nil, 1.2142, -2.0989, 1.7566, -1.29085, 2.033, -2.3428, 0.18414, -0.47177, -3.66395, 4.6801]
+    c_residuals = lr.residuals
     residuals.each_index do |i|
       if c_residuals[i].nil?
         assert(residuals[i].nil?)
       else
-        assert_in_delta(residuals[i],c_residuals[i],0.001)
+        assert_in_delta(residuals[i], c_residuals[i], 0.001)
       end
     end
-
   end
 end

data/test/test_reliability.rb

@@ -1,229 +1,223 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
-class StatsampleReliabilityTestCase < MiniTest::Unit::TestCase
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleReliabilityTestCase < Minitest::Test
   context Statsample::Reliability do
-    should "return correct r according to Spearman-Brown prophecy" do
-      r=0.6849
-      n=62.quo(15)
-      assert_in_delta(0.9, Statsample::Reliability.sbp(r,n), 0.001)
+    should 'return correct r according to Spearman-Brown prophecy' do
+      r = 0.6849
+      n = 62.quo(15)
+      assert_in_delta(0.9, Statsample::Reliability.sbp(r, n), 0.001)
     end
-    should "return correct n for desired realiability" do
-        r=0.6849
-        r_d=0.9
-        assert_in_delta(62, Statsample::Reliability.n_for_desired_reliability(r, r_d, 15),0.5)
-      end
-    context "Cronbach's alpha" do 
+    should 'return correct n for desired realiability' do
+      r = 0.6849
+      r_d = 0.9
+      assert_in_delta(62, Statsample::Reliability.n_for_desired_reliability(r, r_d, 15), 0.5)
+    end
+    context "Cronbach's alpha" do
       setup do
-        @samples=40
-        @n_variables=rand(10)+2
-        @ds=Statsample::Dataset.new()
-        base=@samples.times.collect {|a| rand()}.to_scale
+        @samples = 40
+        @n_variables = rand(10) + 2
+        @ds = Statsample::Dataset.new
+        base = @samples.times.collect { |_a| rand }.to_scale
         @n_variables.times do |i|
-          @ds[i]=base.collect {|v| v+rand()}.to_scale
+          @ds[i] = base.collect { |v| v + rand }.to_scale
         end
-        
+
         @ds.update_valid_data
-        @k=@ds.fields.size
-        @cm=Statsample::Bivariate.covariance_matrix(@ds)
-        @dse=@ds.dup
+        @k = @ds.fields.size
+        @cm = Statsample::Bivariate.covariance_matrix(@ds)
+        @dse = @ds.dup
         @dse.fields.each do |f|
-          @dse[f]=@dse[f].standarized
+          @dse[f] = @dse[f].standarized
         end
-        @cme=Statsample::Bivariate.covariance_matrix(@dse)
-        @a=Statsample::Reliability.cronbach_alpha(@ds)
-        @as=Statsample::Reliability.cronbach_alpha_standarized(@ds)
-      end
-      should "alpha will be equal to sum of matrix covariance less the individual variances" do
-        total_sum=@cm.total_sum
-        ind_var=@ds.fields.inject(0) {|ac,v| ac+@ds[v].variance}
-        expected = @k.quo(@k-1) * (1-(ind_var.quo(total_sum)))
-        assert_in_delta(expected, @a,1e-10)
-      end
-      should "method cronbach_alpha_from_n_s2_cov return correct values" do
-        sa=Statsample::Reliability::ScaleAnalysis.new(@ds)
+        @cme = Statsample::Bivariate.covariance_matrix(@dse)
+        @a = Statsample::Reliability.cronbach_alpha(@ds)
+        @as = Statsample::Reliability.cronbach_alpha_standarized(@ds)
+      end
+      should 'alpha will be equal to sum of matrix covariance less the individual variances' do
+        total_sum = @cm.total_sum
+        ind_var = @ds.fields.inject(0) { |ac, v| ac + @ds[v].variance }
+        expected = @k.quo(@k - 1) * (1 - (ind_var.quo(total_sum)))
+        assert_in_delta(expected, @a, 1e-10)
+      end
+      should 'method cronbach_alpha_from_n_s2_cov return correct values' do
+        sa = Statsample::Reliability::ScaleAnalysis.new(@ds)
         vm, cm = sa.variances_mean, sa.covariances_mean
-        assert_in_delta(sa.alpha, Statsample::Reliability.cronbach_alpha_from_n_s2_cov(@n_variables, vm,cm), 1e-10)        
+        assert_in_delta(sa.alpha, Statsample::Reliability.cronbach_alpha_from_n_s2_cov(@n_variables, vm, cm), 1e-10)
       end
-      should "method cronbach_alpha_from_covariance_matrix returns correct value" do
-        cov=Statsample::Bivariate.covariance_matrix(@ds)
-        assert_in_delta(@a, Statsample::Reliability.cronbach_alpha_from_covariance_matrix(cov),0.0000001)
+      should 'method cronbach_alpha_from_covariance_matrix returns correct value' do
+        cov = Statsample::Bivariate.covariance_matrix(@ds)
+        assert_in_delta(@a, Statsample::Reliability.cronbach_alpha_from_covariance_matrix(cov), 0.0000001)
       end
-      should "return correct n for desired alpha, covariance and variance" do
-        sa=Statsample::Reliability::ScaleAnalysis.new(@ds)
+      should 'return correct n for desired alpha, covariance and variance' do
+        sa = Statsample::Reliability::ScaleAnalysis.new(@ds)
         vm, cm = sa.variances_mean, sa.covariances_mean
-        n_obtained=Statsample::Reliability.n_for_desired_alpha(@a, vm,cm)
-        #p n_obtained
-        assert_in_delta(Statsample::Reliability.cronbach_alpha_from_n_s2_cov(n_obtained, vm,cm) ,@a,0.001) 
-      end
-      
-      should "standarized alpha will be equal to sum of matrix covariance less the individual variances on standarized values" do
-        total_sum=@cme.total_sum
-        ind_var=@dse.fields.inject(0) {|ac,v| ac+@dse[v].variance}
-        expected = @k.quo(@k-1) * (1-(ind_var.quo(total_sum)))
+        n_obtained = Statsample::Reliability.n_for_desired_alpha(@a, vm, cm)
+        # p n_obtained
+        assert_in_delta(Statsample::Reliability.cronbach_alpha_from_n_s2_cov(n_obtained, vm, cm), @a, 0.001)
+      end
+
+      should 'standarized alpha will be equal to sum of matrix covariance less the individual variances on standarized values' do
+        total_sum = @cme.total_sum
+        ind_var = @dse.fields.inject(0) { |ac, v| ac + @dse[v].variance }
+        expected = @k.quo(@k - 1) * (1 - (ind_var.quo(total_sum)))
         assert_in_delta(expected, @as, 1e-10)
       end
     end
     context Statsample::Reliability::ItemCharacteristicCurve do
       setup do
-        @samples=100
-        @points=rand(10)+3
-        @max_point=(@points-1)*3
-        @x1=@samples.times.map{rand(@points)}.to_scale
-        @x2=@samples.times.map{rand(@points)}.to_scale
-        @x3=@samples.times.map{rand(@points)}.to_scale
-        @ds={'a'=>@x1,'b'=>@x2,'c'=>@x3}.to_dataset
-        @icc=Statsample::Reliability::ItemCharacteristicCurve.new(@ds)
-      end
-      should "have a correct automatic vector_total" do
+        @samples = 100
+        @points = rand(10) + 3
+        @max_point = (@points - 1) * 3
+        @x1 = @samples.times.map { rand(@points) }.to_scale
+        @x2 = @samples.times.map { rand(@points) }.to_scale
+        @x3 = @samples.times.map { rand(@points) }.to_scale
+        @ds = { 'a' => @x1, 'b' => @x2, 'c' => @x3 }.to_dataset
+        @icc = Statsample::Reliability::ItemCharacteristicCurve.new(@ds)
+      end
+      should 'have a correct automatic vector_total' do
         assert_equal(@ds.vector_sum, @icc.vector_total)
       end
-      should "have a correct different vector_total" do
-        x2=@samples.times.map{rand(10)}.to_scale
-        @icc=Statsample::Reliability::ItemCharacteristicCurve.new(@ds,x2)
+      should 'have a correct different vector_total' do
+        x2 = @samples.times.map { rand(10) }.to_scale
+        @icc = Statsample::Reliability::ItemCharacteristicCurve.new(@ds, x2)
         assert_equal(x2, @icc.vector_total)
         assert_raises(ArgumentError) do
-          inc=(@samples+10).times.map{rand(10)}.to_scale
-          @icc=Statsample::Reliability::ItemCharacteristicCurve.new(@ds,inc)          
+          inc = (@samples + 10).times.map { rand(10) }.to_scale
+          @icc = Statsample::Reliability::ItemCharacteristicCurve.new(@ds, inc)
         end
       end
-      should "have 0% for 0 points on maximum value values" do
-        max=@icc.curve_field('a',0)[@max_point.to_f]
-        max||=0
+      should 'have 0% for 0 points on maximum value values' do
+        max = @icc.curve_field('a', 0)[@max_point.to_f]
+        max ||= 0
         assert_in_delta(0, max)
       end
-      should "have 0 for max value on minimum value" do
-        max=@icc.curve_field('a',@max_point)[0.0]
-        max||=0
+      should 'have 0 for max value on minimum value' do
+        max = @icc.curve_field('a', @max_point)[0.0]
+        max ||= 0
         assert_in_delta(0, max)
       end
-      should "have correct values of % for any value" do
-        sum=@icc.vector_total
-        total={}
-        total_g=sum.frequencies
-        index=rand(@points)
-        @x1.each_with_index do |v,i|
-          total[sum[i]]||=0
-          total[sum[i]]+=1 if v==index
+      should 'have correct values of % for any value' do
+        sum = @icc.vector_total
+        total = {}
+        total_g = sum.frequencies
+        index = rand(@points)
+        @x1.each_with_index do |v, i|
+          total[sum[i]] ||= 0
+          total[sum[i]] += 1 if v == index
         end
-        expected=total.each {|k,v|
-          total[k]=v.quo(total_g[k])
+        expected = total.each {|k, v|
+          total[k] = v.quo(total_g[k])
         }
-        assert_equal(expected, @icc.curve_field('a',index))
-        
+        assert_equal(expected, @icc.curve_field('a', index))
       end
-      
     end
-    
+
     context Statsample::Reliability::MultiScaleAnalysis do
-      
       setup do
-        size=100
-        @scales=3
-        @items_per_scale=10
-        h={}
+        size = 100
+        @scales = 3
+        @items_per_scale = 10
+        h = {}
         @scales.times {|s|
           @items_per_scale.times {|i|
-            h["#{s}_#{i}"] = (size.times.map {(s*2)+rand}).to_scale
+            h["#{s}_#{i}"] = (size.times.map { (s * 2) + rand }).to_scale
           }
         }
-        @ds=h.to_dataset
-        @msa=Statsample::Reliability::MultiScaleAnalysis.new(:name=>'Multiple Analysis') do |m|
-          m.scale "complete", @ds
+        @ds = h.to_dataset
+        @msa = Statsample::Reliability::MultiScaleAnalysis.new(name: 'Multiple Analysis') do |m|
+          m.scale 'complete', @ds
           @scales.times {|s|
-            m.scale "scale_#{s}", @ds.clone(@items_per_scale.times.map {|i| "#{s}_#{i}"}), {:name=>"Scale #{s}"}
+            m.scale "scale_#{s}", @ds.clone(@items_per_scale.times.map { |i| "#{s}_#{i}" }), name: "Scale #{s}"
           }
         end
       end
-      should "Retrieve correct ScaleAnalysis for whole scale" do
-        sa=Statsample::Reliability::ScaleAnalysis.new(@ds, :name=>"Scale complete") 
-        assert_equal(sa.variances_mean, @msa.scale("complete").variances_mean)
+      should 'Retrieve correct ScaleAnalysis for whole scale' do
+        sa = Statsample::Reliability::ScaleAnalysis.new(@ds, name: 'Scale complete')
+        assert_equal(sa.variances_mean, @msa.scale('complete').variances_mean)
       end
-      should "Retrieve correct ScaleAnalysis for each scale" do
+      should 'Retrieve correct ScaleAnalysis for each scale' do
         @scales.times {|s|
-          sa=Statsample::Reliability::ScaleAnalysis.new(@ds.dup(@items_per_scale.times.map {|i| "#{s}_#{i}"}), :name=>"Scale #{s}")
-          assert_equal(sa.variances_mean,@msa.scale("scale_#{s}").variances_mean)
+          sa = Statsample::Reliability::ScaleAnalysis.new(@ds.dup(@items_per_scale.times.map { |i| "#{s}_#{i}" }), name: "Scale #{s}")
+          assert_equal(sa.variances_mean, @msa.scale("scale_#{s}").variances_mean)
         }
       end
-      should "retrieve correct correlation matrix for each scale" do
-        vectors={'complete' => @ds.vector_sum}
+      should 'retrieve correct correlation matrix for each scale' do
+        vectors = { 'complete' => @ds.vector_sum }
         @scales.times {|s|
-         vectors["scale_#{s}"]=@ds.dup(@items_per_scale.times.map {|i| "#{s}_#{i}"}).vector_sum 
+          vectors["scale_#{s}"] = @ds.dup(@items_per_scale.times.map { |i| "#{s}_#{i}" }).vector_sum
         }
-        ds2=vectors.to_dataset
+        ds2 = vectors.to_dataset
         assert_equal(Statsample::Bivariate.correlation_matrix(ds2), @msa.correlation_matrix)
       end
-      should "delete scale using delete_scale" do
-        @msa.delete_scale("complete")
-        assert_equal(@msa.scales.keys.sort, @scales.times.map {|s| "scale_#{s}"})
+      should 'delete scale using delete_scale' do
+        @msa.delete_scale('complete')
+        assert_equal(@msa.scales.keys.sort, @scales.times.map { |s| "scale_#{s}" })
       end
-      should "retrieve pca for scales" do
-        @msa.delete_scale("complete")
-        vectors=Hash.new
+      should 'retrieve pca for scales' do
+        @msa.delete_scale('complete')
+        vectors = {}
         @scales.times {|s|
-         vectors["scale_#{s}"]=@ds.dup(@items_per_scale.times.map {|i| "#{s}_#{i}"}).vector_sum 
+          vectors["scale_#{s}"] = @ds.dup(@items_per_scale.times.map { |i| "#{s}_#{i}" }).vector_sum
         }
-        ds2=vectors.to_dataset
-        cor_matrix=Statsample::Bivariate.correlation_matrix(ds2)
-        m=3
-        pca=Statsample::Factor::PCA.new(cor_matrix, :m=>m)
-        assert_equal(pca.component_matrix, @msa.pca(:m=>m).component_matrix)
-      end
-      should "retrieve acceptable summary" do
-        @msa.delete_scale("scale_0")
-        @msa.delete_scale("scale_1")
-        @msa.delete_scale("scale_2")
-        
-        
-        #@msa.summary_correlation_matrix=true
-        #@msa.summary_pca=true
-        
-        
-        assert(@msa.summary.size>0)
+        ds2 = vectors.to_dataset
+        cor_matrix = Statsample::Bivariate.correlation_matrix(ds2)
+        m = 3
+        pca = Statsample::Factor::PCA.new(cor_matrix, m: m)
+        assert_equal(pca.component_matrix, @msa.pca(m: m).component_matrix)
+      end
+      should 'retrieve acceptable summary' do
+        @msa.delete_scale('scale_0')
+        @msa.delete_scale('scale_1')
+        @msa.delete_scale('scale_2')
+
+        # @msa.summary_correlation_matrix=true
+        # @msa.summary_pca=true
+
+        assert(@msa.summary.size > 0)
       end
     end
     context Statsample::Reliability::ScaleAnalysis do
-      setup do 
-        @x1=[1,1,1,1,2,2,2,2,3,3,3,30].to_scale
-        @x2=[1,1,1,2,2,3,3,3,3,4,4,50].to_scale
-        @x3=[2,2,1,1,1,2,2,2,3,4,5,40].to_scale
-        @x4=[1,2,3,4,4,4,4,3,4,4,5,30].to_scale
-        @ds={'x1'=>@x1,'x2'=>@x2,'x3'=>@x3,'x4'=>@x4}.to_dataset
-        @ia=Statsample::Reliability::ScaleAnalysis.new(@ds)
-        @cov_matrix=@ia.cov_m
-      end     
-      should "return correct values for item analysis" do 
-        assert_in_delta(0.980,@ia.alpha,0.001)
-        assert_in_delta(0.999,@ia.alpha_standarized,0.001)
-        var_mean=4.times.map{|m| @cov_matrix[m,m]}.to_scale.mean 
+      setup do
+        @x1 = [1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 30].to_scale
+        @x2 = [1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 50].to_scale
+        @x3 = [2, 2, 1, 1, 1, 2, 2, 2, 3, 4, 5, 40].to_scale
+        @x4 = [1, 2, 3, 4, 4, 4, 4, 3, 4, 4, 5, 30].to_scale
+        @ds = { 'x1' => @x1, 'x2' => @x2, 'x3' => @x3, 'x4' => @x4 }.to_dataset
+        @ia = Statsample::Reliability::ScaleAnalysis.new(@ds)
+        @cov_matrix = @ia.cov_m
+      end
+      should 'return correct values for item analysis' do
+        assert_in_delta(0.980, @ia.alpha, 0.001)
+        assert_in_delta(0.999, @ia.alpha_standarized, 0.001)
+        var_mean = 4.times.map { |m| @cov_matrix[m, m] }.to_scale.mean
         assert_in_delta(var_mean, @ia.variances_mean)
         assert_equal(@x1.mean, @ia.item_statistics['x1'][:mean])
         assert_equal(@x4.mean, @ia.item_statistics['x4'][:mean])
-        assert_in_delta(@x1.sds, @ia.item_statistics['x1'][:sds],1e-14)
-        assert_in_delta(@x4.sds, @ia.item_statistics['x4'][:sds],1e-14)
-        ds2=@ds.clone
+        assert_in_delta(@x1.sds, @ia.item_statistics['x1'][:sds], 1e-14)
+        assert_in_delta(@x4.sds, @ia.item_statistics['x4'][:sds], 1e-14)
+        ds2 = @ds.clone
         ds2.delete_vector('x1')
-        vector_sum=ds2.vector_sum
+        vector_sum = ds2.vector_sum
         assert_equal(vector_sum.mean, @ia.stats_if_deleted['x1'][:mean])
         assert_equal(vector_sum.sds, @ia.stats_if_deleted['x1'][:sds])
-        assert_in_delta(vector_sum.variance, @ia.stats_if_deleted['x1'][:variance_sample],1e-10)
+        assert_in_delta(vector_sum.variance, @ia.stats_if_deleted['x1'][:variance_sample], 1e-10)
 
         assert_equal(Statsample::Reliability.cronbach_alpha(ds2), @ia.stats_if_deleted['x1'][:alpha])
-        
-        covariances=[]
+
+        covariances = []
         4.times.each {|i|
           4.times.each {|j|
-            if i!=j 
-              covariances.push(@cov_matrix[i,j])
+            if i != j
+              covariances.push(@cov_matrix[i, j])
             end
           }
         }
         assert_in_delta(covariances.to_scale.mean, @ia.covariances_mean)
-        assert_in_delta(0.999,@ia.item_total_correlation()['x1'],0.001)
-        assert_in_delta(1050.455,@ia.stats_if_deleted()['x1'][:variance_sample],0.001)
+        assert_in_delta(0.999, @ia.item_total_correlation['x1'], 0.001)
+        assert_in_delta(1050.455, @ia.stats_if_deleted['x1'][:variance_sample], 0.001)
       end
-      should "return a summary" do 
-        assert(@ia.summary.size>0)
+      should 'return a summary' do
+        assert(@ia.summary.size > 0)
       end
-      
     end
   end
 end