statsample 0.9.0 → 0.10.0

data/test/test_matrix.rb

@@ -2,23 +2,36 @@ require(File.dirname(__FILE__)+'/test_helpers.rb')
 
 
 class StatsampleMatrixTestCase < MiniTest::Unit::TestCase
-
-  def setup
-  end
-  def test_subindex
-    matrix=Matrix[[1,2,3],[4,5,6],[7,8,9]]
-    assert_equal(5, matrix[1,1])
-    assert_equal(Matrix[[1,2,3]], matrix[0,:*])
-    assert_equal(Matrix[[1],[4],[7]], matrix[:*,0])
-    assert_equal(Matrix[[1,2],[4,5],[7,8]], matrix[:*,0..1])
-    assert_equal(Matrix[[1,2],[4,5]], matrix[0..1,0..1])
-  end
-  def test_sums
-    matrix=Matrix[[1,2,3],[4,5,6],[7,8,9]]
-    assert_equal(6,matrix.row_sum[0])
-    assert_equal(12,matrix.column_sum[0])
-    assert_equal(45,matrix.total_sum)
+  context(Matrix) do
+    setup do 
+      @matrix=Matrix[[1,2,3],[4,5,6],[7,8,9]]
+    end
+    should "return correct value for [i,j]" do
+      assert_equal(5, @matrix[1,1])
+    end
+    should "return correct value for [i,:*]" do
+      assert_equal(Matrix[[1,2,3]], @matrix[0,:*])
+    end
+    should "return correct value for [:*,j]" do 
+      assert_equal(Matrix[[1],[4],[7]], @matrix[:*,0])
+    end
+    should "return correct value for [:*,j1..j2]" do
+      assert_equal(Matrix[[1,2],[4,5],[7,8]], @matrix[:*,0..1])
+    end
+    should "return correct value for [i1..i2,j1..j2]" do
+      assert_equal(Matrix[[1,2],[4,5]], @matrix[0..1,0..1])
+    end
+    should "return correct value for row_sum" do
+      assert_equal(6,@matrix.row_sum[0])
+    end
+    should "return correct value for column_sum" do
+      assert_equal(12,@matrix.column_sum[0])
+    end
+    should "return correct value for total_sum" do
+      assert_equal(45,@matrix.total_sum)
+    end
   end
+  
   def test_covariate
     a=Matrix[[1.0, 0.3, 0.2], [0.3, 1.0, 0.5], [0.2, 0.5, 1.0]]
     a.extend Statsample::CovariateMatrix
@@ -35,9 +48,9 @@ class StatsampleMatrixTestCase < MiniTest::Unit::TestCase
 
     assert_equal(:covariance, a.type)
 
-    a=100.times.collect {rand()}.to_scale
-    b=100.times.collect {rand()}.to_scale
-    c=100.times.collect {rand()}.to_scale
+    a=50.times.collect {rand()}.to_scale
+    b=50.times.collect {rand()}.to_scale
+    c=50.times.collect {rand()}.to_scale
     ds={'a'=>a,'b'=>b,'c'=>c}.to_dataset
     corr=Statsample::Bivariate.correlation_matrix(ds)
     real=Statsample::Bivariate.covariance_matrix(ds).correlation
@@ -46,5 +59,5 @@ class StatsampleMatrixTestCase < MiniTest::Unit::TestCase
         assert_in_delta(corr[i,j], real[i,j],1e-15)
       end
     end
-  end
+  end  
 end

data/test/test_permutation.rb

@@ -2,35 +2,41 @@ require(File.dirname(__FILE__)+'/test_helpers.rb')
 
 
 class StatsamplePermutationTestCase < MiniTest::Unit::TestCase
-  def initialize(*args)
-    super
-  end
-  def test_number_of_permutations
-    per1=Statsample::Permutation.new(4)
-    assert_equal(24,per1.permutation_number)
-    per2=Statsample::Permutation.new([1,1,1,0,0,0])
-    assert_equal(20,per2.permutation_number)
-  end
-  def test_permutation_with_number
-    per1=Statsample::Permutation.new(2)
-    exp1=[[0,1],[1,0]]
-    assert_equal(exp1,per1.permutations)
-    per2=Statsample::Permutation.new(3)
-    exp2=[[0,1,2],[0,2,1],[1,0,2],[1,2,0],[2,0,1],[2,1,0]]
-    assert_equal(exp2,per2.permutations)
-
-  end
-  def test_permutation_with_array_simple
-    per1=Statsample::Permutation.new(%w{a b})
-    exp1=[['a','b'],['b','a']]
-    assert_equal(exp1,per1.permutations)
-    per2=Statsample::Permutation.new(%w{a b c})
-    exp2=[%w{a b c},%w{a c b},%w{b a c} ,%w{b c a},%w{c a b},%w{c b a}]
-    assert_equal(exp2,per2.permutations)
-  end
-  def test_permutation_with_array_repeated
-    per1=Statsample::Permutation.new([0,0,1,1])
-    exp1=[[0,0,1,1],[0,1,0,1],[0,1,1,0],[1,0,0,1],[1,0,1,0],[1,1,0,0]]
-    assert_equal(exp1,per1.permutations)
+  context Statsample::Permutation do
+    should "initialize with number" do
+      per1=Statsample::Permutation.new(2)
+      exp1=[[0,1],[1,0]]
+      assert_equal(exp1,per1.permutations)
+      per2=Statsample::Permutation.new(3)
+      exp2=[[0,1,2],[0,2,1],[1,0,2],[1,2,0],[2,0,1],[2,1,0]]
+      assert_equal(exp2,per2.permutations)
+    end
+    should "initialize with simple array" do
+      per1=Statsample::Permutation.new(%w{a b})
+      exp1=[['a','b'],['b','a']]
+      assert_equal(exp1,per1.permutations)
+      per2=Statsample::Permutation.new(%w{a b c})
+      exp2=[%w{a b c},%w{a c b},%w{b a c} ,%w{b c a},%w{c a b},%w{c b a}]
+      assert_equal(exp2,per2.permutations)
+    end
+    should "initialize with Statsample::Vector" do
+      per2=Statsample::Permutation.new(%w{a b c}.to_vector)
+      exp2=[%w{a b c},%w{a c b},%w{b a c} ,%w{b c a},%w{c a b},%w{c b a}]
+      assert_equal(exp2, per2.permutations)
+    end
+      
+    should "calculate correct number of total permutations without repetitions" do
+      per1=Statsample::Permutation.new(4)
+      assert_equal(24,per1.permutation_number)      
+    end
+    should "calculate correct number of total permutations with repetitions" do
+      per2=Statsample::Permutation.new([1,1,1,0,0,0])
+      assert_equal(20,per2.permutation_number)
+    end
+    should "initialize with array repeated" do 
+      per1=Statsample::Permutation.new([0,0,1,1])
+      exp1=[[0,0,1,1],[0,1,0,1],[0,1,1,0],[1,0,0,1],[1,0,1,0],[1,1,0,0]]
+      assert_equal(exp1,per1.permutations)
+    end
   end
 end

data/test/test_regression.rb

@@ -1,6 +1,26 @@
 require(File.dirname(__FILE__)+'/test_helpers.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
+
+      @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
+  end
   def test_parameters
     @x=[13,20,10,33,15].to_vector(:scale)
     @y=[23,18,35,10,27	].to_vector(:scale)
@@ -19,15 +39,13 @@ class StatsampleRegressionTestCase < MiniTest::Unit::TestCase
     assert_in_delta(4.248,reg.standard_error,0.002)
   end
   def test_summaries
-    a=100.times.map{rand(100)}.to_scale
-    b=100.times.map{rand(100)}.to_scale
-    y=100.times.map{rand(100)}.to_scale
+    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[
@@ -65,7 +83,6 @@ class StatsampleRegressionTestCase < MiniTest::Unit::TestCase
     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
 
 
@@ -170,14 +187,15 @@ class StatsampleRegressionTestCase < MiniTest::Unit::TestCase
     @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]
     c_predicted = lr.predicted
-
     predicted.each_index do |i|
       if c_predicted[i].nil?
-        assert(predicted[i].nil?)
+        assert(predicted[i].nil?, "Actual #{i} is nil, but expected #{predicted[i]}")
       else
         assert_in_delta(predicted[i], c_predicted[i], 0.001)
       end

data/test/test_reliability.rb

@@ -2,20 +2,110 @@ require(File.dirname(__FILE__)+'/test_helpers.rb')
 
 
 class StatsampleReliabilityTestCase < MiniTest::Unit::TestCase
+  context Statsample::Reliability do
+    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
+        @n_variables.times do |i|
+          @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
+        @dse.fields.each do |f|
+          @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 "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
+        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)
+        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)          
+        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
+        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
+        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
+        end
+        expected=total.each {|k,v|
+          total[k]=v.quo(total_g[k])
+        }
+        assert_equal(expected, @icc.curve_field('a',index))
+        
+      end
+      
+    end
+    context Statsample::Reliability::ItemAnalysis do
+      setup do 
+        @x1=[1,1,1,1,2,2,2,2,3,3,3,30].to_vector(:scale)
+        @x2=[1,1,1,2,2,3,3,3,3,4,4,50].to_vector(:scale)
+        @x3=[2,2,1,1,1,2,2,2,3,4,5,40].to_vector(:scale)
+        @x4=[1,2,3,4,4,4,4,3,4,4,5,30].to_vector(:scale)
+        @ds={'x1'=>@x1,'x2'=>@x2,'x3'=>@x3,'x4'=>@x4}.to_dataset
+        @ia=Statsample::Reliability::ItemAnalysis.new(@ds)
 
-  def setup
-    @x1=[1,1,1,1,2,2,2,2,3,3,3,30].to_vector(:scale)
-    @x2=[1,1,1,2,2,3,3,3,3,4,4,50].to_vector(:scale)
-    @x3=[2,2,1,1,1,2,2,2,3,4,5,40].to_vector(:scale)
-    @x4=[1,2,3,4,4,4,4,3,4,4,5,30].to_vector(:scale)
-    @ds={'x1'=>@x1,'x2'=>@x2,'x3'=>@x3,'x4'=>@x4}.to_dataset
-  end
-
-  def test_general
-    ia=Statsample::Reliability::ItemAnalysis.new(@ds)
-    assert_in_delta(0.980,ia.alpha,0.001)
-    assert_in_delta(0.999,ia.alpha_standarized,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 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)
+        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)
+      end
+      
+    end
   end
 end

data/test/test_test_f.rb

@@ -5,33 +5,30 @@ class StatsampleTestFTestCase < MiniTest::Unit::TestCase
     setup do
       @ssb=84
       @ssw=68
-      @f=Statsample::Test::F.new(@ssb,@ssw, 2,15)
+      @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
-      assert_equal((@ssb.quo(2)).quo(@ssw.quo(15)), @f.f)
+    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
-      assert_equal(17, @f.df_total)
+      assert_equal(@df_num+@df_den, @f.df_total)
     end
     should "have probability near 0.002" do 
       assert_in_delta(0.002, @f.probability, 0.0005)
     end
-    context("#summary") do
+    should "be coerced into float" do
+      assert_equal(@f.to_f, @f.f)
+    end
+    
+    context("method #summary") do
       setup do
-        @f.name_numerator="MSb"
-        @f.name_denominator="MSw"
-        @f.name="ANOVA"
         @summary=@f.summary
       end
       should "have size > 0" do
         assert(@summary.size>0)
       end
-      should "include correct names for title, num and den" do
-        assert_match(@f.name_numerator, @summary)
-        assert_match(@f.name_denominator, @summary)
-        assert_match(@f.name, @summary)
-      end
     end
   end
-
 end

data/test/test_test_t.rb

@@ -1,40 +1,47 @@
 require(File.dirname(__FILE__)+'/test_helpers.rb')
 
 class StatsampleTestTTestCase < MiniTest::Unit::TestCase
-  def setup
-    @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
-  def test_t_sample_independent_t
-    assert_in_delta(1.959, Statsample::Test::T.two_sample_independent(@x1, @x2, @s1, @s2, @n1, @n2))
-    assert_in_delta(1.959, Statsample::Test::T.two_sample_independent(@x1, @x2, @s1, @s2, @n1, @n2,true))
-  end
-  def test_t_sample_independent_df
-    assert_equal(10,  Statsample::Test::T.df_equal_variance(@n1,@n2))
-    assert_in_delta(7.03,  Statsample::Test::T.df_not_equal_variance(@s1,@s2,@n1,@n2))    
-  end
-  def test_t_sample_independent_object
-    t=Statsample::Test.t_two_samples_independent(@a,@b)
-    assert(t.summary.size>0)
-    assert_in_delta(1.959, t.t_equal_variance)
-    assert_in_delta(1.959, t.t_not_equal_variance)
-    assert_in_delta(10, t.df_equal_variance)
-    assert_in_delta(7.03, t.df_not_equal_variance)
-    assert_in_delta(0.07856, t.probability_equal_variance)
-    assert_in_delta(0.09095, t.probability_not_equal_variance)
-    
-  end
-  def test_t_one_sample
-    u=@a.mean+(1-rand*2)
-    tos=Statsample::Test::T::OneSample.new(@a,{:u=>u})
-    assert_equal((@a.mean-u).quo(@a.sd.quo(Math::sqrt(@a.n))), tos.t)
-    assert_equal(@a.n-1, tos.df)
-    assert(tos.summary.size>0)
+  include Statsample::Test
+  include Math
+  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 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)
+    end
   end
 end