statsample 0.13.1 → 0.14.0

data/History.txt

@@ -1,3 +1,18 @@
+=== 0.14.0 / 2010-08-16
+* Added Statsample::Factor::MAP, to execute Velicer's (1976) MAP to determine the number of factors to retain on EFA 
+* Bug fix on test suite on Ruby 1.8.7
+* Horn's Parallel Analysis operational and tested for pure random data
+* Fixed bug on Excel writer on Ruby1.9 (frozen string on header raises an error). 
+* Extra information on Factorial Analysis on summaries
+* Fixed bug on Factor::Rotation when used ::Matrix without field method. 
+* Added Vector#vector_percentil method
+* Summaries for PCA, Rotation, MultiScale and ScaleAnalysis created or improved. 
+* Factor::PCA could have rotation and parallel analysis on summary.
+* Cronbach's alpha from covariance matrix raise an error on size<2 
+* MultiScaleAnalysis could have Parallel Analysis on summary.
+* Added Chi Square test
+* Added new information on README.txt
+
 === 0.13.1 / 2010-07-03
 
 * Rserve extensions for dataset and vector operational

data/Manifest.txt

@@ -5,6 +5,7 @@ README.txt
 Rakefile
 bin/statsample
 data/crime.txt
+data/hartman_23.matrix
 data/locale/es/LC_MESSAGES/statsample.mo
 data/repeated_fields.csv
 data/test_binomial.csv
@@ -27,6 +28,7 @@ examples/t_test.rb
 examples/tetrachoric.rb
 examples/u_test.rb
 examples/vector.rb
+examples/velicer_map_test.rb
 lib/distribution.rb
 lib/distribution/chisquare.rb
 lib/distribution/f.rb
@@ -51,6 +53,7 @@ lib/statsample/dataset.rb
 lib/statsample/dominanceanalysis.rb
 lib/statsample/dominanceanalysis/bootstrap.rb
 lib/statsample/factor.rb
+lib/statsample/factor/map.rb
 lib/statsample/factor/parallelanalysis.rb
 lib/statsample/factor/pca.rb
 lib/statsample/factor/principalaxis.rb
@@ -87,6 +90,7 @@ lib/statsample/resample.rb
 lib/statsample/rserve_extension.rb
 lib/statsample/srs.rb
 lib/statsample/test.rb
+lib/statsample/test/chisquare.rb
 lib/statsample/test/f.rb
 lib/statsample/test/levene.rb
 lib/statsample/test/t.rb

data/README.txt

@@ -10,14 +10,15 @@ A suite for basic and advanced statistics on Ruby. Tested on Ruby 1.8.7, 1.9.1,
 Include:
 * Descriptive statistics: frequencies, median, mean, standard error, skew, kurtosis (and many others).
 * Imports and exports datasets from and to Excel, CSV and plain text files.
-* Correlations: Pearson's r, Spearman's rank correlation (rho), point biserial, tau a, tau b, gamma,  Tetrachoric and Polychoric.
+* Correlations: Pearson's r, Spearman's rank correlation (rho), point biserial, tau a, tau b and  gamma.  Tetrachoric and Polychoric correlation provides by +statsample-bivariate-extension+ gem.
 * Anova: generic and vector-based One-way ANOVA and Two-way ANOVA
 * Tests: F, T, Levene, U-Mannwhitney.
 * Regression: Simple, Multiple (OLS), Probit  and Logit
-* Factorial Analysis: Extraction (PCA and Principal Axis), Rotation (Varimax, Equimax, Quartimax) and Parallel Analysis, for estimation of number of factors.
+* Factorial Analysis: Extraction (PCA and Principal Axis), Rotation (Varimax, Equimax, Quartimax) and Parallel Analysis and Velicer's MAP test, for estimation of number of factors.
 * Reliability analysis for simple scale and a DSL to easily analyze multiple scales using factor analysis and correlations, if you want it.
 * Dominance Analysis, with multivariate dependent and bootstrap (Azen & Budescu)
 * Sample calculation related formulas
+* Structural Equation Modeling (SEM), using R libraries +sem+ and +OpenMx+
 * Creates reports on text, html and rtf, using ReportBuilder gem
 
 == FEATURES:
@@ -41,7 +42,9 @@ Include:
     * Statsample::Factor::Varimax
     * Statsample::Factor::Equimax
     * Statsample::Factor::Quartimax
-  * Statsample::Factor::ParallelAnalysis performs Horn's 'parallel analysis' to a principal components analysis to adjust for sample bias in the retention of components. 
+  * Classes for calculation of factors to retain
+    * Statsample::Factor::ParallelAnalysis performs Horn's 'parallel analysis' to a principal components analysis to adjust for sample bias in the retention of components.
+    * Statsample::Factor::MAP performs Velicer's Minimum Average Partial (MAP) test, which retain components as long as the variance in the correlation matrix represents systematic variance.
 * Dominance Analysis. Based on Budescu and Azen papers, dominance analysis is a method to analyze the relative importance of one predictor relative to another on multiple regression
   * Statsample::DominanceAnalysis class can report dominance analysis for a sample, using uni or multivariate dependent variables
   * Statsample::DominanceAnalysis::Bootstrap can execute bootstrap analysis to determine dominance stability, as recomended by  Azen & Budescu (2003) link[http://psycnet.apa.org/journals/met/8/2/129/]. 
@@ -62,6 +65,7 @@ Include:
   * Statsample::Test::UMannWhitney
   * Statsample::Test::T
   * Statsample::Test::F  
+* Gem +statsample-sem+ provides a DSL to R libraries +sem+ and +OpenMx+
 * Interfaces to gdchart, gnuplot and SVG::Graph (experimental)
 * Close integration with gem <tt>reportbuilder</tt>, to easily create reports on text, html and rtf formats.
 
@@ -109,6 +113,10 @@ If you use Ruby 1.8, you should compile statsample-optimization, usign parameter
 
   $ sudo gem install statsample-optimization --platform ruby
 
+If you need to work on Structural Equation Modeling, you could see +statsample-sem+. You need R with +sem+ or +OpenMx+ [http://openmx.psyc.virginia.edu/] libraries installed
+
+  $ sudo gem install statsample-sem
+
 Available setup.rb file
 
   sudo gem ruby setup.rb

data/Rakefile

@@ -4,9 +4,9 @@
 $:.unshift(File.dirname(__FILE__)+'/lib/')
 
 require 'rubygems'
-require 'hoe'
 require 'statsample'
 
+require 'hoe'
 Hoe.plugin :git
 
 desc "Ruby Lint"
@@ -40,7 +40,7 @@ h=Hoe.spec('statsample') do
   #self.testlib=:minitest
 	self.rubyforge_name = "ruby-statsample"
 	self.developer('Claudio Bustos', 'clbustos@gmail.com')
-	self.extra_deps << ["spreadsheet","~>0.6.0"] << ["svg-graph", "~>1.0"] << ["reportbuilder", "~>1.0"] << ["minimization", "~>0.2.0"] << ["fastercsv"] << ["dirty-memoize", "~>0.0"] << ["extendmatrix","~>0.2.0"] << ["statsample-bivariate-extension", "~>0.13.0"]
+	self.extra_deps << ["spreadsheet","~>0.6.0"] << ["svg-graph", "~>1.0"] << ["reportbuilder", "~>1.0"] << ["minimization", "~>0.2.0"] << ["fastercsv"] << ["dirty-memoize", "~>0.0"] << ["extendmatrix","~>0.3.1"] << ["statsample-bivariate-extension", "~>0.13.0"]
   
 	self.extra_dev_deps << ["shoulda"]
   self.clean_globs << "test/images/*" << "demo/item_analysis/*" << "demo/Regression"

data/data/hartman_23.matrix

@@ -0,0 +1,9 @@
+"height" "arm.span" "forearm" "lower.leg" "weight" "bitro.diameter" "chest.girth" "chest.width"
+"height" 1 0.846 0.805 0.859 0.473 0.398 0.301 0.382
+"arm.span" 0.846 1 0.881 0.826 0.376 0.326 0.277 0.415
+"forearm" 0.805 0.881 1 0.801 0.38 0.319 0.237 0.345
+"lower.leg" 0.859 0.826 0.801 1 0.436 0.329 0.327 0.365
+"weight" 0.473 0.376 0.38 0.436 1 0.762 0.73 0.629
+"bitro.diameter" 0.398 0.326 0.319 0.329 0.762 1 0.583 0.577
+"chest.girth" 0.301 0.277 0.237 0.327 0.73 0.583 1 0.539
+"chest.width" 0.382 0.415 0.345 0.365 0.629 0.577 0.539 1

data/examples/correlation_matrix.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/ruby
 $:.unshift(File.dirname(__FILE__)+'/../lib/')
-
+require 'benchmark'
 require 'statsample'
 a=1000.times.collect {rand}.to_scale
 b=1000.times.collect {rand}.to_scale

data/examples/velicer_map_test.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib/')
+
+require 'statsample'
+samples=100
+variables=10
+rng = GSL::Rng.alloc()
+f1=samples.times.collect {rng.ugaussian()}.to_scale
+f2=samples.times.collect {rng.ugaussian()}.to_scale
+
+vectors={}
+
+variables.times do |i|
+  vectors["v#{i}"]=samples.times.collect {|nv|    
+    if i<5
+      f1[nv]*5 + f2[nv] *2 +rng.ugaussian()
+    else
+      f1[nv]*2 + f2[nv] *3 +rng.ugaussian()
+    end
+  }.to_scale
+end
+ds=vectors.to_dataset
+cor=Statsample::Bivariate.correlation_matrix(ds)
+map=Statsample::Factor::MAP.new(cor)
+pca=Statsample::Factor::PCA.new(cor)
+
+rb=ReportBuilder.new(:name=>"Velicer's MAP test") do |g|
+  g.text("There are 2 real factors on data")
+  g.parse_element(pca)
+  g.text("Traditional Kaiser criterion (k>1) returns #{pca.m} factors")
+  g.parse_element(map)
+  g.text("Velicer's MAP Test returns #{map.number_of_factors} factors to preserve")
+end
+
+puts rb.to_text

data/lib/distribution/chisquare.rb

@@ -8,7 +8,7 @@ module Distribution
             # Return the P-value of the corresponding integral with 
             # k degrees of freedom
             def p_value(pr,k)
-                Statistics2.pchi2X_(k, pr)
+                Statistics2.pchi2X_(k.to_i, pr)
             end
             # Chi-square cumulative distribution function (cdf).
             # 
@@ -16,7 +16,7 @@ module Distribution
             # with k degrees of freedom over [0, x]
             # 
             def cdf(x,k)
-                Statistics2.chi2dist(k,x)
+                Statistics2.chi2dist(k.to_i,x)
             end
         end
     end

data/lib/statsample.rb

@@ -113,7 +113,7 @@ module Statsample
     end
   end
   
-  VERSION = '0.13.1'
+  VERSION = '0.14.0'
   SPLIT_TOKEN = ","
   autoload(:Database, 'statsample/converters')
   autoload(:Anova, 'statsample/anova')

data/lib/statsample/bivariate/pearson.rb

@@ -13,7 +13,6 @@ module Statsample
     #   puts pearson.r
     #   puts pearson.t
     #   puts pearson.probability
-    # 
     #   puts pearson.summary
     # 
     class Pearson

data/lib/statsample/converters.rb

@@ -90,7 +90,7 @@ raise "Should'nt be empty headers: [#{row.to_a.join(",")}]" if row.to_a.find_all
         fields=row.to_a.collect{|c| c.downcase}
         fields.recode_repeated
       end
-    
+                                         
       def process_row(row,empty)
         row.to_a.collect do |c|
           if empty.include?(c)
@@ -146,7 +146,7 @@ raise "Should'nt be empty headers: [#{row.to_a.join(",")}]" if row.to_a.find_all
         sheet = book.create_worksheet
         format = Spreadsheet::Format.new :color => :blue,
                            :weight => :bold
-        sheet.row(0).concat(dataset.fields)
+        sheet.row(0).concat(dataset.fields.map {|i| i.dup}) # Unfreeze strings
         sheet.row(0).default_format = format
         i=1
         dataset.each_array{|row|

data/lib/statsample/crosstab.rb

@@ -15,7 +15,7 @@ module Statsample
       @row_label=v1.name
       @column_label=v2.name
       @name=nil
-      @percentage_row=@percentage_column=@percentage_total=false
+      @percentage_row = @percentage_column = @percentage_total=false
       opts.each{|k,v|
         self.send("#{k}=",v) if self.respond_to? k
       }

data/lib/statsample/factor.rb

@@ -1,7 +1,9 @@
+require 'statsample/factor/rotation'
 require 'statsample/factor/pca'
 require 'statsample/factor/principalaxis'
-require 'statsample/factor/rotation'
 require 'statsample/factor/parallelanalysis'
+require 'statsample/factor/map'
+
 module Statsample
   # Factor Analysis toolbox.
   # * Classes for Extraction of factors: 

data/lib/statsample/factor/map.rb

@@ -0,0 +1,102 @@
+module Statsample
+  module Factor
+  # = Velicer's Minimum Average Partial
+  # 
+  # "Velicer’s (1976) MAP test involves a complete princi-
+  # pal components analysis followed by the examination of
+  # a series of matrices of partial correlations. Specifically,
+  # on the first step, the first principal component is par-
+  # tialed out of the correlations between the variables of in-
+  # terest, and the average squared coefficient in the off-
+  # diagonals of the resulting partial correlation matrix is
+  # computed. On the second step, the first two principal
+  # components are partialed out of the original correlation
+  # matrix and the average squared partial correlation is
+  # again computed. These computations are conducted for k
+  # (the number of variables) minus one steps. The average
+  # squared partial correlations from these steps are then
+  # lined up, and the number of components is determined by
+  # the step number in the analyses that resulted in the lowest
+  # average squared partial correlation. The average squared
+  # coefficient in the original correlation matrix is also com-
+  # puted, and if this coefficient happens to be lower than
+  # the lowest average squared partial correlation, then no
+  # components should be extracted from the correlation ma-
+  # trix. Statistically, components are retained as long as the
+  # variance in the correlation matrix represents systematic
+  # variance. Components are no longer retained when there
+  # is proportionately more unsystematic variance than sys-
+  # tematic variance." (O'Connor, 2000, p.397).
+  # 
+  # Current algorithm is loosely based on SPSS O'Connor algorithm
+
+    class MAP
+      include Summarizable
+      include DirtyMemoize
+      # Name of analysis
+      attr_accessor :name
+      attr_reader :eigenvalues
+      # Number of factors to retain
+      attr_reader :number_of_factors
+      # Average squared correlations
+      attr_reader :fm
+      # Smallest average squared correlation
+      attr_reader :minfm
+      def initialize(matrix, opts=Hash.new)
+        @matrix=matrix
+        opts_default={
+          :name=>_("Velicer's MAP")
+        }
+        @opts=opts_default.merge(opts)
+         opts_default.keys.each {|k| send("#{k}=", @opts[k]) }
+      end
+      def compute
+        eigen=@matrix.eigen
+        eigvect,@eigenvalues=eigen[:eigenvectors],eigen[:eigenvalues]
+        loadings=eigvect*(Matrix.diag(*@eigenvalues).sqrt)
+        fm=Array.new(@matrix.row_size)
+        ncol=@matrix.column_size
+        fm[0]=(@matrix.mssq - ncol).quo(ncol*(ncol-1))
+        (ncol-1).times do |m|
+          a=loadings[0..(loadings.row_size-1),0..m]
+          partcov= @matrix - (a*a.t)
+          pc_prediag=partcov.row_size.times.map{|i|
+            1.quo(Math::sqrt(partcov[i,i]))
+          }
+          d=Matrix.diag(*pc_prediag)
+          pr=d*partcov*d
+          fm[m+1]=(pr.mssq-ncol).quo(ncol*(ncol-1))
+        end
+        minfm=fm[0]
+        nfactors=0
+        fm.each_with_index do |v,s|
+          if v < minfm
+            minfm=v
+            nfactors=s
+          end
+        end
+        @number_of_factors=nfactors
+        @fm=fm
+        @minfm=minfm
+      end
+      def report_building(g) #:nodoc:
+        g.section(:name=>@name) do |s|
+          s.table(:name=>_("Eigenvalues"),:header=>[_("Value")]) do |t|
+            eigenvalues.each do |e|
+              t.row(["%0.6f" % e])
+            end
+          end
+          s.table(:name=>_("Velicer's Average Squared Correlations"), :header=>[_("number of components"),_("average square correlation")]) do |t|
+            fm.each_with_index do |v,i|
+              t.row(["%d" % i, "%0.6f" % v])
+            end
+          end
+          s.text(_("The smallest average squared correlation is : %0.6f" % minfm))
+          s.text(_("The number of components is : %d" % number_of_factors))
+        end
+      end
+      dirty_memoize :number_of_factors, :fm, :minfm, :eigenvalues
+
+    end
+  end
+end

data/lib/statsample/factor/parallelanalysis.rb

@@ -2,19 +2,30 @@ module Statsample
   module Factor
     # Performs Horn's 'parallel analysis' to a principal components analysis
     # to adjust for sample bias in the retention of components. 
-    # Can create the bootstrap samples using parameters (mean and standard
-    # deviation of each variable) or sampling for actual data.
+    # Can create the bootstrap samples using random data, using number
+    # of cases and variables, parameters for actual data (mean and standard
+    # deviation of each variable) or bootstrap sampling for actual data.
     # == Description
     # "PA involves the construction of a number of correlation matrices of random variables based on the same sample size and number of variables in the real data set. The average eigenvalues from the random correlation matrices are then compared to the eigenvalues from the real data correlation matrix, such that the first observed eigenvalue is compared to the first random eigenvalue, the second observed eigenvalue is compared to the second random eigenvalue, and so on." (Hayton, Allen & Scarpello, 2004, p.194)
     # == Usage
+    # *With real dataset*
     #   # ds should be any valid dataset
     #   pa=Statsample::Factor::ParallelAnalysis.new(ds, :iterations=>100, :bootstrap_method=>:raw_data)
     #
+    # *With number of cases and variables*
+    #   pa=Statsample::Factor::ParallelAnalysis.with_random_data(100,8)
+    # 
     # == References:
     # * Hayton, J., Allen, D. & Scarpello, V.(2004). Factor Retention Decisions in Exploratory Factor Analysis: a Tutorial on Parallel Analysis. <i>Organizational Research Methods, 7</i> (2), 191-205.
-    # * https://people.ok.ubc.ca/brioconn/nfactors/nfactors.html (for inspiration)
+    # * O'Connor, B. (2000). SPSS and SAS programs for determining the number of components using parallel analysis and Velicer’s MAP test. Behavior Research Methods, Instruments, & Computers, 32 (3), 396-402
     class ParallelAnalysis
-      
+      def self.with_random_data(cases,vars,iterations=100,percentil=95)
+        require 'ostruct'
+        ds=OpenStruct.new
+        ds.fields=vars.times.map {|i| "v#{i+1}"}
+        ds.cases=cases
+        pa=new(ds,{:bootstrap_method=>:random, :no_data=>true, :iterations=>iterations,:percentil=>percentil})
+      end
       include DirtyMemoize
       include Summarizable
       # Number of random sets to produce. 50 by default
@@ -23,25 +34,31 @@ module Statsample
       attr_accessor :name
       # Dataset. You could use mock vectors when use bootstrap method
       attr_reader :ds
-      # Bootstrap method. <tt>:raw_data</tt> used by default
-      # * <tt>:parameter</tt>: uses mean and standard deviation of each variable
-      # * <tt>:raw_data</tt> : sample with replacement from actual data. 
-      # 
+      # Bootstrap method. <tt>:random</tt> used by default
+      # * <tt>:random</tt>: uses number of variables and cases for the dataset
+      # * <tt>:raw_data</tt> : sample with replacement from actual data.       
+      # * <tt>:parameter</tt>: uses number of variables and cases, uses mean and standard deviation of each variable
+
       attr_accessor :bootstrap_method
       # Factor method.
       # Could be Statsample::Factor::PCA or Statsample::Factor::PrincipalAxis.
       # PCA used by default.
+      # Remember to set n_variables when using Principal Axis Analysis.
       attr_accessor :factor_class
       # Percentil over bootstrap eigenvalue should be accepted. 95 by default
       attr_accessor :percentil
       # Correlation matrix used with :raw_data . <tt>:correlation_matrix</tt> used by default
-      attr_accessor :matrix_method 
+      attr_accessor :matrix_method
+      # Number of eigenvalues to calculate. Should be set for 
+      # Principal Axis Analysis.
+      attr_accessor :n_variables
       # Dataset with bootstrapped eigenvalues
       attr_reader :ds_eigenvalues
+      # Perform analysis without actual data. 
+      attr_accessor :no_data
       # Show extra information if true
       attr_accessor :debug
-      
-      
+
       def initialize(ds, opts=Hash.new)
         @ds=ds
         @fields=@ds.fields
@@ -49,11 +66,12 @@ module Statsample
         @n_cases=ds.cases
         opts_default={
           :name=>_("Parallel Analysis"),
-          :iterations=>50,
-          :bootstrap_method => :raw_data,
+          :iterations=>100,
+          :bootstrap_method => :random,
           :factor_class => Statsample::Factor::PCA,
           :percentil=>95, 
           :debug=>false,
+          :no_data=>false,
           :matrix_method=>:correlation_matrix
         }
         @opts=opts_default.merge(opts)
@@ -75,11 +93,20 @@ module Statsample
           s.text _("Number of variables: %d") % @n_variables
           s.text _("Number of cases: %d") % @n_cases
           s.text _("Number of iterations: %d") % @iterations
-          s.text _("Number or factors to preserve: %d") % number_of_factors
-          s.table(:name=>_("Eigenvalues"), :header=>[_("n"), _("data eigenvalue"), _("generated eigenvalue"),"p.#{percentil}",_("preserve?")]) do |t|
-            ds_eigenvalues.fields.each_with_index do |f,i|
-              v=ds_eigenvalues[f]
-              t.row [i+1, "%0.4f" % @original[i], "%0.4f" %  v.mean, "%0.4f" %  v.percentil(percentil), (v.percentil(percentil)>0 and @original[i] > v.percentil(percentil)) ? "Yes":""]
+          if @no_data
+            s.table(:name=>_("Eigenvalues"), :header=>[_("n"), _("generated eigenvalue"), "p.#{percentil}"]) do |t|
+              ds_eigenvalues.fields.each_with_index do |f,i|
+                v=ds_eigenvalues[f]
+                t.row [i+1, "%0.4f" %  v.mean, "%0.4f" %  v.percentil(percentil), ]
+              end
+            end
+          else
+            s.text _("Number or factors to preserve: %d") % number_of_factors 
+            s.table(:name=>_("Eigenvalues"), :header=>[_("n"), _("data eigenvalue"), _("generated eigenvalue"),"p.#{percentil}",_("preserve?")]) do |t|
+              ds_eigenvalues.fields.each_with_index do |f,i|
+                v=ds_eigenvalues[f]
+                t.row [i+1, "%0.4f" % @original[i], "%0.4f" %  v.mean, "%0.4f" %  v.percentil(percentil), (v.percentil(percentil)>0 and @original[i] > v.percentil(percentil)) ? "Yes":""]
+              end
             end
           end
           
@@ -87,26 +114,29 @@ module Statsample
       end
       # Perform calculation. Shouldn't be called directly for the user
       def compute
-        @original=factor_class.new(Statsample::Bivariate.correlation_matrix(@ds), :m=>@n_variables).eigenvalues.sort.reverse
+        @original=factor_class.new(Statsample::Bivariate.correlation_matrix(@ds), :m=>@n_variables).eigenvalues.sort.reverse unless no_data
+        
         @ds_eigenvalues=Statsample::Dataset.new((1..@n_variables).map{|v| "ev_%05d" % v})
         @ds_eigenvalues.fields.each {|f| @ds_eigenvalues[f].type=:scale}
+        if bootstrap_method==:parameter or bootstrap_method==:random
+          rng = GSL::Rng.alloc(GSL::Rng::MT19937, rand(32000))
+        end
         
         @iterations.times do |i|
           # Create a dataset of dummy values
           ds_bootstrap=Statsample::Dataset.new(@ds.fields)
-          if bootstrap_method==:parameter
-            rng = GSL::Rng.alloc()
-          end
           @fields.each do |f|
-    
             if bootstrap_method==:parameter
               sd=@ds[f].sd
               mean=@ds[f].mean
-              ds_bootstrap[f]=@n_cases.times.map {|c| rng.gaussian(sd)+mean}.to_scale
+              ds_bootstrap[f]=@n_cases.times.map {|c| rng.gaussian(sd) + mean }.to_scale
+            elsif bootstrap_method==:random
+              ds_bootstrap[f]=@n_cases.times.map {|c| rng.ugaussian()}.to_scale
             elsif bootstrap_method==:raw_data
               ds_bootstrap[f]=ds[f].sample_with_replacement(@n_cases).to_scale
             end
           end
+          #pp Statsample::Bivariate.correlation_matrix(ds_bootstrap)
           fa=factor_class.new(Statsample::Bivariate.send(matrix_method, ds_bootstrap), :m=>@n_variables)
           ev=fa.eigenvalues.sort.reverse
           @ds_eigenvalues.add_case_array(ev)