statsample 0.6.1 → 0.6.2

data/History.txt

@@ -1,3 +1,7 @@
+=== 0.6.2 / 2010-02-11
+* New Statsample::Bivariate::Polychoric. For implement: X2 and G2
+* New matrix.rb, for faster development of Contingence Tables and Correlation Matrix
+
 === 0.6.1 / 2010-02-08
 * Bug fix on DominanceAnalysis summary for Ruby1.9
 * Some extra documentation

data/Manifest.txt

@@ -9,35 +9,23 @@ data/repeated_fields.csv
 data/test_binomial.csv
 data/tetmat_matrix.txt
 data/tetmat_test.txt
-demo/benchmark.rb
-demo/chi-square.rb
-demo/crosstab.rb
-demo/dice.rb
-demo/distribution_t.rb
-demo/graph.rb
-demo/item_analysis.rb
-demo/mean.rb
-demo/nunnally_6.rb
-demo/pca.rb
-demo/proportion.rb
-demo/regression.rb
-demo/sample_test.csv
-demo/spss_matrix.rb
-demo/strata_proportion.rb
-demo/stratum.rb
-demo/t-student.rb
-demo/umann.rb
+demo/dominance_analysis_bootstrap.rb
+demo/dominanceanalysis.rb
+demo/multiple_regression.rb
+demo/polychoric.rb
+demo/tetrachoric.rb
 lib/distribution.rb
 lib/distribution/chisquare.rb
 lib/distribution/f.rb
 lib/distribution/normal.rb
+lib/distribution/normalbivariate.rb
 lib/distribution/t.rb
-lib/matrix_extension.rb
 lib/spss.rb
 lib/statistics2.rb
 lib/statsample.rb
 lib/statsample/anova.rb
 lib/statsample/bivariate.rb
+lib/statsample/bivariate/polychoric.rb
 lib/statsample/bivariate/tetrachoric.rb
 lib/statsample/codification.rb
 lib/statsample/combination.rb
@@ -60,6 +48,7 @@ lib/statsample/graph/svghistogram.rb
 lib/statsample/graph/svgscatterplot.rb
 lib/statsample/histogram.rb
 lib/statsample/htmlreport.rb
+lib/statsample/matrix.rb
 lib/statsample/mle.rb
 lib/statsample/mle/logit.rb
 lib/statsample/mle/normal.rb

data/demo/dominance_analysis_bootstrap.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib/')
+require 'statsample'
+
+
+a=100.times.collect {rand}.to_scale
+b=100.times.collect {rand}.to_scale
+c=100.times.collect {rand}.to_scale
+d=100.times.collect {rand}.to_scale
+
+ds={'a'=>a,'b'=>b,'c'=>c,'d'=>d}.to_dataset
+
+ds['y']=ds.collect{|row| row['a']*5+row['b']*2+row['c']*2+row['d']*2+10*rand()}
+dab=Statsample::DominanceAnalysis::Bootstrap.new(ds, 'y')
+if HAS_GSL
+  # Use Gsl if available (faster calculation)
+  dab.regression_class=Statsample::Regression::Multiple::GslEngine
+end
+dab.bootstrap(100,nil,true)
+puts dab.summary

data/demo/dominanceanalysis.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib/')
+
+require 'statsample'
+a=1000.times.collect {rand}.to_scale
+b=1000.times.collect {rand}.to_scale
+c=1000.times.collect {rand}.to_scale
+ds={'a'=>a,'b'=>b,'c'=>c}.to_dataset
+ds['y']=ds.collect{|row| row['a']*5+row['b']*3+row['c']*2+rand()}
+da=Statsample::DominanceAnalysis.new(ds,'y')
+puts da.summary

data/demo/multiple_regression.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib/')
+
+require 'statsample'
+require 'benchmark'
+samples=10000
+a=samples.times.collect {rand}.to_scale
+b=samples.times.collect {rand}.to_scale
+c=samples.times.collect {rand}.to_scale
+d=samples.times.collect {rand}.to_scale
+
+ds={'a'=>a,'b'=>b,'c'=>c,'d'=>d}.to_dataset
+ds['y']=ds.collect{|row| row['a']*5+row['b']*3+row['c']*2+row['d']*1+rand()}
+
+Benchmark.bm(7) do |x|
+
+
+rb=ReportBuilder.new("Multiple Regression Engines")
+
+if HAS_GSL
+  x.report("GSL:") {
+  lr=Statsample::Regression::Multiple::GslEngine.new(ds,'y',:name=>"Multiple Regression using GSL")
+  rb.add(lr.summary)
+  }
+end
+
+
+if HAS_ALGIB
+  x.report("Alglib:") {
+  lr=Statsample::Regression::Multiple::AlglibEngine.new(ds,'y', :name=>"Multiple Regression using Alglib")
+  rb.add(lr.summary)
+  }
+end
+  x.report("Ruby:") {
+  lr=Statsample::Regression::Multiple::RubyEngine.new(ds,'y',:name=>"Multiple Regression using RubyEngine")
+  rb.add(lr.summary)
+  }
+
+  puts rb.to_text
+end

data/demo/polychoric.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib/')
+
+require 'statsample'
+#ct=Matrix[[58,52,1],[26,58,3],[8,12,9]]
+
+ct=Matrix[[30,1,0,0,0,0],[0,10,2,0,0,0], [0,4,8,3,1,0], [0,3,3,37,9,0], [0,0,1, 25, 71, 49], [ 0,0,0,2, 20, 181]]
+poly=Statsample::Bivariate::Polychoric.new(ct)
+
+puts poly.summary
+puts poly.chi_square_independence
+puts poly.chi_square_model
+puts poly.chi_square_independence

data/demo/tetrachoric.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib/')
+
+require 'statsample'
+a=40
+b=10
+c=20
+d=30
+tetra=Statsample::Bivariate::Tetrachoric.new(a,b,c,d)
+puts tetra.summary

data/lib/distribution.rb

@@ -12,4 +12,5 @@ module Distribution
     autoload(:T, 'distribution/t')
     autoload(:F, 'distribution/f')
     autoload(:Normal, 'distribution/normal')
+    autoload(:NormalBivariate, 'distribution/normalbivariate')
 end

data/lib/distribution/normalbivariate.rb

@@ -0,0 +1,100 @@
+module Distribution
+  # Calculate pdf and cdf for bivariate normal distribution
+  module NormalBivariate
+    
+    class << self
+      SIDE=0.1
+      LIMIT=5
+      # Probability density function
+      # Source: http://en.wikipedia.org/wiki/Multivariate_normal_distribution
+      def pdf(x,y, rho, sigma1=1.0, sigma2=1.0)
+        (1.quo(2 * Math::PI * sigma1*sigma2 * Math::sqrt( 1 - rho**2 ))) *
+          Math::exp(-(1.quo(2*(1-rho**2))) *
+          ((x**2/sigma1) + (y**2/sigma2) - (2*rho*x*y).quo(sigma1*sigma2)  ))
+      end
+      def f(x,y,aprime,bprime,rho)
+        r=aprime*(2*x-aprime)+bprime*(2*y-bprime)+2*rho*(x-aprime)*(y-bprime)
+        Math::exp(r)
+      end
+      def cdf(a,b,rho)
+        cdf_math(a,b,rho)
+      end
+      def sgn(x)
+        if(x>=0)
+        1
+        else
+        -1
+        end     
+      end
+      # As http://finance.bi.no/~bernt/gcc_prog/recipes/recipes/node23.html
+      def cdf_math(a,b,rho)
+        #puts "a:#{a} - b:#{b} - rho:#{rho}"
+        if (a<=0 and b<=0 and rho<=0)
+         # puts "ruta 1"
+          aprime=a.quo(Math::sqrt(2.0*(1.0-rho**2)))
+          bprime=b.quo(Math::sqrt(2.0*(1.0-rho**2)))
+          aa=[0.3253030, 0.4211071, 0.1334425, 0.006374323]
+          bb=[0.1337764, 0.6243247, 1.3425378, 2.2626645]
+          sum=0
+          4.times do |i|
+            4.times do |j|
+              sum+=aa[i]*aa[j] * f(bb[i], bb[j], aprime, bprime,rho)
+            end
+          end
+          sum=sum*(Math::sqrt(1.0-rho**2).quo(Math::PI))
+          return sum
+        elsif(a*b*rho<=0.0)
+          
+          #puts "ruta 2"
+          if(a<=0 and b>=0 and rho>=0)
+            return Distribution::Normal.cdf(a) - cdf(a,-b,-rho)
+          elsif (a>=0.0 and b<=0.0 and rho>=0)
+            return Distribution::Normal.cdf(b) - cdf(-a,b,-rho)
+          elsif (a>=0.0 and b>=0.0 and rho<=0)
+            return Distribution::Normal.cdf(a) + Distribution::Normal.cdf(b) - 1.0 + cdf(-a,-b,rho)
+          end
+        elsif (a*b*rho>=0.0)
+          #puts "ruta 3"
+          denum=Math::sqrt(a**2 - 2*rho*a*b + b**2)
+          rho1=((rho*a-b)*sgn(a)).quo(denum)
+          rho2=((rho*b-a)*sgn(b)).quo(denum)
+          delta=(1.0-sgn(a)*sgn(b)).quo(4)
+          #puts "#{rho1} - #{rho2}"
+          return cdf(a, 0.0, rho1) + cdf(b, 0.0, rho2) - delta
+        end
+        raise "Should'nt be here! #{a} - #{b} #{rho}"
+      end
+      # Cdf for a given x and y 
+      # Reference:
+      # * Jantaravareerat, M. & Thomopoulos, N. (n/d). Tables for standard bivariate normal distribution
+     
+      def cdf_iterate(x,y,rho,s1=1,s2=1)
+        # Special cases
+        return 1 if x>LIMIT and y>LIMIT
+        return 0 if x<-LIMIT or y<-LIMIT
+        return Distribution::Normal.cdf(y) if  x>LIMIT
+        return Distribution::Normal.cdf(x) if  y>LIMIT
+
+        #puts "x:#{x} - y:#{y}"
+        x=-LIMIT if x<-LIMIT
+        x=LIMIT if x>LIMIT
+        y=-LIMIT if y<-LIMIT
+        y=LIMIT if y>LIMIT
+
+        x_squares=((LIMIT+x) / SIDE).to_i
+        y_squares=((LIMIT+y) / SIDE).to_i
+        sum=0
+        x_squares.times do |i|
+          y_squares.times do |j|
+            z1=-LIMIT+(i+1)*SIDE
+            z2=-LIMIT+(j+1)*SIDE
+            #puts " #{z1}-#{z2}"
+            h=(pdf(z1,z2,rho,s1,s2)+pdf(z1-SIDE,z2,rho,s1,s2)+pdf(z1,z2-SIDE,rho,s1,s2) + pdf(z1-SIDE,z2-SIDE,rho,s1,s2)).quo(4)
+            sum+= (SIDE**2)*h # area
+          end
+        end
+        sum
+      end
+    end
+  end
+end

data/lib/statsample.rb

@@ -23,6 +23,7 @@ $:.unshift(File.expand_path(File.dirname(__FILE__)+"/../ext"))
 
 require 'matrix'
 require 'distribution'
+require 'reportbuilder'
 
 class Numeric
   def square ; self * self ; end
@@ -108,7 +109,7 @@ end
 # * Dataset: An union of vectors.
 #
 module Statsample
-  VERSION = '0.6.1'
+  VERSION = '0.6.2'
   SPLIT_TOKEN = ","
   autoload(:Database, 'statsample/converters')
   autoload(:Anova, 'statsample/anova')
@@ -135,6 +136,7 @@ module Statsample
   autoload(:Regression, 'statsample/regression')
   autoload(:Test, 'statsample/test')
   autoload(:Factor, 'statsample/factor')
+  
   def self.load(filename)
     if File.exists? filename
       o=false
@@ -165,110 +167,6 @@ module Statsample
       fp.close
     end        
   end
-  module HtmlSummary
-    def add_line(n=nil)
-        self << "<hr />"
-    end
-    def nl
-        self << "<br />"
-    end
-    def add(text)
-        self << ("<p>"+text.gsub("\n","<br />")+"</p>")
-    end
-    def parse_table(table)
-        self << table.parse_html
-    end
-  end
-  module ConsoleSummary
-    def add_line(n=80)
-      self << "-"*n+"\n"
-    end
-    def nl
-      self << "\n"
-    end
-    def add(text)
-      self << text
-    end
-    def parse_table(table)
-      self << table.parse_console
-    end
-  end
-  class ReportTable
-    attr_reader :header
-    def initialize(h=[])
-        @rows=[]
-        @max_cols=[]
-        self.header=(h)
-    end
-    def add_row(row)
-        row.each_index{|i|
-            @max_cols[i]=row[i].to_s.size if @max_cols[i].nil? or row[i].to_s.size > @max_cols[i]
-        }
-        @rows.push(row)
-    end
-    def add_horizontal_line
-        @rows.push(:hr)
-    end
-    def header=(h)
-        h.each_index{|i|
-            @max_cols[i]=h[i].to_s.size if @max_cols[i].nil? or h[i].to_s.size>@max_cols[i]
-        }    
-        @header=h
-    end
-    def parse_console_row(row)
-        out="| "
-        @max_cols.each_index{|i|
-            if row[i].nil?
-                out << " "*(@max_cols[i]+2)+"|"
-            else
-                t=row[i].to_s
-                out << " "+t+" "*(@max_cols[i]-t.size+1)+"|"
-            end
-        }
-        out << "\n"
-        out
-    end
-    def parse_console_hr
-        "-"*(@max_cols.inject(0){|a,v|a+v.size+3}+2)+"\n"
-    end
-    def parse_console
-        out="\n"
-        out << parse_console_hr
-        out << parse_console_row(header)
-        out << parse_console_hr
-  
-        @rows.each{|row|
-            if row==:hr
-               out << parse_console_hr 
-            else
-            out << parse_console_row(row)
-            end
-        }
-        out << parse_console_hr
-  
-        out
-    end
-    def parse_html
-        out="<table>\n"
-        if header.size>0
-        out << "<thead><th>"+header.join("</th><th>")+"</thead><tbody>"
-        end
-        out << "<tbody>\n"
-        row_with_line=false
-        @rows.each{|row|
-            if row==:hr
-                row_with_line=true
-            else
-                out << "<tr class='"+(row_with_line ? 'line':'')+"'><td>"
-                out << row.join("</td><td>") +"</td>"
-                out << "</tr>\n"
-                row_with_line=false
-            end
-        }
-        out << "</tbody></table>\n"
-        out
-    end
-  end
     
   module STATSAMPLE__ #:nodoc:
   end
@@ -288,3 +186,4 @@ end
 require 'statsample/vector'
 require 'statsample/dataset'
 require 'statsample/crosstab'
+require 'statsample/matrix'

data/lib/statsample/bivariate.rb

@@ -1,4 +1,5 @@
 require 'statsample/bivariate/tetrachoric'
+require 'statsample/bivariate/polychoric'
 module Statsample
   # Diverse correlation methods 
   module Bivariate
@@ -132,7 +133,7 @@ module Statsample
       # Order of rows and columns depends on Dataset#fields order
       
       def correlation_matrix(ds)
-        ds.collect_matrix do |row,col|
+        cm=ds.collect_matrix do |row,col|
           if row==col
             1.0
           elsif (ds[row].type!=:scale or ds[col].type!=:scale)
@@ -141,6 +142,9 @@ module Statsample
             pearson(ds[row],ds[col])
           end
         end
+        cm.extend(Statsample::CorrelationMatrix)
+        cm.labels=ds.fields
+        cm
       end
       
       # Retrieves the n valid pairwise.

data/lib/statsample/bivariate/polychoric.rb

@@ -0,0 +1,581 @@
+module Statsample
+  module Bivariate
+    # Calculate Polychoric correlation for two vectors.
+    def self.polychoric(v1,v2)
+      pc=Polychoric.new_with_vectors(v1,v2)
+      pc.r
+    end
+    
+    # Polychoric correlation matrix.
+    # Order of rows and columns depends on Dataset#fields order
+    def self.polychoric_correlation_matrix(ds)
+      ds.collect_matrix do |row,col|
+        if row==col
+          1.0
+        else
+          begin
+            polychoric(ds[row],ds[col])
+          rescue RuntimeError
+            nil
+          end
+        end
+      end
+    end
+    # Compute polychoric correlation.
+    #
+    # The polychoric correlation estimate what the correlation between raters, who classified on a ordered category scale,  would be if ratings were made on a continuous scale; they are, theoretically, invariant over changes in the number or "width" of rating categories. 
+    # See extensive documentation on http://www.john-uebersax.com/stat/tetra.htm
+    
+    class Polychoric
+      include GetText
+      bindtextdomain("statsample")
+      # Name of the analysis
+      attr_accessor :name
+      # Max number of iterations used on iterative methods. Default to 100
+      attr_accessor :max_iterations
+      # Debug algorithm (See iterations, for example)
+      attr_accessor :debug
+      # Minimizer type. Default GSL::Min::FMinimizer::BRENT
+      # See http://rb-gsl.rubyforge.org/min.html for reference.  
+      attr_accessor :minimizer_type
+      # Method of calculation.
+      #
+      # Drasgow (1988, cited by Uebersax, 2002) describe two method: joint maximum likelihood (ML) approach and two-step ML estimation.
+      # For now, only implemented two-step ML (:two_step), with algorithm
+      # based on Drasgow(1986, cited by Gegenfurtner, 1992)
+      #
+      attr_accessor :method
+      # Absolute error for iteration. Default to 0.001
+      attr_accessor :epsilon
+      
+      # Number of iterations
+      attr_reader :iteration
+      
+      # Log of algorithm
+      attr_reader :log
+      attr_reader :loglike
+      MAX_ITERATIONS=100
+      EPSILON=0.001
+      MINIMIZER_TYPE=GSL::Min::FMinimizer::BRENT
+      def new_with_vectors(v1,v2)
+        Polychoric.new(Crosstab.new(v1,v2).to_matrix)
+      end
+      
+      def initialize(matrix, opts=Hash.new)
+        @matrix=matrix
+        @n=matrix.column_size
+        @m=matrix.row_size
+        raise "row size <1" if @m<=1
+        raise "column size <1" if @n<=1
+        
+        @method=:two_step
+        @name="Polychoric correlation"
+        @max_iterations=MAX_ITERATIONS
+        @epsilon=EPSILON
+        @minimizer_type=GSL::Min::FMinimizer::BRENT
+        @debug=false
+        @iteration=nil
+        opts.each{|k,v|
+          self.send("#{k}=",v) if self.respond_to? k
+        }
+        @r=nil
+      end
+      def r
+        if @r.nil?
+          compute
+        end
+        @r
+      end
+      
+      def threshold_x
+        if @alpha.nil?
+          compute
+        end
+        @alpha[0,@alpha.size-1]
+      end
+      
+      def threshold_y
+        if @beta.nil?
+          compute
+        end
+        @beta[0,@beta.size-1]
+      end
+      
+      
+      
+      def compute
+        if @method==:two_step
+          compute_two_step_mle_drasgow
+        elsif @method==:as87
+          compute_two_step_as87
+        else
+          raise "Not implemented"
+        end
+      end
+      # *Computation of polychoric correlation usign two-step ML estimation.*
+      # 
+      # Two-step ML estimation "first estimates the thresholds from the one-way marginal frequencies, then estimates rho, conditional on these thresholds, via maximum likelihood" (Uebersax, 2006).
+      #
+      # The algorithm is based on Drasgow(1986, cited by Gegenfurtner (1992)
+      # References:
+      # * Gegenfurtner, K. (1992). PRAXIS: Brent's algorithm for function minimization. Behavior Research Methods, Instruments & Computers, 24(4), 560-564. Available on http://www.allpsych.uni-giessen.de/karl/pdf/03.praxis.pdf
+      # * Uebersax, J.S. (2006). The tetrachoric and polychoric correlation coefficients. Statistical Methods for Rater Agreement web site. 2006. Available at: http://john-uebersax.com/stat/tetra.htm . Accessed February, 11, 2010
+      #
+      def compute_two_step_mle_drasgow
+        @nr=@matrix.row_size
+        @nc=@matrix.column_size
+        @sumr=[0]*@matrix.row_size
+        @sumrac=[0]*@matrix.row_size
+        @sumc=[0]*@matrix.column_size
+        @sumcac=[0]*@matrix.column_size
+        @alpha=[0]*@matrix.row_size
+        @beta=[0]*@matrix.row_size
+        @total=0
+        @nr.times do |i|
+          @nc.times do |j|
+            @sumr[i]+=@matrix[i,j]
+            @sumc[j]+=@matrix[i,j]
+            @total+=@matrix[i,j]
+          end
+        end
+        ac=0
+        (@nr-1).times do |i|
+          @sumrac[i]=@sumr[i]+ac
+          @alpha[i]=Distribution::Normal.p_value(@sumrac[i] / @total.to_f)
+          ac=@sumrac[i]
+        end
+        ac=0
+        (@nc-1).times do |i|
+          @sumcac[i]=@sumc[i]+ac
+          @beta[i]=Distribution::Normal.p_value(@sumcac[i] / @total.to_f)
+          ac=@sumcac[i]
+        end
+        @alpha[@nr-1]=10
+        @beta[@nc-1]=10
+        fn1=GSL::Function.alloc {|x| 
+          loglike=0
+          pd=@nr.times.collect{ [0]*@nc}
+          pc=@nr.times.collect{ [0]*@nc}
+
+          @nr.times { |i|
+            @nc.times { |j|
+              pd[i][j]=Distribution::NormalBivariate.cdf(@alpha[i], @beta[j], x)
+              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]
+              
+              if res==0.0
+                res=1e-15
+               end 
+               
+              # puts "i:#{i} | j:#{j} | ac: #{sprintf("%0.4f", pc[i][j])} | pd: #{sprintf("%0.4f", pd[i][j])} | res:#{sprintf("%0.4f", res)}"
+              loglike+= @matrix[i,j]  * Math::log( res )
+            }
+          }
+          # p pd
+          @loglike=loglike
+          @pd=pd
+          -loglike
+        }
+      @iteration = 0
+      max_iter = @max_iterations
+      m = 0             # initial guess
+      m_expected = 0.5
+      a=-0.99999
+      b=+0.99999
+      gmf = GSL::Min::FMinimizer.alloc(@minimizer_type)
+      gmf.set(fn1, m, a, b)
+      header=sprintf("using %s method\n", gmf.name)
+      header+=sprintf("%5s [%9s, %9s] %9s %10s %9s\n", "iter", "lower", "upper", "min",
+         "err", "err(est)")
+        
+      header+=sprintf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n", @iteration, a, b, m, m - m_expected, b - a)
+      @log=header
+      puts header if @debug
+      begin
+        @iteration += 1
+        status = gmf.iterate
+        status = gmf.test_interval(0.001, 0.0)
+        
+        if status == GSL::SUCCESS
+          @log+="Converged:"
+          puts "Converged:" if @debug
+        end
+        a = gmf.x_lower
+        b = gmf.x_upper
+        m = gmf.x_minimum
+        message=sprintf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n",
+          @iteration, a, b, m, m - m_expected, b - a);
+        @log+=message
+        puts message if @debug
+      end while status == GSL::CONTINUE and @iteration < @max_iterations
+      @r=gmf.x_minimum
+      end
+      # Chi-square to test r=0
+      def chi_square_independence
+        Statsample::Test::chi_square(@matrix, expected)
+      end
+      # Chi-square to test model==independence
+      
+      def chi_square_model_expected
+        calculate if @r.nil?
+        model=Matrix.rows(@pd).collect {|c| c*@total}
+        Statsample::Test::chi_square(model, expected)
+
+      end
+      # Chi-square to test real == calculated with rho
+      def  chi_square_model
+        calculate if @r.nil?
+        e=Matrix.rows(@pd).collect {|c| c*@total}
+        Statsample::Test::chi_square(@matrix, e)
+      end
+      def matrix_for_rho(rho)
+        pd=@nr.times.collect{ [0]*@nc}
+        pc=@nr.times.collect{ [0]*@nc}
+        @nr.times { |i|
+            @nc.times { |j|
+              pd[i][j]=Distribution::NormalBivariate.cdf(@alpha[i], @beta[j], rho)
+              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]
+            }
+         }
+         Matrix.rows(pc)
+      end
+      def g2
+        raise "Doesn't work"
+        e=expected
+        no_r_likehood=0
+        @nr.times {|i|
+          @nc.times {|j|
+            #p @matrix[i,j]
+            if @matrix[i,j]!=0
+              no_r_likehood+= @matrix[i,j]*Math::log(e[i,j])
+            end
+          }
+        }
+        p no_r_likehood
+        model=Matrix.rows(@pd).collect {|c| c*@total}
+
+        model_likehood=0
+        @nr.times {|i|
+          @nc.times {|j|
+            #p @matrix[i,j]
+            if @matrix[i,j]!=0
+              model_likehood+= @matrix[i,j] * Math::log(model[i,j])
+            end
+          }
+        }
+        
+        p model_likehood
+        
+        -2*(no_r_likehood-model_likehood)
+        
+      end
+      def expected
+        rt=[]
+        ct=[]
+        t=0
+        @matrix.row_size.times {|i|
+          @matrix.column_size.times {|j|
+            rt[i]=0 if rt[i].nil?
+            ct[j]=0 if ct[j].nil?
+            rt[i]+=@matrix[i,j]
+            ct[j]+=@matrix[i,j]
+            t+=@matrix[i,j]
+          }
+        }
+        m=[]
+        @matrix.row_size.times {|i|
+          row=[]
+          @matrix.column_size.times {|j|
+            row[j]=(rt[i]*ct[j]).quo(t)
+          }
+          m.push(row)
+        }
+        
+        Matrix.rows(m)
+      end
+      # Compute polychoric using AS87.
+      # Doesn't work for now! I can't find the error :(
+      
+      def compute_two_step_as87
+        @nn=@n-1
+        @mm=@m-1
+        @nn7=7*@nn
+        @mm7=7*@mm
+        @mn=@n*@m
+        @cont=[nil]
+        @n.times {|j|
+          @m.times {|i|
+            @cont.push(@matrix[i,j])
+          }
+        }
+
+        pcorl=0
+        cont=@cont
+        xmean=0.0
+        sum=0.0
+        row=[]
+        colmn=[]
+        (1..@m).each do |i|
+          row[i]=0.0
+          l=i
+          (1..@n).each do |j|
+            row[i]=row[i]+cont[l]
+            l+=@m
+          end
+          raise "Should not be empty rows" if(row[i]==0.0)
+          xmean=xmean+row[i]*i.to_f
+          sum+=row[i]
+        end
+        xmean=xmean/sum.to_f
+        ymean=0.0
+        (1..@n).each do |j|
+          colmn[j]=0.0
+          l=(j-1)*@m
+          (1..@m).each do |i|
+            l=l+1
+            colmn[j]=colmn[j]+cont[l] #12
+          end
+          raise "Should not be empty cols" if colmn[j]==0
+          ymean=ymean+colmn[j]*j.to_f
+        end
+        ymean=ymean/sum.to_f
+        covxy=0.0
+        (1..@m).each do |i|
+          l=i
+          (1..@n).each do |j|
+            conxy=covxy+cont[l]*(i.to_f-xmean)*(j.to_f-ymean)
+            l=l+@m
+          end
+        end
+        
+        chisq=0.0
+        (1..@m).each do |i|
+          l=i
+          (1..@n).each do |j|
+            chisq=chisq+((cont[l]**2).quo(row[i]*colmn[j]))
+            l=l+@m
+          end
+        end
+        
+        phisq=chisq-1.0-(@mm*@nn).to_f / sum.to_f
+        phisq=0 if(phisq<0.0) 
+        # Compute cumulative sum of columns and rows
+        sumc=[]
+        sumr=[]
+        sumc[1]=colmn[1]
+        sumr[1]=row[1]
+        cum=0
+        (1..@nn).each do |i| # goto 17 r20
+          cum=cum+colmn[i]
+          sumc[i]=cum
+        end
+        cum=0
+        (1..@mm).each do |i| 
+          cum=cum+row[i]
+          sumr[i]=cum
+        end
+        alpha=[]
+        beta=[]
+        # Compute points of polytomy
+        (1..@mm).each do |i| #do 21
+          alpha[i]=Distribution::Normal.p_value(sumr[i] / sum.to_f)
+        end # 21
+        (1..@nn).each do |i| #do 22
+          beta[i]=Distribution::Normal.p_value(sumc[i] / sum.to_f)
+        end # 21
+        @alpha=alpha[1,alpha.size] << nil
+        @beta=beta[1,beta.size] << nil
+        @sumr=sumr
+        @sumc=sumc
+        @total=sum
+        
+        # Compute Fourier coefficients a and b. Verified
+        h=hermit(alpha,@mm)
+        hh=hermit(beta,@nn)
+        a=[]
+        b=[]
+        if @m!=2 # goto 24
+          mmm=@m-2
+          (1..mmm).each do |i| #do 23
+            a1=sum.quo(row[i+1] * sumr[i] * sumr[i+1])
+            a2=sumr[i]   * xnorm(alpha[i+1])
+            a3=sumr[i+1] * xnorm(alpha[i])
+            l=i
+            (1..7).each do |j| #do 23
+              a[l]=Math::sqrt(a1.quo(j))*(h[l+1] * a2 - h[l] * a3)
+              l=l+@mm
+            end
+          end #23
+        end
+        # 24
+        
+        
+        if @n!=2 # goto 26
+          nnn=@n-2
+          (1..nnn).each do |i| #do 25
+            a1=sum.quo(colmn[i+1] * sumc[i] * sumc[i+1])
+            a2=sumc[i] * xnorm(beta[i+1])
+            a3=sumc[i+1] * xnorm(beta[i])
+            l=i
+            (1..7).each do |j| #do 25
+              b[l]=Math::sqrt(a1.quo(j))*(a2 * hh[l+1] - a3*hh[l])
+              l=l+@nn
+            end # 25
+          end # 25
+        end
+        #26 r20
+        l = @mm
+        a1 = -sum * xnorm(alpha[@mm])
+        a2 = row[@m] * sumr[@mm] 
+        (1..7).each do |j| # do 27
+          a[l]=a1 * h[l].quo(Math::sqrt(j*a2))
+          l=l+@mm
+        end # 27
+        
+        l = @nn
+        a1 = -sum * xnorm(beta[@nn])
+        a2 = colmn[@n] * sumc[@nn]
+
+        (1..7).each do |j| # do 28
+          b[l]=a1 * hh[l].quo(Math::sqrt(j*a2))
+          l = l + @nn
+        end # 28
+        rcof=[]
+        # compute coefficients rcof of polynomial of order 8
+        rcof[1]=-phisq
+        (2..9).each do |i| # do 30
+          rcof[i]=0.0
+        end #30 
+        m1=@mm
+        (1..@mm).each do |i| # do 31
+          m1=m1+1
+          m2=m1+@mm
+          m3=m2+@mm
+          m4=m3+@mm
+          m5=m4+@mm
+          m6=m5+@mm
+          n1=@nn
+          (1..@nn).each do |j| # do 31
+            n1=n1+1
+            n2=n1+@nn
+            n3=n2+@nn
+            n4=n3+@nn
+            n5=n4+@nn
+            n6=n5+@nn
+            
+            rcof[3] = rcof[3] + a[i]**2 * b[j]**2
+            
+            rcof[4] = rcof[4] + 2.0 * a[i] * a[m1] * b[j] * b[n1]
+            
+            rcof[5] = rcof[5] + a[m1]**2 * b[n1]**2 +
+              2.0 * a[i] * a[m2] * b[j] * b[n2]
+            
+            rcof[6] = rcof[6] + 2.0 * (a[i] * a[m3] * b[j] *
+              b[n3] + a[m1] * a[m2] * b[n1] * b[n2])
+            
+            rcof[7] = rcof[7] + a[m2]**2 * b[n2]**2 +
+              2.0 * (a[i] * a[m4] * b[j] * b[n4] + a[m1] * a[m3] *
+                b[n1] * b[n3])
+            
+            rcof[8] = rcof[8] + 2.0 * (a[i] * a[m5] * b[j] * b[n5] +
+              a[m1] * a[m4] * b[n1] * b[n4] + a[m2] *  a[m3] * b[n2] * b[n3])
+            
+            rcof[9] = rcof[9] + a[m3]**2 * b[n3]**2 +
+              2.0 * (a[i] * a[m6] * b[j] * b[n6] + a[m1] * a[m5] * b[n1] *
+              b[n5] + (a[m2] * a[m4] * b[n2] * b[n4]))
+          end # 31
+        end # 31
+
+        rcof=rcof[1,rcof.size]
+        poly = GSL::Poly.alloc(rcof)
+        roots=poly.solve
+        rootr=[nil]
+        rooti=[nil]
+        roots.each {|c|
+          rootr.push(c.real)
+          rooti.push(c.im)
+        }
+        @rootr=rootr
+        @rooti=rooti
+        
+        norts=0
+        (1..7).each do |i| # do 43
+          
+          next if rooti[i]!=0.0 
+          if (covxy>=0.0)
+            next if(rootr[i]<0.0 or rootr[i]>1.0)
+            pcorl=rootr[i]
+            norts=norts+1
+          else
+            if (rootr[i]>=-1.0 and rootr[i]<0.0)
+              pcorl=rootr[i]
+              norts=norts+1              
+            end
+          end
+        end # 43
+        raise "Error" if norts==0
+        @r=pcorl
+      end
+      #Computes vector h(mm7) of orthogonal hermite...
+      def hermit(s,k)
+        h=[]
+        (1..k).each do |i| # do 14
+          l=i
+          ll=i+k
+          lll=ll+k
+          h[i]=1.0
+          h[ll]=s[i]
+          v=1.0
+          (2..6).each do |j| #do 14
+            w=Math::sqrt(j)
+            h[lll]=(s[i]*h[ll] - v*h[l]).quo(w)
+            v=w
+            l=l+k
+            ll=ll+k
+            lll=lll+k
+          end
+        end
+        h
+      end
+      def xnorm(t)
+        Math::exp(-0.5 * t **2) * (1.0/Math::sqrt(2*Math::PI))
+      end
+      
+      def summary
+        rp=ReportBuilder.new()
+        rp.add(self)
+        rp.to_text
+      end
+      
+      def to_reportbuilder(generator)
+        compute if @r.nil?
+        section=ReportBuilder::Section.new(:name=>@name)
+        t=ReportBuilder::Table.new(:name=>_("Contingence Table"),:header=>[""]+(@n.times.collect {|i| "Y=#{i}"})+["Total"])
+        @m.times do |i|
+          t.add_row(["X = #{i}"]+(@n.times.collect {|j| @matrix[i,j]}) + [@sumr[i]])
+        end
+        t.add_hr
+        t.add_row(["T"]+(@n.times.collect {|j| @sumc[j]})+[@total])
+        section.add(t)
+        #generator.parse_element(t)
+        section.add(sprintf("r: %0.4f",r))
+        t=ReportBuilder::Table.new(:name=>_("Thresholds"), :header=>["","Value"])
+        threshold_x.each_with_index {|val,i|
+          t.add_row(["Threshold X #{i}", sprintf("%0.4f", val)])
+        }
+        threshold_y.each_with_index {|val,i|
+          t.add_row(["Threshold Y #{i}", sprintf("%0.4f", val)])
+        }
+        section.add(t)
+        generator.parse_element(section)
+      end
+    end
+  end
+end