statsample 0.6.1 → 0.6.2

data/lib/statsample/mle.rb

@@ -10,7 +10,7 @@ module Statsample
   #   iterations=mle.iterations
   # 
   module MLE
-      class BaseMLE
+    class BaseMLE
       attr_accessor :verbose
       attr_accessor :output
       # Could be :parameters or :mle
@@ -40,7 +40,7 @@ module Statsample
           xi=Matrix.rows([x.row(i).to_a.collect{|v| v.to_f}])
           y_val=y[i,0].to_f
           fbx=f(b,x)
-          prod=prod*likehood_i(xi,y_val,b)
+          prod=prod*likehood_i(xi, y_val ,b)
         }
         prod
       end
@@ -54,6 +54,8 @@ module Statsample
         }
         sum
       end
+      
+      
       # Creates a zero matrix Mx1, with M=x.M
       def set_default_parameters(x)
         fd=[0.0]*x.column_size
@@ -82,9 +84,9 @@ module Statsample
         h=nil
         fd=nil
         if @stop_criteria==:mle
-            old_likehood=log_likehood(x, y, parameters)
+          old_likehood=log_likehood(x, y, parameters)
         else
-            old_parameters=parameters
+          old_parameters=parameters
         end
         ITERATIONS.times do |i|
           @iterations=i+1

data/lib/statsample/mle/probit.rb

@@ -1,4 +1,3 @@
-require 'matrix_extension'
 module Statsample
   module MLE
     # Probit MLE estimation.

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

@@ -17,29 +17,29 @@ module Multiple
 #   lr=Statsample::Regression::Multiple::AlglibEngine.new(ds,'y')
 #            
 class AlglibEngine < BaseEngine
-    def initialize(ds,y_var)
-        @ds=ds.dup_only_valid
-        @ds_valid=@ds
-        @y_var=y_var
-        @dy=@ds[@y_var]
-        @ds_indep=ds.dup(ds.fields-[y_var])
-        # Create a custom matrix
-        columns=[]
-        @fields=[]
-        @ds.fields.each{|f|
-            if f!=@y_var
-                columns.push(@ds[f].to_a)
-                @fields.push(f)
-            end
-        }
-        @dep_columns=columns.dup
-        columns.push(@ds[@y_var])
-        matrix=Matrix.columns(columns)
-        @lr_s=nil
-        @lr=::Alglib::LinearRegression.build_from_matrix(matrix)
-        @coeffs=assign_names(@lr.coeffs)
-        
-    end
+  def initialize(ds,y_var, opts=Hash.new)
+    super    
+    @ds=ds.dup_only_valid
+    @ds_valid=@ds
+    @dy=@ds[@y_var]
+    @ds_indep=ds.dup(ds.fields-[y_var])
+    # Create a custom matrix
+    columns=[]
+    @fields=[]
+    @ds.fields.each{|f|
+        if f!=@y_var
+            columns.push(@ds[f].to_a)
+            @fields.push(f)
+        end
+    }
+    @dep_columns=columns.dup
+    columns.push(@ds[@y_var])
+    matrix=Matrix.columns(columns)
+    @lr_s=nil
+    @lr=::Alglib::LinearRegression.build_from_matrix(matrix)
+    @coeffs=assign_names(@lr.coeffs)
+    
+  end
     
     def _dump(i)
         Marshal.dump({'ds'=>@ds,'y_var'=>@y_var})

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

@@ -3,188 +3,187 @@ module Statsample
     module Multiple
       # Base class for Multiple Regression Engines
       class BaseEngine
-        def initialize(ds,y_var)
-        @ds=ds
-        @y_var=y_var
-        @r2=nil
+        include GetText
+        bindtextdomain("statsample")
+        # Name of analysis
+        attr_accessor :name
+        def initialize(ds, y_var, opts = Hash.new)
+          @ds=ds
+          @y_var=y_var
+          @r2=nil
+          @name=_("Multiple Regression:  %s over %s") % [ ds.fields.join(",") , @y_var]
+          opts.each{|k,v|
+            self.send("#{k}=",v) if self.respond_to? k
+          }
         end
 
         # Retrieves a vector with predicted values for y
         def predicted
-        (0...@ds.cases).collect { |i|
-        invalid=false
-        vect=@dep_columns.collect {|v| invalid=true if v[i].nil?; v[i]}
-        if invalid
-        nil
-        else
-        process(vect)
-        end
-        }.to_vector(:scale)
+          (0...@ds.cases).collect { |i|
+          invalid=false
+          vect=@dep_columns.collect {|v| invalid=true if v[i].nil?; v[i]}
+          if invalid
+            nil
+          else
+            process(vect)
+          end
+          }.to_vector(:scale)
         end
         # Retrieves a vector with standarized values for y
         def standarized_predicted
-        predicted.standarized
+          predicted.standarized
         end
         # Retrieves a vector with residuals values for y
         def residuals
-        (0...@ds.cases).collect{|i|
-        invalid=false
-        vect=@dep_columns.collect{|v| invalid=true if v[i].nil?; v[i]}
-        if invalid or @ds[@y_var][i].nil?
-        nil
-        else
-        @ds[@y_var][i] - process(vect)
-        end
-        }.to_vector(:scale)
+          (0...@ds.cases).collect{|i|
+            invalid=false
+            vect=@dep_columns.collect{|v| invalid=true if v[i].nil?; v[i]}
+            if invalid or @ds[@y_var][i].nil?
+              nil
+            else
+              @ds[@y_var][i] - process(vect)
+            end
+          }.to_vector(:scale)
         end
         # R Multiple
         def r
-        raise "You should implement this"
+          raise "You should implement this"
         end
         # Sum of squares Total
         def sst
-        raise "You should implement this"
+          raise "You should implement this"
         end
         # Sum of squares (regression)
         def ssr
-        r2*sst
+          r2*sst
         end
         # Sum of squares (Error)
         def sse
-        sst - ssr
+          sst - ssr
         end
         # T values for coeffs
         def coeffs_t
-        out={}
-        se=coeffs_se
-        coeffs.each{|k,v|
-        out[k]=v / se[k]
-        }
-        out
+          out={}
+          se=coeffs_se
+          coeffs.each do |k,v|
+            out[k]=v / se[k]
+          end
+          out
         end
         # Mean square Regression
         def msr
-        ssr.quo(df_r)
+          ssr.quo(df_r)
         end
         # Mean Square Error
         def mse
-        sse.quo(df_e)
+          sse.quo(df_e)
         end
         # Degrees of freedom for regression
         def df_r
-        @dep_columns.size
+          @dep_columns.size
         end
         # Degrees of freedom for error
         def df_e
-        @ds_valid.cases-@dep_columns.size-1
+          @ds_valid.cases-@dep_columns.size-1
         end
         # Fisher for Anova
         def f
-        (ssr.quo(df_r)).quo(sse.quo(df_e))
+          (ssr.quo(df_r)).quo(sse.quo(df_e))
         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)
         end
         # Tolerance for a given variable
         # http://talkstats.com/showthread.php?t=5056
         def tolerance(var)
-        ds=assign_names(@dep_columns)
-        ds.each{|k,v|
-        ds[k]=v.to_vector(:scale)
-        }
-        lr=Multiple.listwise(ds.to_dataset,var)
-        1-lr.r2
+          ds=assign_names(@dep_columns)
+          ds.each{|k,v|
+          ds[k]=v.to_vector(:scale)
+          }
+          lr=Multiple.listwise(ds.to_dataset,var)
+          1-lr.r2
         end
         # Tolerances for each coefficient
         def coeffs_tolerances
-        @fields.inject({}) {|a,f|
-        a[f]=tolerance(f);
-        a
-        }
+          @fields.inject({}) {|a,f|
+          a[f]=tolerance(f);
+            a
+          }
         end
         # Standard Error for coefficients
         def coeffs_se
-        out={}
-        mse=sse.quo(df_e)
-        coeffs.each {|k,v|
-        out[k]=Math::sqrt(mse/(@ds[k].sum_of_squares*tolerance(k)))
-        }
-        out
+          out={}
+          mse=sse.quo(df_e)
+          coeffs.each {|k,v|
+            out[k]=Math::sqrt(mse/(@ds[k].sum_of_squares*tolerance(k)))
+          }
+          out
         end
         # Estimated Variance-Covariance Matrix
         # Used for calculation of se of constant
         def estimated_variance_covariance_matrix
-        mse_p=mse
-        columns=[]
-        @ds_valid.each_vector{|k,v|
-        columns.push(v.data) unless k==@y_var
-        }
-        columns.unshift([1.0]*@ds_valid.cases)
-        x=Matrix.columns(columns)
-        matrix=((x.t*x)).inverse * mse
-        matrix.collect {|i|
-        Math::sqrt(i) if i>0
-        }
+          mse_p=mse
+          columns=[]
+          @ds_valid.each_vector{|k,v|
+            columns.push(v.data) unless k==@y_var
+          }
+          columns.unshift([1.0]*@ds_valid.cases)
+          x=Matrix.columns(columns)
+          matrix=((x.t*x)).inverse * mse
+          matrix.collect {|i| Math::sqrt(i) if i>0 }
         end
         # T for constant
         def constant_t
-        constant.to_f/constant_se
+          constant.to_f/constant_se
         end
         # Standard error for constant
         def constant_se
-        estimated_variance_covariance_matrix[0,0]
-        end
-        # Retrieves a summary for Regression
-        def summary(report_type=ConsoleSummary)
-        c=coeffs
-        out=""
-        out.extend report_type
-        out.add <<-HEREDOC
-Summary for regression of #{@fields.join(',')} over #{@y_var}
-*************************************************************
-Engine: #{self.class}
-Cases(listwise)=#{@ds.cases}(#{@ds_valid.cases})
-r=#{sprintf("%0.3f",r)}
-r2=#{sprintf("%0.3f",r2)}
-Equation=#{sprintf("%0.3f",constant)}+#{@fields.collect {|k| sprintf("%0.3f%s",c[k],k)}.join(' + ')}
-HEREDOC
-
-        out.add_line
-        out.add "ANOVA TABLE"
-
-        t=Statsample::ReportTable.new(%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])
-
-        out.parse_table(t)
-
-        begin
-        out.add "Beta coefficientes"
-        sc=standarized_coeffs
-        cse=coeffs_se
-        t=Statsample::ReportTable.new(%w{coeff b beta se t})
-        t.add_row(["Constant", sprintf("%0.3f", constant), "-", sprintf("%0.3f", constant_se), sprintf("%0.3f", constant_t)])
-        @fields.each{|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]))])
-        }
-        out.parse_table(t)
-
-        rescue
+          estimated_variance_covariance_matrix[0,0]
         end
-        out
+        def summary
+          rp=ReportBuilder.new()
+          rp.add(self)
+          rp.to_text
         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(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(_("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)} )
+          
+          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  
+          generator.parse_element(t)
+          generator.add_html("</div>")
+        end
+        
+        
         def assign_names(c)
           a={}
           @fields.each_index {|i|
-          a[@fields[i]]=c[i]
+            a[@fields[i]]=c[i]
           }
           a
         end
 
-
         # Deprecated
         # Sum of squares of error (manual calculation)
         # using the predicted value minus the y_i value
@@ -193,10 +192,10 @@ HEREDOC
           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)
+            cases+=1
+            a+((pr[i]-@dy[i])**2)
           else
-          a
+            a
           end
           }
           sse*(min_n_valid-1.0).quo(cases-1)

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

@@ -17,105 +17,102 @@ module Multiple
 #   lr=Statsample::Regression::Multiple::GslEngine.new(ds,'y')
 #            
 class GslEngine < BaseEngine
-    def initialize(ds,y_var)
-        @ds=ds.dup_only_valid
-        @ds_valid=@ds
-        @y_var=y_var
-        @dy=@ds[@y_var]
-        @ds_indep=ds.dup(ds.fields-[y_var])
-        # Create a custom matrix
-        columns=[]
-        @fields=[]
-        max_deps = GSL::Matrix.alloc(@ds.cases, @ds.fields.size)
-        constant_col=@ds.fields.size-1
-        for i in 0...@ds.cases
-            max_deps.set(i,constant_col,1)
-        end
-        j=0
-        @ds.fields.each{|f|
-            if f!=@y_var
-                @ds[f].each_index{|i1|
-                    max_deps.set(i1,j,@ds[f][i1])
-                }
-                columns.push(@ds[f].to_a)
-                @fields.push(f)
-                j+=1
-            end
-        }
-        @dep_columns=columns.dup
-        @lr_s=nil
-        c, @cov, @chisq, @status = GSL::MultiFit.linear(max_deps, @dy.gsl)
-        @constant=c[constant_col]
-        @coeffs_a=c.to_a.slice(0...constant_col)
-        @coeffs=assign_names(@coeffs_a)
-        c=nil
-    end
-    
-    def _dump(i)
-        Marshal.dump({'ds'=>@ds,'y_var'=>@y_var})
-    end
-    def self._load(data)
-        h=Marshal.load(data)
-        self.new(h['ds'], h['y_var'])
-    end
-    
-    def coeffs
-        @coeffs
-    end
-    # Coefficients using a constant
-    # Based on http://www.xycoon.com/ols1.htm
-    def matrix_resolution
-        mse_p=mse
-        columns=@dep_columns.dup.map {|xi| xi.map{|i| i.to_f}}
-        columns.unshift([1.0]*@ds.cases)
-        y=Matrix.columns([@dy.data.map  {|i| i.to_f}])
-        x=Matrix.columns(columns)
-        xt=x.t
-        matrix=((xt*x)).inverse*xt
-        matrix*y
-    end
-    def r2
-        r**2
+  def initialize(ds,y_var, opts=Hash.new)
+    super
+    @ds=ds.dup_only_valid
+    @ds_valid=@ds
+    @dy=@ds[@y_var]
+    @ds_indep=ds.dup(ds.fields-[y_var])
+    # Create a custom matrix
+    columns=[]
+    @fields=[]
+    max_deps = GSL::Matrix.alloc(@ds.cases, @ds.fields.size)
+    constant_col=@ds.fields.size-1
+    for i in 0...@ds.cases
+        max_deps.set(i,constant_col,1)
     end
-    def r
-        Bivariate::pearson(@dy, predicted)
-    end  
-    def sst
-        @dy.ss
-    end
-    def constant
-        @constant
-    end
-    def standarized_coeffs
-        l=lr_s
-        l.coeffs
-    end
-    def lr_s
-        if @lr_s.nil?
-            build_standarized
+    j=0
+    @ds.fields.each{|f|
+        if f!=@y_var
+            @ds[f].each_index{|i1|
+                max_deps.set(i1,j,@ds[f][i1])
+            }
+            columns.push(@ds[f].to_a)
+            @fields.push(f)
+            j+=1
         end
-        @lr_s
-    end
-    def build_standarized
-        @ds_s=@ds.standarize
-        @lr_s=GslEngine.new(@ds_s,@y_var)
-    end
-    def process_s(v)
-        lr_s.process(v)
-    end
-    # ???? Not equal to SPSS output
-    def standarized_residuals
-        res=residuals
-        red_sd=residuals.sds
-        res.collect {|v|
-            v.quo(red_sd)
-        }.to_vector(:scale)
+    }
+    @dep_columns=columns.dup
+    @lr_s=nil
+    c, @cov, @chisq, @status = GSL::MultiFit.linear(max_deps, @dy.gsl)
+    @constant=c[constant_col]
+    @coeffs_a=c.to_a.slice(0...constant_col)
+    @coeffs=assign_names(@coeffs_a)
+    c=nil
+  end
+    
+  def _dump(i)
+    Marshal.dump({'ds'=>@ds,'y_var'=>@y_var})
+  end
+  def self._load(data)
+    h=Marshal.load(data)
+    self.new(h['ds'], h['y_var'])
+  end
+  
+  def coeffs
+    @coeffs
+  end
+  # Coefficients using a constant
+  # Based on http://www.xycoon.com/ols1.htm
+  def matrix_resolution
+    mse_p=mse
+    columns=@dep_columns.dup.map {|xi| xi.map{|i| i.to_f}}
+    columns.unshift([1.0]*@ds.cases)
+    y=Matrix.columns([@dy.data.map  {|i| i.to_f}])
+    x=Matrix.columns(columns)
+    xt=x.t
+    matrix=((xt*x)).inverse*xt
+    matrix*y
+  end
+  def r2
+    r**2
+  end
+  def r
+    Bivariate::pearson(@dy, predicted)
+  end  
+  def sst
+    @dy.ss
+  end
+  def constant
+    @constant
+  end
+  def standarized_coeffs
+    l=lr_s
+    l.coeffs
+  end
+  def lr_s
+    if @lr_s.nil?
+        build_standarized
     end
+    @lr_s
+  end
+  def build_standarized
+    @ds_s=@ds.standarize
+    @lr_s=GslEngine.new(@ds_s,@y_var)
+  end
+  def process_s(v)
+    lr_s.process(v)
+  end
+  # ???? Not equal to SPSS output
+  def standarized_residuals
+    res=residuals
+    red_sd=residuals.sds
+    res.collect {|v|
+        v.quo(red_sd)
+    }.to_vector(:scale)
+  end
 end
 end
 end
 end # for Statsample
 end # for if
-
-        
-