statsample 0.9.0 → 0.10.0

data/test/test_anovaoneway.rb

@@ -0,0 +1,27 @@
+require(File.dirname(__FILE__)+'/test_helpers.rb')
+
+class StatsampleAnovaOneWayTestCase < MiniTest::Unit::TestCase
+  context(Statsample::Anova::OneWay) do
+    setup do
+      @ss_num=30.08
+      @ss_den=87.88
+      @df_num=2
+      @df_den=21
+      @anova=Statsample::Anova::OneWay.new(:ss_num=>@ss_num, :ss_den=>@ss_den, :df_num=>@df_num, :df_den=>@df_den)
+    end
+    should "Statsample::Anova.oneway respond to #oneway" do
+      assert(Statsample::Anova.respond_to? :oneway)
+    end
+    should "return correct value for ms_num and ms_den" do
+      assert_in_delta(15.04, @anova.ms_num, 0.01)
+      assert_in_delta(4.18, @anova.ms_den, 0.01)
+    end
+    should "return correct value for f" do
+      assert_in_delta(3.59, @anova.f, 0.01)
+    end
+    should "respond to summary" do
+      assert(@anova.respond_to? :summary)
+      assert(@anova.summary.size>0)
+    end
+  end
+end

data/test/test_anovawithvectors.rb

@@ -0,0 +1,97 @@
+require(File.dirname(__FILE__)+'/test_helpers.rb')
+
+class StatsampleAnovaOneWayWithVectorsTestCase < MiniTest::Unit::TestCase
+  context(Statsample::Anova::OneWayWithVectors) do
+    context("when initializing") do
+      setup do
+        @v1=10.times.map {rand(100)}.to_scale
+        @v2=10.times.map {rand(100)}.to_scale
+        @v3=10.times.map {rand(100)}.to_scale
+      end
+      should "be the same using [] or args*" do
+        a1=Statsample::Anova::OneWayWithVectors.new(@v1,@v2,@v3)
+        a2=Statsample::Anova::OneWayWithVectors.new([@v1,@v2,@v3])
+        assert_equal(a1.f,a2.f)
+      end
+      should "be the same using module method or object instantiation" do
+        a1=Statsample::Anova::OneWayWithVectors.new(@v1,@v2,@v3)
+        a2=Statsample::Anova.oneway_with_vectors(@v1,@v2,@v3)
+        assert_equal(a1.f,a2.f)
+      end
+      should "detect optional hash" do
+        a1=Statsample::Anova::OneWayWithVectors.new(@v1,@v2,@v3, {:name=>'aaa'})
+        assert_equal('aaa', a1.name)
+      end
+      should "omit incorrect arguments" do
+        a1=Statsample::Anova::OneWayWithVectors.new(@v1,@v2,@v3, {:name=>'aaa'})
+        a2=Statsample::Anova::OneWayWithVectors.new(@v1,nil,nil,@v2,@v3, {:name=>'aaa'})
+        assert_equal(a1.f,a2.f)
+      end
+    end
+    setup do
+      @v1=[3,3,2,3,6].to_vector(:scale)
+      @v2=[7,6,5,6,7].to_vector(:scale)
+      @v3=[9,8,9,7,8].to_vector(:scale)
+      @name="Anova testing"
+      @anova=Statsample::Anova::OneWayWithVectors.new(@v1,@v2,@v3, :name=>@name)
+    end
+    should "respond to #summary" do
+      assert(@anova.respond_to? :summary)
+    end
+    should "have correct name of analysis on #summary" do
+      assert_match(/#{@name}/, @anova.summary)
+    end
+    should "returns same levene values as direct Levene creation" do
+      assert_equal(@anova.levene.f, Statsample::Test.levene([@v1,@v2,@v3]).f)
+    end
+    should "have correct value for levene" do
+      assert_in_delta(0.604,@anova.levene.f, 0.001)
+      assert_in_delta(0.562,@anova.levene.probability, 0.001)
+    end
+    should "have correct value for sst" do
+     assert_in_delta(72.933, @anova.sst,0.001)
+    end
+    should "have correct value for sswg" do
+      assert_in_delta(14.8,@anova.sswg,0.001)
+    end
+    should "have correct value for ssb" do
+      assert_in_delta(58.133,@anova.ssbg,0.001)
+    end
+    should "sst=sswg+ssbg" do
+      assert_in_delta(@anova.sst,@anova.sswg+@anova.ssbg,0.00001)
+    end
+    should "df total equal to number of n-1" do
+      assert_equal(@v1.n+@v2.n+@v3.n-1,@anova.df_total)
+    end
+    should "df wg equal to number of n-k" do
+      assert_equal(@v1.n+@v2.n+@v3.n-3,@anova.df_wg)
+    end
+    should "df bg equal to number of k-1" do
+      assert_equal(2,@anova.df_bg)
+    end
+    should "f=(ssbg/df_bg)/(sswt/df_wt)" do
+      assert_in_delta((@anova.ssbg.quo(@anova.df_bg)).quo( @anova.sswg.quo(@anova.df_wg)), @anova.f, 0.001)
+    end
+    should "p be correct" do
+      assert(@anova.probability<0.01)
+    end
+    should "be correct using different test values" do
+      anova2=Statsample::Anova::OneWayWithVectors.new([@v1,@v1,@v1,@v1,@v2])
+      assert_in_delta(3.960, anova2.f,0.001)
+      assert_in_delta(0.016, anova2.probability,0.001)
+    end
+    context "with extra information on summary" do
+      setup do
+        @anova.summary_descriptives=true
+        @anova.summary_levene=true
+        @summary=@anova.summary
+      end
+      should "have section with levene statistics" do
+        assert_match(/Levene/, @summary)
+      end
+      should "have section with descriptives" do
+        assert_match(/Min/, @summary)
+      end
+    end
+  end
+end

data/test/test_bivariate.rb

@@ -8,8 +8,8 @@ class StatsampleBivariateTestCase < MiniTest::Unit::TestCase
   end
   def test_covariance
     if Statsample.has_gsl?
-      v1=1000.times.collect {|a| rand()}.to_scale
-      v2=1000.times.collect {|a| rand()}.to_scale
+      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)
     else
       skip "Bivariate::covariance not tested (needs GSL)"
@@ -19,8 +19,8 @@ class StatsampleBivariateTestCase < MiniTest::Unit::TestCase
 
   def test_gsl_pearson
     if Statsample.has_gsl?
-      v1=100.times.collect {|a| rand()}.to_scale
-      v2=100.times.collect {|a| rand()}.to_scale
+      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)
     else
@@ -51,13 +51,8 @@ class StatsampleBivariateTestCase < MiniTest::Unit::TestCase
       end
     end
   end
-  def test_polychoric_summary
-      matrix=Matrix[[150+rand(2),150+rand(2)],[150+rand(2),150+rand(2)],[200,300]]
-      poly  = Statsample::Bivariate::Polychoric.new(matrix)
-      assert(poly.summary.size>0)
-  end
   def test_poly_vs_tetra
-    5.times {
+    2.times {
       # Should be the same results as Tetrachoric for 2x2 matrix
       matrix=Matrix[[150+rand(10),1000+rand(20)],[1000+rand(20),200+rand(20)]]
       tetra = Statsample::Bivariate::Tetrachoric.new_with_matrix(matrix)
@@ -72,52 +67,6 @@ class StatsampleBivariateTestCase < MiniTest::Unit::TestCase
       end
     }
   end
-  def test_polychoric
-
-    matrix=Matrix[[58,52,1],[26,58,3],[8,12,9]]
-    poly=Statsample::Bivariate::Polychoric.new(matrix)
-    poly.compute_two_step_mle_drasgow_ruby
-    assert_in_delta(0.420, poly.r, 0.001)
-    assert_in_delta(-0.240, poly.threshold_y[0],0.001)
-    assert_in_delta(-0.027, poly.threshold_x[0],0.001)
-    assert_in_delta(1.578, poly.threshold_y[1],0.001)
-    assert_in_delta(1.137, poly.threshold_x[1],0.001)
-    if Statsample.has_gsl?
-      poly.method=:polychoric_series
-      poly.compute
-
-      assert_in_delta(0.556, poly.r, 0.001)
-      assert_in_delta(-0.240, poly.threshold_y[0],0.001)
-      assert_in_delta(-0.027, poly.threshold_x[0],0.001)
-      assert_in_delta(1.578, poly.threshold_y[1],0.001)
-      assert_in_delta(1.137, poly.threshold_x[1],0.001)
-
-      # Example for Tallis(1962, cited by Drasgow, 2006)
-
-      matrix=Matrix[[58,52,1],[26,58,3],[8,12,9]]
-      poly=Statsample::Bivariate::Polychoric.new(matrix)
-      poly.compute_two_step_mle_drasgow_gsl
-      assert_in_delta(0.420, poly.r, 0.001)
-      assert_in_delta(-0.240, poly.threshold_y[0],0.001)
-      assert_in_delta(-0.027, poly.threshold_x[0],0.001)
-      assert_in_delta(1.578, poly.threshold_y[1],0.001)
-      assert_in_delta(1.137, poly.threshold_x[1],0.001)
-
-
-      poly.method=:joint
-      poly.compute
-
-
-      assert_in_delta(0.4192, poly.r, 0.0001)
-      assert_in_delta(-0.2421, poly.threshold_y[0],0.0001)
-      assert_in_delta(-0.0297, poly.threshold_x[0],0.0001)
-      assert_in_delta(1.5938, poly.threshold_y[1],0.0001)
-      assert_in_delta(1.1331, poly.threshold_x[1],0.0001)
-    else
-      skip "Two-step optimized, polychoric series and Joint method for Polychoric  requires GSL"
-    end
-    assert(poly.summary)
-  end
 
   def test_tetrachoric
     a,b,c,d=0,0,0,0
@@ -176,7 +125,7 @@ class StatsampleBivariateTestCase < MiniTest::Unit::TestCase
       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}  ")
+        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)

data/test/test_bivariate_polychoric.rb

@@ -0,0 +1,65 @@
+require(File.dirname(__FILE__)+'/test_helpers.rb')
+
+class StatsampleBivariatePolychoricTestCase < MiniTest::Unit::TestCase
+  context Statsample::Bivariate do
+    should "responde to polychoric_correlation_matrix" do
+      a=([1,1,2,2,2,3,3,3,2,2,3,3,3]*4).to_scale
+      b=([1,2,2,2,1,3,2,3,2,2,3,3,2]*4).to_scale
+      c=([1,1,1,2,2,2,2,3,2,3,2,2,3]*4).to_scale
+      ds={'a'=>a,'b'=>b,'c'=>c}.to_dataset
+      assert(Statsample::Bivariate.polychoric_correlation_matrix(ds).is_a? ::Matrix)
+    end
+  end
+  context Statsample::Bivariate::Polychoric do
+    setup do
+      matrix=Matrix[[58,52,1],[26,58,3],[8,12,9]]
+      @poly=Statsample::Bivariate::Polychoric.new(matrix)
+    end
+    should "have summary.size > 0" do
+      assert(@poly.summary.size>0)
+    end
+    should "compute two step mle with ruby" do
+      @poly.compute_two_step_mle_drasgow_ruby
+      assert_in_delta(0.420, @poly.r, 0.001)
+      assert_in_delta(-0.240, @poly.threshold_y[0],0.001)
+      assert_in_delta(-0.027, @poly.threshold_x[0],0.001)
+      assert_in_delta(1.578, @poly.threshold_y[1],0.001)
+      assert_in_delta(1.137, @poly.threshold_x[1],0.001)
+    end
+    should "compute two-step with gsl" do
+      if Statsample.has_gsl?
+        @poly.compute_two_step_mle_drasgow_gsl
+        assert_in_delta(0.420, @poly.r, 0.001)
+        assert_in_delta(-0.240, @poly.threshold_y[0],0.001)
+        assert_in_delta(-0.027, @poly.threshold_x[0],0.001)
+        assert_in_delta(1.578, @poly.threshold_y[1],0.001)
+        assert_in_delta(1.137, @poly.threshold_x[1],0.001)
+      else
+        skip "Requires GSL"
+      end
+    end
+    should "compute polychoric series" do 
+      if Statsample.has_gsl?
+      @poly.method=:polychoric_series
+      @poly.compute
+      assert_in_delta(0.556, @poly.r, 0.001)
+      assert_in_delta(-0.240, @poly.threshold_y[0],0.001)
+      assert_in_delta(-0.027, @poly.threshold_x[0],0.001)
+      assert_in_delta(1.578, @poly.threshold_y[1],0.001)
+      assert_in_delta(1.137, @poly.threshold_x[1],0.001)
+      end
+    end
+  should "compute joint" do
+    if Statsample.has_gsl?
+      @poly.method=:joint
+      @poly.compute
+      assert_in_delta(0.4192, @poly.r, 0.0001)
+      assert_in_delta(-0.2421, @poly.threshold_y[0],0.0001)
+      assert_in_delta(-0.0297, @poly.threshold_x[0],0.0001)
+      assert_in_delta(1.5938, @poly.threshold_y[1],0.0001)
+      assert_in_delta(1.1331, @poly.threshold_x[1],0.0001)
+    end
+  end  
+  end
+  
+end

data/test/test_crosstab.rb

@@ -41,6 +41,12 @@ class StatsampleCrosstabTestCase < MiniTest::Unit::TestCase
     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)
+  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

data/test/test_dataset.rb

@@ -6,6 +6,9 @@ class StatsampleDatasetTestCase < MiniTest::Unit::TestCase
       'city'=>Statsample::Vector.new(['New York','London','London','Paris','Tome']),
     'a1'=>Statsample::Vector.new(['a,b','b,c','a',nil,'a,b,c'])}, ['id','name','age','city','a1'])
   end
+  def test_should_have_summary
+    assert(@ds.summary.size>0)
+  end
   def test_basic
     assert_equal(5,@ds.cases)
     assert_equal(%w{id name age city a1}, @ds.fields)
@@ -192,7 +195,9 @@ class StatsampleDatasetTestCase < MiniTest::Unit::TestCase
     assert_equal([1,0,1,nil,1],@ds.col('a1_1').to_a)
     assert_equal([1,1,0,nil,1],@ds.col('a1_2').to_a)
     assert_equal([0,1,0,nil,1],@ds.col('a1_3').to_a)
-    assert_equal({'a1_1'=>'a1:a', 'a1_2'=>'a1:b', 'a1_3'=>'a1:c'},@ds.labels)
+    {'a1_1'=>'a1:a', 'a1_2'=>'a1:b', 'a1_3'=>'a1:c'}.each do |k,v|
+      assert_equal(v, @ds[k].name)
+    end
   end
   def test_split_by_separator
     @ds.add_vectors_by_split("a1","_")
@@ -243,6 +248,29 @@ class StatsampleDatasetTestCase < MiniTest::Unit::TestCase
     assert_same(ds1['v2'],ds2['v2'])
 
 
+  end
+  def test_clone
+    v1=[1,2,3,4].to_vector
+    v2=[5,6,7,8].to_vector
+    ds1=Statsample::Dataset.new({'v1'=>v1,'v2'=>v2}, %w{v2 v1})
+    ds2=ds1.clone
+    assert_equal(ds1,ds2)
+    assert_not_same(ds1,ds2)
+    assert_equal(ds1['v1'],ds2['v1'])
+    assert_same(ds1['v1'], ds2['v1'])
+    assert_equal(ds1.fields,ds2.fields)
+    assert_not_same(ds1.fields,ds2.fields)
+
+    # partial clone
+    ds3=ds1.clone('v1')
+    ds_exp=Statsample::Dataset.new({'v1'=>v1},%w{v1})
+    assert_equal(ds_exp,ds3)
+    assert_not_same(ds_exp,ds3)
+    assert_equal(ds3['v1'],ds_exp['v1'])
+    assert_same(ds3['v1'],ds_exp['v1'])
+    assert_equal(ds3.fields,ds_exp.fields)
+    assert_not_same(ds3.fields,ds_exp.fields)
+     
   end
   def test_dup
     v1=[1,2,3,4].to_vector

data/test/test_distribution.rb

@@ -2,17 +2,10 @@ require(File.dirname(__FILE__)+'/test_helpers.rb')
 
 require 'distribution'
 
-begin
-  require 'rbgsl'
-  NOT_GSL=false
-rescue LoadError
-  NOT_GSL=true
-end
-
 
 class DistributionTestCase < MiniTest::Unit::TestCase
   def test_chi
-    if !NOT_GSL
+    if Distribution.has_gsl?
       [2,3,4,5].each{|k|
         chis=rand()*10
         area=Distribution::ChiSquare.cdf(chis, k)
@@ -22,7 +15,7 @@ class DistributionTestCase < MiniTest::Unit::TestCase
     end
   end
   def test_t
-    if !NOT_GSL
+    if Distribution.has_gsl?
       [-2,0.1,0.5,1,2].each{|t|
         [2,5,10].each{|n|
           area=Distribution::T.cdf(t,n)
@@ -34,7 +27,7 @@ class DistributionTestCase < MiniTest::Unit::TestCase
     end
   end
   def test_normal
-    if !NOT_GSL
+    if Distribution.has_gsl?
       [-2,0.1,0.5,1,2].each{|x|
         area=Distribution::Normal.cdf(x)
         assert_in_delta(area, GSL::Cdf.ugaussian_P(x),0.0001)
@@ -44,7 +37,7 @@ class DistributionTestCase < MiniTest::Unit::TestCase
     end
   end
   def test_normal_bivariate
-    if !NOT_GSL
+    if Distribution.has_gsl?
       [0.2,0.4,0.6,0.8,0.9, 0.99,0.999,0.999999].each {|rho|
         assert_equal(GSL::Ran::bivariate_gaussian_pdf(0, 0, 1,1,rho), Distribution::NormalBivariate.pdf(0,0, rho , 1,1))
 
@@ -53,7 +46,7 @@ class DistributionTestCase < MiniTest::Unit::TestCase
 
     [-3,-2,-1,0,1,1.5].each {|x|
       assert_in_delta(Distribution::NormalBivariate.cdf_hull(x,x,0.5), Distribution::NormalBivariate.cdf_genz(x,x,0.5), 0.001)
-      assert_in_delta(Distribution::NormalBivariate.cdf_genz(x,x,0.5), Distribution::NormalBivariate.cdf_jantaravareerat(x,x,0.5), 0.001)
+      #assert_in_delta(Distribution::NormalBivariate.cdf_genz(x,x,0.5), Distribution::NormalBivariate.cdf_jantaravareerat(x,x,0.5), 0.001)
     }
 
     assert_in_delta(0.686, Distribution::NormalBivariate.cdf(2,0.5,0.5), 0.001)
@@ -63,7 +56,7 @@ class DistributionTestCase < MiniTest::Unit::TestCase
     assert_in_delta(Distribution::Normal.cdf(0), Distribution::NormalBivariate.cdf(10,0,0.9), 0.001)
   end
   def test_f
-    if !NOT_GSL
+    if Distribution.has_gsl?
       [0.1,0.5,1,2,10,20,30].each{|f|
         [2,5,10].each{|n2|
           [2,5,10].each{|n1|

data/test/test_dominance_analysis.rb

@@ -1,7 +1,7 @@
 require(File.dirname(__FILE__)+'/test_helpers.rb')
 
 class StatsampleDominanceAnalysisTestCase < MiniTest::Unit::TestCase
-  def aatest_dominance_univariate
+  def test_dominance_univariate
     # Example from Budescu (1993)
     m=Matrix[[1, 0.683, 0.154, 0.460, 0.618],[0.683, 1, -0.050, 0.297, 0.461], [0.154, -0.050, 1, 0.006, 0.262],[0.460, 0.297, 0.006, 1, 0.507],[0.618, 0.461, 0.262, 0.507, 1]]
     m.extend Statsample::CovariateMatrix

data/test/test_factor.rb

@@ -84,9 +84,9 @@ class StatsampleFactorTestCase < MiniTest::Unit::TestCase
         [0.0826106, 0.435975, -0.893379],
       [0.939901, -0.0965213, -0.309596]].to_gsl
       varimax=Statsample::Factor::Varimax.new(a)
-      refute(varimax.rotated.nil?,"Rotated shouldn't be empty")
-      refute(varimax.component_transformation_matrix.nil?, "Component matrix shouldn't be empty")
-      refute(varimax.h2.nil?,"H2 shouldn't be empty")
+      assert(!varimax.rotated.nil?, "Rotated shouldn't be empty")
+      assert(!varimax.component_transformation_matrix.nil?, "Component matrix shouldn't be empty")
+      assert(!varimax.h2.nil?,"H2 shouldn't be empty")
       _test_matrix(expected,varimax.rotated)
     else
       skip "Rotation not tested. Requires GSL"

data/test/test_helpers.rb

@@ -1,38 +1,38 @@
 $:.unshift(File.dirname(__FILE__)+'/../lib/')
+
 require 'statsample'
 require 'minitest/unit'
 require 'tempfile'
 require 'tmpdir'
 require 'shoulda'
+
 module MiniTest
   class Unit
     class TestCase
       include Shoulda::InstanceMethods
       extend Shoulda::ClassMethods
       include Shoulda::Assertions
-      
+
     end
   end
-end
 
-module MiniTest::Assertions
-  
-  alias :assert_raise :assert_raises unless method_defined? :assert_raise
-  alias :assert_not_equal :refute_equal unless method_defined? :assert_not_equal
-  alias :assert_not_same :refute_same unless method_defined? :assert_not_same
-  unless method_defined? :assert_nothing_raised
-    def assert_nothing_raised(msg=nil)
-      msg||="Nothing should be raised, but raised %s"
-      begin
-        yield
-        not_raised=true
-      rescue Exception => e
-        not_raised=false
-        msg=sprintf(msg,e)
+  module Assertions
+    alias :assert_raise :assert_raises unless method_defined? :assert_raise
+    alias :assert_not_equal :refute_equal unless method_defined? :assert_not_equal
+    alias :assert_not_same :refute_same unless method_defined? :assert_not_same
+    unless method_defined? :assert_nothing_raised
+      def assert_nothing_raised(msg=nil)
+        msg||="Nothing should be raised, but raised %s"
+        begin
+          yield
+          not_raised=true
+        rescue Exception => e
+          not_raised=false
+          msg=sprintf(msg,e)
+        end
+        assert(not_raised,msg)
       end
-      assert(not_raised,msg)
     end
   end
 end
-
 MiniTest::Unit.autorun