statsample 0.6.3 → 0.6.4

data/lib/statsample/regression.rb

@@ -1,8 +1,11 @@
 require 'statsample/regression/simple'
 require 'statsample/regression/multiple'
+
+require 'statsample/regression/multiple/matrixengine'
 require 'statsample/regression/multiple/alglibengine'
 require 'statsample/regression/multiple/rubyengine'
 require 'statsample/regression/multiple/gslengine'
+
 require 'statsample/regression/binomial'
 require 'statsample/regression/binomial/logit'
 require 'statsample/regression/binomial/probit'

data/lib/statsample/regression/multiple.rb

@@ -42,35 +42,77 @@ module Statsample
     #  -----------------------------------------------
     # 
     module Multiple
-        # Creates an object for listwise regression. 
-        # Alglib is faster, so is prefered over GSL
-        #   lr=Statsample::Regression::Multiple.listwise(ds,'y')
-        def self.listwise(ds,y_var)
-          if HAS_ALGIB
-            AlglibEngine.new(ds,y_var)
-          elsif HAS_GSL
-            GslEngine.new(ds,y_var)
-          else
-            ds2=ds.dup_only_valid
-            RubyEngine.new(ds2,y_var)
-          end
+      # Creates an object for listwise regression. 
+      # Alglib is faster, so is prefered over GSL
+      #   lr=Statsample::Regression::Multiple.listwise(ds,'y')
+      def self.listwise(ds,y_var)
+        if HAS_ALGIB
+          AlglibEngine.new(ds,y_var)
+        elsif HAS_GSL
+          GslEngine.new(ds,y_var)
+        else
+          ds2=ds.dup_only_valid
+          RubyEngine.new(ds2,y_var)
+        end
+      end
+      
+      # Creates an object for pairwise regression
+      # For now, always retrieves a RubyEngine
+      #    lr=Statsample::Regression::Multiple.listwise(ds,'y')
+      def self.pairwise(ds,y_var)
+        RubyEngine.new(ds,y_var)
+      end
+      def self.listwise_by_exp(ds,exp)
+        raise "Not implemented yet"
+      end
+      # Obtain r2 for regressors
+      def self.r2_from_matrices(rxx,rxy)
+        matrix=(rxy.transpose*rxx.inverse*rxy)
+        matrix[0,0]
+      end
+      
+      class MultipleDependent
+        def significance
+          0.0
+        end
+        def initialize(matrix,y_var, opts=Hash.new)
+           matrix.extend Statsample::CovariateMatrix
+           @matrix=matrix
+           @fields=matrix.fields-y_var
+           @y_var=y_var
+           @q=@y_var.size
+           @matrix_cor=matrix.correlation
+           @matrix_cor_xx = @matrix_cor.submatrix(@fields)
+           @matrix_cor_yy = @matrix_cor.submatrix(y_var, y_var)
+           
+           @sxx = @matrix.submatrix(@fields)
+           @syy = @matrix.submatrix(y_var, y_var)
+           @sxy = @matrix.submatrix(@fields, y_var)
+           @syx = @sxy.t
+           
+           
         end
         
-        # Creates an object for pairwise regression
-        # For now, always retrieves a RubyEngine
-        #    lr=Statsample::Regression::Multiple.listwise(ds,'y')
-        def self.pairwise(ds,y_var)
-          RubyEngine.new(ds,y_var)
+        def r2yx
+          1- (@matrix_cor.determinant.quo(@matrix_cor_yy.determinant * @matrix_cor_xx.determinant))
         end
-        def self.listwise_by_exp(ds,exp)
-          raise "Not implemented yet"
+        # Residual covariance of Y after accountin with lineal relation with x
+        def syyx
+          @syy-@syx*@sxx.inverse*@sxy
         end
-        # Obtain r2 for regressors
-        def self.r2_from_matrices(rxx,rxy)
-          matrix=(rxy.transpose*rxx.inverse*rxy)
-          matrix[0,0]
+        def r2yx_covariance
+          1-(syyx.determinant.quo(@syy.determinant))
         end
         
+        def vxy
+          @q-(@syy.inverse*syyx).trace
+        end
+        def p2yx
+          vxy.quo(@q)
+        end
+      end
+      
+      
     end
   end
 end

data/lib/statsample/regression/multiple/baseengine.rb

@@ -3,12 +3,21 @@ module Statsample
     module Multiple
       # Base class for Multiple Regression Engines
       class BaseEngine
+        
         include GetText
         bindtextdomain("statsample")
         # Name of analysis
         attr_accessor :name
+        
+        def self.univariate?
+          true
+        end
+        
+
+        
         def initialize(ds, y_var, opts = Hash.new)
           @ds=ds
+          @cases=@ds.cases
           @y_var=y_var
           @r2=nil
           @name=_("Multiple Regression:  %s over %s") % [ ds.fields.join(",") , @y_var]
@@ -92,7 +101,7 @@ module Statsample
         end
         # Significance of Fisher
         def significance
-          1.0-Distribution::F.cdf(f,df_r,df_e)
+          (1.0-Distribution::F.cdf(f, df_r, df_e)).abs
         end
         # Tolerance for a given variable
         # http://talkstats.com/showthread.php?t=5056
@@ -120,6 +129,11 @@ module Statsample
           }
           out
         end
+        # Estandar error of R
+        def se_r2
+          Math::sqrt((4*r2*(1-r2)**2*(df_e)**2).quo((@cases**2-1)*(@cases+3)))
+        end
+         
         # Estimated Variance-Covariance Matrix
         # Used for calculation of se of constant
         def estimated_variance_covariance_matrix
@@ -152,8 +166,8 @@ module Statsample
           c=coeffs
           generator.add_text(_("Engine: %s") % self.class)
           generator.add_text(_("Cases(listwise)=%d(%d)") % [@ds.cases, @ds_valid.cases])
-          generator.add_text("r=#{sprintf('%0.3f',r)}")
-          generator.add_text("r=#{sprintf('%0.3f',r2)}")
+          generator.add_text("R=#{sprintf('%0.3f',r)}")
+          generator.add_text("R^2=#{sprintf('%0.3f',r2)}")
           
           generator.add_text(_("Equation")+"="+ sprintf('%0.3f',constant) +" + "+ @fields.collect {|k| sprintf('%0.3f%s',c[k],k)}.join(' + ') )
           
@@ -167,7 +181,8 @@ module Statsample
           cse=coeffs_se
           t=ReportBuilder::Table.new(:name=>"Beta coefficients", :header=>%w{coeff b beta se t}.collect{|field| _(field)} )
           
-          t.add_row([_("Constant"), sprintf("%0.3f", constant), "-", sprintf("%0.3f", constant_se), sprintf("%0.3f", constant_t)])
+            t.add_row([_("Constant"), sprintf("%0.3f", constant), "-", sprintf("%0.3f", constant_se), sprintf("%0.3f", constant_t)])
+          
           @fields.each do |f|
             t.add_row([f, sprintf("%0.3f", c[f]), sprintf("%0.3f", sc[f]), sprintf("%0.3f", cse[f]), sprintf("%0.3f", c[f].quo(cse[f]))])
           end  
@@ -184,22 +199,6 @@ module Statsample
           a
         end
 
-        # Deprecated
-        # Sum of squares of error (manual calculation)
-        # using the predicted value minus the y_i value
-        def sse_manual
-          pr=predicted
-          cases=0
-          sse=(0...@ds.cases).inject(0) {|a,i|
-          if !@dy.data_with_nils[i].nil? and !pr[i].nil?
-            cases+=1
-            a+((pr[i]-@dy[i])**2)
-          else
-            a
-          end
-          }
-          sse*(min_n_valid-1.0).quo(cases-1)
-        end
         # Sum of squares of regression
         # using the predicted value minus y mean
         def ssr_direct

data/lib/statsample/regression/multiple/matrixengine.rb

@@ -0,0 +1,187 @@
+module Statsample
+module Regression
+module Multiple
+  # Pure Ruby Class for Multiple Regression Analysis, based on a covariance or correlation matrix.
+  # <b>Remember:</b> NEVER use a Covariance data if you have missing data. Use only correlation matrix on that case.
+  #
+  # 
+  # Example:
+  #
+  #   matrix=[[1.0, 0.5, 0.2], [0.5, 1.0, 0.7], [0.2, 0.7, 1.0]]
+  #   
+  #   lr=Statsample::Regression::Multiple::MatrixEngine.new(matrix,2)
+
+class MatrixEngine < BaseEngine 
+  # Hash of standard deviation of predictors. 
+  # Only useful for Correlation Matrix, because by default is set to 1
+  attr_accessor :x_sd
+  # Standard deviation of criteria. 
+  # Only useful for Correlation Matrix, because by default is set to 1
+  
+  attr_accessor :y_sd
+  # Hash of mean for predictors. By default, set to 0
+  # 
+  attr_accessor :x_mean
+  
+  # Mean for criteria. By default, set to 0
+  # 
+  attr_accessor :y_mean
+  
+  # Number of cases
+  attr_writer :cases
+  
+  # Create object
+  #
+  def initialize(matrix,y_var, opts=Hash.new)
+    matrix.extend Statsample::CovariateMatrix
+    raise "#{y_var} variable should be on data" unless matrix.fields.include? y_var
+    
+    @matrix_cor=matrix.correlation
+    
+    @y_var=y_var
+    @fields=matrix.fields-[y_var]
+    @n_predictors=@fields.size
+    @matrix=matrix
+    @matrix_x= matrix.submatrix(@fields)
+    @matrix_y = matrix.submatrix(@fields, [y_var])
+    @matrix_y_cor=@matrix_cor.submatrix(@fields, [y_var])
+    @result_matrix=@matrix_x.inverse * @matrix_y
+    @y_sd=Math::sqrt(@matrix.submatrix([y_var])[0,0])
+    @x_sd=@matrix_x.row_size.times.inject({}) {|ac,i|
+      ac[@matrix_x.fields[i]]=Math::sqrt(@matrix_x[i,i])
+      ac;
+    }
+    @cases=nil
+    @x_mean=@fields.inject({}) {|ac,f|
+      ac[f]=0.0
+      ac;
+    }
+    
+    @y_mean=0.0
+    @name=_("Multiple reggresion of %s on %s") % [@fields.join(","), @y_var]
+    
+    
+    opts.each{|k,v|
+        self.send("#{k}=",v) if self.respond_to? k
+    }
+    if matrix.type==:covariance
+      @coeffs=@result_matrix.column(0).to_a
+      @coeffs_stan=coeffs.collect {|k,v|
+        coeffs[k]*@x_sd[k].quo(@y_sd)
+      }
+    else
+      @coeffs_stan=@result_matrix.column(0).to_a
+      
+      @coeffs=standarized_coeffs.collect {|k,v|
+        standarized_coeffs[k]*@y_sd.quo(@x_sd[k])
+      } 
+    end
+
+  end
+  def cases
+    raise "You should define the number of valid cases first" if @cases.nil?
+    @cases
+  end
+  # Get R^2 for the regression
+  # Equal to 
+  # * 1-(|R| / |R_x|) or
+  # * Sum(b_i*r_yi)
+  def r2
+    @n_predictors.times.inject(0) {|ac,i| ac+@coeffs_stan[i]* @matrix_y_cor[i,0]} 
+    #1-(@matrix.correlation.determinant.quo(@matrix_x.correlation.determinant))
+  end
+  def r
+    Math::sqrt(r2)
+  end
+  
+  def constant
+    c=coeffs
+    @y_mean - @fields.inject(0){|a,k| a + (c[k] * @x_mean[k])}
+  end
+  def coeffs
+    assign_names(@coeffs)    
+  end
+  def standarized_coeffs
+    assign_names(@coeffs_stan)
+  end
+  
+  def sst
+    @y_sd**2*(cases-1.0)
+  end
+  
+  # Degrees of freedom for regression
+  def df_r
+    @n_predictors
+  end
+  # Degrees of freedom for error
+  def df_e
+    cases-@n_predictors-1
+  end
+  
+  # Tolerance for a given variable
+  # defined as (1-r2) of regression of other independent variables
+  # over the selected
+  # http://talkstats.com/showthread.php?t=5056
+  def tolerance(var)
+    lr=Statsample::Regression::Multiple::MatrixEngine.new(@matrix_x, var)
+    1-lr.r2
+  end
+  # Standard Error for coefficients.
+  # Standard error of a coefficients depends on
+  # * Tolerance of the coeffients: Higher tolerances implies higher error
+  # * Higher r2 implies lower error
+  
+  # Reference: Cohen et al. (2003). Applied Multiple Reggression / Correlation Analysis for the Behavioral Sciences
+  #
+  def coeffs_se
+    out={}
+    mse=sse.quo(df_e)
+    coeffs.each {|k,v|
+      out[k]=@y_sd.quo(@x_sd[k])*Math::sqrt( 1.quo(tolerance(k)))*Math::sqrt((1-r2).quo(df_e))
+    }
+    out
+  end
+# Standard error for constant
+  def constant_se
+   nil
+  end
+  
+  def to_reportbuilder(generator)
+    anchor=generator.add_toc_entry(_("Multiple Regression: ")+@name)
+    generator.add_html "<div class='multiple-regression'>#{@name}<a name='#{anchor}'></a>"
+    c=coeffs
+    generator.add_text(_("Engine: %s") % self.class)
+    generator.add_text(_("Cases=%d") % [@cases])
+    generator.add_text("R=#{sprintf('%0.3f',r)}")
+    generator.add_text("R^2=#{sprintf('%0.3f',r2)}")
+    
+    generator.add_text(_("Equation")+"="+ sprintf('%0.3f',constant) +" + "+ @fields.collect {|k| sprintf('%0.3f%s',c[k],k)}.join(' + ') )
+    
+    t=ReportBuilder::Table.new(:name=>"ANOVA", :header=>%w{source ss df ms f s})
+    t.add_row([_("Regression"), sprintf("%0.3f",ssr), df_r, sprintf("%0.3f",msr), sprintf("%0.3f",f), sprintf("%0.3f", significance)])
+    t.add_row([_("Error"), sprintf("%0.3f",sse), df_e, sprintf("%0.3f",mse)])
+  
+    t.add_row([_("Total"), sprintf("%0.3f",sst), df_r+df_e])
+    generator.parse_element(t)
+    sc=standarized_coeffs
+    cse=coeffs_se
+    t=ReportBuilder::Table.new(:name=>"Beta coefficients", :header=>%w{coeff b beta se t}.collect{|field| _(field)} )
+    
+    if (constant_se.nil?)
+      t.add_row([_("Constant"), sprintf("%0.3f", constant),"--","?","?"])
+    else
+      t.add_row([_("Constant"), sprintf("%0.3f", constant), "-", sprintf("%0.3f", constant_se), sprintf("%0.3f", constant_t)])
+    end
+    
+    @fields.each do |f|
+      t.add_row([f, sprintf("%0.3f", c[f]), sprintf("%0.3f", sc[f]), sprintf("%0.3f", cse[f]), sprintf("%0.3f", c[f].quo(cse[f]))])
+    end  
+    generator.parse_element(t)
+    generator.add_html("</div>")
+  end
+  
+  
+end
+end
+end
+end

data/lib/statsample/regression/multiple/rubyengine.rb

@@ -15,119 +15,79 @@ module Multiple
 #   ds={'a'=>@a,'b'=>@b,'c'=>@c,'y'=>@y}.to_dataset
 #   lr=Statsample::Regression::Multiple::RubyEngine.new(ds,'y')
 
-class RubyEngine < BaseEngine 
+class RubyEngine < MatrixEngine
   def initialize(ds,y_var, opts=Hash.new)
-    super
+    matrix=Statsample::Bivariate.correlation_matrix(ds)
+    fields_indep=ds.fields-[y_var]
+    default={
+      :y_mean=>ds[y_var].mean,
+      :x_mean=>fields_indep.inject({}) {|ac,f|  ac[f]=ds[f].mean; ac},
+      :y_sd=>ds[y_var].sd,
+      :x_sd=>fields_indep.inject({}) {|ac,f|  ac[f]=ds[f].sd; ac},
+      :cases=>Statsample::Bivariate.min_n_valid(ds)
+    }
+    opts=opts.merge(default)
+    super(matrix, y_var, opts)
+    @ds=ds
     @dy=ds[@y_var]
     @ds_valid=ds.dup_only_valid
-    @ds_indep=ds.dup(ds.fields-[y_var])
-    @fields=@ds_indep.fields
+    @ds_indep = ds.dup(ds.fields-[y_var])
+    
+#    p obtain_predictor_matrix
+#    p @matrix_x.correlation
+    
     set_dep_columns
-    obtain_y_vector
-    @matrix_x = Bivariate.correlation_matrix(@ds_indep)
-    @coeffs_stan=(@matrix_x.inverse * @matrix_y).column(0).to_a
-    @min_n_valid=nil
-  end
-  def min_n_valid
-    if @min_n_valid.nil?
-      min=@ds.cases
-      m=Bivariate::n_valid_matrix(@ds)
-      for x in 0...m.row_size
-        for y in 0...m.column_size
-          min=m[x,y] if m[x,y] < min
-        end
-      end
-      @min_n_valid=min
-    end
-    @min_n_valid
   end
+  
   def set_dep_columns
     @dep_columns=[]
     @ds_indep.each_vector{|k,v|
       @dep_columns.push(v.data_with_nils)
     }                
   end
-    # Sum of square total
-  def sst
-    #if @sst.nil?
-    @sst=@dy.variance*(min_n_valid-1.0)
-    #end
-    @sst
-  end
-  def r2
-    if @r2.nil?
-      c=@matrix_y
-      rxx=obtain_predictor_matrix
-      matrix=(c.t*rxx.inverse*c)
-      @r2=matrix[0,0]
-    end
-    @r2
-  end
-    def r
-        Math::sqrt(r2)
-    end
 
-    def df_e
-        min_n_valid-@dep_columns.size-1
-    end
-    def fix_with_mean
-      i=0
-      @ds_indep.each do |row|
-        empty=[]
-        row.each do |k,v|
-          empty.push(k) if v.nil?
-        end
-        if empty.size==1
-          @ds_indep[empty[0]][i]=@ds[empty[0]].mean
-        end
-        i+=1
+  def fix_with_mean
+    i=0
+    @ds_indep.each do |row|
+      empty=[]
+      row.each do |k,v|
+        empty.push(k) if v.nil?
       end
-      @ds_indep.update_valid_data
-      set_dep_columns
+      if empty.size==1
+        @ds_indep[empty[0]][i]=@ds[empty[0]].mean
+      end
+      i+=1
     end
-    def fix_with_regression
-        i=0
-        @ds_indep.each{|row|
-            empty=[]
-            row.each{|k,v|
-                empty.push(k) if v.nil?
-            }
-            if empty.size==1
-                field=empty[0]
-                lr=MultipleRegression.new(@ds_indep,field)
-                fields=[]
-                @ds_indep.fields.each{|f|
-                    fields.push(row[f]) unless f==field
-                }
-                @ds_indep[field][i]=lr.process(fields)
-            end
-            i+=1
+    @ds_indep.update_valid_data
+    set_dep_columns
+  end
+  def fix_with_regression
+    i=0
+    @ds_indep.each{|row|
+      empty=[]
+      row.each{|k,v|
+          empty.push(k) if v.nil?
+      }
+      if empty.size==1
+        field=empty[0]
+        lr=MultipleRegression.new(@ds_indep,field)
+        fields=[]
+        @ds_indep.fields.each{|f|
+            fields.push(row[f]) unless f==field
         }
-        @ds_indep.update_valid_data
-        set_dep_columns
-    end
-    def obtain_y_vector
-        @matrix_y=Matrix.columns([@ds_indep.fields.collect{|f|
-                Bivariate.pearson(@dy, @ds_indep[f])
-        }])
-    end
-    def obtain_predictor_matrix
-        Bivariate::correlation_matrix(@ds_indep)
-    end
-    def constant
-        c=coeffs
-        @dy.mean-@fields.inject(0){|a,k| a+(c[k] * @ds_indep[k].mean)}
-    end
-   
-    def coeffs
-        sc=standarized_coeffs
-        assign_names(@fields.collect{|f|
-            (sc[f]*@dy.sds).quo(@ds_indep[f].sds)
-        })
-    end
-    def standarized_coeffs
-        assign_names(@coeffs_stan)
-    end
+        @ds_indep[field][i]=lr.process(fields)
+      end
+      i+=1
+    }
+    @ds_indep.update_valid_data
+    set_dep_columns
+  end
+  
+
+  # Standard error for constant
+  def constant_se
+    estimated_variance_covariance_matrix[0,0]
+  end
 end
 end
 end