statsample-ekatena 2.0.2

data/lib/statsample-ekatena/factor/parallelanalysis.rb

@@ -0,0 +1,166 @@
+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 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=>:data)
+    #
+    # *With number of cases and variables*
+    #   pa=Statsample::Factor::ParallelAnalysis.with_random_data(100,8)
+    # 
+    # == Reference
+    # * 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.
+    # * 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.
+    # * Liu, O., & Rijmen, F. (2008). A modified procedure for parallel analysis of ordered categorical data. Behavior Research Methods, 40(2), 556-562.
+
+    class ParallelAnalysis
+      def self.with_random_data(cases,vars,opts=Hash.new)
+        ds= Daru::DataFrame.new({}, 
+          order: vars.times.map {|i| "v#{i+1}".to_sym},
+          index: cases )
+        opts=opts.merge({:bootstrap_method=> :random, :no_data=>true})
+        new(ds, opts)
+      end
+
+      include DirtyMemoize
+      include Summarizable
+      # 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>:random</tt> used by default
+      # * <tt>:random</tt>: uses number of variables and cases for the dataset
+      # * <tt>:data</tt> : sample with replacement from actual data.
+      attr_accessor :bootstrap_method
+      # Uses smc on diagonal of matrixes, to perform simulation
+      # of a Principal Axis analysis.
+      # By default, false.
+      attr_accessor :smc
+      # 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
+      # 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
+      attr_accessor :use_gsl
+      def initialize(ds, opts=Hash.new)
+        @ds=ds
+        @fields=@ds.vectors.to_a
+        @n_variables=@fields.size
+        @n_cases=ds.nrows
+        opts_default={
+          :name=>_("Parallel Analysis"),
+          :iterations=>50, # See Liu and Rijmen (2008)
+          :bootstrap_method => :random,
+          :smc=>false,
+          :percentil=>95, 
+          :debug=>false,
+          :no_data=>false,
+          :matrix_method=>:correlation_matrix
+        }
+        @use_gsl=Statsample.has_gsl?
+        @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
+      # Number of factor to retent
+      def number_of_factors
+        total=0
+        ds_eigenvalues.vectors.to_a.each_with_index do |f,i|
+          if (@original[i]>0 and @original[i]>ds_eigenvalues[f].percentil(percentil))
+            total+=1
+          else
+            break
+          end
+        end
+        total
+      end
+      def report_building(g) #:nodoc:
+        g.section(:name=>@name) do |s|
+          s.text _("Bootstrap Method: %s") % bootstrap_method
+          s.text _("Uses SMC: %s") % (smc ? _("Yes") : _("No"))
+          s.text _("Correlation Matrix type : %s") % matrix_method
+          s.text _("Number of variables: %d") % @n_variables
+          s.text _("Number of cases: %d") % @n_cases
+          s.text _("Number of iterations: %d") % @iterations
+          if @no_data
+            s.table(:name=>_("Eigenvalues"), :header=>[_("n"), _("generated eigenvalue"), "p.#{percentil}"]) do |t|
+              ds_eigenvalues.vectors.to_a.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.vectors.to_a.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
+      end
+      # Perform calculation. Shouldn't be called directly for the user
+      def compute
+        @original=Statsample::Bivariate.send(matrix_method, @ds).eigenvalues unless no_data
+        @ds_eigenvalues=Daru::DataFrame.new({}, order: (1..@n_variables).map{|v| ("ev_%05d" % v).to_sym})
+        
+        if bootstrap_method==:parameter or bootstrap_method==:random
+          rng = Distribution::Normal.rng
+        end
+        
+        @iterations.times do |i|
+          begin
+            puts "#{@name}: Iteration #{i}" if $DEBUG or debug
+            # Create a dataset of dummy values
+            ds_bootstrap = Daru::DataFrame.new({}, order: @ds.vectors, index: @n_cases)
+            
+            @fields.each do |f|
+              if bootstrap_method==:random
+                ds_bootstrap[f] = Daru::Vector.new(@n_cases.times.map {|c| rng.call})
+              elsif bootstrap_method==:data
+                ds_bootstrap[f] = ds[f].sample_with_replacement(@n_cases)
+              else
+                raise "bootstrap_method doesn't recogniced"
+              end
+            end
+
+            matrix=Statsample::Bivariate.send(matrix_method, ds_bootstrap)
+            matrix=matrix.to_gsl if @use_gsl
+            if smc
+                smc_v=matrix.inverse.diagonal.map{|ii| 1-(1.quo(ii))}
+                smc_v.each_with_index do |v,ii| 
+                  matrix[ii,ii]=v
+                end
+            end
+            ev=matrix.eigenvalues
+            @ds_eigenvalues.add_row(ev)
+          rescue Statsample::Bivariate::Tetrachoric::RequerimentNotMeet => e
+            puts "Error: #{e}" if $DEBUG
+            redo
+          end
+        end
+      end
+      dirty_memoize :number_of_factors, :ds_eigenvalues
+      dirty_writer :iterations, :bootstrap_method, :percentil, :smc
+    end
+  end
+end

data/lib/statsample-ekatena/factor/pca.rb

@@ -0,0 +1,242 @@
+# encoding: UTF-8
+module Statsample
+module Factor
+  # Principal Component Analysis (PCA) of a covariance or 
+  # correlation matrix.. 
+  #
+  # NOTE: Sign of second and later eigenvalues could be different
+  # using Ruby or GSL, so values for PCs and component matrix
+  # should differ, because extendmatrix and gsl's methods to calculate
+  # eigenvectors are different. Using R is worse, cause first 
+  # eigenvector could have negative values!
+  # For Principal Axis Analysis, use Statsample::Factor::PrincipalAxis
+  # 
+  # == Usage:
+  #   require 'statsample'
+  #   a = Daru::Vector.new([2.5, 0.5, 2.2, 1.9, 3.1, 2.3, 2.0, 1.0, 1.5, 1.1])
+  #   b = Daru::Vector.new([2.4,0.7,2.9,2.2,3.0,2.7,1.6,1.1,1.6,0.9])
+  #   ds = Daru::DataFrame.new({:a => a,:b => b})
+  #   cor_matrix = Statsample::Bivariate.correlation_matrix(ds)
+  #   pca=  Statsample::Factor::PCA.new(cor_matrix)
+  #   pca.m
+  #   => 1
+  #   pca.eigenvalues
+  #   => [1.92592927269225, 0.0740707273077545]
+  #   pca.component_matrix
+  #   => GSL::Matrix
+  #   [  9.813e-01 
+  #     9.813e-01 ]
+  #   pca.communalities
+  #   => [0.962964636346122, 0.962964636346122]
+  #
+  # == References:
+  # * SPSS Manual
+  # * Smith, L. (2002). A tutorial on Principal Component Analysis. Available on http://courses.eas.ualberta.ca/eas570/pca_tutorial.pdf 
+  # * Härdle, W. & Simar, L. (2003). Applied Multivariate Statistical Analysis. Springer
+  # 
+  class PCA
+    include Summarizable
+    # Name of analysis
+    attr_accessor :name
+
+    # Number of factors. Set by default to the number of factors
+    # with eigen values > 1
+    attr_accessor :m
+    # Use GSL if available
+    attr_accessor :use_gsl
+    # Add to the summary a rotation report
+    attr_accessor :summary_rotation
+    # Add to the summary a parallel analysis report
+    attr_accessor :summary_parallel_analysis
+    # Type of rotation. By default, Statsample::Factor::Rotation::Varimax
+    attr_accessor :rotation_type
+    attr_accessor :matrix_type
+    def initialize(matrix, opts=Hash.new)
+      @use_gsl = opts[:use_gsl]
+      opts.delete :use_gsl
+
+      @name=_("Principal Component Analysis")
+      @matrix=matrix
+      @n_variables=@matrix.column_size      
+      @variables_names=(@matrix.respond_to? :fields) ? @matrix.fields : @n_variables.times.map {|i| "VAR_#{i+1}".to_sym }
+      
+      @matrix_type = @matrix.respond_to?(:_type) ? @matrix._type : :correlation
+      
+      @m=nil
+      
+      @rotation_type=Statsample::Factor::Varimax
+      
+      opts.each{|k,v|
+        self.send("#{k}=",v) if self.respond_to? k
+      }
+
+      if @use_gsl.nil?
+        @use_gsl=Statsample.has_gsl?
+      end
+      if @matrix.respond_to? :fields
+        @variables_names=@matrix.fields
+      else
+        @variables_names=@n_variables.times.map {|i| "V#{i+1}".to_sym}
+      end
+      calculate_eigenpairs
+      
+      if @m.nil?
+        # Set number of factors with eigenvalues > 1
+        @m=@eigenpairs.find_all {|ev,ec| ev>=1.0}.size
+      end
+    end
+    def rotation
+      @rotation_type.new(component_matrix)
+    end
+    def total_eigenvalues
+      eigenvalues.inject(0) {|ac,v| ac+v}
+    end
+    def create_centered_ds
+      h={}
+      @original_ds.factors.each {|f|
+        mean = @original_ds[f].mean
+        h[f] = @original_ds[f].recode {|c| c-mean}
+      }
+      @ds = Daru::DataFrame.new(h)
+    end
+    
+    # Feature matrix for +m+ factors
+    # Returns +m+ eigenvectors as columns.
+    # So, i=variable, j=component
+    def feature_matrix(m=nil)
+      m||=@m
+      if @use_gsl
+        omega_m=GSL::Matrix.zeros(@n_variables,m)
+        ev=eigenvectors
+        m.times do |i|
+          omega_m.set_column(i,ev[i])
+        end
+        omega_m
+      else
+        omega_m=::Matrix.build(@n_variables, m) {0}
+        m.times do |i|
+          omega_m.column= i, @eigenpairs[i][1]
+        end
+        omega_m
+      end
+    end
+    # Returns Principal Components for +input+ matrix or dataset
+    # The number of PC to return is equal to parameter +m+. 
+    # If +m+ isn't set, m set to number of PCs selected at object creation.
+    # Use covariance matrix
+    
+    def principal_components(input, m=nil)
+      if @use_gsl
+        data_matrix=input.to_gsl
+      else
+        data_matrix=input.to_matrix
+      end
+      m||=@m
+      
+      raise "data matrix variables<>pca variables" if data_matrix.column_size!=@n_variables
+      
+      fv=feature_matrix(m)
+      pcs=(fv.transpose*data_matrix.transpose).transpose
+      
+      pcs.extend Statsample::NamedMatrix
+      pcs.fields_y = m.times.map { |i| "PC_#{i+1}".to_sym }
+      pcs.to_dataframe
+    end
+    def component_matrix(m=nil)
+      var="component_matrix_#{matrix_type}"
+      send(var,m)
+    end
+    # Matrix with correlations between components and
+    # variables. Based on Härdle & Simar (2003, p.243)
+    def component_matrix_covariance(m=nil)
+      m||=@m
+      raise "m should be > 0" if m<1
+      ff=feature_matrix(m)
+      cm=::Matrix.build(@n_variables, m) {0}
+      @n_variables.times {|i|
+        m.times {|j|
+          cm[i,j]=ff[i,j] * Math.sqrt(eigenvalues[j] / @matrix[i,i])
+        }
+      }
+      cm.extend NamedMatrix
+      cm.name=_("Component matrix (from covariance)")
+      cm.fields_x = @variables_names
+      cm.fields_y = m.times.map {|i| "PC_#{i+1}".to_sym }
+      
+      cm
+    end
+    # Matrix with correlations between components and
+    # variables
+    def component_matrix_correlation(m=nil)
+      m||=@m
+      raise "m should be > 0" if m<1
+      omega_m=::Matrix.build(@n_variables, m) {0}
+      gammas=[]
+      m.times {|i|
+        omega_m.column=i, @eigenpairs[i][1]
+        gammas.push(Math::sqrt(@eigenpairs[i][0]))
+      }
+      gamma_m=::Matrix.diagonal(*gammas)
+      cm=(omega_m*(gamma_m)).to_matrix
+      
+      cm.extend CovariateMatrix
+      cm.name=_("Component matrix")
+      cm.fields_x = @variables_names
+      cm.fields_y = m.times.map { |i| "PC_#{i+1}".to_sym }
+      cm
+    end
+    def communalities(m=nil)
+      m||=@m
+      h=[]
+      @n_variables.times do |i|
+        sum=0
+        m.times do |j|
+          sum += (@eigenpairs[j][0].abs*@eigenpairs[j][1][i]**2)
+        end
+        h.push(sum)
+      end
+      h
+    end
+    # Array with eigenvalues
+    def eigenvalues
+      @eigenpairs.collect {|c| c[0] }
+    end
+    def eigenvectors
+      @eigenpairs.collect {|c| 
+        @use_gsl ? c[1].to_gsl : Daru::Vector.new(c[1])
+      }
+    end
+    def calculate_eigenpairs
+      @eigenpairs= @use_gsl ? @matrix.to_gsl.eigenpairs : @matrix.to_matrix.eigenpairs_ruby
+    end
+  
+    
+    def report_building(builder) # :nodoc:
+      builder.section(:name=>@name) do |generator|
+        generator.text _("Number of factors: %d") % m
+        generator.table(:name=>_("Communalities"), :header=>[_("Variable"),_("Initial"),_("Extraction"), _("%")]) do |t|
+          communalities(m).each_with_index {|com, i|
+            perc=com*100.quo(@matrix[i,i])
+            t.row([@variables_names[i], "%0.3f" % @matrix[i,i]  , "%0.3f" % com, "%0.3f" % perc])
+          }
+        end
+        te=total_eigenvalues
+        generator.table(:name=>_("Total Variance Explained"), :header=>[_("Component"), _("E.Total"), _("%"), _("Cum. %")]) do |t|
+          ac_eigen=0
+          eigenvalues.each_with_index {|eigenvalue,i|
+            ac_eigen+=eigenvalue
+            t.row([_("Component %d") % (i+1), sprintf("%0.3f",eigenvalue), sprintf("%0.3f%%", eigenvalue*100.quo(te)), sprintf("%0.3f",ac_eigen*100.quo(te))])
+          }
+        end
+        
+        generator.parse_element(component_matrix(m))
+                  
+        if (summary_rotation)
+          generator.parse_element(rotation)
+        end
+      end
+    end
+    private :calculate_eigenpairs, :create_centered_ds
+  end
+end
+end

data/lib/statsample-ekatena/factor/principalaxis.rb

@@ -0,0 +1,243 @@
+module Statsample
+module Factor
+  # Principal Axis Analysis for a covariance or correlation matrix. 
+  #
+  # For PCA, use Statsample::Factor::PCA
+  # 
+  # == Usage:
+  #   require 'statsample'
+  #   a = Daru::Vector.new([2.5, 0.5, 2.2, 1.9, 3.1, 2.3, 2.0, 1.0, 1.5, 1.1])
+  #   b = Daru::Vector.new([2.4,0.7,2.9,2.2,3.0,2.7,1.6,1.1,1.6,0.9])
+  #   ds= Daru::DataFrame.new({:a => a,:b => b})
+  #   cor_matrix=Statsample::Bivariate.correlation_matrix(ds)
+  #   pa=Statsample::Factor::PrincipalAxis.new(cor_matrix)
+  #   pa.iterate(1)
+  #   pa.m
+  #   => 1
+  #   pca.component_matrix
+  #   => GSL::Matrix
+  #   [  9.622e-01 
+  #      9.622e-01 ]
+  #   pca.communalities
+  #   => [0.962964636346122, 0.962964636346122]
+  #
+  # == References:
+  # * SPSS Manual
+  # * Smith, L. (2002). A tutorial on Principal Component Analysis. Available on http://courses.eas.ualberta.ca/eas570/pca_tutorial.pdf 
+  #   
+  class PrincipalAxis
+    include DirtyMemoize
+    include Summarizable
+    # Name of analysis
+    attr_accessor :name
+
+    # Number of factors. Set by default to the number of factors
+    # with eigenvalues > 1 (Kaiser criterion).
+    # 
+    # _Warning:_ Kaiser criterion overfactors! Give yourself some time
+    # and use Horn's Parallel Analysis.
+    #
+    attr_accessor :m
+    
+    # Number of iterations required to converge
+    attr_reader :iterations
+    
+    # Initial eigenvalues 
+    attr_reader :initial_eigenvalues
+    
+    # Tolerance for iterations
+    attr_accessor :epsilon
+    
+    # Use SMC(squared multiple correlations) as diagonal. If false, use 1
+    attr_accessor :smc
+    
+    # Maximum number of iterations
+    attr_accessor :max_iterations
+    
+    # Eigenvalues of factor analysis
+    attr_reader :eigenvalues
+    
+    # Minimum difference between succesive iterations on sum of communalities
+    DELTA=1e-3
+    # Maximum number of iterations
+    MAX_ITERATIONS=25
+    
+    def initialize(matrix, opts=Hash.new)
+      @matrix=matrix
+      if @matrix.respond_to? :fields
+        @fields=@matrix.fields
+      else
+        @fields=@matrix.row_size.times.map {|i| _("Variable %d") % (i+1)}
+      end
+      @n_variables=@matrix.row_size
+      @name=""
+      @m=nil
+      @initial_eigenvalues=nil
+      @initial_communalities=nil
+      @component_matrix=nil
+      @delta=DELTA
+      @smc=true
+      @max_iterations=MAX_ITERATIONS
+      opts.each{|k,v|
+        self.send("#{k}=",v) if self.respond_to? k
+      }
+      if @matrix.respond_to? :fields
+        @variables_names=@matrix.fields
+      else
+        @variables_names=@n_variables.times.map {|i| "V#{i+1}"}
+      end
+      if @m.nil?
+        pca=PCA.new(::Matrix.rows(@matrix.to_a))
+        @m=pca.m
+      end
+      
+      @clean=true
+    end
+    # Communality for all variables given m factors
+    def communalities(m=nil)
+      if m!=@m or @clean
+        iterate(m)
+        raise "Can't calculate comunality" if @communalities.nil?
+      end
+      @communalities
+    end
+    # Component matrix for m factors
+    def component_matrix(m=nil)
+      if m!=@m  or @clean
+        iterate(m)
+      end
+      @component_matrix
+    end
+    # Iterate to find the factors
+    def iterate(m=nil)
+      @clean=false
+      m||=@m
+      @m=m
+      t = @max_iterations
+      work_matrix=@matrix.to_a
+      
+      prev_com=initial_communalities
+      
+      pca=PCA.new(::Matrix.rows(work_matrix))
+      @initial_eigenvalues=pca.eigenvalues
+      prev_sum=prev_com.inject(0) {|ac,v| ac+v}
+      @iterations=0
+      t.times do |i|
+        "#{@name}: Iteration #{i}" if $DEBUG
+        @iterations+=1
+        prev_com.each_with_index{|v,it|
+          work_matrix[it][it]=v
+        }
+        pca=PCA.new(::Matrix.rows(work_matrix))
+        @communalities=pca.communalities(m)
+        @eigenvalues=pca.eigenvalues
+        com_sum = @communalities.inject(0) {|ac,v| ac+v}
+        #jump=true
+        
+        break if (com_sum-prev_sum).abs < @delta
+        @communalities.each_with_index do |v2,i2|
+          raise "Variable #{i2} with communality > 1" if v2>1.0
+        end
+        prev_sum=com_sum
+        prev_com=@communalities
+        
+      end
+      @component_matrix=pca.component_matrix(m)
+      @component_matrix.extend CovariateMatrix
+      @component_matrix.name=_("Factor Matrix")
+      @component_matrix.fields_x = @variables_names
+      @component_matrix.fields_y = m.times.map {|i| "factor_#{i+1}"}
+      
+    end
+    alias :compute :iterate 
+    
+    def initial_communalities
+      if @initial_communalities.nil?
+        
+        if @smc
+          # Based on O'Connors(2000)
+          @initial_communalities=@matrix.inverse.diagonal.map{|i| 1-(1.quo(i))}
+=begin
+        @initial_communalities=@matrix.column_size.times.collect {|i|
+          rxx , rxy = PrincipalAxis.separate_matrices(@matrix,i)
+          matrix=(rxy.t*rxx.inverse*rxy)
+          matrix[0,0]
+        }
+=end
+        else
+          @initial_communalities=[1.0]*@matrix.column_size
+        end
+      end      
+      @initial_communalities
+    end
+    
+    
+    # Returns two matrixes from a correlation matrix
+    # with regressors correlation matrix and criteria xy
+    # matrix.
+    def self.separate_matrices(matrix, y)
+      ac=[]
+      matrix.column_size.times do |i|
+        ac.push(matrix[y,i]) if i!=y
+      end
+      rxy=Matrix.columns([ac])
+      rows=[]
+      matrix.row_size.times do |i|
+        if i!=y
+          row=[]
+          matrix.row_size.times do |j|
+            row.push(matrix[i,j]) if j!=y
+          end
+          rows.push(row)
+        end
+      end
+      rxx=Matrix.rows(rows)
+      [rxx,rxy]
+    end
+    def report_building(generator)
+      iterate if @clean
+      generator.section(:name=>@name) do |s|
+        s.text _("Number of factors: %d") % m
+        s.text _("Iterations: %d") % @iterations
+        s.table(:name=>_("Communalities"), :header=>[_("Variable"),_("Initial"),_("Extraction")]) do |t|
+          communalities(m).each_with_index {|com,i|
+            t.row([@fields[i], sprintf("%0.4f", initial_communalities[i]), sprintf("%0.3f", com)])
+          }
+        end
+        s.table(:name=>_("Total Variance"), :header=>[_("Factor"), _("I.E.Total"), _("I.E. %"), _("I.E.Cum. %"),
+        _("S.L.Total"), _("S.L. %"), _("S.L.Cum. %")
+          ]) do |t|
+        ac_eigen,ac_i_eigen=0,0
+          @initial_eigenvalues.each_with_index {|eigenvalue,i|
+            ac_i_eigen+=eigenvalue
+            ac_eigen+=@eigenvalues[i]
+            new_row=[
+            _("Factor %d") % (i+1), 
+            sprintf("%0.3f",eigenvalue),
+            sprintf("%0.3f%%", eigenvalue*100.quo(@n_variables)),
+            sprintf("%0.3f",ac_i_eigen*100.quo(@n_variables))
+            ]
+            if i<@m
+              new_row.concat [
+                sprintf("%0.3f", @eigenvalues[i]),
+                sprintf("%0.3f%%", @eigenvalues[i]*100.quo(@n_variables)),
+                sprintf("%0.3f",ac_eigen*100.quo(@n_variables))              
+              ]
+            else
+              new_row.concat ["","",""]
+            end
+            
+            t.row new_row
+          }
+        end
+        s.parse_element(component_matrix)
+      end
+    end
+    
+    dirty_writer :max_iterations, :epsilon, :smc
+    dirty_memoize :eigenvalues, :iterations, :initial_eigenvalues
+
+  end
+  
+end
+end