statsample-ekatena 2.0.2

data/lib/statsample-ekatena/dominanceanalysis/bootstrap.rb

@@ -0,0 +1,232 @@
+module Statsample
+  class DominanceAnalysis
+    # == Goal
+    # Generates Bootstrap sample to identity the replicability of a Dominance Analysis. See Azen & Bodescu (2003) for more information.
+    #
+    # == Usage
+    # 
+    # require 'statsample'
+    # a = Daru::Vector.new(100.times.collect {rand})
+    # b = Daru::Vector.new(100.times.collect {rand})
+    # c = Daru::Vector.new(100.times.collect {rand})
+    # d = Daru::Vector.new(100.times.collect {rand})
+    # ds = Daru::DataFrame.new({:a => a,:b => b,:c => c,:d => d})
+    # ds[:y] = ds.collect_rows { |row| row[:a]*5+row[:b]*2+row[:c]*2+row[:d]*2+10*rand() }
+    # dab=Statsample::DominanceAnalysis::Bootstrap.new(ds, :y, :debug=>true)
+    # dab.bootstrap(100,nil)
+    # puts dab.summary
+    # <strong>Output</strong>
+    #   Sample size: 100
+    #  t: 1.98421693632958
+    #  
+    #  Linear Regression Engine: Statsample::Regression::Multiple::MatrixEngine
+    #  Table: Bootstrap report
+    #  --------------------------------------------------------------------------------------------
+    #  | pairs                 | sD  | Dij    | SE(Dij) | Pij   | Pji   | Pno   | Reproducibility |
+    #  --------------------------------------------------------------------------------------------
+    #  | Complete dominance    |
+    #  --------------------------------------------------------------------------------------------
+    #  | a - b                 | 1.0 | 0.6150 | 0.454   | 0.550 | 0.320 | 0.130 | 0.550           |
+    #  | a - c                 | 1.0 | 0.9550 | 0.175   | 0.930 | 0.020 | 0.050 | 0.930           |
+    #  | a - d                 | 1.0 | 0.9750 | 0.131   | 0.960 | 0.010 | 0.030 | 0.960           |
+    #  | b - c                 | 1.0 | 0.8800 | 0.276   | 0.820 | 0.060 | 0.120 | 0.820           |
+    #  | b - d                 | 1.0 | 0.9250 | 0.193   | 0.860 | 0.010 | 0.130 | 0.860           |
+    #  | c - d                 | 0.5 | 0.5950 | 0.346   | 0.350 | 0.160 | 0.490 | 0.490           |
+    #  --------------------------------------------------------------------------------------------
+    #  | Conditional dominance |
+    #  --------------------------------------------------------------------------------------------
+    #  | a - b                 | 1.0 | 0.6300 | 0.458   | 0.580 | 0.320 | 0.100 | 0.580           |
+    #  | a - c                 | 1.0 | 0.9700 | 0.156   | 0.960 | 0.020 | 0.020 | 0.960           |
+    #  | a - d                 | 1.0 | 0.9800 | 0.121   | 0.970 | 0.010 | 0.020 | 0.970           |
+    #  | b - c                 | 1.0 | 0.8850 | 0.283   | 0.840 | 0.070 | 0.090 | 0.840           |
+    #  | b - d                 | 1.0 | 0.9500 | 0.181   | 0.920 | 0.020 | 0.060 | 0.920           |
+    #  | c - d                 | 0.5 | 0.5800 | 0.360   | 0.350 | 0.190 | 0.460 | 0.460           |
+    #  --------------------------------------------------------------------------------------------
+    #  | General Dominance     |
+    #  --------------------------------------------------------------------------------------------
+    #  | a - b                 | 1.0 | 0.6500 | 0.479   | 0.650 | 0.350 | 0.000 | 0.650           |
+    #  | a - c                 | 1.0 | 0.9800 | 0.141   | 0.980 | 0.020 | 0.000 | 0.980           |
+    #  | a - d                 | 1.0 | 0.9900 | 0.100   | 0.990 | 0.010 | 0.000 | 0.990           |
+    #  | b - c                 | 1.0 | 0.9000 | 0.302   | 0.900 | 0.100 | 0.000 | 0.900           |
+    #  | b - d                 | 1.0 | 0.9700 | 0.171   | 0.970 | 0.030 | 0.000 | 0.970           |
+    #  | c - d                 | 1.0 | 0.5600 | 0.499   | 0.560 | 0.440 | 0.000 | 0.560           |
+    #  --------------------------------------------------------------------------------------------
+    #  
+    #  Table: General averages
+    #  ---------------------------------------
+    #  | var | mean  | se    | p.5   | p.95  |
+    #  ---------------------------------------
+    #  | a   | 0.133 | 0.049 | 0.062 | 0.218 |
+    #  | b   | 0.106 | 0.048 | 0.029 | 0.199 |
+    #  | c   | 0.035 | 0.032 | 0.002 | 0.106 |
+    #  | d   | 0.023 | 0.019 | 0.002 | 0.062 |
+    #  ---------------------------------------
+    #
+    # == References:
+    # * Azen, R. & Budescu, D.V. (2003). The dominance analysis approach for comparing predictors in multiple regression. <em>Psychological Methods, 8</em>(2), 129-148.
+    class Bootstrap
+      include Writable
+      include Summarizable
+      # Total Dominance results
+      attr_reader :samples_td
+      # Conditional Dominance results
+      attr_reader :samples_cd
+      # General Dominance results
+      attr_reader :samples_gd
+      # General average results 
+      attr_reader :samples_ga
+      # Name of fields
+      attr_reader :fields
+      # Regression class used for analysis
+      attr_accessor :regression_class
+      # Dataset
+      attr_accessor :ds
+      # Name of analysis
+      attr_accessor :name
+      # Alpha level of confidence. Default: ALPHA
+      attr_accessor :alpha
+      # Debug?
+      attr_accessor :debug
+      # Default level of confidence for t calculation
+      ALPHA=0.95
+      # Create a new Dominance Analysis Bootstrap Object
+      # 
+      # * ds: A Daru::DataFrame object
+      # * y_var: Name of dependent variable
+      # * opts: Any other attribute of the class 
+      def initialize(ds,y_var, opts=Hash.new)
+        @ds    = ds
+        @y_var = y_var.respond_to?(:to_sym) ? y_var.to_sym : y_var
+        @n     = ds.nrows
+        
+        @n_samples=0
+        @alpha=ALPHA
+        @debug=false
+        if y_var.is_a? Array
+          @fields=ds.vectors.to_a - y_var
+          @regression_class=Regression::Multiple::MultipleDependent
+          
+        else
+          @fields=ds.vectors.to_a - [y_var]
+          @regression_class=Regression::Multiple::MatrixEngine
+        end
+        @samples_ga=@fields.inject({}) { |a,v| a[v]=[]; a }
+
+        @name=_("Bootstrap dominance Analysis:  %s over %s") % [ ds.vectors.to_a.join(",") , @y_var]
+        opts.each{|k,v|
+          self.send("#{k}=",v) if self.respond_to? k
+        }
+        create_samples_pairs            
+      end
+      # lr_class deprecated
+      alias_method :lr_class, :regression_class
+      def da
+        if @da.nil?
+          @da=DominanceAnalysis.new(@ds,@y_var, :regression_class => @regression_class)
+        end
+        @da
+      end
+      # Creates n re-samples from original dataset and store result of
+      # each sample on @samples_td, @samples_cd, @samples_gd, @samples_ga
+      # 
+      # * number_samples: Number of new samples to add
+      # * n: size of each new sample. If nil, equal to original sample size     
+      def bootstrap(number_samples,n=nil)
+        number_samples.times{ |t|
+          @n_samples+=1
+          puts _("Bootstrap %d of %d") % [t+1, number_samples] if @debug
+          ds_boot=@ds.bootstrap(n)                 
+          da_1=DominanceAnalysis.new(ds_boot, @y_var, :regression_class => @regression_class)
+
+          da_1.total_dominance.each{|k,v|
+            @samples_td[k].push(v)
+          }
+          da_1.conditional_dominance.each{|k,v|
+            @samples_cd[k].push(v)
+          }
+          da_1.general_dominance.each{|k,v|
+            @samples_gd[k].push(v)
+          }
+          da_1.general_averages.each{|k,v|
+            @samples_ga[k].push(v)
+          }
+        }
+      end
+      def create_samples_pairs
+        @samples_td={}
+        @samples_cd={}
+        @samples_gd={}
+        @pairs=[]
+        c=(0...@fields.size).to_a.combination(2)
+        c.each do |data|
+          p data
+          convert=data.collect {|i| @fields[i] }
+          @pairs.push(convert)
+          [@samples_td, @samples_cd, @samples_gd].each{|s|
+            s[convert]=[]
+          }
+        end
+      end
+      def t
+        Distribution::T.p_value(1-((1-@alpha) / 2), @n_samples - 1)
+      end
+      def report_building(builder) # :nodoc:
+        raise "You should bootstrap first" if @n_samples==0
+        builder.section(:name=>@name) do |generator|
+          generator.text _("Sample size: %d\n") % @n_samples
+          generator.text "t: #{t}\n"
+          generator.text _("Linear Regression Engine: %s") % @regression_class.name
+          
+          table=ReportBuilder::Table.new(:name=>"Bootstrap report", :header => [_("pairs"), "sD","Dij", _("SE(Dij)"), "Pij", "Pji", "Pno", _("Reproducibility")])
+          table.row([_("Complete dominance"),"","","","","","",""])
+          table.hr
+          @pairs.each{|pair|
+            std=Daru::Vector.new(@samples_td[pair])
+            ttd=da.total_dominance_pairwise(pair[0],pair[1])
+            table.row(summary_pairs(pair,std,ttd))
+          }
+          table.hr
+          table.row([_("Conditional dominance"),"","","","","","",""])
+          table.hr
+          @pairs.each{|pair|
+            std=Daru::Vector.new(@samples_cd[pair])
+            ttd=da.conditional_dominance_pairwise(pair[0],pair[1])
+            table.row(summary_pairs(pair,std,ttd))
+          
+          }
+          table.hr
+          table.row([_("General Dominance"),"","","","","","",""])
+          table.hr
+          @pairs.each{|pair|
+            std=Daru::Vector.new(@samples_gd[pair])
+            ttd=da.general_dominance_pairwise(pair[0],pair[1])
+            table.row(summary_pairs(pair,std,ttd))
+          }
+          generator.parse_element(table)
+          
+          table=ReportBuilder::Table.new(:name=>_("General averages"), :header=>[_("var"), _("mean"), _("se"), _("p.5"), _("p.95")])
+          
+          @fields.each{|f|
+            v=Daru::Vector.new(@samples_ga[f])
+            row=[@ds[f].name, sprintf("%0.3f",v.mean), sprintf("%0.3f",v.sd), sprintf("%0.3f",v.percentil(5)),sprintf("%0.3f",v.percentil(95))]
+            table.row(row)          
+          }
+          
+          generator.parse_element(table)
+        end
+      end
+      def summary_pairs(pair,std,ttd)
+          freqs=std.proportions
+          [0, 0.5, 1].each{|n|
+              freqs[n]=0 if freqs[n].nil?
+          }
+          name="%s - %s" % [@ds[pair[0]].name, @ds[pair[1]].name]
+          [name,f(ttd,1),f(std.mean,4),f(std.sd),f(freqs[1]), f(freqs[0]), f(freqs[0.5]), f(freqs[ttd])]
+      end
+      def f(v,n=3)
+          prec="%0.#{n}f"
+          sprintf(prec,v)
+      end
+    end
+  end
+end

data/lib/statsample-ekatena/factor.rb

@@ -0,0 +1,104 @@
+require 'statsample/factor/rotation'
+require 'statsample/factor/pca'
+require 'statsample/factor/principalaxis'
+require 'statsample/factor/parallelanalysis'
+require 'statsample/factor/map'
+
+module Statsample
+  # Factor Analysis toolbox.
+  # * Classes for Extraction of factors: 
+  #   * Statsample::Factor::PCA
+  #   * Statsample::Factor::PrincipalAxis
+  # * Classes for Rotation of factors: 
+  #   * Statsample::Factor::Varimax
+  #   * Statsample::Factor::Equimax
+  #   * Statsample::Factor::Quartimax
+  # * Classes for determining the number of components
+  #   * Statsample::Factor::MAP
+  #   * Statsample::Factor::ParallelAnalysis
+  #
+  # About number of components, O'Connor(2000) said:
+  #  The two procedures [PA and MAP ] complement each other nicely,
+  #  in that the MAP tends to err (when it does err) in the direction
+  #  of underextraction, whereas parallel analysis tends to err
+  #  (when it does err) in the direction of overextraction.
+  #  Optimal decisions are thus likely to be made after considering
+  #  the results of both analytic procedures. (p.10)
+
+  module Factor
+    # Anti-image covariance matrix.
+    # Useful for inspection of desireability of data for factor analysis.
+    # According to Dziuban  & Shirkey (1974, p.359): 
+    #   "If this matrix does not exhibit many zero off-diagonal elements,
+    #   the investigator has evidence that the correlation
+    #   matrix is not appropriate for factor analysis."
+    # 
+    def self.anti_image_covariance_matrix(matrix)
+      s2=Matrix.diagonal(*(matrix.inverse.diagonal)).inverse
+      aicm=(s2)*matrix.inverse*(s2)
+      aicm.extend(Statsample::CovariateMatrix)
+      aicm.fields=matrix.fields if matrix.respond_to? :fields
+      aicm
+    end
+    def self.anti_image_correlation_matrix(matrix)
+      matrix=matrix.to_matrix
+      s=Matrix.diagonal(*(matrix.inverse.diagonal)).sqrt.inverse
+      aicm=s*matrix.inverse*s
+      
+      aicm.extend(Statsample::CovariateMatrix)
+      aicm.fields=matrix.fields if matrix.respond_to? :fields
+      aicm
+    end
+      
+    # Kaiser-Meyer-Olkin measure of sampling adequacy for correlation matrix.
+    # 
+    # Kaiser's (1974, cited on Dziuban  & Shirkey, 1974) present calibration of the index is as follows :
+    # * .90s—marvelous
+    # * .80s— meritorious
+    # * .70s—middling
+    # * .60s—mediocre
+    # * .50s—miserable
+    # * .50 •—unacceptable
+    def self.kmo(matrix)
+      q=anti_image_correlation_matrix(matrix)
+      n=matrix.row_size
+      sum_r,sum_q=0,0
+      n.times do |j|
+        n.times do |k|
+          if j!=k
+            sum_r+=matrix[j,k]**2
+            sum_q+=q[j,k]**2
+          end
+        end
+      end
+      sum_r.quo(sum_r+sum_q)
+    end
+    # Kaiser-Meyer-Olkin measure of sampling adequacy for one variable.
+    # 
+    def self.kmo_univariate(matrix, var)
+      if var.is_a? String
+        if matrix.respond_to? :fields
+          j=matrix.fields.index(var)
+          raise "Matrix doesn't have field #{var}" if j.nil?
+        else
+          raise "Matrix doesn't respond to fields"
+        end
+      else
+        j=var
+      end
+      
+      q=anti_image_correlation_matrix(matrix)
+      n=matrix.row_size
+      
+      sum_r,sum_q=0,0
+      
+      n.times do |k|
+        if j!=k
+          sum_r+=matrix[j,k]**2
+          sum_q+=q[j,k]**2
+        end
+      end
+      sum_r.quo(sum_r+sum_q)
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+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
+  # 
+  # == Reference
+  # * 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 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
+      
+      attr_accessor :use_gsl
+      def self.with_dataset(ds,opts=Hash.new)
+        new(ds.correlation_matrix,opts)
+      end
+      def initialize(matrix, opts=Hash.new)
+        @matrix=matrix
+        opts_default={
+          :use_gsl=>true,
+          :name=>_("Velicer's MAP")
+        }
+        @opts=opts_default.merge(opts)
+         opts_default.keys.each {|k| send("#{k}=", @opts[k]) }
+      end
+      def compute
+        gsl_m=(use_gsl and Statsample.has_gsl?) ? @matrix.to_gsl : @matrix
+        klass_m=gsl_m.class
+        eigvect,@eigenvalues=gsl_m.eigenvectors_matrix, gsl_m.eigenvalues
+        eigenvalues_sqrt=@eigenvalues.collect {|v| Math.sqrt(v)}
+        loadings=eigvect*(klass_m.diagonal(*eigenvalues_sqrt))
+        fm=Array.new(@matrix.row_size)
+        ncol=@matrix.column_size
+        
+        fm[0]=(gsl_m.mssq - ncol).quo(ncol*(ncol-1))
+        
+        (ncol-1).times do |m|
+          puts "MAP:Eigenvalue #{m+1}" if $DEBUG
+          a=use_gsl ? loadings[0..(loadings.row_size-1),0..m] : 
+            loadings.minor(0..(loadings.row_size-1),0..m)
+          partcov= gsl_m - (a*a.transpose)
+          
+          d=klass_m.diagonal(*(partcov.diagonal.collect {|v| Math::sqrt(1/v)}))
+          pr=d*partcov*d
+          fm[m+1]=(pr.mssq-ncol).quo(ncol*(ncol-1))
+        end
+        minfm=fm[0]
+        nfactors=0
+        @errors=[]
+        fm.each_with_index do |v,s|
+          if defined?(Complex) and v.is_a? ::Complex
+            @errors.push(s)
+          else
+            if v < minfm
+              minfm=v
+              nfactors=s
+            end
+          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_with_index do |e,i|
+                t.row([@errors.include?(i) ? "*" : "%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, @errors.include?(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