statsample 0.11.2 → 0.12.0

data.tar.gz.sig

@@ -1,2 +1 @@
-��2�>Pfrg�*}�1���=�1�B�xQ*2���m��yН�:�qW3W�n�/��y�K��Ub)�4�KU�ާ>�B2�q����K�|Z�=V8؎���ݕҕ⹳:<��	R�K��
-�VW��}�5�j�}�i������$�RR�U�����^c�B�Ҽ�^h��>*���������@�����QhR��Τ�v��[��W3�\���]{!��\P��J��M�D�,�Hq-��b��%g�{U5
+�HG��@��^��uH�

data/History.txt

@@ -1,3 +1,14 @@
+=== 0.12.0 / 2010-06-09
+
+* Modified Rakefile to remove dependencies based on C extensions. These are moved to statsample-optimization
+* T test with unequal variance fixed on i686
+* API Change: Renamed Reliability::ItemAnalysis and moved to independent file 
+* New Reliability::MultiScaleAnalysis for easy analysis of scales on a same survey, includind reliability, correlation matrix and Factor Analysis
+* Updated README to reflect changes on Reliability module
+* SvgGraph works with reportbuilder. 
+* Added methods on Polychoric based on Olsson(1979): the idea is estimate using second derivatives.
+* Distribution test changed (reduced precision on 32 bits system
+
 === 0.11.2 / 2010-05-05
 * Updated dependency for 'extendedmatrix' to 0.2 (Matrix#build method)
 

data/Manifest.txt

@@ -10,6 +10,7 @@ data/repeated_fields.csv
 data/test_binomial.csv
 data/tetmat_matrix.txt
 data/tetmat_test.txt
+doc_latex/manual/equations.tex
 examples/correlation_matrix.rb
 examples/dataset.rb
 examples/dominance_analysis.rb
@@ -30,6 +31,7 @@ lib/distribution/chisquare.rb
 lib/distribution/f.rb
 lib/distribution/normal.rb
 lib/distribution/normalbivariate.rb
+lib/distribution/normalmultivariate.rb
 lib/distribution/t.rb
 lib/spss.rb
 lib/statsample.rb
@@ -79,6 +81,8 @@ lib/statsample/regression/multiple/matrixengine.rb
 lib/statsample/regression/multiple/rubyengine.rb
 lib/statsample/regression/simple.rb
 lib/statsample/reliability.rb
+lib/statsample/reliability/multiscaleanalysis.rb
+lib/statsample/reliability/scaleanalysis.rb
 lib/statsample/resample.rb
 lib/statsample/srs.rb
 lib/statsample/test.rb

data/README.txt

@@ -15,6 +15,7 @@ Include:
 * Tests: F, T, Levene, U-Mannwhitney.
 * Regression: Simple, Multiple (OLS), Probit  and Logit
 * Factorial Analysis: Extraction (PCA and Principal Axis), Rotation (Varimax, Equimax, Quartimax) and Parallel Analysis, for estimation of number of factors.
+* Reliability analysis for simple scale and helpers to analyze multiple scales using factor analysis and correlations
 * Dominance Analysis, with multivariate dependent and bootstrap (Azen & Budescu)
 * Sample calculation related formulas
 * Creates reports on text, html and rtf, using ReportBuilder gem
@@ -50,7 +51,9 @@ Include:
   * Statsample::Mx    : Write Mx Files
   * Statsample::GGobi : Write Ggobi files
 * Module Statsample::Crosstab provides function to create crosstab for categorical data
-* Reliability analysis provides functions to analyze scales. Class ItemAnalysis provides statistics like mean, standard deviation for a scale, Cronbach's alpha and standarized Cronbach's alpha, and for each item: mean, correlation with total scale, mean if deleted, Cronbach's alpha is deleted. With HtmlReport, graph the histogram of the scale and the Item Characteristic Curve for each item
+* Module Statsample::Reliability provides functions to analyze scales. 
+  * Class ScaleAnalysis provides statistics like mean, standard deviation for a scale, Cronbach's alpha and standarized Cronbach's alpha, and for each item: mean, correlation with total scale, mean if deleted, Cronbach's alpha is deleted.
+  * Class MultiScaleAnalysis provides a DSL to easily analyze reliability of multiple scales and retrieve correlation matrix and factor analysis of them.
 * Module Statsample::SRS (Simple Random Sampling) provides a lot of functions to estimate standard error for several type of samples
 * Module Statsample::Test provides several methods and classes to perform inferencial statistics
   * Statsample::Test::Levene
@@ -104,16 +107,22 @@ Optional:
 
 * Source code on github: http://github.com/clbustos/statsample
 * API: http://ruby-statsample.rubyforge.org/statsample/
-* Bug report and feature request: http://code.google.com/p/ruby-statsample/issues/list
+* Bug report and feature request: http://github.com/clbustos/statsample/issues
 
 
 == INSTALL:
 
-  sudo gem install ruby-statsample
+  $ sudo gem install statsample
+
+On *nix, you should install statsample-optimization to retrieve gems gsl, statistics2 and a C extension to speed some methods. 
+
+  $sudo gem install statsample-optimization
+
+To use it, on Ubuntu I recommend install build-essential and libgsl0-dev using apt-get and compile ruby 1.8 or 1.9 from source code.
+
+  $sudo apt-get install build-essential libgsl0-dev
 
-For optimization on *nix env
 
-  sudo gem install gsl ruby-statsample-optimization
 
 Available setup.rb file
 

data/Rakefile

@@ -5,7 +5,8 @@ $:.unshift(File.dirname(__FILE__)+'/lib/')
 
 require 'rubygems'
 require 'hoe'
-require './lib/statsample'
+require 'statsample'
+
 Hoe.plugin :git
 
 desc "Ruby Lint"
@@ -39,8 +40,28 @@ h=Hoe.spec('statsample') do
   #self.testlib=:minitest
 	self.rubyforge_name = "ruby-statsample"
 	self.developer('Claudio Bustos', 'clbustos@gmail.com')
-	self.extra_deps << ["spreadsheet","~>0.6.0"] << ["svg-graph", "~>1.0"] << ["reportbuilder", "~>1.0"] << ["minimization", "~>0.2.0"] << ["fastercsv"] << ["dirty-memoize", "~>0.0"] << ["statistics2", "~>0.54"] << ["extendmatrix","~>0.2.0"] << ["gsl", "~>1.12.109"]
-	self.clean_globs << "test/images/*" << "demo/item_analysis/*" << "demo/Regression"
+	self.extra_deps << ["spreadsheet","~>0.6.0"] << ["svg-graph", "~>1.0"] << ["reportbuilder", "~>1.0"] << ["minimization", "~>0.2.0"] << ["fastercsv"] << ["dirty-memoize", "~>0.0"] << ["extendmatrix","~>0.2.0"]
+	self.extra_dev_deps << ["shoulda"]
+  self.clean_globs << "test/images/*" << "demo/item_analysis/*" << "demo/Regression"
+  self.post_install_message = <<-EOF
+***************************************************
+Thanks for installing statsample.
+
+On *nix, you should install statsample-optimization
+to retrieve gems gsl, statistics2 and a C extension
+to speed some methods.
+
+  $sudo gem install statsample-optimization
+
+To use it, on Ubuntu I recommend install 
+build-essential and libgsl0-dev using apt-get and 
+compile ruby 1.8 or 1.9 from source code first.
+
+  $sudo apt-get install build-essential libgsl0-dev
+
+
+*****************************************************
+  EOF
 	self.need_rdoc=false
 end
 

data/doc_latex/manual/equations.tex

@@ -0,0 +1,78 @@
+\part{Equations}
+\section{Convention}
+\begin{align*}
+n &= \text{sample size}\\
+N &= \text{population size}\\
+p &= \text{proportion inside a sample}\\
+P &= \text{proportion inside a population}
+\end{align*}
+\section{Ruby::Regression::Multiple}
+
+To compute the standard error of coefficients, you obtain the estimated variance-covariance matrix of error.
+
+Let \mathbf{X} be matrix of predictors data, including a constant column; \mathbf{MSE} as mean square error; SSE as Sum of squares of errors; n the number of cases; p as number of predictors
+
+\begin{equation}
+\mathbf{MSE}=\frac{SSE}{n-p-1}
+\end{equation}
+
+\begin{equation}
+\mathbf{E}=(\mathbf{X'}\mathbf{X})^-1\mathbf{MSE}
+\end{equation}
+
+The root squares of diagonal should be standard errors
+
+
+\section{Ruby::SRS}
+Finite Poblation correction is used on standard error calculation on poblation below 10.000. Function 
+\begin{verbatim}
+fpc_var(sam,pop)
+\end{verbatim}
+calculate FPC for variance with
+\begin{equation}
+fpc_{var} = \frac{N-n} {N-1}
+\end{equation}
+
+with n  as sam and N as pop
+
+Function 
+\begin{verbatim}
+fpc = fpc(sam,pop)
+\end{verbatim}
+
+calculate FPC for standard deviation with 
+\begin{equation}
+fpc_{sd} = \sqrt{\frac{N-n} {N-1}}
+\label{fpc}
+\end{equation}
+with n  as sample size and N as population size.
+
+\subsection{Sample Size estimation for proportions}
+
+On infinite poblations, you should use method
+\begin{verbatim}
+estimation_n0(d,prop,margin=0.95)
+\end{verbatim}
+which uses
+\begin{equation}
+n = \frac{t^2(pq)}{d^2}
+\label{n_i}
+\end{equation}
+where
+\begin{align*}
+t &= \text{t value for given level of confidence ( 1.96 for 95\% )}\\
+d &= \text{margin of error}
+\end{align*}
+
+On finite poblations, you should use
+\begin{verbatim}
+estimation_n(d,prop,n_pobl, margin=0.95)
+\end{verbatim}
+which uses
+\begin{equation}
+n = \frac{n_i}{1+(\frac{n_i-1}{N})}
+\end{equation}
+
+Where $n_i$ is n on \ref{n_i} and N is population size
+
+

data/examples/reliability.rb

@@ -8,5 +8,5 @@ ds=Statsample::Dataset.new
         ds["v#{i}"]=a.collect {|v| v+rand(20)}.to_scale
 end
 ds.update_valid_data
-rel=Statsample::Reliability::ItemAnalysis.new(ds)
+rel=Statsample::Reliability::ScaleAnalysis.new(ds)
 puts rel.summary

data/lib/distribution.rb

@@ -1,4 +1,8 @@
-require 'statistics2'
+begin
+    require 'statistics2'
+rescue LoadError
+        puts "You should install statistics2"
+end
 # Several distributions modules to calculate cdf, inverse cdf and pdf
 # See Distribution::Pdf for interface.
 # 

data/lib/distribution/normalbivariate.rb

@@ -15,7 +15,13 @@ module Distribution
     class << self
       SIDE=0.1 # :nodoc:
       LIMIT=5 # :nodoc:
-      
+      # Return the partial derivative of cdf over x, with y and rho constant
+      # Reference:
+      # * Tallis, 1962, p.346, cited by Olsson, 1979
+      def partial_derivative_cdf_x(x,y,rho)
+        Distribution::Normal.pdf(x) * Distribution::Normal.cdf((y-rho*x).quo( Math::sqrt( 1 - rho**2 )))
+      end
+      alias  :pd_cdf_x  :partial_derivative_cdf_x 
       # Probability density function for a given x, y and rho value.
       # 
       # Source: http://en.wikipedia.org/wiki/Multivariate_normal_distribution

data/lib/distribution/normalmultivariate.rb

@@ -0,0 +1,73 @@
+module Distribution
+    # Calculate cdf and inverse cdf for Multivariate Distribution.
+    module NormalMultivariate
+      class << self
+        # Returns multivariate cdf distribution
+        # * a is the array of lower values
+        # * b is the array of higher values
+        # * s is an symmetric positive definite covariance matrix
+        def cdf(aa,bb,sigma, epsilon=0.0001, alpha=2.5, max_iterations=100) # :nodoc:
+          raise "Doesn't work yet"
+          a=[nil]+aa
+          b=[nil]+bb
+          m=aa.size
+          sigma=sigma.to_gsl if sigma.respond_to? :to_gsl
+          
+          cc=GSL::Linalg::Cholesky.decomp(sigma)
+          c=cc.lower
+          intsum=0
+          varsum=0
+          n=0
+          d=Array.new(m+1,nil)
+          e=Array.new(m+1,nil)
+          f=Array.new(m+1,nil)
+          (1..m).each {|i|
+            d[i]=0.0 if a[i].nil?
+            e[i]=1.0 if b[i].nil?
+          }
+          d[1]=uPhi(a[1].quo( c[0,0])) unless d[1]==0
+          e[1]=uPhi(b[1].quo( c[0,0])) unless e[1]==1
+          f[1]=e[1]-d[1]
+
+          error=1000
+          begin 
+            w=(m+1).times.collect {|i| rand*epsilon}
+            y=[]
+            (2..m).each do |i|
+              y[i-1]=iPhi(d[i-1] + w[i-1] * (e[i-1] - d[i-1]))
+              sumc=0
+              (1..(i-1)).each do |j|
+                sumc+=c[i-1, j-1]*y[j]
+              end
+              
+              if a[i]!=nil
+                d[i]=uPhi((a[i]-sumc).quo(c[i-1,i-1]))
+              end
+             # puts "sumc:#{sumc}"
+              
+              if b[i]!=nil
+                #puts "e[#{i}] :#{c[i-1,i-1]}"
+                e[i]=uPhi((b[i]-sumc).quo(c[i-1, i-1]))
+              end
+              f[i]=(e[i]-d[i])*f[i-1]
+            end
+            intsum+=intsum+f[m]
+            varsum=varsum+f[m]**2
+            n+=1
+            error=alpha*Math::sqrt((varsum.quo(n) - (intsum.quo(n))**2).quo(n))
+            end while(error>epsilon and n<max_iterations)
+          
+            f=intsum.quo(n)
+          #p intsum
+          #puts "f:#{f}, n:#{n}, error:#{error}"
+          f
+        end
+        def iPhi(pr)
+          Distribution::Normal.p_value(pr)
+        end
+        def uPhi(x)
+          Distribution::Normal.cdf(x)
+        end
+      end
+    end
+end

data/lib/distribution/t.rb

@@ -1,3 +1,4 @@
+require 'rbconfig'
 module Distribution
 
     # Calculate cdf and inverse cdf for T Distribution.
@@ -15,8 +16,40 @@ module Distribution
             # with n degrees of freedom over (-Infty, x].
             # 
             def cdf(x,k)
-                Statistics2.tdist(k, x)
+                if RbConfig::CONFIG['arch']=~/i686/
+		tdist(k, x)
+		else
+		Statistics2.tdist(k,x)
+		end
             end
+              
+            # Returns the integral of t-distribution with n degrees of freedom over (-Infty, x].
+            def tdist(n, t)
+              p_t(n, t)
+            end
+            
+            # t-distribution ([1])
+            # (-\infty, x]
+            def p_t(df, t)
+              c2 = df.to_f / (df + t * t);
+              s = Math.sqrt(1.0 - c2)
+              s = -s if t < 0.0
+              p = 0.0;
+              i = df % 2 + 2
+              while i <= df
+                p += s
+                s *= (i - 1) * c2 / i
+                i += 2
+              end
+              if df.is_a? Float or df & 1 != 0
+                0.5+(p*Math.sqrt(c2)+Math.atan(t/Math.sqrt(df)))/Math::PI
+              else
+                (1.0 + p) / 2.0
+              end
+            end  
+              
+              
+              
         end
     end
 end

data/lib/statsample.rb

@@ -23,6 +23,7 @@ require 'matrix'
 require 'distribution'
 require 'dirty-memoize'
 require 'reportbuilder'
+
 class Numeric
   def square ; self * self ; end
 end
@@ -111,7 +112,7 @@ module Statsample
       false
     end
   end
-  VERSION = '0.11.2'
+  VERSION = '0.12.0'
   SPLIT_TOKEN = ","
   autoload(:Database, 'statsample/converters')
   autoload(:Anova, 'statsample/anova')

data/lib/statsample/anova/twoway.rb

@@ -175,7 +175,7 @@ module Statsample
         df_b=_q-1
         df_within=(_p*_q)*(n-1)
         
-        opts_default={:name=>_("Anova Two-Way on #{@ds[dep_var].name}"), 
+        opts_default={:name=>_("Anova Two-Way on %s") % @ds[dep_var].name, 
           :name_a=>@ds[a_var].name,
             :name_b=>@ds[b_var].name,
             :summary_descriptives=>true,

data/lib/statsample/bivariate/polychoric.rb

@@ -75,6 +75,65 @@ module Statsample
     # * Drasgow F. (2006). Polychoric and polyserial correlations. In Kotz L, Johnson NL (Eds.), Encyclopedia of statistical sciences. Vol. 7 (pp. 69-74). New York: Wiley.
     
     class Polychoric
+
+      class Processor
+        attr_reader :alpha, :beta, :rho
+        def initialize(alpha,beta,rho)
+          @alpha=alpha
+          @beta=beta
+          @nr=@alpha.size+1
+          @nc=@beta.size+1
+          @rho=rho
+          @pd=nil
+        end
+        def bipdf(i,j)
+           Distribution::NormalBivariate.pdf(a(i), b(j), rho)
+        end
+        def a(i)
+          i < 0 ? -100 : (i==@nr-1 ? 100 : alpha[i])
+        end
+        def b(j)
+          j < 0 ? -100 : (j==@nc-1 ? 100 : beta[j])
+        end
+        # Equation(10) from Olsson(1979)
+        def fd_loglike_cell_a(i,j,k)
+          if k==i
+            Distribution::NormalBivariate.pd_cdf_x(a(k),b(j), rho) - Distribution::NormalBivariate.pd_cdf_x(a(k),b(j-1),rho)
+          elsif k==(i-1)
+            -Distribution::NormalBivariate.pd_cdf_x(a(k),b(j),rho) + Distribution::NormalBivariate.pd_cdf_x(a(k),b(j-1),rho)
+          else
+            0
+          end
+          
+        end
+        # phi_ij for each i and j
+        # Uses equation(4) from Olsson(1979)
+        def pd
+          if @pd.nil?
+            @pd=@nr.times.collect{ [0] * @nc}
+            pc=@nr.times.collect{ [0] * @nc}
+            @nr.times do |i|
+            @nc.times do |j|
+             
+              if i==@nr-1 and j==@nc-1
+                @pd[i][j]=1.0
+              else
+                a=(i==@nr-1) ? 100: alpha[i]
+                b=(j==@nc-1) ? 100: beta[j]
+                #puts "a:#{a} b:#{b}"
+                @pd[i][j]=Distribution::NormalBivariate.cdf(a, b, rho)
+              end
+              pc[i][j] = @pd[i][j]
+              @pd[i][j] = @pd[i][j] - pc[i-1][j] if i>0
+              @pd[i][j] = @pd[i][j] - pc[i][j-1] if j>0
+              @pd[i][j] = @pd[i][j] + pc[i-1][j-1] if (i>0 and j>0)
+            end
+            end
+          end
+          @pd
+        end
+      end
+      
       include GetText
       include DirtyMemoize
       bindtextdomain("statsample")
@@ -145,6 +204,7 @@ module Statsample
           self.send("#{k}=",v) if self.respond_to? k
         }
         @r=nil
+        @pd=nil
         compute_basic_parameters
       end
       # Returns the polychoric correlation
@@ -174,7 +234,7 @@ module Statsample
           raise "Not implemented"
         end
       end
-      
+      # Retrieve log likehood for actual data.
       def loglike_data
         loglike=0
         @nr.times do |i|
@@ -188,97 +248,147 @@ module Statsample
         end
         loglike
       end
+      
+      # Chi Square of model
       def chi_square
         if @loglike_model.nil?
           compute
         end
         -2*(@loglike_model-loglike_data)
       end
+      
       def chi_square_df
         (@nr*@nc)-@nc-@nr
       end
-      
-      def loglike_fd_rho(alpha,beta,rho)
-        if rho.abs>0.9999
-          rho= (rho>0) ? 0.9999 : -0.9999
-        end
-         #puts "rho: #{rho}"
-        
-        loglike=0
-        pd=@nr.times.collect{ [0]*@nc}
-        pc=@nr.times.collect{ [0]*@nc}
-        @nr.times { |i|
-          @nc.times { |j|
+
+
+
+
+      # Retrieve all cell probabilities for givens alpha, beta and rho
+      def cell_probabilities(alpha,beta,rho)
+        pd=@nr.times.collect{ [0] * @nc}
+        pc=@nr.times.collect{ [0] * @nc}
+        @nr.times do |i|
+          @nc.times do |j|
+           
             if i==@nr-1 and j==@nc-1
               pd[i][j]=1.0
-              a=100
-              b=100
             else
               a=(i==@nr-1) ? 100: alpha[i]
               b=(j==@nc-1) ? 100: beta[j]
+              #puts "a:#{a} b:#{b}"
               pd[i][j]=Distribution::NormalBivariate.cdf(a, b, rho)
             end
             pc[i][j] = pd[i][j]
             pd[i][j] = pd[i][j] - pc[i-1][j] if i>0
             pd[i][j] = pd[i][j] - pc[i][j-1] if j>0
             pd[i][j] = pd[i][j] + pc[i-1][j-1] if (i>0 and j>0)
-            
-            pij= pd[i][j]+EPSILON
-            if i==0
-              alpha_m1=-10
-            else
-              alpha_m1=alpha[i-1]
-            end
-            
-            if j==0
-              beta_m1=-10
-            else
-              beta_m1=beta[j-1]
-            end
-            
-            loglike+= (@matrix[i,j].quo(pij))*(Distribution::NormalBivariate.pdf(a,b,rho) - Distribution::NormalBivariate.pdf(alpha_m1, b,rho) - Distribution::NormalBivariate.pdf(a, beta_m1,rho) + Distribution::NormalBivariate.pdf(alpha_m1, beta_m1,rho) )
-            
-          }
-        }
-        #puts "derivative: #{loglike}"
-        -loglike
+          end
+        end
+        @pd=pd
+        pd
       end
       def loglike(alpha,beta,rho)
         if rho.abs>0.9999
           rho= (rho>0) ? 0.9999 : -0.9999
         end
-        
+        pr=Processor.new(alpha,beta,rho)
         loglike=0
-        pd=@nr.times.collect{ [0]*@nc}
-        pc=@nr.times.collect{ [0]*@nc}
-        @nr.times { |i|
-          @nc.times { |j|
-            #puts "i:#{i} | j:#{j}"
-            if i==@nr-1 and j==@nc-1
-              pd[i][j]=1.0
-            else
-              a=(i==@nr-1) ? 100: alpha[i]
-              b=(j==@nc-1) ? 100: beta[j]
-              #puts "a:#{a} b:#{b}"
-              pd[i][j]=Distribution::NormalBivariate.cdf(a, b, rho)
-              
-            end
-            pc[i][j] = pd[i][j]
-            pd[i][j] = pd[i][j] - pc[i-1][j] if i>0
-            pd[i][j] = pd[i][j] - pc[i][j-1] if j>0
-            pd[i][j] = pd[i][j] + pc[i-1][j-1] if (i>0 and j>0)
-            res= pd[i][j]
-             #puts "i:#{i} | j:#{j} | ac: #{sprintf("%0.4f", pc[i][j])} | pd: #{sprintf("%0.4f", pd[i][j])} | res:#{sprintf("%0.4f", res)}"
-          if (res<=0)
-           #    puts "Correccion"
-            res=1e-16
-          end
+
+        
+        @nr.times do |i|
+          @nc.times do |j|
+            res=pr.pd[i][j]+EPSILON
             loglike+= @matrix[i,j]  * Math::log( res )
-          }
-        }
-        @pd=pd
+          end
+        end
         -loglike
       end
+      # First derivate for rho
+      # Uses equation (9) from Olsson(1979)
+      def fd_loglike_rho(alpha,beta,rho)
+        if rho.abs>0.9999
+          rho= (rho>0) ? 0.9999 : -0.9999
+        end
+        total=0
+        pr=Processor.new(alpha,beta,rho)
+        @nr.times do |i|
+          @nc.times do |j|
+            pi=pr.pd[i][j] + EPSILON
+            total+= (@matrix[i,j] / pi)  * (pr.bipdf(i,j)-pr.bipdf(i-1,j)-pr.bipdf(i,j-1)+pr.bipdf(i-1,j-1))  
+          end
+        end
+        total
+      end
+      
+      # First derivative for alpha_k
+      def fd_loglike_a(alpha,beta,rho,k)
+        fd_loglike_a_eq6(alpha,beta,rho,k)
+      end
+      # Uses equation (6) from Olsson(1979)
+      def fd_loglike_a_eq6(alpha,beta,rho,k)
+        if rho.abs>0.9999
+          rho= (rho>0) ? 0.9999 : -0.9999
+        end
+        pr=Processor.new(alpha,beta,rho)
+        total=0
+        pd=pr.pd
+        @nr.times do |i|
+          @nc.times  do |j|
+            total+=@matrix[i,j].quo(pd[i][j]+EPSILON) * pr.fd_loglike_cell_a(i,j,k)
+          end
+        end
+        total
+      end
+      # Uses equation(13) from Olsson(1979)
+      def fd_loglike_a_eq13(alpha,beta,rho,k)
+        if rho.abs>0.9999
+          rho= (rho>0) ? 0.9999 : -0.9999
+        end
+        pr=Processor.new(alpha,beta,rho)
+        total=0
+        a_k=pr.a(k)
+        pd=pr.pd
+        @nc.times do |j|
+          #puts "j: #{j}"
+          #puts "b #{j} : #{b.call(j)}"
+          #puts "b #{j-1} : #{b.call(j-1)}"
+
+          e_1=@matrix[k,j].quo(pd[k][j]+EPSILON) - @matrix[k+1,j].quo(pd[k+1][j]+EPSILON)
+          e_2=Distribution::Normal.pdf(a_k)
+          e_3=Distribution::Normal.cdf((pr.b(j)-rho*a_k).quo(Math::sqrt(1-rho**2))) - Distribution::Normal.cdf((pr.b(j-1)-rho*a_k).quo(Math::sqrt(1-rho**2)))
+          #puts "val #{j}: #{e_1} | #{e_2} | #{e_3}"
+          
+          total+= e_1*e_2*e_3
+        end
+        total
+      end
+      # First derivative for beta_m
+      # Uses equation(14) from Olsson(1979)
+      def fd_loglike_b(alpha,beta,rho,m)
+        if rho.abs>0.9999
+          rho= (rho>0) ? 0.9999 : -0.9999
+        end
+        pr=Processor.new(alpha,beta,rho)
+        total=0
+        b_m=pr.b m
+        pd=pr.pd
+        @nr.times do |i|
+          #puts "j: #{j}"
+          #puts "b #{j} : #{b.call(j)}"
+          #puts "b #{j-1} : #{b.call(j-1)}"
+
+          e_1=@matrix[i,m].quo(pd[i][m]+EPSILON) - @matrix[i,m+1].quo(pd[i][m+1]+EPSILON)
+          e_2=Distribution::Normal.pdf(b_m)
+          e_3=Distribution::Normal.cdf((pr.a(i)-rho*b_m).quo(Math::sqrt(1-rho**2))) - Distribution::Normal.cdf((pr.a(i-1)-rho*b_m).quo(Math::sqrt(1-rho**2)))
+          #puts "val #{j}: #{e_1} | #{e_2} | #{e_3}"
+          
+          total+= e_1*e_2*e_3
+        end
+        total
+      end
+      
+      
       def compute_basic_parameters
         @nr=@matrix.row_size
         @nc=@matrix.column_size
@@ -333,7 +443,7 @@ module Statsample
       
       def compute_two_step_mle_drasgow_ruby #:nodoc:
         
-        f=proc {|rho| 
+        f=proc {|rho|
           loglike(@alpha,@beta, rho)
         }
         @log="Minimizing using GSL Brent method\n"
@@ -351,9 +461,9 @@ module Statsample
       
       def compute_two_step_mle_drasgow_gsl #:nodoc:
         
-        fn1=GSL::Function.alloc {|rho| 
-          loglike(@alpha,@beta, rho)
-        }
+      fn1=GSL::Function.alloc {|rho| 
+        loglike(@alpha,@beta, rho)
+      }
       @iteration = 0
       max_iter = @max_iterations
       m = 0             # initial guess
@@ -405,8 +515,19 @@ module Statsample
         parameters=[rho]+cut_alpha+cut_beta
         minimization = Proc.new { |v, params|
          rho=v[0]
-         alpha=v[1,@nr-1]
-         beta=v[@nr,@nc-1]
+         alpha=v[1, @nr-1]
+         beta=v[@nr, @nc-1]
+         
+         #puts "f'rho=#{fd_loglike_rho(alpha,beta,rho)}"
+         #(@nr-1).times {|k|
+         #  puts "f'a(#{k}) = #{fd_loglike_a(alpha,beta,rho,k)}"         
+         #  puts "f'a(#{k}) v2 = #{fd_loglike_a2(alpha,beta,rho,k)}"         
+         #
+         #}
+         #(@nc-1).times {|k|
+         #  puts "f'b(#{k}) = #{fd_loglike_b(alpha,beta,rho,k)}"         
+         #}
+         
          loglike(alpha,beta,rho)
         }
         np=@nc-1+@nr