statsample 0.9.0 → 0.10.0

data/lib/statsample/dominanceanalysis.rb

@@ -134,6 +134,7 @@ module Statsample
       end
       @models=nil
       @models_data=nil
+      @general_averages=nil
     end
     # Compute models. 
     def compute
@@ -308,11 +309,7 @@ module Statsample
       @general_averages
     end
     
-    def summary
-      rp=ReportBuilder.new()
-      rp.add(self)
-      rp.to_text
-    end
+
     def report_building(g)
       compute if @models.nil?
       

data/lib/statsample/factor.rb

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

data/lib/statsample/factor/parallelanalysis.rb

@@ -0,0 +1,122 @@
+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.
+  # == 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
+  #   # ds should be any valid dataset
+  #   pa=Statsample::Factor::ParallelAnalysis.new(ds, :iterations=>100, :bootstrap_method=>:raw_data)
+  # == 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)
+class ParallelAnalysis
+  
+  include DirtyMemoize
+  
+  # Number of random sets to produce. 50 by default
+  attr_accessor :iterations
+  # Name of analysis
+  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. 
+  # 
+  attr_accessor :bootstrap_method
+  # Factor method.
+  # Could be Statsample::Factor::PCA or Statsample::Factor::PrincipalAxis.
+  # PCA used by default.
+  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 
+  # Dataset with bootstrapped eigenvalues
+  attr_reader :ds_eigenvalues
+  # Show extra information if true
+  attr_accessor :debug
+  
+  
+  def initialize(ds, opts=Hash.new)
+    @ds=ds
+    @fields=@ds.fields
+    @n_variables=@fields.size
+    @n_cases=ds.cases
+    opts_default={
+      :name=>"Parallel Analysis",
+      :iterations=>50,
+      :bootstrap_method => :raw_data,
+      :factor_class => Statsample::Factor::PCA,
+      :percentil=>95, 
+      :debug=>false,
+      :matrix_method=>:correlation_matrix
+    }
+    @opts=opts_default.merge(opts)
+    @opts[:matrix_method]==:correlation_matrix if @opts[:bootstrap_method]==:parameters
+    opts_default.keys.each {|k| send("#{k}=", @opts[k]) }
+  end
+  # Summary of results
+  def summary
+    ReportBuilder.new(:no_title=>true).add(self).to_text
+  end
+  # Number of factor to retent
+  def number_of_factors
+    total=0
+    ds_eigenvalues.fields.each_with_index do |f,i|
+      total+=1 if (@original[i]>0 and @original[i]>ds_eigenvalues[f].percentil(percentil))
+    end
+    total
+  end
+  def report_building(g) #:nodoc:
+    g.section(:name=>@name) do |s|
+      s.text "Bootstrap Method: #{bootstrap_method}"
+      s.text "Correlation Matrix type : #{matrix_method}"
+      s.text "Number of variables: #{@n_variables}"
+      s.text "Number of cases: #{@n_cases}"
+      s.text "Number of iterations: #{@iterations}"
+      s.text "Number or factors to preserve: #{number_of_factors}"
+      s.table(:name=>"Eigenvalues", :header=>["Eigenvalue", "actual", "mean","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
+  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
+    @ds_eigenvalues=Statsample::Dataset.new((1..@n_variables).map{|v| "ev_%05d" % v})
+    @ds_eigenvalues.fields.each {|f| @ds_eigenvalues[f].type=:scale}
+    
+    @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
+          ds_bootstrap[f]=@n_cases.times.map {|c| rng.gaussian( @ds[f].sd)+@ds[f].mean}.to_scale
+        elsif bootstrap_method==:raw_data
+          ds_bootstrap[f]=ds[f].sample_with_replacement(@n_cases).to_scale
+        end
+      end
+      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)
+      puts "iteration #{i}" if $DEBUG or debug
+    end
+    @ds_eigenvalues.update_valid_data
+  end
+  dirty_memoize :number_of_factors, :ds_eigenvalues
+  dirty_writer :iterations, :bootstrap_method, :factor_class, :percentil
+end
+end
+end

data/lib/statsample/factor/pca.rb

@@ -41,7 +41,7 @@ module Factor
       if matrix.respond_to? :to_gsl
         matrix=matrix.to_gsl
       end
-      @name=""
+      @name=_("Principal Component Analysis")
       @matrix=matrix
       @n_variables=@matrix.size1
       @m=nil
@@ -51,7 +51,7 @@ module Factor
       calculate_eigenpairs
       if @m.nil?
         # Set number of factors with eigenvalues > 1
-        @m=@eigenpairs.find_all {|v| v[0]>=1.0}.size
+        @m=@eigenpairs.find_all {|ev,ec| ev>=1.0}.size
       end
 
     end
@@ -120,36 +120,31 @@ module Factor
       @eigenpairs=@eigenpairs.sort.reverse
     end
     def summary
-      rp=ReportBuilder.new()
-      rp.add(self)
-      rp.to_text
+      ReportBuilder.new(:no_title=>true).add(self).to_text
     end
-    def report_building(generator) # :nodoc:
-      anchor=generator.toc_entry(_("PCA: ")+name)
-      generator.html "<div class='pca'>"+_("PCA")+" #{@name}<a name='#{anchor}'></a>"
-
+    def report_building(builder) # :nodoc:
+      builder.section(:name=>@name) do |generator|
       generator.text "Number of factors: #{m}"
-      t=ReportBuilder::Table.new(:name=>_("Communalities"), :header=>["Variable","Initial","Extraction"])
-      communalities(m).each_with_index {|com,i|
-        t.row([i, 1.0, sprintf("%0.3f", com)])
-      }
-      generator.parse_element(t)
-      
-      t=ReportBuilder::Table.new(:name=>_("Eigenvalues"), :header=>["Variable","Value"])
-      eigenvalues.each_with_index {|eigenvalue,i|
-        t.row([i, sprintf("%0.3f",eigenvalue)])
-      }
-      generator.parse_element(t)
-      
-      t=ReportBuilder::Table.new(:name=>_("Component Matrix"), :header=>["Variable"]+m.times.collect {|c| c+1})
+      generator.table(:name=>_("Communalities"), :header=>["Variable","Initial","Extraction"]) do |t|
+        communalities(m).each_with_index {|com,i|
+          t.row([i, 1.0, sprintf("%0.3f", com)])
+        }
+      end      
+      generator.table(:name=>_("Eigenvalues"), :header=>["Variable","Value"]) do |t|
+        eigenvalues.each_with_index {|eigenvalue,i|
+          t.row([i, sprintf("%0.3f",eigenvalue)])
+        }
+      end
       
-      i=0
-      component_matrix(m).to_a.each do |row|
-        t.row([i]+row.collect {|c| sprintf("%0.3f",c)})
-        i+=1
+      generator.table(:name=>_("Component Matrix"), :header=>["Variable"]+m.times.collect {|c| c+1}) do |t|
+        
+        i=0
+        component_matrix(m).to_a.each do |row|
+          t.row([i]+row.collect {|c| sprintf("%0.3f",c)})
+          i+=1
+        end
+      end
       end
-      generator.parse_element(t)
-      generator.html("</div>")
     end
     private :calculate_eigenpairs, :create_centered_ds
   end

data/lib/statsample/factor/principalaxis.rb

@@ -27,6 +27,7 @@ module Factor
   # * Smith, L. (2002). A tutorial on Principal Component Analysis. Available on http://courses.eas.ualberta.ca/eas570/pca_tutorial.pdf 
   #   
   class PrincipalAxis
+    include DirtyMemoize
     # Minimum difference between succesive iterations on sum of communalities
     DELTA=1e-3
     # Maximum number of iterations
@@ -51,7 +52,9 @@ module Factor
     # Maximum number of iterations
     attr_accessor :max_iterations
     # Eigenvalues of factor analysis
-    attr_accessor :eigenvalues
+    attr_reader :eigenvalues
+    
+    
     
     def initialize(matrix, opts=Hash.new)
       @matrix=matrix
@@ -124,7 +127,7 @@ module Factor
       end
       @component_matrix=pca.component_matrix(m)
     end
-    
+    alias :compute :iterate 
     
     def initial_communalities
       if @initial_communalities.nil?
@@ -200,7 +203,9 @@ module Factor
       generator.html("</div>")
     end
     
-    
+    dirty_writer :max_iterations, :epsilon, :smc
+    dirty_memoize :eigenvalues, :iterations, :initial_eigenvalues
+
   end
   
 end

data/lib/statsample/matrix.rb

@@ -1,7 +1,8 @@
 require 'matrix'
-if RUBY_VERSION<="1.9.0"
-  class ::Vector
-  alias_method :old_coerce, :coerce
+
+class ::Vector
+  if RUBY_VERSION<="1.9.0"
+    alias_method :old_coerce, :coerce
     def coerce(other)
       case other
       when Numeric
@@ -10,9 +11,11 @@ if RUBY_VERSION<="1.9.0"
         raise TypeError, "#{self.class} can't be coerced into #{other.class}"
       end
     end
+    
   end
 end
 
+
 class ::Matrix
   def to_gsl
     out=[]
@@ -21,7 +24,6 @@ class ::Matrix
     }
     GSL::Matrix[*out]
   end
-  
   # Calculate marginal of rows
   def row_sum
   (0...row_size).collect {|i|
@@ -78,6 +80,7 @@ class ::Matrix
   def total_sum
     row_sum.inject(0){|a,v| a+v}
   end
+
 end
 
 module GSL
@@ -98,7 +101,7 @@ module Statsample
   #  matrix.extend CovariateMatrix
   # 
   module CovariateMatrix
-    # Gives a nice 
+    # Gives a nice summary
     def summary
       rp=ReportBuilder.new()
       rp.add(self)
@@ -158,16 +161,10 @@ module Statsample
       @fields_y=v
     end
     def fields_x
-      if @fields_x.nil?
-        @fields_x=row_size.times.collect {|i| i} 
-      end
-      @fields_x
+      @fields_x||=row_size.times.collect {|i| i} 
     end
     def fields_y
-      if @fields_y.nil?
-        @fields_y=column_size.times.collect {|i| i} 
-      end
-      @fields_y
+      @fields_y||=column_size.times.collect {|i| i} 
     end
     
     def name=(v)
@@ -176,11 +173,17 @@ module Statsample
     def name
       @name
     end
-    # Select a submatrix of factors. You could use labels or index to select
-    # the factors.
-    # If you don't specify columns, will be equal to rows
+    # Select a submatrix of factors. If you have a correlation matrix
+    # with a, b and c, you could obtain a submatrix of correlations of
+    # a and b, b and c or a and b
+    #
+    # You could use labels or index to select the factors.
+    # If you don't specify columns, its will be equal to rows.
+    #
     # Example:
-    #   a=Matrix[[1.0, 0.3, 0.2], [0.3, 1.0, 0.5], [0.2, 0.5, 1.0]]
+    #   a=Matrix[[1.0, 0.3, 0.2],
+    #            [0.3, 1.0, 0.5], 
+    #            [0.2, 0.5, 1.0]]
     #   a.extends CovariateMatrix
     #   a.labels=%w{a b c}
     #   a.submatrix(%{c a}, %w{b})
@@ -188,6 +191,7 @@ module Statsample
     #   a.submatrix(%{c a})
     #   => Matrix[[1.0, 0.2] , [0.2, 1.0]]
     def submatrix(rows,columns=nil)
+      raise ArgumentError, "rows shouldn't be empty" if rows.respond_to? :size and rows.size==0
       columns||=rows
       # Convert all labels on index
       row_index=rows.collect {|v| 
@@ -196,8 +200,7 @@ module Statsample
       column_index=columns.collect {|v| 
         v.is_a?(Numeric) ? v : fields_y.index(v)
       }
-      
-      
+
       fx=row_index.collect {|v| fields_x[v]}
       fy=column_index.collect {|v| fields_y[v]}
         
@@ -211,11 +214,11 @@ module Statsample
     end
     def report_building(generator)
       @name||= (type==:correlation ? "Correlation":"Covariance")+" Matrix"
-      t=ReportBuilder::Table.new(:name=>@name, :header=>[""]+fields_y)
-      row_size.times {|i|
-        t.row([fields_x[i]]+@rows[i].collect {|i1| sprintf("%0.3f",i1).gsub("0.",".")})
-      }
-      generator.parse_element(t)
+      generator.table(:name=>@name, :header=>[""]+fields_y) do |t|
+        row_size.times {|i|
+          t.row([fields_x[i]]+@rows[i].collect {|i1| sprintf("%0.3f",i1).gsub("0.",".")})
+        }
+      end
     end
   end
 end

data/lib/statsample/mle.rb

@@ -101,17 +101,17 @@ module Statsample
           parameters = parameters-(h.inverse*(fd))
           
           if @stop_criteria==:parameters
-          flag=true
-          k.times do |j|
-            diff= ( parameters[j,0] - old_parameters[j,0] ) / parameters[j,0]
-            flag=false if diff.abs >= MIN_DIFF_PARAMETERS
-            @output.puts "Parameters #{j}: #{diff}" if @verbose
-          end
-          if flag
-            @var_cov_matrix = h.inverse*-1.0
-            return parameters
-          end
-          old_parameters=parameters
+            flag=true
+            k.times do |j|
+              diff= ( parameters[j,0] - old_parameters[j,0] ) / parameters[j,0]
+              flag=false if diff.abs >= MIN_DIFF_PARAMETERS
+              @output.puts "Parameters #{j}: #{diff}" if @verbose
+            end
+            if flag
+              @var_cov_matrix = h.inverse*-1.0
+              return parameters
+            end
+            old_parameters=parameters
           else
             begin
               new_likehood = log_likehood(x,y,parameters)

data/lib/statsample/permutation.rb

@@ -50,7 +50,7 @@ module Statsample
     end
     def reset
       @iterations=0
-      @data=@original.dup
+      @data=@original.to_a.dup
     end
     def each
       reset
@@ -58,6 +58,7 @@ module Statsample
         yield next_value
       end
     end
+    # Returns permutations
     def permutations
       a=Array.new
       each {|c| a.push(c)}

data/lib/statsample/regression.rb

@@ -65,23 +65,25 @@ module Statsample
       # Creates one of the Statsample::Regression::Multiple object,
       # for OLS multiple regression.
       # Parameters:
-      # * ds: Dataset.
+      # * <tt>ds</tt>: Dataset.
       # * y: Name of dependent variable.
-      # * missing_data: Could be
-      #   * :listwise: delete cases with one or more empty data (default).
-      #   * :pairwise: uses correlation matrix. Use with caution.
+      # * opts: A hash with options
+      #   * missing_data: Could be
+      #     * :listwise: delete cases with one or more empty data (default).
+      #     * :pairwise: uses correlation matrix. Use with caution.
       # 
       # <b>Usage:</b>
       #   lr=Statsample::Regression::multiple(ds,'y')
-      def self.multiple(ds,y_var, missing_data=:listwise)
+      def self.multiple(ds,y_var, opts=Hash.new)
+        missing_data= (opts[:missing_data].nil? ) ? :listwise : opts.delete(:missing_data)
         if missing_data==:pairwise
-           RubyEngine.new(ds,y_var)
+           Statsample::Regression::Multiple::RubyEngine.new(ds,y_var, opts)
         else
           if Statsample.has_gsl?
-            Statsample::Regression::Multiple::GslEngine.new(ds, y_var)
+            Statsample::Regression::Multiple::GslEngine.new(ds, y_var, opts)
           else
             ds2=ds.dup_only_valid
-            Statsample::Regression::Multiple::RubyEngine.new(ds2,y_var)
+            Statsample::Regression::Multiple::RubyEngine.new(ds2,y_var, opts)
           end
         end
       end