statsample 1.4.1 → 1.4.2

data/test/test_reliability_icc.rb

@@ -1,140 +1,138 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 
-$reliability_icc=nil
+$reliability_icc = nil
 
-class StatsampleReliabilityIccTestCase < MiniTest::Test
+class StatsampleReliabilityIccTestCase < Minitest::Test
   context Statsample::Reliability::ICC do
     setup do
-      a=[9,6,8,7,10,6].to_scale
-      b=[2,1,4,1,5,2].to_scale
-      c=[5,3,6,2,6,4].to_scale
-      d=[8,2,8,6,9,7].to_scale
-      @ds={'a'=>a,'b'=>b,'c'=>c,'d'=>d}.to_dataset
-      @icc=Statsample::Reliability::ICC.new(@ds)
+      a = [9, 6, 8, 7, 10, 6].to_scale
+      b = [2, 1, 4, 1, 5, 2].to_scale
+      c = [5, 3, 6, 2, 6, 4].to_scale
+      d = [8, 2, 8, 6, 9, 7].to_scale
+      @ds = { 'a' => a, 'b' => b, 'c' => c, 'd' => d }.to_dataset
+      @icc = Statsample::Reliability::ICC.new(@ds)
     end
-    should "basic method be correct" do
-      assert_equal(6,@icc.n)
-      assert_equal(4,@icc.k)
+    should 'basic method be correct' do
+      assert_equal(6, @icc.n)
+      assert_equal(4, @icc.k)
     end
-    should "total mean be correct" do
+    should 'total mean be correct' do
       assert_in_delta(5.291, @icc.total_mean, 0.001)
     end
-    should "df methods be correct" do
+    should 'df methods be correct' do
       assert_equal(5,  @icc.df_bt)
       assert_equal(18, @icc.df_wt)
       assert_equal(3,  @icc.df_bj)
       assert_equal(15, @icc.df_residual)
     end
-    should "ms between targets be correct" do
+    should 'ms between targets be correct' do
       assert_in_delta(11.24, @icc.ms_bt, 0.01)
     end
-    should "ms within targets be correct" do
+    should 'ms within targets be correct' do
       assert_in_delta(6.26,  @icc.ms_wt, 0.01)
     end
-    should "ms between judges be correct" do 
+    should 'ms between judges be correct' do
       assert_in_delta(32.49, @icc.ms_bj, 0.01)
     end
-    should "ms residual be correct" do
+    should 'ms residual be correct' do
       assert_in_delta(1.02,  @icc.ms_residual, 0.01)
     end
-    context "with McGraw and Wong denominations," do 
-      
+    context 'with McGraw and Wong denominations,' do
     end
-    context "with Shrout & Fleiss denominations, " do 
-      should "icc(1,1) method be correct" do
+    context 'with Shrout & Fleiss denominations, ' do
+      should 'icc(1,1) method be correct' do
         assert_in_delta(0.17, @icc.icc_1_1, 0.01)
       end
       # Verified on SPSS and R
-      should "icc(2,1) method be correct" do    
+      should 'icc(2,1) method be correct' do
         assert_in_delta(0.29, @icc.icc_2_1, 0.01)
       end
-      should "icc(3,1) method be correct" do
+      should 'icc(3,1) method be correct' do
         assert_in_delta(0.71, @icc.icc_3_1, 0.01)
       end
-      should "icc(1,k) method be correct" do
+      should 'icc(1,k) method be correct' do
         assert_in_delta(0.44, @icc.icc_1_k, 0.01)
       end
       # Verified on SPSS and R
-      should "icc(2,k) method be correct" do
+      should 'icc(2,k) method be correct' do
         assert_in_delta(0.62, @icc.icc_2_k, 0.01)
-      end 
-      should "icc(3,k) method be correct" do
+      end
+      should 'icc(3,k) method be correct' do
         assert_in_delta(0.91, @icc.icc_3_k, 0.01)
       end
-      
-      should "icc(1,1) F be correct" do
+
+      should 'icc(1,1) F be correct' do
         assert_in_delta(1.795, @icc.icc_1_f.f)
       end
-      should "icc(1,1) confidence interval should be correct" do
+      should 'icc(1,1) confidence interval should be correct' do
         assert_in_delta(-0.133, @icc.icc_1_1_ci[0], 0.001)
         assert_in_delta(0.723, @icc.icc_1_1_ci[1], 0.001)
       end
-      should "icc(1,k) confidence interval should be correct" do
+      should 'icc(1,k) confidence interval should be correct' do
         assert_in_delta(-0.884, @icc.icc_1_k_ci[0], 0.001)
         assert_in_delta(0.912, @icc.icc_1_k_ci[1], 0.001)
       end
-      
-      should "icc(2,1) F be correct" do
+
+      should 'icc(2,1) F be correct' do
         assert_in_delta(11.027, @icc.icc_2_f.f)
       end
-      should "icc(2,1) confidence interval should be correct" do
-        #skip("Not yet operational")
+      should 'icc(2,1) confidence interval should be correct' do
+        # skip("Not yet operational")
         assert_in_delta(0.019, @icc.icc_2_1_ci[0], 0.001)
         assert_in_delta(0.761, @icc.icc_2_1_ci[1], 0.001)
       end
-      
-      # Verified on SPSS and R      
-      should "icc(2,k) confidence interval should be correct" do
-        #skip("Not yet operational")
-        #p @icc.icc_2_k_ci
+
+      # Verified on SPSS and R
+      should 'icc(2,k) confidence interval should be correct' do
+        # skip("Not yet operational")
+        # p @icc.icc_2_k_ci
         assert_in_delta(0.039, @icc.icc_2_k_ci[0], 0.001)
         assert_in_delta(0.929, @icc.icc_2_k_ci[1], 0.001)
-
       end
-      #should "Shrout icc(2,k) and McGraw icc(a,k) ci be equal" do
+      # should "Shrout icc(2,k) and McGraw icc(a,k) ci be equal" do
       #  assert_in_delta(@icc.icc_2_k_ci_shrout[0], @icc.icc_2_k_ci_mcgraw[0], 10e-5)
-      #end
-      
-      should "icc(3,1) F be correct" do
+      # end
+
+      should 'icc(3,1) F be correct' do
         assert_in_delta(11.027, @icc.icc_3_f.f)
       end
-      
-      should "icc(3,1) confidence interval should be correct" do
+
+      should 'icc(3,1) confidence interval should be correct' do
         assert_in_delta(0.342, @icc.icc_3_1_ci[0], 0.001)
         assert_in_delta(0.946, @icc.icc_3_1_ci[1], 0.001)
       end
-      should "icc(3,k) confidence interval should be correct" do
+      should 'icc(3,k) confidence interval should be correct' do
         assert_in_delta(0.676, @icc.icc_3_k_ci[0], 0.001)
         assert_in_delta(0.986, @icc.icc_3_k_ci[1], 0.001)
       end
-      should "incorrect type raises an error" do
-        assert_raise(::RuntimeError) do 
-          @icc.type=:nonexistant_type
+      should 'incorrect type raises an error' do
+        assert_raise(::RuntimeError) do
+          @icc.type = :nonexistant_type
         end
       end
     end
-    
+
     begin
       require 'rserve'
       require 'statsample/rserve_extension'
-      context "McGraw and Wong" do
+      context 'McGraw and Wong' do
         teardown do
-          @r=$reliability_icc[:r].close unless $reliability_icc[:r].nil?
+          @r = $reliability_icc[:r].close unless $reliability_icc[:r].nil?
         end
         setup do
-          if($reliability_icc.nil?)
-            size=100
-            a=size.times.map {rand(10)}.to_scale
-            b=a.recode{|i|i+rand(4)-2}
-            c=a.recode{|i|i+rand(4)-2}
-            d=a.recode{|i|i+rand(4)-2}
-            @ds={'a'=>a,'b'=>b,'c'=>c,'d'=>d}.to_dataset
-            
-            @icc=Statsample::Reliability::ICC.new(@ds)
-            @r=Rserve::Connection.new
-            
-            @r.assign('ds',@ds)
-          
+          if $reliability_icc.nil?
+            size = 100
+            a = size.times.map { rand(10) }.to_scale
+            b = a.recode { |i| i + rand(4) - 2 }
+            c = a.recode { |i| i + rand(4) - 2 }
+            d = a.recode { |i| i + rand(4) - 2 }
+            @ds = { 'a' => a, 'b' => b, 'c' => c, 'd' => d }.to_dataset
+
+            @icc = Statsample::Reliability::ICC.new(@ds)
+            @r = Rserve::Connection.new
+
+            @r.assign('ds', @ds)
+
             @r.void_eval("library(irr);
               iccs=list(
               icc_1=icc(ds,'o','c','s'),
@@ -144,59 +142,57 @@ class StatsampleReliabilityIccTestCase < MiniTest::Test
               icc_a_1=icc(ds,'t','a','s'),
               icc_a_k=icc(ds,'t','a','a'))
               ")
-            @iccs=@r.eval('iccs').to_ruby
-            $reliability_icc={ :icc=>@icc, :iccs=>@iccs, :r=>@r
+            @iccs = @r.eval('iccs').to_ruby
+            $reliability_icc = { icc: @icc, iccs: @iccs, r: @r
             }
-            
-          end
-          @icc=$reliability_icc[:icc]
-          @iccs=$reliability_icc[:iccs]
-          @r=$reliability_icc[:r]
 
+          end
+          @icc = $reliability_icc[:icc]
+          @iccs = $reliability_icc[:iccs]
+          @r = $reliability_icc[:r]
         end
         [:icc_1, :icc_k, :icc_c_1, :icc_c_k, :icc_a_1, :icc_a_k].each do |t|
           context "ICC Type #{t} " do
-            should "value be correct" do
-              @icc.type=t
-              @r_icc=@iccs[t.to_s]
-              assert_in_delta(@r_icc['value'],@icc.r)
+            should 'value be correct' do
+              @icc.type = t
+              @r_icc = @iccs[t.to_s]
+              assert_in_delta(@r_icc['value'], @icc.r)
             end
-            should "fvalue be correct" do
-              @icc.type=t
-              @r_icc=@iccs[t.to_s]
-              assert_in_delta(@r_icc['Fvalue'],@icc.f.f)
+            should 'fvalue be correct' do
+              @icc.type = t
+              @r_icc = @iccs[t.to_s]
+              assert_in_delta(@r_icc['Fvalue'], @icc.f.f)
             end
-            should "num df be correct" do
-              @icc.type=t
-              @r_icc=@iccs[t.to_s]
-              assert_in_delta(@r_icc['df1'],@icc.f.df_num)
+            should 'num df be correct' do
+              @icc.type = t
+              @r_icc = @iccs[t.to_s]
+              assert_in_delta(@r_icc['df1'], @icc.f.df_num)
             end
-            should "den df be correct" do
-              @icc.type=t
-              @r_icc=@iccs[t.to_s]
-              assert_in_delta(@r_icc['df2'],@icc.f.df_den)
+            should 'den df be correct' do
+              @icc.type = t
+              @r_icc = @iccs[t.to_s]
+              assert_in_delta(@r_icc['df2'], @icc.f.df_den)
             end
 
-            should "f probability be correct" do
-              @icc.type=t
-              @r_icc=@iccs[t.to_s]
-              assert_in_delta(@r_icc['p.value'],@icc.f.probability)
+            should 'f probability be correct' do
+              @icc.type = t
+              @r_icc = @iccs[t.to_s]
+              assert_in_delta(@r_icc['p.value'], @icc.f.probability)
             end
-            should "bounds be equal" do
-              @icc.type=t
-              @r_icc=@iccs[t.to_s]
-              assert_in_delta(@r_icc['lbound'],@icc.lbound)
-              assert_in_delta(@r_icc['ubound'],@icc.ubound)  
+            should 'bounds be equal' do
+              @icc.type = t
+              @r_icc = @iccs[t.to_s]
+              assert_in_delta(@r_icc['lbound'], @icc.lbound)
+              assert_in_delta(@r_icc['ubound'], @icc.ubound)
             end
-            should "summary generated" do
-              assert(@icc.summary.size>0)
+            should 'summary generated' do
+              assert(@icc.summary.size > 0)
             end
           end
         end
       end
     rescue
-      puts "requires rserve"
+      puts 'requires rserve'
     end
-    
   end
 end

data/test/test_reliability_skillscale.rb

@@ -1,57 +1,55 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 
-
-class StatsampleReliabilitySkillScaleTestCase < MiniTest::Unit::TestCase
+class StatsampleReliabilitySkillScaleTestCase < Minitest::Test
   context Statsample::Reliability::SkillScaleAnalysis do
     setup do
-      options=%w{a b c d e}
-      cases=20
-      @id=cases.times.map {|v| v}.to_scale
-      @a=cases.times.map {options[rand(5)]}.to_vector
-      @b=cases.times.map {options[rand(5)]}.to_vector
-      @c=cases.times.map {options[rand(5)]}.to_vector
-      @d=cases.times.map {options[rand(5)]}.to_vector
-      @e=cases.times.map {|i|
-        i==0 ? options[rand(0)] : 
-          rand()>0.8 ? nil : options[rand(5)]
+      options = %w(a b c d e)
+      cases = 20
+      @id = cases.times.map { |v| v }.to_scale
+      @a = cases.times.map { options[rand(5)] }.to_vector
+      @b = cases.times.map { options[rand(5)] }.to_vector
+      @c = cases.times.map { options[rand(5)] }.to_vector
+      @d = cases.times.map { options[rand(5)] }.to_vector
+      @e = cases.times.map {|i|
+        i == 0 ? options[rand(0)] :
+          rand > 0.8 ? nil : options[rand(5)]
       }.to_vector
-      @ds={'id'=>@id,'a'=>@a,'b'=>@b,'c'=>@c,'d'=>@d,'e'=>@e}.to_dataset
-      @key={'a'=>"a", 'b'=>options[rand(5)], 'c'=>options[rand(5)], 'd'=>options[rand(5)],'e'=>options[rand(5)]}
-      @ssa=Statsample::Reliability::SkillScaleAnalysis.new(@ds, @key)
-      @ac=@a.map {|v| v==@key['a'] ? 1 : 0}.to_scale
-      @bc=@b.map {|v| v==@key['b'] ? 1 : 0}.to_scale
-      @cc=@c.map {|v| v==@key['c'] ? 1 : 0}.to_scale
-      @dc=@d.map {|v| v==@key['d'] ? 1 : 0}.to_scale
-      @ec=@e.map {|v| v.nil? ? nil : (v==@key['e'] ? 1 : 0)}.to_scale
-
+      @ds = { 'id' => @id, 'a' => @a, 'b' => @b, 'c' => @c, 'd' => @d, 'e' => @e }.to_dataset
+      @key = { 'a' => 'a', 'b' => options[rand(5)], 'c' => options[rand(5)], 'd' => options[rand(5)], 'e' => options[rand(5)] }
+      @ssa = Statsample::Reliability::SkillScaleAnalysis.new(@ds, @key)
+      @ac = @a.map { |v| v == @key['a'] ? 1 : 0 }.to_scale
+      @bc = @b.map { |v| v == @key['b'] ? 1 : 0 }.to_scale
+      @cc = @c.map { |v| v == @key['c'] ? 1 : 0 }.to_scale
+      @dc = @d.map { |v| v == @key['d'] ? 1 : 0 }.to_scale
+      @ec = @e.map { |v| v.nil? ? nil : (v == @key['e'] ? 1 : 0) }.to_scale
     end
-    should "return proper corrected dataset" do
-      cds={'id'=>@id, 'a'=>@ac,'b'=>@bc,'c'=>@cc,'d'=>@dc, 'e'=>@ec}.to_dataset
+    should 'return proper corrected dataset' do
+      cds = { 'id' => @id, 'a' => @ac, 'b' => @bc, 'c' => @cc, 'd' => @dc, 'e' => @ec }.to_dataset
       assert_equal(cds, @ssa.corrected_dataset)
     end
-    should "return proper corrected minimal dataset" do
-      cdsm={'a'=>@ac,'b'=>@bc,'c'=>@cc,'d'=>@dc, 'e'=>@ec}.to_dataset
+    should 'return proper corrected minimal dataset' do
+      cdsm = { 'a' => @ac, 'b' => @bc, 'c' => @cc, 'd' => @dc, 'e' => @ec }.to_dataset
       assert_equal(cdsm, @ssa.corrected_dataset_minimal)
     end
-    should "return correct vector_sum and vector_sum" do
-      cdsm=@ssa.corrected_dataset_minimal
+    should 'return correct vector_sum and vector_sum' do
+      cdsm = @ssa.corrected_dataset_minimal
       assert_equal(cdsm.vector_sum, @ssa.vector_sum)
       assert_equal(cdsm.vector_mean, @ssa.vector_mean)
     end
-    should "not crash on rare case" do
-      a=Statsample::Vector["c","c","a","a","c","a","b","c","c","b","a","d","a","d","a","a","d","e","c","d"]
-      b=Statsample::Vector["e","b","e","b","c","d","a","e","e","c","b","e","e","b","d","c","e","b","b","d"]
-      c=Statsample::Vector["e","b","e","c","e","c","b","d","e","c","a","a","b","d","e","c","b","a","a","e"]
-      d=Statsample::Vector["a","b","d","d","e","b","e","b","d","c","e","a","c","d","c","c","e","d","d","b"]
-      e=Statsample::Vector["a","b",nil,"d","c","c","d",nil,"d","d","e","e",nil,nil,nil,"d","c",nil,"e","d"]
-      key={"a"=>"a", "b"=>"e", "c"=>"d", "d"=>"c", "e"=>"d"}
-      ds=Statsample::Dataset.new("a"=>a,"b"=>b,"c"=>c,"d"=>d,"e"=>e)
-      ssa=Statsample::Reliability::SkillScaleAnalysis.new(ds, key)
+    should 'not crash on rare case' do
+      a = Statsample::Vector['c', 'c', 'a', 'a', 'c', 'a', 'b', 'c', 'c', 'b', 'a', 'd', 'a', 'd', 'a', 'a', 'd', 'e', 'c', 'd']
+      b = Statsample::Vector['e', 'b', 'e', 'b', 'c', 'd', 'a', 'e', 'e', 'c', 'b', 'e', 'e', 'b', 'd', 'c', 'e', 'b', 'b', 'd']
+      c = Statsample::Vector['e', 'b', 'e', 'c', 'e', 'c', 'b', 'd', 'e', 'c', 'a', 'a', 'b', 'd', 'e', 'c', 'b', 'a', 'a', 'e']
+      d = Statsample::Vector['a', 'b', 'd', 'd', 'e', 'b', 'e', 'b', 'd', 'c', 'e', 'a', 'c', 'd', 'c', 'c', 'e', 'd', 'd', 'b']
+      e = Statsample::Vector['a', 'b', nil, 'd', 'c', 'c', 'd', nil, 'd', 'd', 'e', 'e', nil, nil, nil, 'd', 'c', nil, 'e', 'd']
+      key = { 'a' => 'a', 'b' => 'e', 'c' => 'd', 'd' => 'c', 'e' => 'd' }
+      ds = Statsample::Dataset.new('a' => a, 'b' => b, 'c' => c, 'd' => d, 'e' => e)
+      ssa = Statsample::Reliability::SkillScaleAnalysis.new(ds, key)
       assert(ssa.summary)
     end
-    
-    should "return valid summary" do
-      assert(@ssa.summary.size>0)
+
+    should 'return valid summary' do
+      assert(@ssa.summary.size > 0)
     end
   end
 end

data/test/test_resample.rb

@@ -1,22 +1,24 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 
-class StatsampleResampleTestCase < MiniTest::Unit::TestCase
+class StatsampleResampleTestCase < Minitest::Test
   def initialize(*args)
     super
   end
+
   def test_basic
-    r=Statsample::Resample.generate(20,1,10)
-    assert_equal(20,r.size)
-    assert(r.min>=1)
-    assert(r.max<=10)
+    r = Statsample::Resample.generate(20, 1, 10)
+    assert_equal(20, r.size)
+    assert(r.min >= 1)
+    assert(r.max <= 10)
   end
+
   def test_repeat_and_save
-    r=Statsample::Resample.repeat_and_save(400) {
-      Statsample::Resample.generate(20,1,10).count(1)
+    r = Statsample::Resample.repeat_and_save(400) {
+      Statsample::Resample.generate(20, 1, 10).count(1)
     }
-    assert_equal(400,r.size)
-    v=Statsample::Vector.new(r,:scale)
-    a=v.count {|x|  x > 3}
-    assert(a>=30 && a<=70)
+    assert_equal(400, r.size)
+    v = Statsample::Vector.new(r, :scale)
+    a = v.count { |x|  x > 3 }
+    assert(a >= 30 && a <= 70)
   end
 end

data/test/test_rserve_extension.rb

@@ -1,42 +1,42 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 begin
   require 'rserve'
   require 'statsample/rserve_extension'
 
-class StatsampleRserveExtensionTestCase < MiniTest::Unit::TestCase
-  context "Statsample Rserve extensions" do
-    setup do
-      @r=Rserve::Connection.new
-    end
-    teardown do
-      @r.close
-    end
-    should "return a valid rexp for numeric vector" do
-      a=100.times.map {|i| rand()>0.9 ? nil : i+rand() }.to_scale
-      rexp=a.to_REXP
-      assert(rexp.is_a? Rserve::REXP::Double)
-      assert_equal(rexp.to_ruby,a.data_with_nils)
-      @r.assign 'a',rexp
-      assert_equal(a.data_with_nils, @r.eval('a').to_ruby)
-    end
-    should "return a valid rserve dataframe for statsample datasets" do
-      a=100.times.map {|i| rand()>0.9 ? nil : i+rand() }.to_scale
-      b=100.times.map {|i| rand()>0.9 ? nil : i+rand() }.to_scale
-      c=100.times.map {|i| rand()>0.9 ? nil : i+rand() }.to_scale
-      ds={'a'=>a,'b'=>b,'c'=>c}.to_dataset
-      rexp=ds.to_REXP
-      assert(rexp.is_a? Rserve::REXP::GenericVector)
-      ret=rexp.to_ruby
-      assert_equal(a.data_with_nils, ret['a']) 
-      @r.assign 'df', rexp
-      out_df=@r.eval('df').to_ruby
-      assert_equal('data.frame', out_df.attributes['class'])
-      assert_equal(['a','b','c'], out_df.attributes['names'])
-      assert_equal(a.data_with_nils, out_df['a'])
+  class StatsampleRserveExtensionTestCase < Minitest::Test
+    context 'Statsample Rserve extensions' do
+      setup do
+        @r = Rserve::Connection.new
+      end
+      teardown do
+        @r.close
+      end
+      should 'return a valid rexp for numeric vector' do
+        a = 100.times.map { |i| rand > 0.9 ? nil : i + rand }.to_scale
+        rexp = a.to_REXP
+        assert(rexp.is_a? Rserve::REXP::Double)
+        assert_equal(rexp.to_ruby, a.data_with_nils)
+        @r.assign 'a', rexp
+        assert_equal(a.data_with_nils, @r.eval('a').to_ruby)
+      end
+      should 'return a valid rserve dataframe for statsample datasets' do
+        a = 100.times.map { |i| rand > 0.9 ? nil : i + rand }.to_scale
+        b = 100.times.map { |i| rand > 0.9 ? nil : i + rand }.to_scale
+        c = 100.times.map { |i| rand > 0.9 ? nil : i + rand }.to_scale
+        ds = { 'a' => a, 'b' => b, 'c' => c }.to_dataset
+        rexp = ds.to_REXP
+        assert(rexp.is_a? Rserve::REXP::GenericVector)
+        ret = rexp.to_ruby
+        assert_equal(a.data_with_nils, ret['a'])
+        @r.assign 'df', rexp
+        out_df = @r.eval('df').to_ruby
+        assert_equal('data.frame', out_df.attributes['class'])
+        assert_equal(%w(a b c), out_df.attributes['names'])
+        assert_equal(a.data_with_nils, out_df['a'])
+      end
     end
   end
-end
 
 rescue LoadError
-  puts "Require rserve extension"
+  puts 'Require rserve extension'
 end