test_factor.rb in statsample-1.0.0

- old
+ new

@@ -33,21 +33,22 @@
     }
     
   end
   def test_principalcomponents_ruby_gsl
     
-    ran=Distribution::Normal.rng_ugaussian
+    ran=Distribution::Normal.rng
     
 #    @r=::Rserve::Connection.new
 
     samples=20
-    (3..7).each {|k|
+    [3,5,7].each {|k|
       v={}
       v["x0"]=samples.times.map { ran.call()}.to_scale.centered
       (1...k).each {|i|
         v["x#{i}"]=samples.times.map {|ii| ran.call()*0.5+v["x#{i-1}"][ii]*0.5}.to_scale.centered
       }
+      
       ds=v.to_dataset
       cm=ds.covariance_matrix
 #      @r.assign('ds',ds)
 #      @r.eval('cm<-cor(ds);sm<-eigen(cm, sym=TRUE);v<-sm$vectors')
 #      puts "eigenvalues"
@@ -80,11 +81,11 @@
   principalcomponents(true)
   principalcomponents(false)
   
   end  
   def principalcomponents(gsl)
-    ran=Distribution::Normal.rng_ugaussian
+    ran=Distribution::Normal.rng
     samples=50
     x1=samples.times.map { ran.call()}.to_scale
     x2=samples.times.map {|i| ran.call()*0.5+x1[i]*0.5}.to_scale
     ds={'x1'=>x1,'x2'=>x2}.to_dataset
     
@@ -92,14 +93,15 @@
     r=cm[0,1]
     pca=Statsample::Factor::PCA.new(cm,:m=>2,:use_gsl=>gsl)
     assert_in_delta(1+r,pca.eigenvalues[0],1e-10)
     assert_in_delta(1-r,pca.eigenvalues[1],1e-10)
     hs=1.0 / Math.sqrt(2)
-    assert_equal_matrix(hs*Matrix[[1],[1]],pca.eigenvectors[0])
-    m_1=gsl ? Matrix[[-1],[1]] : Matrix[[1],[-1]]
-    assert_equal_matrix(hs*m_1, pca.eigenvectors[1])    
+    assert_equal_vector(Vector[1, 1]*hs, pca.eigenvectors[0])
+    m_1=gsl ? Vector[-1,1] : Vector[1,-1]
     
+    assert_equal_vector(hs*m_1, pca.eigenvectors[1])    
+    
     pcs=pca.principal_components(ds)
     exp_pc_1=ds.collect_with_index {|row,i|
       hs*(row['x1']+row['x2'])
     }
     exp_pc_2=ds.collect_with_index {|row,i|
@@ -131,72 +133,9 @@
     m=harman_817
     expected=[0.73,0.76,0.84,0.87,0.53,0.93,0.78,0.86]
     m.row_size.times.map {|i|
       assert_in_delta(expected[i], Statsample::Factor.kmo_univariate(m,i),0.01)
     }
-  end
-  def test_parallelanalysis_with_data
-    if Statsample.has_gsl?
-      samples=100
-      variables=10
-      iterations=50
-      rng = Distribution::Normal.rng_ugaussian
-      f1=samples.times.collect {rng.call}.to_scale
-      f2=samples.times.collect {rng.call}.to_scale    
-      vectors={}
-      variables.times do |i|
-        if i<5
-          vectors["v#{i}"]=samples.times.collect {|nv|
-            f1[nv]*5+f2[nv]*2+rng.call
-          }.to_scale
-        else
-          vectors["v#{i}"]=samples.times.collect {|nv|
-            f2[nv]*5+f1[nv]*2+rng.call
-          }.to_scale
-        end
-        
-      end
-      ds=vectors.to_dataset
-      
-      pa1=Statsample::Factor::ParallelAnalysis.new(ds, :bootstrap_method=>:data, :iterations=>iterations)
-      pa2=Statsample::Factor::ParallelAnalysis.with_random_data(samples,variables,:iterations=>iterations,:percentil=>95)
-      3.times do |n|
-        var="ev_0000#{n+1}"
-        assert_in_delta(pa1.ds_eigenvalues[var].mean,pa2.ds_eigenvalues[var].mean,0.04)
-      end
-    else
-      skip("Too slow without GSL")
-    end
-    
-  end
-  def test_parallelanalysis
-    pa=Statsample::Factor::ParallelAnalysis.with_random_data(305,8,:iterations=>100,:percentil=>95)
-    assert_in_delta(1.2454, pa.ds_eigenvalues['ev_00001'].mean, 0.01)
-    assert_in_delta(1.1542, pa.ds_eigenvalues['ev_00002'].mean, 0.01)
-    assert_in_delta(1.0836, pa.ds_eigenvalues['ev_00003'].mean, 0.01)
-    #puts pa.summary
-    assert(pa.summary.size>0)
-    #pa=Statsample::Factor::ParallelAnalysis.with_random_data(305,8,100, 95, true)
-    #puts pa.summary
-  end
-  def test_map
-    #fields=%w{height arm.span forearm lower.leg weight bitro.diameter chest.girth chest.width}
-    m=Matrix[ 
-          [ 1, 0.846, 0.805, 0.859, 0.473, 0.398, 0.301, 0.382],
-          [ 0.846, 1, 0.881, 0.826, 0.376, 0.326, 0.277, 0.415],
-          [ 0.805, 0.881, 1, 0.801, 0.38, 0.319, 0.237, 0.345],
-          [ 0.859, 0.826, 0.801, 1, 0.436, 0.329, 0.327, 0.365],
-          [ 0.473, 0.376, 0.38, 0.436, 1, 0.762, 0.73, 0.629],
-          [ 0.398, 0.326, 0.319, 0.329, 0.762, 1, 0.583, 0.577],
-          [ 0.301, 0.277, 0.237, 0.327, 0.73, 0.583, 1, 0.539],
-          [ 0.382, 0.415, 0.345, 0.365, 0.629, 0.577, 0.539, 1]
-    ]
-    map=Statsample::Factor::MAP.new(m)
-    assert_in_delta(map.minfm, 0.066445,0.00001)
-    assert_equal(map.number_of_factors, 2)
-    assert_in_delta(map.fm[0], 0.312475,0.00001)
-    assert_in_delta(map.fm[1], 0.245121,0.00001)
-
   end
   # Tested with SPSS and R
   def test_pca
       a=[2.5, 0.5, 2.2, 1.9, 3.1, 2.3, 2.0, 1.0, 1.5, 1.1].to_scale
       b=[2.4, 0.7, 2.9, 2.2, 3.0, 2.7, 1.6, 1.1, 1.6, 0.9].to_scale