distribution 0.3.0 → 0.4.0

data/History.txt

@@ -1,3 +1,13 @@
+=== 0.4.0 / 2011-02-01
+
+* Poisson and exponential distributions implemented. Implementation of inverse cdf for poisson is not perfect, yet.
+* +distribution+ executable can create template files for new distributions. 
+* MathExtension should work fine with Ruby 1.8. Fixed shadowed variable on MathExtension.naive_factorial
+* Added factorial lookup table for n<20.
+* Added exact cdf for Binomial
+* Binomial coefficient in function of permutations. Deleted incomplete beta until we found a faster way to calculate it
+
+
 === 0.3.0 / 2011-01-28
 
 * Included support for binomial distribution. p_value is not accurate

data/Manifest.txt

@@ -4,9 +4,17 @@ Manifest.txt
 README.txt
 Rakefile
 benchmark/binomial_coefficient.rb
+benchmark/binomial_coefficient/binomial_coefficient.ds
+benchmark/binomial_coefficient/binomial_coefficient.xls
+benchmark/binomial_coefficient/experiment.rb
+benchmark/factorial_hash.rb
 benchmark/factorial_method.rb
 benchmark/odd.rb
 bin/distribution
+data/template/distribution.erb
+data/template/distribution/gsl.erb
+data/template/distribution/ruby.erb
+data/template/spec.erb
 lib/distribution.rb
 lib/distribution/binomial.rb
 lib/distribution/binomial/gsl.rb
@@ -22,6 +30,9 @@ lib/distribution/chisquare/gsl.rb
 lib/distribution/chisquare/java.rb
 lib/distribution/chisquare/ruby.rb
 lib/distribution/chisquare/statistics2.rb
+lib/distribution/exponential.rb
+lib/distribution/exponential/gsl.rb
+lib/distribution/exponential/ruby.rb
 lib/distribution/f.rb
 lib/distribution/f/gsl.rb
 lib/distribution/f/java.rb
@@ -38,6 +49,9 @@ lib/distribution/normal/java.rb
 lib/distribution/normal/ruby.rb
 lib/distribution/normal/statistics2.rb
 lib/distribution/normalmultivariate.rb
+lib/distribution/poisson.rb
+lib/distribution/poisson/gsl.rb
+lib/distribution/poisson/ruby.rb
 lib/distribution/t.rb
 lib/distribution/t/gsl.rb
 lib/distribution/t/java.rb
@@ -47,10 +61,12 @@ spec/binomial_spec.rb
 spec/bivariatenormal_spec.rb
 spec/chisquare_spec.rb
 spec/distribution_spec.rb
+spec/exponential_spec.rb
 spec/f_spec.rb
 spec/hypergeometric_spec.rb
 spec/math_extension_spec.rb
 spec/normal_spec.rb
+spec/poisson_spec.rb
 spec/shorthand_spec.rb
 spec/spec.opts
 spec/spec_helper.rb

data/README.txt

@@ -4,16 +4,17 @@
 
 == DESCRIPTION:
 
-Statistical Distributions multi library wrapper.
+Statistical Distributions library. Includes Normal univariate and bivariate, T, F, Chi Square, Binomial, Hypergeometric, Exponential and Poisson.
+
 Uses Ruby by default and C (statistics2/GSL) or Java extensions where available.
 
-Includes code from statistics2
+Includes code from statistics2 on Normal, T, F and Chi Square ruby code [http://blade.nagaokaut.ac.jp/~sinara/ruby/math/statistics2] 
 
 == FEATURES/PROBLEMS:
 
 * Very fast ruby 1.8.7/1.9.+ implementation, with improved method to calculate factorials and others common functions
 * All methods tested on several ranges. See spec/
-* On Jruby, BivariateNormal returns incorrect pdf
+* On Jruby and Rubinius, BivariateNormal returns incorrect pdf
 
 == API structure
 
@@ -31,7 +32,7 @@ On discrete distributions, exact cdf, pdf and p_value are
 
   <Distribution shortname>_(ecdf|epdf|ep)
   
-Shortnames are:
+Shortnames for distributions:
 
 * Normal: norm
 * Bivariate Normal: bnor
@@ -40,6 +41,8 @@ Shortnames are:
 * Chi Square: chisq
 * Binomial: bino
 * Hypergeometric: hypg
+* Exponential: expo
+* Poisson: pois
 
 For example
 
@@ -83,6 +86,12 @@ After checking out the source, run:
 This task will install any missing dependencies, run the tests/specs,
 and generate the RDoc.
 
+If you want to provide a new distribution, /lib/distribution run
+
+  $ distribution --new your_distribution
+  
+This should create the main distribution file, the directory with ruby and gsl engines and the rspec on /spec directory.
+
 == LICENSE:
 
 GPL V2

data/benchmark/binomial_coefficient.rb

@@ -1,18 +1,21 @@
-$:.unshift(File.dirname(__FILE__)+"/../lib")
+$:.unshift(File.expand_path(File.dirname(__FILE__)+"/../lib"))
 require 'distribution'
 require 'bench_press'
 
 extend BenchPress
 
+
+
+samples=10.times.map {|i| 2**(i+1)}
+
 name 'binomial coefficient: multiplicative, factorial and optimized factorial methods'
 author 'Claudio Bustos'
 date '2011-01-27'
-summary "Exact calculation of Binomial Coefficient could be obtained using multiplicative, pure factorial or optimized factorial algorithm. 
+summary "Exact calculation of Binomial Coefficient could be obtained using multiplicative, pure factorial or optimized factorial algorithm (failing + factorial). 
 Which one is faster?
 
 Lower k is the best for all 
-k=n/2 is the worst case for optimized algorithm
-k near n is the worst for multiplicative
+k=n/2 is the worst case.
 
 The factorial method uses the fastest Swing Prime Algorithm."
 
@@ -23,31 +26,29 @@ x=100
 n=100
 k=50
 
-samples=10.times.map {|i| 2**(i+1)}
-
 
 
 measure "Multiplicative" do
   samples.each do |n|
-    [5,n/2,n-1].each do |k|
+    [5,n/2].each do |k|
       k=[k,n-k].min
       (1..k).inject(1) {|ac, i| (ac*(n-k+i).quo(i))}
     end
   end
 end
 
-measure "Factorial" do
+measure "Pure Factorial" do
   samples.each do |n|
-    [5,n/2,n-1].each do |k|
+    [5,n/2].each do |k|
       k=[k,n-k].min
       Math.factorial(n).quo(Math.factorial(k) * Math.factorial(n - k))
     end
   end
 end
 
-measure "Optimized Factorial" do
+measure "Failing factorial + factorial" do
   samples.each do |n|
-    [5,n/2,n-1].each do |k|
+    [5,n/2].each do |k|
       k=[k,n-k].min
       (((n-k+1)..n).inject(1) {|ac,v| ac * v}).quo(Math.factorial(k))
     end

data/benchmark/binomial_coefficient/experiment.rb

@@ -0,0 +1,54 @@
+# This test create a database to adjust the best algorithm
+# to use on correlation matrix
+$:.unshift(File.expand_path(File.dirname(__FILE__)+"/../../lib"))
+require 'distribution'
+require 'statsample'
+require 'benchmark'
+
+if !File.exists?("binomial_coefficient.ds") or File.mtime(__FILE__) > File.mtime("binomial_coefficient.ds")
+reps=100 #number of repetitions
+ns={
+  5=>    [1,3],
+  10=>   [1,3,5],
+  50=>   [1,3,5,10,25],
+  100=>  [1,3,5,10,25,50],
+  500=>  [1,3,5,10,25,50,100,250],
+  1000=> [1,3,5,10,25,50,100,250,500],
+  5000=> [1,3,5,10,25,50,100,250,500,1000,2500],
+  10000=>[1,3,5,10,25,50,100,250,500,1000,2500,5000]
+}
+
+rs=Statsample::Dataset.new(%w{n k mixed_factorial multiplicative})
+
+ns.each do |n,ks|
+  ks.each do |k|
+      
+      time_factorial= Benchmark.realtime do
+        reps.times { 
+           (((n-k+1)..n).inject(1) {|ac,v| ac * v}).quo(Math.factorial(k))
+        }
+      end
+      
+      time_multiplicative= Benchmark.realtime do
+        reps.times { 
+          (1..k).inject(1) {|ac, i| (ac*(n-k+i).quo(i))}
+        }
+      end
+      
+      puts "n:#{n}, k:#{k} -> factorial:%0.3f | multiplicative: %0.3f " % [time_factorial, time_multiplicative]
+      
+      rs.add_case({'n'=>n,'k'=>k,'mixed_factorial'=>time_factorial, 'multiplicative'=>time_multiplicative})
+    end
+  end
+  
+else
+  rs=Statsample.load("binomial_coefficient.ds")
+end
+
+
+rs.fields.each {|f| rs[f].type=:scale}
+
+
+rs.update_valid_data
+rs.save("binomial_coefficient.ds")
+Statsample::Excel.write(rs,"binomial_coefficient.xls")

data/benchmark/factorial_hash.rb

@@ -0,0 +1,24 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__)+"/../lib"))
+require 'bench_press'
+require 'distribution'
+extend BenchPress
+
+name 'calculate factorial vs looking on a Hash'
+author 'Claudio Bustos'
+date '2011-01-31'
+summary "
+Is better create a lookup table for factorial or just calculate it?
+Distribution::MathExtension::SwingFactorial has a lookup table 
+for factorials n<20
+"
+
+reps 1000 #number of repetitions
+
+measure "Lookup" do
+	Math.factorial(19)
+end
+
+measure "calculate" do
+	Distribution::MathExtension::SwingFactorial.naive_factorial(19)
+end
+

data/bin/distribution

@@ -1,3 +1,51 @@
 #!/usr/bin/env ruby
 
-abort "you need to write me"
+require 'optparse'
+require 'fileutils'
+require 'erb'
+gem_base=File.expand_path(File.dirname(__FILE__)+"/..")
+require gem_base+"/lib/distribution"
+
+new=false
+parameters=""
+OptionParser.new do |opts|
+  opts.banner="Usage: distribution [--new] [--params parameters] distribution"
+  opts.on("-n", "--new", "Create a new template for distribution") do
+    new=true
+  end
+  opts.on("-PMANDATORY", "--params MANDATORY", String, "Parameters for distribution") do |n_param|
+    parameters=", #{n_param}"
+  end
+  
+  opts.on("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  begin
+    ARGV << "-h" if ARGV.empty?
+    opts.parse!(ARGV)
+  rescue OptionParser::ParseError => e
+    STDERR.puts e.message, "\n", opts
+    exit(-1)
+  end
+end
+
+ARGV.each do |distribution|
+  if new
+    basename=distribution.downcase
+    raise "You should be inside distribution lib directory" unless File.exists? "../distribution.rb"
+    raise "Distribution already created" if File.exists? basename+".rb"
+    main=ERB.new(File.read(gem_base+"/data/template/distribution.erb"),)
+    ruby=ERB.new(File.read(gem_base+"/data/template/distribution/ruby.erb"))
+    gsl=ERB.new(File.read(gem_base+"/data/template/distribution/gsl.erb"))
+    spec=ERB.new(File.read(gem_base+"/data/template/spec.erb"))
+    
+    FileUtils.mkdir(basename) unless File.exists? basename
+    File.open(basename+".rb","w") {|fp| fp.write(main.result(binding))}
+    File.open(basename+"/ruby.rb","w") {|fp| fp.write(ruby.result(binding))}
+    File.open(basename+"/gsl.rb","w") {|fp| fp.write(gsl.result(binding))}
+    File.open("../../spec/#{basename}_spec.rb","w") {|fp| fp.write(spec.result(binding))}
+    
+  end
+end

data/data/template/distribution.erb

@@ -0,0 +1,23 @@
+require 'distribution/<%= distribution.downcase %>/ruby'
+require 'distribution/<%= distribution.downcase %>/gsl'
+#require 'distribution/<%= distribution.downcase %>/java'
+
+
+module Distribution
+  # TODO: Document this Distribution
+  module <%= distribution.capitalize %>
+    SHORTHAND='<%= distribution.downcase[0,4] %>'
+    extend Distributable
+    create_distribution_methods
+
+    ##
+    # :singleton-method: pdf(x <%= parameters %>)
+
+    ##
+    # :singleton-method: cdf(x <%= parameters %>)
+    
+    ##
+    # :singleton-method: p_value(pr <%= parameters %>)
+
+  end
+end

data/data/template/distribution/gsl.erb

@@ -0,0 +1,14 @@
+module Distribution
+  module <%= distribution.capitalize %>
+    module GSL_
+      class << self
+        def pdf(x <% parameters %>)
+        end
+        def cdf(x <% parameters %>)
+        end
+        def p_value(pr <% parameters %>)
+        end
+      end
+    end
+  end
+end

data/data/template/distribution/ruby.erb

@@ -0,0 +1,14 @@
+module Distribution
+  module <%= distribution.capitalize %>
+    module Ruby_
+      class << self
+        def pdf(x <% parameters %>)
+        end
+        def cdf(x <% parameters %>)
+        end
+        def p_value(pr <% parameters %>)
+        end
+      end
+    end
+  end
+end

data/data/template/spec.erb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
+  
+describe Distribution::<%= distribution.capitalize %> do
+    
+  shared_examples_for "<%= distribution %> engine" do
+    it "should return correct pdf" do
+      if @engine.respond_to? :pdf
+      else
+        pending("No #{@engine}.pdf")
+      end
+    end
+    
+    it "should return correct cdf" do
+      if @engine.respond_to? :cdf
+      else
+        pending("No #{@engine}.cdf")
+      end
+    end
+  
+    
+    it "should return correct p_value" do
+      if @engine.respond_to? :p_value
+      else
+        pending("No #{@engine}.cdf")
+      end
+    end
+  end
+  
+
+  describe "singleton" do
+    before do
+      @engine=Distribution::<%= distribution.capitalize %>
+    end
+    it_should_behave_like "<%= distribution %> engine"
+  end
+  
+  describe Distribution::<%= distribution.capitalize %>::Ruby_ do
+    before do
+      @engine=Distribution::<%= distribution.capitalize %>::Ruby_
+    end
+    it_should_behave_like "<%= distribution %> engine"
+    
+  end
+    
+  describe Distribution::<%= distribution.capitalize %>::GSL_ do
+    before do
+      @engine=Distribution::<%= distribution.capitalize %>::GSL_
+    end
+    it_should_behave_like "<%= distribution %> engine"
+    
+  end
+  
+  
+end

data/lib/distribution.rb

@@ -49,7 +49,7 @@ require 'distribution/math_extension'
 #    Distribution::Normal.p_value(0.95)
 #    => 1.64485364660836
 module Distribution
-  VERSION="0.3.0"
+  VERSION="0.4.0"
   
   module Shorthand
     EQUIVALENCES={:p_value=>:p, :cdf=>:cdf, :pdf=>:pdf, :rng=>:r, :exact_pdf=>:epdf, :exact_cdf=>:ecdf, :exact_p_value=>:ep}
@@ -144,8 +144,10 @@ module Distribution
   autoload(:F, 'distribution/f')
   autoload(:BivariateNormal, 'distribution/bivariatenormal')
   autoload(:Binomial, 'distribution/binomial')
-
   autoload(:Hypergeometric, 'distribution/hypergeometric')
+  autoload(:Exponential, 'distribution/exponential')
+  autoload(:Poisson, 'distribution/poisson')
+
 end
 
 

data/lib/distribution/binomial/ruby.rb

@@ -9,17 +9,18 @@ module Distribution
           #(0..x.floor).inject(0) {|ac,i| ac+pdf(i,n,pr)}
           Math.regularized_beta_function(1-pr,n - k,k+1)
         end
+        def exact_cdf(k,n,pr)
+          (0..k).inject(0) {|ac,i| ac+pdf(i,n,pr)}
+        end
         def p_value(prob,n,pr)
           ac=0
           (0..n).each do |i|
             ac+=pdf(i,n,pr)
-            return i if ac>=prob
+            return i if prob<=ac
           end
         end
         
         alias :exact_pdf :pdf 
-
-        
       end
     end
   end

data/lib/distribution/chisquare/ruby.rb

@@ -3,8 +3,7 @@ module Distribution
     module Ruby_
       class << self
       
-        include Distribution::MathExtension
-      
+        include Math
         def pdf(x,n)
           if n == 1
             1.0/Math.sqrt(2 * Math::PI * x) * Math::E**(-x/2.0)

data/lib/distribution/exponential.rb

@@ -0,0 +1,34 @@
+require 'distribution/exponential/ruby'
+require 'distribution/exponential/gsl'
+#require 'distribution/exponential/java'
+
+
+module Distribution
+  # From Wikipedia:
+  #   In probability theory and statistics, the exponential distribution 
+  #   (a.k.a. negative exponential distribution) is a family of continuous
+  #   probability distributions. It describes the time between events in a
+  #   Poisson process, i.e. a process in which events occur continuously 
+  #   and independently at a constant average rate.
+  #
+  # Parameter +l+ is the rate parameter, the number of occurrences/unit time.
+  module Exponential
+    SHORTHAND='expo'
+    extend Distributable
+    create_distribution_methods
+
+    ##
+    # :singleton-method: pdf(x,l)
+    # PDF of exponential distribution, with parameters +x+ and +l+.
+    # +l+ is rate parameter
+
+    ##
+    # :singleton-method: cdf(x,l)
+    # CDF of exponential distribution, with parameters +x+ and +l+.
+    # +l+ is rate parameter
+    ##
+    # :singleton-method: p_value(pr,l)
+    # Inverse CDF of exponential distribution, with parameters +pr+ and +l+.
+    # +l+ is rate parameter
+  end
+end

data/lib/distribution/exponential/gsl.rb

@@ -0,0 +1,19 @@
+module Distribution
+  module Exponential
+    module GSL_
+      class << self
+        def pdf(x,l)
+          return 0 if x<0
+          GSL::Ran.exponential_pdf(x,1/l.to_f)
+        end
+        def cdf(x,l)
+          return 0 if x<0
+          GSL::Cdf.exponential_P(x,1/l.to_f)
+        end
+        def p_value(pr,l)
+          GSL::Cdf.exponential_Pinv(pr,1/l.to_f)
+        end
+      end
+    end
+  end
+end

data/lib/distribution/exponential/ruby.rb

@@ -0,0 +1,19 @@
+module Distribution
+  module Exponential
+    module Ruby_
+      class << self
+        def pdf(x,l)
+          return 0 if x<0
+          l*Math.exp(-l*x)
+        end
+        def cdf(x,l)
+          return 0 if x<0
+          1-Math.exp(-l*x)
+        end
+        def p_value(pr,l)
+          (-Math.log(1-pr)).quo(l)
+        end
+      end
+    end
+  end
+end

data/lib/distribution/math_extension.rb

@@ -14,8 +14,52 @@ end
 require 'bigdecimal'
 require 'bigdecimal/math'
 
-# Useful additions to Math
 module Distribution
+  # Extension for Ruby18
+  # Includes gamma and lgamma
+  module MathExtension18
+    LOG_2PI = Math.log(2 * Math::PI)# log(2PI)
+    N = 8
+    B0  = 1.0
+    B1  = -1.0 / 2.0
+    B2  = 1.0 / 6.0
+    B4  = -1.0 / 30.0
+    B6  =  1.0 / 42.0
+    B8  = -1.0 / 30.0
+    B10 =  5.0 / 66.0
+    B12 = -691.0 / 2730.0
+    B14 =  7.0 / 6.0
+    B16 = -3617.0 / 510.0
+    # From statistics2
+    def loggamma(x)
+      v = 1.0
+      while (x < N)
+        v *= x
+        x += 1.0
+      end
+      w = 1.0 / (x * x)
+      ret = B16 / (16 * 15)
+      ret = ret * w + B14 / (14 * 13)
+      ret = ret * w + B12 / (12 * 11)
+      ret = ret * w + B10 / (10 *  9)
+      ret = ret * w + B8  / ( 8 *  7)
+      ret = ret * w + B6  / ( 6 *  5)
+      ret = ret * w + B4  / ( 4 *  3)
+      ret = ret * w + B2  / ( 2 *  1)
+      ret = ret / x + 0.5 * LOG_2PI - Math.log(v) - x + (x - 0.5) * Math.log(x)
+      ret
+    end
+
+    # Gamma function.
+    # From statistics2    
+    def gamma(x)
+      if (x < 0.0)
+        return Math::PI / (Math.sin(Math.PI * x) * Math.exp(loggamma(1 - x))) #/
+      end
+      Math.exp(loggamma(x))
+    end
+  end
+  # Useful additions to Math
   module MathExtension
     # Factorization based on Prime Swing algorithm, by Luschny (the king of factorial numbers analysis :P )
     # == Reference
@@ -24,6 +68,7 @@ module Distribution
     class SwingFactorial
       attr_reader :result
       SmallOddSwing=[ 1, 1, 1, 3, 3, 15, 5, 35, 35, 315, 63, 693, 231, 3003, 429, 6435, 6435, 109395, 12155, 230945, 46189, 969969, 88179, 2028117, 676039, 16900975, 1300075, 35102025, 5014575,145422675, 9694845, 300540195, 300540195]
+      SmallFactorial=[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000, 20922789888000, 355687428096000, 6402373705728000, 121645100408832000, 2432902008176640000]
       def bitcount(n)
         bc = n - ((n >> 1) & 0x55555555);
         bc = (bc & 0x33333333) + ((bc >> 2) & 0x33333333);
@@ -35,7 +80,8 @@ module Distribution
       end
       def initialize(n)
         if (n<20)
-          naive_factorial(n)
+          @result=SmallFactorial[n]
+          #naive_factorial(n)
         else
         @prime_list=[]
         exp2 = n - bitcount(n);
@@ -89,7 +135,7 @@ module Distribution
         @result=(self.class).naive_factorial(n)
       end
       def self.naive_factorial(n)
-        (2..n).inject(1) { |f,n| f * n }
+        (2..n).inject(1) { |f,nn| f * nn }
       end
     end
     # Module to calculate approximated factorial
@@ -140,8 +186,8 @@ module Distribution
        end
      end
      # Exact factorial. 
-     # Use naive algorithm (iterative) on n<20
-     # and Prime Swing algorithm for higher values
+     # Use lookup on a Hash table on n<20
+     # and Prime Swing algorithm for higher values.
     def factorial(n)
       SwingFactorial.new(n).result
     end
@@ -150,14 +196,6 @@ module Distribution
     def fast_factorial(n)
       ApproxFactorial.stieltjes_factorial(n)
     end
-       
-
-    # Quick, accurate approximation of factorial for very small n. Special case, generally you want to use stirling instead.
-    # ==Reference
-    # * http://mathworld.wolfram.com/StirlingsApproximation.html
-    def gosper(n)
-      Math.sqrt( (2*n + 1/3.0) * Math::PI ) * (n/Math::E)**n
-    end
     
     # Beta function.
     # Source:
@@ -166,14 +204,14 @@ module Distribution
       (gamma(x)*gamma(y)).quo(gamma(x+y))
     end
     # I_x(a,b): Regularized incomplete beta function
-    #   
+    # TODO: Find a faster version.
     # Source:
-    #
+    # * http://dlmf.nist.gov/8.17
     def regularized_beta_function(x,a,b)
       return 1 if x==1
       #incomplete_beta(x,a,b).quo(beta(a,b))
-      m=a
-      n=b+a-1
+      m=a.to_i
+      n=(b+a-1).to_i
       (m..n).inject(0) {|sum,j|
         sum+(binomial_coefficient(n,j)* x**j * (1-x)**(n-j))
       }
@@ -183,65 +221,38 @@ module Distribution
     # Should be replaced by
     # http://lib.stat.cmu.edu/apstat/63
     def incomplete_beta(x,a,b)
-      raise "Not work"
-      return beta(a,b) if x==1
-      
-      ((x**a * (1-x)**b).quo(a)) * hyper_f(a+b,1,a+1,x)
-    end
-    def permutations(x,n)
-      factorial(x).quo(factorial(x-n))
+      raise "Doesn't work"
     end
     
+    # Rising factorial
     def rising_factorial(x,n)
       factorial(x+n-1).quo(factorial(x-1))
     end
    
-    
-    LOG_2PI = Math.log(2 * Math::PI)# log(2PI)
-    N = 8
-    B0  = 1.0
-    B1  = -1.0 / 2.0
-    B2  = 1.0 / 6.0
-    B4  = -1.0 / 30.0
-    B6  =  1.0 / 42.0
-    B8  = -1.0 / 30.0
-    B10 =  5.0 / 66.0
-    B12 = -691.0 / 2730.0
-    B14 =  7.0 / 6.0
-    B16 = -3617.0 / 510.0
-    # From statistics2
+    # Ln of gamma
     def loggamma(x)
-      v = 1.0
-      while (x < N)
-        v *= x
-        x += 1.0
-      end
-      w = 1.0 / (x * x)
-      ret = B16 / (16 * 15)
-      ret = ret * w + B14 / (14 * 13)
-      ret = ret * w + B12 / (12 * 11)
-      ret = ret * w + B10 / (10 *  9)
-      ret = ret * w + B8  / ( 8 *  7)
-      ret = ret * w + B6  / ( 6 *  5)
-      ret = ret * w + B4  / ( 4 *  3)
-      ret = ret * w + B2  / ( 2 *  1)
-      ret = ret / x + 0.5 * LOG_2PI - Math.log(v) - x + (x - 0.5) * Math.log(x)
-      ret
+      lg=Math.lgamma(x)
+      lg[0]*lg[1]
     end
-    # Gamma function.
-    # From statistics2    
-    def gamma(x)
-      if (x < 0.0)
-        return Math::PI / (Math.sin(Math.PI * x) * Math.exp(loggamma(1 - x))) #/
-      end
-      Math.exp(loggamma(x))
+    
+    
+    # Sequences without repetition. n^k'
+    # Also called 'failing factorial'
+    def permutations(n,k)
+      return 1 if k==0
+      return n if k==1
+      return factorial(n) if k==n
+      (((n-k+1)..n).inject(1) {|ac,v| ac * v})
+      #factorial(x).quo(factorial(x-n))
     end
+    
     # Binomial coeffients, or:
     # ( n )
     # ( k )
-    # Gives the number of different k size subsets of a set size n
+    #
+    # Gives the number of *different* k size subsets of a set size n
     # 
-    # Replaces (n,k) for (n, n-k) if k>n-k
+    # Uses:
     #
     #  (n)   n^k'    (n)..(n-k+1)
     #  ( ) = ---- =  ------------
@@ -250,41 +261,63 @@ module Distribution
     def binomial_coefficient(n,k)
       return 1 if (k==0 or k==n)
       k=[k, n-k].min
-      (((n-k+1)..n).inject(1) {|ac,v| ac * v}).quo(factorial(k))
-      # Other way to calcule binomial is this: 
+      permutations(n,k).quo(factorial(k))
+      # The factorial way is
+      # factorial(n).quo(factorial(k)*(factorial(n-k)))
+      # The multiplicative way is
       # (1..k).inject(1) {|ac, i| (ac*(n-k+i).quo(i))}
     end
+    # Binomial coefficient using multiplicative algorithm
+    # On benchmarks, is faster that raising factorial method
+    # when k is little. Use only when you're sure of that.
+    def binomial_coefficient_multiplicative(n,k)
+      return 1 if (k==0 or k==n)
+      k=[k, n-k].min
+      (1..k).inject(1) {|ac, i| (ac*(n-k+i).quo(i))}
+    end
+    
     # Approximate binomial coefficient, using gamma function.
     # The fastest method, until we fall on BigDecimal!
     def binomial_coefficient_gamma(n,k)
       return 1 if (k==0 or k==n)
-      k=[k, n-k].min
-      
-      val=gamma(n+1) / (gamma(k+1)*gamma(n-k+1))
+      k=[k, n-k].min      
+      # First, we try direct gamma calculation for max precission
+
+      val=gamma(n + 1).quo(gamma(k+1)*gamma(n-k+1))
+      # Ups. Outside float point range. We try with logs
       if (val.nan?)
-        lg=lgamma(n+1) - (lgamma(k+1)+lgamma(n-k+1))
+        #puts "nan"
+        lg=loggamma( n + 1 ) - (loggamma(k+1)+ loggamma(n-k+1))
         val=Math.exp(lg)
         # Crash again! We require BigDecimals
         if val.infinite?
+          #puts "infinite"
           val=BigMath.exp(BigDecimal(lg.to_s),16)
         end
       end
-      
       val
     end
+    alias :combinations :binomial_coefficient
   end
 end
 
 module Math
   include Distribution::MathExtension
-  alias :lgamma :loggamma 
-
-  module_function :factorial, :beta, :gamma, :gosper, :loggamma, :lgamma, :binomial_coefficient, :binomial_coefficient_gamma, :regularized_beta_function, :incomplete_beta, :permutations, :rising_factorial , :fast_factorial
+  module_function :factorial, :beta, :loggamma, :binomial_coefficient, :binomial_coefficient_gamma, :regularized_beta_function, :incomplete_beta, :permutations, :rising_factorial , :fast_factorial, :combinations
 end
 
 # Necessary on Ruby 1.9
 module CMath # :nodoc:
   include Distribution::MathExtension
-  module_function :factorial, :beta, :gosper, :loggamma,  :binomial_coefficient, :binomial_coefficient_gamma, :regularized_beta_function, :incomplete_beta, :permutations, :rising_factorial, :fast_factorial
+  module_function :factorial, :beta, :loggamma,  :binomial_coefficient, :binomial_coefficient_gamma, :regularized_beta_function, :incomplete_beta, :permutations, :rising_factorial, :fast_factorial, :combinations
+end
+
+if RUBY_VERSION<"1.9"
+  module Math
+    remove_method :loggamma
+    include Distribution::MathExtension18
+    module_function :gamma, :loggamma
+  end
 end
 
+

data/lib/distribution/poisson.rb

@@ -0,0 +1,34 @@
+require 'distribution/poisson/ruby'
+require 'distribution/poisson/gsl'
+#require 'distribution/poisson/java'
+
+
+module Distribution
+  # From Wikipedia
+  #  In probability theory and statistics, the Poisson distribution is 
+  #  a discrete probability distribution that expresses the probability of 
+  #  a number of events occurring in a fixed period of time if these 
+  #  events occur with a known average rate and independently of the time 
+  #  since the last event.
+  module Poisson
+    SHORTHAND='pois'
+    extend Distributable
+    create_distribution_methods
+
+    ##
+    # :singleton-method: pdf(k , l)
+    # PDF for Poisson distribution, 
+    # [+k+] is the number of occurrences of an event 
+    # [+l+] is a positive real number, equal to the expected number of occurrences that occur during the given interval.
+    
+    ##
+    # :singleton-method: cdf(k , l)
+    # CDF for Poisson distribution
+    # [+k+] is the number of occurrences of an event 
+    # [+l+] is a positive real number, equal to the expected number of occurrences that occur during the given interval.    
+    
+    # TODO: Not implemented yet
+    # :singleton-method: p_value(pr , l)
+
+  end
+end

data/lib/distribution/poisson/gsl.rb

@@ -0,0 +1,17 @@
+module Distribution
+  module Poisson
+    module GSL_
+      class << self
+        def pdf(k,l)
+          return 0 if k<0
+          GSL::Ran.poisson_pdf(k,l.to_f)
+        end
+        def cdf(k,l)
+          return 0 if k<0
+          GSL::Cdf.poisson_P(k, l.to_f)
+        end
+        
+      end
+    end
+  end
+end

data/lib/distribution/poisson/ruby.rb

@@ -0,0 +1,21 @@
+module Distribution
+  module Poisson
+    module Ruby_
+      class << self
+        def pdf(k,l )
+          (l**k*Math.exp(-l)).quo(Math.factorial(k))
+        end
+        def cdf(k,l)
+          Math.exp(-l)*(0..k).inject(0) {|ac,i| ac+ (l**i).quo(Math.factorial(i))}
+        end
+        def p_value(prob,l)
+          ac=0
+          (0..100).each do |i|
+            ac+=pdf(i,l)
+            return i if prob<=ac
+          end
+        end
+      end
+    end
+  end
+end

data/spec/binomial_spec.rb

@@ -51,6 +51,14 @@ end
       pending("No exact_p_value")
       @engine.should respond_to(:exact_p_value) 
     }
+    it "exact_cdf should return same values as cdf for n=50" do
+      pr=rand()*0.8+0.1
+      n=rand(10)+10
+      [1,(n/2).to_i,n-1].each do |k|
+       
+        @engine.exact_cdf(k,n,pr).should be_within(1e-10).of(@engine.cdf(k,n,pr))
+      end
+    end
     
     it "exact_pdf should not return a Float if not float is used as parameter" do
       @engine.exact_pdf(1,1,1).should_not be_a(Float)

data/spec/exponential_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
+  
+describe Distribution::Exponential do
+    
+  shared_examples_for "exponential engine" do
+    it "should return correct pdf" do
+      if @engine.respond_to? :pdf
+        [0.5,1,1.5].each {|l|
+          1.upto(5) {|x|
+            @engine.pdf(x,l).should be_within(1e-10).of(l*Math.exp(-l*x))
+          }
+        }
+      else
+        pending("No #{@engine}.pdf")
+      end
+    end
+    
+    it "should return correct cdf" do
+      if @engine.respond_to? :cdf
+        [0.5,1,1.5].each {|l|
+          1.upto(5) {|x|
+            @engine.cdf(x,l).should be_within(1e-10).of(1-Math.exp(-l*x))
+          }
+        }
+      else
+        pending("No #{@engine}.cdf")
+      end
+    end
+  
+    
+    it "should return correct p_value" do
+      if @engine.respond_to? :p_value
+        [0.5,1,1.5].each {|l|
+          1.upto(5) {|x|
+            pr=@engine.cdf(x,l)
+            @engine.p_value(pr,l).should be_within(1e-10).of(x)
+          }
+        }
+      else
+        pending("No #{@engine}.p_value")
+      end
+    end
+  end
+  
+
+  describe "singleton" do
+    before do
+      @engine=Distribution::Exponential
+    end
+    it_should_behave_like "exponential engine"
+  end
+  
+  describe Distribution::Exponential::Ruby_ do
+    before do
+      @engine=Distribution::Exponential::Ruby_
+    end
+    it_should_behave_like "exponential engine"
+    
+  end
+    
+  if Distribution.has_gsl?
+    describe Distribution::Exponential::GSL_ do
+      before do
+        @engine=Distribution::Exponential::GSL_
+      end
+    it_should_behave_like "exponential engine"
+    end
+  end
+  
+#  if Distribution.has_java?
+#    describe Distribution::Exponential::Java_ do
+#      before do
+#        @engine=Distribution::Exponential::Java_
+#      end
+#    it_should_behave_like "exponential engine"
+#    
+#    end  
+#  end
+  
+end

data/spec/math_extension_spec.rb

@@ -8,13 +8,7 @@ describe Distribution::MathExtension do
     end
   end
   
-  it "binomial coefficient(gamma) with n<=48 should be correct " do
-    
-    [1,5,10,25,48].each {|n|
-      k=(n/2).to_i
-      Math.binomial_coefficient_gamma(n,k).round.should eq(Math.binomial_coefficient(n,k))
-    }
-  end
+  
   it "rising_factorial should return correct values" do
     
     x=rand(10)+1
@@ -25,6 +19,17 @@ describe Distribution::MathExtension do
     Math.rising_factorial(x,4).should eq x**4+6*x**3+11*x**2+6*x
 
   end
+  
+  it "permutations should return correct values" do
+    n=rand(50)+50
+    10.times { |k|
+      Math.permutations(n,k).should eq(Math.factorial(n) / Math.factorial(n-k))
+    }
+    
+    
+    Math.permutations(n,n).should eq(Math.factorial(n) / Math.factorial(n-n))
+  end
+  
   it "incomplete beta function should return similar results to R" do
     pending("Not working yet")
     Math.incomplete_beta(0.5,5,6).should be_within(1e-6).of(Math.beta(5,6)*0.6230469)
@@ -46,12 +51,22 @@ describe Distribution::MathExtension do
     
     
   end
-  it "binomial coefficient(gamma) with 48<n<1000 should have 12 correct digits" do 
+  
+  it "binomial coefficient(gamma) with n<=48 should be correct " do
+    
+    [1,5,10,25,48].each {|n|
+      k=(n/2).to_i
+      Math.binomial_coefficient_gamma(n,k).round.should eq(Math.binomial_coefficient(n,k))
+    }
+  end
+  
+  it "binomial coefficient(gamma) with 48<n<1000 should have 11 correct digits" do 
     
-    [50,100,1000].each {|n|
-      k=n/2.to_i
-      obs=Math.binomial_coefficient_gamma(n,k).to_i.to_s[0,12]
-      exp=Math.binomial_coefficient(n,k).to_i.to_s[0,12]
+    [50,100,200,1000].each {|n|
+      k=(n/2).to_i
+      obs=Math.binomial_coefficient_gamma(n, k).to_i.to_s[0,11]
+      exp=Math.binomial_coefficient(n, k).to_i.to_s[0,11]
+      
       obs.should eq(exp)
     }
   end

data/spec/poisson_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
+  include ExampleWithGSL
+describe Distribution::Poisson do
+    
+  shared_examples_for "poisson engine" do
+    it "should return correct pdf" do
+      if @engine.respond_to? :pdf
+        [0.5,1,1.5].each {|l|
+          1.upto(5) {|k|
+            @engine.pdf(k,l).should be_within(1e-10).of((l**k*Math.exp(-l)).quo(Math.factorial(k)))
+          }
+        }
+      else
+        pending("No #{@engine}.pdf")
+      end
+    end
+    
+    it_only_with_gsl "should return correct cdf" do
+      if @engine.respond_to? :cdf
+        [0.5,1,1.5,4,10].each {|l|
+          1.upto(5) {|k|
+            @engine.cdf(k,l).should be_within(1e-10).of(GSL::Cdf.poisson_P(k,l))
+          }
+        }
+        
+      else
+        pending("No #{@engine}.cdf")
+      end
+    end
+  
+    
+    it "should return correct p_value" do
+      pending("No exact p_value")
+      if @engine.respond_to? :p_value
+         [0.1,1,5,10].each {|l|
+          1.upto(20) {|k|
+            pr=@engine.cdf(k,l)
+            @engine.p_value(pr,l).should eq(k)
+          }
+        }
+      else
+        pending("No #{@engine}.p_value")
+      end
+    end
+  end
+  
+
+  describe "singleton" do
+    before do
+      @engine=Distribution::Poisson
+    end
+    it_should_behave_like "poisson engine"
+  end
+  
+  describe Distribution::Poisson::Ruby_ do
+    before do
+      @engine=Distribution::Poisson::Ruby_
+    end
+    it_should_behave_like "poisson engine"
+    
+  end
+    
+  describe Distribution::Poisson::GSL_ do
+    before do
+      @engine=Distribution::Poisson::GSL_
+    end
+    it_should_behave_like "poisson engine"
+    
+  end
+  
+  
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
+  - 4
   - 0
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Claudio Bustos
@@ -35,7 +35,7 @@ cert_chain:
   rpP0jjs0
   -----END CERTIFICATE-----
 
-date: 2011-01-28 00:00:00 -03:00
+date: 2011-02-01 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -96,10 +96,11 @@ dependencies:
   type: :development
   version_requirements: *id004
 description: |-
-  Statistical Distributions multi library wrapper.
+  Statistical Distributions library. Includes Normal univariate and bivariate, T, F, Chi Square, Binomial, Hypergeometric, Exponential and Poisson.
+  
   Uses Ruby by default and C (statistics2/GSL) or Java extensions where available.
   
-  Includes code from statistics2
+  Includes code from statistics2 on Normal, T, F and Chi Square ruby code [http://blade.nagaokaut.ac.jp/~sinara/ruby/math/statistics2]
 email: 
 - clbustos_at_gmail.com
 executables: 
@@ -117,9 +118,17 @@ files:
 - README.txt
 - Rakefile
 - benchmark/binomial_coefficient.rb
+- benchmark/binomial_coefficient/binomial_coefficient.ds
+- benchmark/binomial_coefficient/binomial_coefficient.xls
+- benchmark/binomial_coefficient/experiment.rb
+- benchmark/factorial_hash.rb
 - benchmark/factorial_method.rb
 - benchmark/odd.rb
 - bin/distribution
+- data/template/distribution.erb
+- data/template/distribution/gsl.erb
+- data/template/distribution/ruby.erb
+- data/template/spec.erb
 - lib/distribution.rb
 - lib/distribution/binomial.rb
 - lib/distribution/binomial/gsl.rb
@@ -135,6 +144,9 @@ files:
 - lib/distribution/chisquare/java.rb
 - lib/distribution/chisquare/ruby.rb
 - lib/distribution/chisquare/statistics2.rb
+- lib/distribution/exponential.rb
+- lib/distribution/exponential/gsl.rb
+- lib/distribution/exponential/ruby.rb
 - lib/distribution/f.rb
 - lib/distribution/f/gsl.rb
 - lib/distribution/f/java.rb
@@ -151,6 +163,9 @@ files:
 - lib/distribution/normal/ruby.rb
 - lib/distribution/normal/statistics2.rb
 - lib/distribution/normalmultivariate.rb
+- lib/distribution/poisson.rb
+- lib/distribution/poisson/gsl.rb
+- lib/distribution/poisson/ruby.rb
 - lib/distribution/t.rb
 - lib/distribution/t/gsl.rb
 - lib/distribution/t/java.rb
@@ -160,10 +175,12 @@ files:
 - spec/bivariatenormal_spec.rb
 - spec/chisquare_spec.rb
 - spec/distribution_spec.rb
+- spec/exponential_spec.rb
 - spec/f_spec.rb
 - spec/hypergeometric_spec.rb
 - spec/math_extension_spec.rb
 - spec/normal_spec.rb
+- spec/poisson_spec.rb
 - spec/shorthand_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -200,6 +217,6 @@ rubyforge_project: distribution
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Statistical Distributions multi library wrapper
+summary: Statistical Distributions library
 test_files: []