statsample 0.5.1 → 0.6.0

data/lib/statsample/multiset.rb

@@ -263,7 +263,7 @@ module Statsample
                 s_size=@strata_sizes[s_name]
                 (s_size**2 * (1-(nh/s_size)) * prop * (1-prop) / (nh -1 ))
             }
-            (1/@population_size.to_f) * Math::sqrt(sum)
+            (1.quo(@population_size)) * Math::sqrt(sum)
         end
         # Cochran(1971), p. 150 
         def variance_pst(field,v=1)

data/lib/statsample/permutation.rb

@@ -0,0 +1,96 @@
+module Statsample
+  # Permutation class systematically generates all permutations 
+  # of elements on an array, using Dijkstra algorithm (1997).
+  #
+  # As argument, you could use 
+  # * Number of elements: an array with numbers from 0 to n-1 will be used
+  # * Array: if ordered, you obtain permutations on lexicographic order
+  #          you can repeat elements, if you will.
+  #  
+  #  Use:
+  #  perm=Statsample::Permutation.new(3)
+  #  perm.permutations
+  #  => [[0,1,2],[0,2,1],[1,0,2],[1,2,0],[2,0,1],[2,1,0]]
+  #  perm=Statsample::Permutation.new([0,0,1,1])
+  #  => [[0,0,1,1],[0,1,0,1],[0,1,1,0],[1,0,0,1],[1,0,1,0],[1,1,0,0]]
+  #
+  # Reference: http://www.cut-the-knot.org/do_you_know/AllPerm.shtml
+  class Permutation
+    attr_reader :permutation_number
+    def initialize(v)
+      if v.is_a? Numeric
+        @original=(0...v.to_i).to_a
+        @permutation_number=factorial(v)
+      else
+        @original=v
+        calculate_max_iterations_from_array
+      end
+      @n=@original.size
+      reset
+    end
+    def calculate_max_iterations_from_array
+      if @original.respond_to? :frequencies
+        freq=@original.frequencies
+      else
+        freq=@original.to_vector.frequencies
+      end
+      if freq.length==@original.size
+        @permutation_number=factorial(@original.size)
+      else
+        numerator=factorial(@original.size)
+        denominator=freq.inject(1) {|a,v|
+          a*factorial(v[1])
+        }
+        @permutation_number=numerator/denominator
+      end
+    end
+    def factorial (n)
+      (1..n).inject(1){|a,v| a*v}
+    end
+    def reset
+      @iterations=0
+      @data=@original.dup
+    end
+    def each
+      reset
+      @permutation_number.times do
+        yield next_value
+      end
+    end
+    def permutations
+      a=Array.new
+      each {|c| a.push(c)}
+      a
+    end
+    def next_value
+      prev=@data.dup
+      i = @n-1
+      while @data[i-1] >= @data[i]
+        #return false if i<0 
+        i=i-1
+      end
+      j=@n
+      while @data[j-1] <= @data[i-1]
+        j=j-1
+      end
+      # swap values at positions (i-1) and (j-1)
+      swap(i-1, j-1);    
+      
+      i+=1
+      j = @n
+      
+      while (i < j)
+        swap(i-1, j-1);
+        i+=1;
+        j-=1;
+        sprintf("%d %d",i,j)
+      end
+      prev
+    end
+    def swap(i,j)
+      tmp=@data[i]
+      @data[i]=@data[j]
+      @data[j]=tmp
+    end
+  end
+end

data/lib/statsample/regression.rb

@@ -8,7 +8,7 @@ require 'statsample/regression/binomial/logit'
 require 'statsample/regression/binomial/probit'
 
 module Statsample
-    # Module for regression procedures 
+    # Module for regression procedures.
     module Regression
     end
 end

data/lib/statsample/regression/binomial.rb

@@ -1,91 +1,91 @@
-
 module Statsample
-    module Regression
-        module Binomial
-            # Create a Logit model object.
-            # ds:: Dataset
-            # y::  Name of dependent vector
-            # Use
-            #   dataset=Statsample::CSV.read("data.csv")
-            #   y="y" 
-            #   lr=Statsample::Regression::Binomial.logit(dataset,y)
-            #   
-            def self.logit(ds,y_var)
-                Logit.new(ds,y_var)                
-            end
-            # Create a Probit model object.
-            # ds:: Dataset
-            # y::  Name of dependent vector
-            # Use
-            #   dataset=Statsample::CSV.read("data.csv")
-            #   y="y" 
-            #   lr=Statsample::Regression::Binomial.probit(dataset,y)
-            #   
-            
-            def self.probit(ds,y_var)
-                Probit.new(ds,y_var)                
-            end
-            # Base Engine for binomial regression analysis.
-            # See Statsample::Regression::Binomial.logit() and
-            # Statsample::Regression::Binomial.probit for fast
-            # access methods.
-            # 
-            # Use:
-            #   dataset=Statsample::CSV.read("data.csv")
-            #   y="y" 
-            #   model=Statsample::MLE::Logit.new
-            #   lr=Statsample::Regression::Binomial::BaseEngine(dataset, y, model)
-         class BaseEngine
-             attr_reader :log_likehood, :iterations
-            def initialize(ds,y_var,model)
-                @ds=ds
-                @y_var=y_var
-                @dy=@ds[@y_var]
-                @ds_indep=ds.dup(ds.fields-[y_var])
-                constant=([1.0]*ds.cases).to_vector(:scale)
-                @ds_indep.add_vector("_constant",constant)
-                mat_x=@ds_indep.to_matrix
-                mat_y=@dy.to_matrix(:vertical)
-                @fields=@ds_indep.fields
-                @model=model
-                coeffs=model.newton_raphson(mat_x, mat_y)
-                @coeffs=assign_names(coeffs.column(0).to_a)
-                @iterations=model.iterations
-                @var_cov_matrix=model.var_cov_matrix
-                @log_likehood=model.log_likehood(mat_x, mat_y, coeffs)
-                end # init
-                # Coefficients standard error
-                def coeffs_se
-                    out={}
-                    @fields.each_index{|i|
-                        f=@fields[i]
-                        out[f]=Math::sqrt(@var_cov_matrix[i,i])
-                    }
-                    out.delete("_constant")
-                    out
-                end
-                def constant
-                    @coeffs['_constant']
-                end
-                def coeffs
-                    c=@coeffs.dup
-                    c.delete("_constant")
-                    c
-                end
-                # Constant standard error
-                def constant_se
-                    i=@fields.index :_constant
-                    Math::sqrt(@var_cov_matrix[i,i])
-                end
-                def assign_names(c)
-                    a={}
-                    @fields.each_index {|i|
-                        a[@fields[i]]=c[i]
-                    }
-                    a
-                end
-            end # Base Engine
-            
-        end # Dichotomic
-    end # Regression
+  module Regression
+    module Binomial
+      # Create a Logit model object.
+      # ds:: Dataset
+      # y::  Name of dependent vector
+      # Use
+      #   dataset=Statsample::CSV.read("data.csv")
+      #   y="y" 
+      #   lr=Statsample::Regression::Binomial.logit(dataset,y)
+      #   
+      def self.logit(ds,y_var)
+        Logit.new(ds,y_var)                
+      end
+      # Create a Probit model object.
+      # ds:: Dataset
+      # y::  Name of dependent vector
+      # Use
+      #   dataset=Statsample::CSV.read("data.csv")
+      #   y="y" 
+      #   lr=Statsample::Regression::Binomial.probit(dataset,y)
+      #   
+      
+      def self.probit(ds,y_var)
+        Probit.new(ds,y_var)                
+      end
+      # Base Engine for binomial regression analysis.
+      # See Statsample::Regression::Binomial.logit() and
+      # Statsample::Regression::Binomial.probit for fast
+      # access methods.
+      # 
+      # Use:
+      #   dataset=Statsample::CSV.read("data.csv")
+      #   y="y" 
+      #   model=Statsample::MLE::Logit.new
+      #   lr=Statsample::Regression::Binomial::BaseEngine(dataset, y, model)
+    class BaseEngine
+      attr_reader :log_likehood, :iterations
+      def initialize(ds,y_var,model)
+      @ds=ds
+      @y_var=y_var
+      @dy=@ds[@y_var]
+      @ds_indep=ds.dup(ds.fields-[y_var])
+      constant=([1.0]*ds.cases).to_vector(:scale)
+      @ds_indep.add_vector("_constant",constant)
+      mat_x=@ds_indep.to_matrix
+      mat_y=@dy.to_matrix(:vertical)
+      @fields=@ds_indep.fields
+      @model=model
+      coeffs=model.newton_raphson(mat_x, mat_y)
+      @coeffs=assign_names(coeffs.column(0).to_a)
+      @iterations=model.iterations
+      @var_cov_matrix=model.var_cov_matrix
+      @log_likehood=model.log_likehood(mat_x, mat_y, coeffs)
+      end # init
+      # Coefficients standard error
+      def coeffs_se
+        out={}
+        @fields.each_index{|i|
+            f=@fields[i]
+            out[f]=Math::sqrt(@var_cov_matrix[i,i])
+        }
+        out.delete("_constant")
+        out
+      end
+      # Constant value
+      def constant
+        @coeffs['_constant']
+      end
+      # Regression coefficients
+      def coeffs
+        c=@coeffs.dup
+        c.delete("_constant")
+        c
+      end
+      # Constant standard error
+      def constant_se
+        i=@fields.index :_constant
+        Math::sqrt(@var_cov_matrix[i,i])
+      end
+      def assign_names(c)
+        a={}
+        @fields.each_index do |i|
+          a[@fields[i]]=c[i]
+        end
+        a
+      end
+      end # Base Engine
+    end # Dichotomic
+  end # Regression
 end # Stasample

data/lib/statsample/regression/binomial/logit.rb

@@ -1,13 +1,13 @@
 module Statsample
-    module Regression
-        module Binomial
-            # Logistic Regression
-            class Logit < BaseEngine
-                def initialize(ds,y_var)
-                    model=Statsample::MLE::Logit.new
-                    super(ds,y_var,model)
-                end
-            end
+  module Regression
+    module Binomial
+      # Logistic Regression
+      class Logit < BaseEngine
+        def initialize(ds,y_var)
+            model=Statsample::MLE::Logit.new
+            super(ds,y_var,model)
         end
+      end
     end
+  end
 end

data/lib/statsample/regression/binomial/probit.rb

@@ -1,13 +1,13 @@
 module Statsample
-    module Regression
-        module Binomial
-            # Logistic Regression
-            class Probit < BaseEngine
-                def initialize(ds,y_var)
-                    model=Statsample::MLE::Probit.new
-                    super(ds,y_var,model)
-                end
-            end
+  module Regression
+    module Binomial
+      # Logistic Regression
+      class Probit < BaseEngine
+        def initialize(ds,y_var)
+          model=Statsample::MLE::Probit.new
+          super(ds,y_var,model)
         end
+      end
     end
+  end
 end

data/lib/statsample/regression/multiple.rb

@@ -1,8 +1,10 @@
 require 'statsample/regression/multiple/baseengine'
 module Statsample
   module Regression
-    # Module for Linear Multiple Regression Analysis
-    # You can call Regression::Multiple.listwise or Regression::Multiple.pairwise or instance directly the engines
+    # Module for Linear Multiple Regression Analysis.
+    # 
+    # You can call Regression::Multiple.listwise or Regression::Multiple.pairwise or instance directly the engines.
+    # 
     # Example.
     #
     #  require 'statsample'
@@ -37,18 +39,10 @@ module Statsample
         def self.listwise_by_exp(ds,exp)
           raise "Not implemented yet"
         end
-        # Returns a dataset and name of criteria using a expression.
-        # All nominal vectors are replaced by dummy coding
-        # and interactions are calculated
-        
-        def self.ds_by_exp(ds,exp)
-          raise "Not implemented"
-          parts=exp.split(/[\+=]/)
-          dependent=parts.pop
-          ds_out=[]
-          parts.each{|p|
-          
-          }
+        # Obtain r2 for regressors
+        def self.r2_from_matrices(rxx,rxy)
+          matrix=(rxy.transpose*rxx.inverse*rxy)
+          matrix[0,0]
         end
         
     end

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

@@ -78,7 +78,7 @@ class GslEngine < BaseEngine
         r**2
     end
     def r
-        Bivariate::pearson(@dy,predicted)
+        Bivariate::pearson(@dy, predicted)
     end  
     def sst
         @dy.ss

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

@@ -16,53 +16,53 @@ module Multiple
 #   lr=Statsample::Regression::Multiple::RubyEngine.new(ds,'y')
 
 class RubyEngine < BaseEngine 
-    def initialize(ds,y_var)
+  def initialize(ds,y_var)
     super
-        @dy=ds[@y_var]
-        @ds_valid=ds.dup_only_valid
-        @ds_indep=ds.dup(ds.fields-[y_var])
-        @fields=@ds_indep.fields
-        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
+    @dy=ds[@y_var]
+    @ds_valid=ds.dup_only_valid
+    @ds_indep=ds.dup(ds.fields-[y_var])
+    @fields=@ds_indep.fields
+    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
-        @min_n_valid
-    end
-    def set_dep_columns
-        @dep_columns=[]
-        @ds_indep.each_vector{|k,v|
-            @dep_columns.push(v.data_with_nils)
-        }                
+      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
+  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
@@ -71,19 +71,19 @@ class RubyEngine < BaseEngine
         min_n_valid-@dep_columns.size-1
     end
     def fix_with_mean
-        i=0
-        @ds_indep.each{|row|
-            empty=[]
-            row.each{|k,v|
-                empty.push(k) if v.nil?
-            }
-            if empty.size==1
-                @ds_indep[empty[0]][i]=@ds[empty[0]].mean
-            end
-            i+=1
-        }
-        @ds_indep.update_valid_data
-        set_dep_columns
+      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
+      end
+      @ds_indep.update_valid_data
+      set_dep_columns
     end
     def fix_with_regression
         i=0