statsample 0.5.1 → 0.6.0

data/lib/statsample/mle.rb

@@ -1,135 +1,134 @@
 module Statsample
-    # Module for MLE calculations.
-    # Use subclass of BaseMLE for specific MLE model estimation.
-    # Usage:
-    # 
-    #   mle=Statsample::MLE::Probit.new
-    #   mle.newton_raphson(x,y)
-    #   beta=mle.parameters
-    #   likehood=mle.likehood(x,y,beta)
-    #   iterations=mle.iterations
-    # 
-    module MLE
-        class BaseMLE
-        attr_accessor :verbose
-        attr_accessor :output
-        # Could be :parameters or :mle
-        attr_accessor :stop_criteria
-        # Variance - Covariance matrix
-        attr_reader :var_cov_matrix
-        # Iterations
-        attr_reader :iterations
-        # Parameters (beta coefficients)
-        attr_reader :parameters
-        ITERATIONS=100
-        MIN_DIFF=1e-5
-        MIN_DIFF_PARAMETERS=1e-2
-        # Model should be a MLE subclass
-        def initialize()
-            @verbose        = false
-            @output         = STDOUT
-            @stop_criteria  = :parameters
-            @var_cov_matrix = nil
-            @iterations     = nil
-            @parameters     = nil
+  # Module for MLE calculations.
+  # Use subclass of BaseMLE for specific MLE model estimation.
+  # Usage:
+  # 
+  #   mle=Statsample::MLE::Probit.new
+  #   mle.newton_raphson(x,y)
+  #   beta=mle.parameters
+  #   likehood=mle.likehood(x,y,beta)
+  #   iterations=mle.iterations
+  # 
+  module MLE
+      class BaseMLE
+      attr_accessor :verbose
+      attr_accessor :output
+      # Could be :parameters or :mle
+      attr_accessor :stop_criteria
+      # Variance - Covariance matrix
+      attr_reader :var_cov_matrix
+      # Iterations
+      attr_reader :iterations
+      # Parameters (beta coefficients)
+      attr_reader :parameters
+      ITERATIONS=100
+      MIN_DIFF=1e-5
+      MIN_DIFF_PARAMETERS=1e-2
+      # Model should be a MLE subclass
+      def initialize()
+        @verbose        = false
+        @output         = STDOUT
+        @stop_criteria  = :parameters
+        @var_cov_matrix = nil
+        @iterations     = nil
+        @parameters     = nil
+      end
+      # Calculate likehood for matrices x and y, given b parameters
+      def likehood(x,y,b)
+        prod=1
+        x.row_size.times{|i|
+          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
+      end
+      # Calculate log likehood for matrices x and y, given b parameters
+      def log_likehood(x,y,b)
+        sum=0
+        x.row_size.times{|i|
+          xi=Matrix.rows([x.row(i).to_a.collect{|v| v.to_f}])
+          y_val=y[i,0].to_f
+          sum+=log_likehood_i(xi,y_val,b)
+        }
+        sum
+      end
+      # Creates a zero matrix Mx1, with M=x.M
+      def set_default_parameters(x)
+        fd=[0.0]*x.column_size
+        fd.push(0.1)    if self.is_a? Statsample::MLE::Normal
+        parameters = Matrix.columns([fd])
+      end
+      
+      # Newton Raphson with automatic stopping criteria.
+      # Based on: Von Tessin, P. (2005). Maximum Likelihood Estimation With Java and Ruby
+      #
+      # <tt>x</tt>:: matrix of dependent variables. Should have nxk dimensions
+      # <tt>y</tt>:: matrix of independent values. Should have nx1 dimensions
+      # <tt>@m</tt>:: class for @ming. Could be Normal or Logit
+      # <tt>start_values</tt>:: matrix of coefficients. Should have 1xk dimensions
+      def newton_raphson(x,y, start_values=nil)
+        # deep copy?
+        if start_values.nil?
+            parameters=set_default_parameters(x)
+        else
+            parameters = start_values.dup
         end
-        # Calculate likehood for matrices x and y, given b parameters
-        def likehood(x,y,b)
-            prod=1
-            x.row_size.times{|i|
-                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
+        k=parameters.row_size
+        cv=Matrix.rows([([1.0]*k)])
+        last_diff=nil
+        raise "n on y != n on x" if x.row_size!=y.row_size
+        h=nil
+        fd=nil
+        if @stop_criteria==:mle
+            old_likehood=log_likehood(x, y, parameters)
+        else
+            old_parameters=parameters
         end
-        # Calculate log likehood for matrices x and y, given b parameters
-        def log_likehood(x,y,b)
-            sum=0
-            x.row_size.times{|i|
-                xi=Matrix.rows([x.row(i).to_a.collect{|v| v.to_f}])
-                y_val=y[i,0].to_f
-                sum+=log_likehood_i(xi,y_val,b)
-            }
-            sum
-        end
-        # Creates a zero matrix Mx1, with M=x.M
-        def set_default_parameters(x)
-            fd=[0.0]*x.column_size
-	    fd.push(0.1)    if self.is_a? Statsample::MLE::Normal
-            parameters = Matrix.columns([fd])
-        end
-        
-        # Newton Raphson with automatic stopping criteria.
-        # Based on: Von Tessin, P. (2005). Maximum Likelihood Estimation With Java and Ruby
-        #
-        # <tt>x</tt>:: matrix of dependent variables. Should have nxk dimensions
-        # <tt>y</tt>:: matrix of independent values. Should have nx1 dimensions
-        # <tt>@m</tt>:: class for @ming. Could be Normal or Logit
-        # <tt>start_values</tt>:: matrix of coefficients. Should have 1xk dimensions
-        def newton_raphson(x,y, start_values=nil)
-            # deep copy?
-            if start_values.nil?
-                parameters=set_default_parameters(x)
-            else
-                parameters = start_values.dup
+        ITERATIONS.times do |i|
+          @iterations=i+1
+          puts "Set #{i}" if @verbose
+          h = second_derivative(x,y,parameters)
+          if h.singular?
+            raise "Hessian is singular!"
+          end
+          fd = first_derivative(x,y,parameters)
+          parameters = parameters-(h.inverse*(fd))
+          
+          if @stop_criteria==:parameters
+          flag=true
+          k.times do |j|
+            diff= ( parameters[j,0] - old_parameters[j,0] ) / parameters[j,0]
+            flag=false if diff.abs >= MIN_DIFF_PARAMETERS
+            @output.puts "Parameters #{j}: #{diff}" if @verbose
+          end
+          if flag
+            @var_cov_matrix = h.inverse*-1.0
+            return parameters
+          end
+          old_parameters=parameters
+          else
+            begin
+              new_likehood = log_likehood(x,y,parameters)
+              @output.puts "[#{i}]Log-MLE:#{new_likehood} (Diff:#{(new_likehood-old_likehood) / new_likehood})" if @verbose
+              if(new_likehood < old_likehood) or ((new_likehood - old_likehood) / new_likehood).abs < MIN_DIFF
+                  @var_cov_matrix = h.inverse*-1.0
+              #@output.puts "Ok"
+                  break;
+              end
+              old_likehood=new_likehood
+            rescue =>e
+              puts "#{e}"
+              #puts "dup"
             end
-            k=parameters.row_size
-            cv=Matrix.rows([([1.0]*k)])
-            last_diff=nil
-            raise "n on y != n on x" if x.row_size!=y.row_size
-            h=nil
-            fd=nil
-            if @stop_criteria==:mle
-                old_likehood=log_likehood(x, y, parameters)
-            else
-                old_parameters=parameters
-            end
-            ITERATIONS.times do |i|
-                @iterations=i+1
-                puts "Set #{i}" if @verbose
-                h = second_derivative(x,y,parameters)
-                if h.singular?
-                    raise "Hessian is singular!"
-                end
-                fd = first_derivative(x,y,parameters)
-                parameters = parameters-(h.inverse*(fd))
-
-                if @stop_criteria==:parameters
-                    flag=true
-                    k.times do |j|
-                        diff= ( parameters[j,0] - old_parameters[j,0] ) / parameters[j,0]
-                        flag=false if diff.abs >= MIN_DIFF_PARAMETERS
-                        @output.puts "Parameters #{j}: #{diff}" if @verbose
-                    end
-
-                    if flag
-                        @var_cov_matrix = h.inverse*-1.0
-                        return parameters
-                    end
-                    old_parameters=parameters
-                else
-                    begin
-                        new_likehood = log_likehood(x,y,parameters)
-                        @output.puts "[#{i}]Log-MLE:#{new_likehood} (Diff:#{(new_likehood-old_likehood) / new_likehood})" if @verbose
-                        if(new_likehood < old_likehood) or ((new_likehood - old_likehood) / new_likehood).abs < MIN_DIFF
-                            @var_cov_matrix = h.inverse*-1.0
-                        #@output.puts "Ok"
-                            break;
-                        end
-                        old_likehood=new_likehood
-                    rescue =>e
-                        puts "#{e}"
-                        #puts "dup"
-                    end
-                end
-            end
-            @parameters=parameters
-            parameters
+          end
         end
+        @parameters=parameters
+        parameters
+      end
     end
-    end
+  end
 end
 
 require 'statsample/mle/normal'

data/lib/statsample/mle/logit.rb

@@ -1,95 +1,95 @@
 module Statsample
-    module MLE
-        # Logit MLE estimation.
-        # Usage:
-        # 
-        #   mle=Statsample::MLE::Logit.new
-        #   mle.newton_raphson(x,y)
-        #   beta=mle.parameters
-        #   likehood=mle.likehood(x,y,beta)
-        #   iterations=mle.iterations
-        #         
-        class Logit < BaseMLE
-        # F(B'Xi)
-        def f(b,xi)
-            p_bx=(xi*b)[0,0] 
-            res=(1.0/(1.0+Math::exp(-p_bx)))
-            if res==0.0
-                res=1e-15
-            elsif res==1.0
-                res=0.999999999999999
-            end
-            res
+  module MLE
+    # Logit MLE estimation.
+    # Usage:
+    # 
+    #   mle=Statsample::MLE::Logit.new
+    #   mle.newton_raphson(x,y)
+    #   beta=mle.parameters
+    #   likehood=mle.likehood(x,y,beta)
+    #   iterations=mle.iterations
+    #         
+    class Logit < BaseMLE
+    # F(B'Xi)
+    def f(b,xi)
+      p_bx=(xi*b)[0,0] 
+      res=(1.0/(1.0+Math::exp(-p_bx)))
+      if res==0.0
+          res=1e-15
+      elsif res==1.0
+          res=0.999999999999999
+      end
+      res
+    end
+    # Likehood for x_i vector, y_i scalar and b parameters
+    def likehood_i(xi,yi,b)
+      (f(b,xi)**yi)*((1-f(b,xi))**(1-yi))
+    end
+    # Log Likehood for x_i vector, y_i scalar and b parameters
+    def log_likehood_i(xi,yi,b)
+      fbx=f(b,xi)
+      (yi.to_f*Math::log(fbx))+((1.0-yi.to_f)*Math::log(1.0-fbx))
+    end
+    
+    # First derivative of log-likehood function
+    # x: Matrix (NxM)
+    # y: Matrix (Nx1)
+    # p: Matrix (Mx1)
+    def first_derivative(x,y,p)
+      raise "x.rows!=y.rows" if x.row_size!=y.row_size
+      raise "x.columns!=p.rows" if x.column_size!=p.row_size            
+      n = x.row_size
+      k = x.column_size
+      fd = Array.new(k)
+      k.times {|i| fd[i] = [0.0]}
+      n.times do |i|
+        row = x.row(i).to_a
+        value1 = (1-y[i,0]) -p_plus(row,p)
+      k.times do |j|
+        fd[j][0] -= value1*row[j]
         end
-        # Likehood for x_i vector, y_i scalar and b parameters
-        def likehood_i(xi,yi,b)
-            (f(b,xi)**yi)*((1-f(b,xi))**(1-yi))
+      end
+      Matrix.rows(fd, true)
+    
+    end
+    # Second derivative of log-likehood function
+    # x: Matrix (NxM)
+    # y: Matrix (Nx1)
+    # p: Matrix (Mx1)
+    def second_derivative(x,y,p)
+      raise "x.rows!=y.rows" if x.row_size!=y.row_size
+      raise "x.columns!=p.rows" if x.column_size!=p.row_size             
+      n = x.row_size
+      k = x.column_size
+      sd = Array.new(k)
+      k.times do |i|
+        arr = Array.new(k)
+        k.times{ |j| arr[j]=0.0}
+        sd[i] = arr
+      end
+      n.times do |i|
+        row = x.row(i).to_a
+        p_m = p_minus(row,p)
+        k.times do |j|
+          k.times do |l|
+          sd[j][l] -= p_m *(1-p_m)*row[j]*row[l]
+          end
         end
-        # Log Likehood for x_i vector, y_i scalar and b parameters
-        def log_likehood_i(xi,yi,b)
-            fbx=f(b,xi)
-            (yi.to_f*Math::log(fbx))+((1.0-yi.to_f)*Math::log(1.0-fbx))
-        end
-        
-        # First derivative of log-likehood function
-        # x: Matrix (NxM)
-        # y: Matrix (Nx1)
-        # p: Matrix (Mx1)
-        def first_derivative(x,y,p)
-                raise "x.rows!=y.rows" if x.row_size!=y.row_size
-                raise "x.columns!=p.rows" if x.column_size!=p.row_size            
-            n = x.row_size
-            k = x.column_size
-            fd = Array.new(k)
-            k.times {|i| fd[i] = [0.0]}
-            n.times do |i|
-	            row = x.row(i).to_a
-	            value1 = (1-y[i,0]) -p_plus(row,p)
-            k.times do |j|
-	            fd[j][0] -= value1*row[j]
-	            end
-            end
-            Matrix.rows(fd, true)
-
-        end
-        # Second derivative of log-likehood function
-        # x: Matrix (NxM)
-        # y: Matrix (Nx1)
-        # p: Matrix (Mx1)
-        def second_derivative(x,y,p)
-                raise "x.rows!=y.rows" if x.row_size!=y.row_size
-                raise "x.columns!=p.rows" if x.column_size!=p.row_size             
-            n = x.row_size
-            k = x.column_size
-            sd = Array.new(k)
-            k.times do |i|
-                arr = Array.new(k)
-                k.times{ |j| arr[j]=0.0}
-                sd[i] = arr
-            end
-            n.times do |i|
-                row = x.row(i).to_a
-                p_m = p_minus(row,p)
-                k.times do |j|
-                    k.times do |l|
-                    sd[j][l] -= p_m *(1-p_m)*row[j]*row[l]
-                    end
-                end
-            end
-            Matrix.rows(sd, true)
-        end
-        private
-        def p_minus(x_row,p)
-            value = 0.0;
-            x_row.each_index { |i| value += x_row[i]*p[i,0]}
-            1/(1+Math.exp(-value))
-        end
-        def p_plus(x_row,p)
-            value = 0.0;
-            x_row.each_index { |i| value += x_row[i]*p[i,0]}
-            1/(1+Math.exp(value))
-        end
-
-        end # Logit
-    end # MLE
+      end
+      Matrix.rows(sd, true)
+    end
+    private
+    def p_minus(x_row,p)
+      value = 0.0;
+      x_row.each_index { |i| value += x_row[i]*p[i,0]}
+      1/(1+Math.exp(-value))
+    end
+    def p_plus(x_row,p)
+      value = 0.0;
+      x_row.each_index { |i| value += x_row[i]*p[i,0]}
+      1/(1+Math.exp(value))
+    end
+    
+    end # Logit
+  end # MLE
 end # Statsample

data/lib/statsample/mle/probit.rb

@@ -1,93 +1,92 @@
 require 'matrix_extension'
 module Statsample
-    module MLE
-        # Probit MLE estimation.
-        # Usage:
-        # 
-        #   mle=Statsample::MLE::Probit.new
-        #   mle.newton_raphson(x,y)
-        #   beta=mle.parameters
-        #   likehood=mle.likehood(x,y,beta)
-        #   iterations=mle.iterations
-        class Probit < BaseMLE
+  module MLE
+    # Probit MLE estimation.
+    # Usage:
+    # 
+    #   mle=Statsample::MLE::Probit.new
+    #   mle.newton_raphson(x,y)
+    #   beta=mle.parameters
+    #   likehood=mle.likehood(x,y,beta)
+    #   iterations=mle.iterations
+    class Probit < BaseMLE
+      # F(B'Xi)
+      if  HAS_GSL
         # F(B'Xi)
-        if  HAS_GSL
-            # F(B'Xi)
-            def f(b,x)
-                p_bx=(x*b)[0,0] 
-                GSL::Cdf::ugaussian_P(p_bx)
-            end
-            # f(B'Xi)
-            def ff(b,x)
-                p_bx=(x*b)[0,0] 
-                GSL::Ran::ugaussian_pdf(p_bx)
-            end
-        else
-            def f(b,x) #:nodoc:
-                p_bx=(x*b)[0,0] 
-                Distribution::Normal.cdf(p_bx)
-            end
-            def ff(b,x) #:nodoc:
-                p_bx=(x*b)[0,0] 
-                Distribution::Normal.pdf(p_bx)
-                
-            end
+        def f(b,x)
+            p_bx=(x*b)[0,0] 
+            GSL::Cdf::ugaussian_P(p_bx)
+        end
+        # f(B'Xi)
+        def ff(b,x)
+            p_bx=(x*b)[0,0] 
+            GSL::Ran::ugaussian_pdf(p_bx)
+        end
+      else
+        def f(b,x) #:nodoc:
+            p_bx=(x*b)[0,0] 
+            Distribution::Normal.cdf(p_bx)
         end
-        # Log Likehood for x_i vector, y_i scalar and b parameters
-        def log_likehood_i(xi,yi,b)
-            fbx=f(b,xi)
-            (yi.to_f*Math::log(fbx))+((1.0-yi.to_f)*Math::log(1.0-fbx))
+        def ff(b,x) #:nodoc:
+            p_bx=(x*b)[0,0] 
+            Distribution::Normal.pdf(p_bx)
+        end
+      end
+      # Log Likehood for x_i vector, y_i scalar and b parameters
+      def log_likehood_i(xi,yi,b)
+        fbx=f(b,xi)
+        (yi.to_f*Math::log(fbx))+((1.0-yi.to_f)*Math::log(1.0-fbx))
+      end
+      # First derivative of log-likehood probit function
+      # x: Matrix (NxM)
+      # y: Matrix (Nx1)
+      # p: Matrix (Mx1)
+      def first_derivative(x,y,b)
+        raise "x.rows!=y.rows" if x.row_size!=y.row_size
+        raise "x.columns!=p.rows" if x.column_size!=b.row_size            
+        n = x.row_size
+        k = x.column_size
+        fd = Array.new(k)
+        k.times {|i| fd[i] = [0.0]}
+        n.times do |i|
+          xi = Matrix.rows([x.row(i).to_a])
+          fbx=f(b,xi)
+          value1 = (y[i,0]-fbx)/ ( fbx*(1-fbx))*ff(b,xi) 
+          k.times do |j|
+            fd[j][0] += value1*xi[0,j]
+          end
+        end
+        Matrix.rows(fd, true)
+      end
+      # Second derivative of log-likehood probit function
+      # x: Matrix (NxM)
+      # y: Matrix (Nx1)
+      # p: Matrix (Mx1)
+      
+      def second_derivative(x,y,b)
+        raise "x.rows!=y.rows" if x.row_size!=y.row_size
+        raise "x.columns!=p.rows" if x.column_size!=b.row_size
+        n = x.row_size
+        k = x.column_size
+        if HAS_GSL
+          sum=GSL::Matrix.zeros(k)
+        else
+          sum=Matrix.zero(k)
         end
-        # First derivative of log-likehood probit function
-        # x: Matrix (NxM)
-        # y: Matrix (Nx1)
-        # p: Matrix (Mx1)
-        def first_derivative(x,y,b)
-                raise "x.rows!=y.rows" if x.row_size!=y.row_size
-                raise "x.columns!=p.rows" if x.column_size!=b.row_size            
-            n = x.row_size
-            k = x.column_size
-            fd = Array.new(k)
-            k.times {|i| fd[i] = [0.0]}
-            n.times do |i|
-	            xi = Matrix.rows([x.row(i).to_a])
-	            fbx=f(b,xi)
-                value1 = (y[i,0]-fbx)/ ( fbx*(1-fbx))*ff(b,xi) 
-            k.times do |j|
-	            fd[j][0] += value1*xi[0,j]
-	            end
-            end
-            Matrix.rows(fd, true)
+        n.times do |i|
+          xi=Matrix.rows([x.row(i).to_a])
+          fbx=f(b,xi)
+          val=((ff(b,xi)**2) / (fbx*(1.0-fbx)))*xi.t*xi
+          if HAS_GSL
+            val=val.to_gsl
+          end
+          sum-=val
         end
-        # Second derivative of log-likehood probit function
-        # x: Matrix (NxM)
-        # y: Matrix (Nx1)
-        # p: Matrix (Mx1)
-
-        def second_derivative(x,y,b)
-            raise "x.rows!=y.rows" if x.row_size!=y.row_size
-            raise "x.columns!=p.rows" if x.column_size!=b.row_size
-            n = x.row_size
-            k = x.column_size
-            if HAS_GSL
-                sum=GSL::Matrix.zeros(k)
-            else
-                sum=Matrix.zero(k)
-            end
-            n.times do |i|
-                xi=Matrix.rows([x.row(i).to_a])
-                fbx=f(b,xi)
-                val=((ff(b,xi)**2) / (fbx*(1.0-fbx)))*xi.t*xi
-                if HAS_GSL
-                    val=val.to_gsl
-                end
-                sum-=val
-            end
-            if HAS_GSL
-                sum=sum.to_matrix
-            end
-            sum
+        if HAS_GSL
+          sum=sum.to_matrix
         end
-        end # Probit
-    end # MLE
+        sum
+      end
+    end # Probit
+  end # MLE
 end # Statsample