distribution 0.2.0 → 0.3.0

data/lib/distribution/chisquare/java.rb

@@ -0,0 +1,9 @@
+module Distribution
+  module ChiSquare
+    # TODO
+    module Java_
+      class << self
+      end
+    end
+  end
+end

data/lib/distribution/f.rb

@@ -1,6 +1,7 @@
 require 'distribution/f/ruby'
 require 'distribution/f/gsl'
 require 'distribution/f/statistics2'
+require 'distribution/f/java'
 module Distribution
   # Calculate cdf and inverse cdf for Chi Square Distribution.
   # 

data/lib/distribution/f/gsl.rb

@@ -3,14 +3,14 @@ module Distribution
   module GSL_
     class << self
       def pdf(x,k1,k2)
-        GSL::Ran.fdist_pdf(x,k1,k2)
+        GSL::Ran.fdist_pdf(x.to_f,k1,k2)
       end
       # Return the P-value of the corresponding integral with 
       # k degrees of freedom
       #
       #   Distribution::F.p_value(0.95,1,2)
       def p_value(pr,k1,k2)
-        GSL::Cdf.fdist_Pinv(pr,k1,k2)
+        GSL::Cdf.fdist_Pinv(pr.to_f,k1,k2)
       end
       # F cumulative distribution function (cdf).
       # 
@@ -20,7 +20,7 @@ module Distribution
       #   Distribution::F.cdf(20,3,2)
       # 
       def cdf(x, k1, k2)
-        GSL::Cdf.fdist_P(x.to_f,k1,k2)
+        GSL::Cdf.fdist_P(x.to_f.to_f,k1,k2)
       end
       end
     end

data/lib/distribution/f/java.rb

@@ -0,0 +1,9 @@
+module Distribution
+  module F
+    # TODO
+    module Java_
+      class << self
+      end
+    end
+  end
+end

data/lib/distribution/hypergeometric.rb

@@ -1,5 +1,7 @@
 require 'distribution/hypergeometric/ruby'
 require 'distribution/hypergeometric/gsl'
+require 'distribution/hypergeometric/java'
+
 
 module Distribution
   # From Wikipedia:

data/lib/distribution/hypergeometric/gsl.rb

@@ -5,9 +5,9 @@ module Distribution
         def pdf(k, m, n, total)  # :nodoc:
           GSL::Ran::hypergeometric_pdf(k, m, total-m, n)
         end
-        # The GSL::Cdf function for hypergeometric is broken:
+        # The GSL::Cdf function for hypergeometric 
         #   
-        def cdf_broken(k, m, n, total) # :nodoc:
+        def cdf(k, m, n, total) # :nodoc:
           GSL::Cdf::hypergeometric_P(k, m, total-m, n)
         end
         

data/lib/distribution/hypergeometric/java.rb

@@ -0,0 +1,9 @@
+module Distribution
+  module Hypergeometric
+    # TODO
+    module Java_
+      class << self
+      end
+    end
+  end
+end

data/lib/distribution/hypergeometric/ruby.rb

@@ -1,32 +1,13 @@
-# Added by John O. Woods, SciRuby project.
-
-# Extensions to Fixnum for Hypergeometric calculations in pure Ruby.
-# ==Reference
-# * http://bluebones.net/2007/09/combinatorics-in-ruby/
-# * http://mathworld.wolfram.com/StirlingsApproximation.html
-class Fixnum
-  # +k+-combination of a set of size +self+
-  def choose(k)
-    Math.factorial(self) / (Math.factorial(k) * Math.factorial(self - k))
-  end
-
-  # Fast combination calculation using Gosper's approximation of factorials.
-  def fast_choose(k)
-    Math.fast_factorial(self).quo(Math.fast_factorial(self - k) * Math.fast_factorial(k))
-  end
-end
+# Added by John O. Woods, SciRuby project. 
+# Optimized by Claudio Bustos
 
 module Distribution
   module Hypergeometric
     module Ruby_
       class << self
-        # Calculates PDF quickly. Not guaranteed to produce any accuracy, since it uses Stirling's approximation.
-        # This can be improved, most likely, by writing specific cases of when to use fast_choose and when to use
-        # choose.
-        def pdf_aprox(k, m, n, total)
-          m.fast_choose(k) * (total-m).fast_choose(n-k).quo( total.fast_choose(n))
+        def bc(n,k)
+          Math.binomial_coefficient(n,k)
         end
-
         # Hypergeometric probability density function
         #
         # Probability p(+k+, +m+, +n+, +total+) of drawing sets of size +m+ and +n+ with an intersection of size +k+
@@ -39,19 +20,26 @@ module Distribution
           min_m_n=m<n ? m : n
           max_t=[0,m+n-total].max
           return 0 if k>min_m_n or k<max_t
-          m.choose(k) * (total-m).choose(n-k) / total.choose(n).to_f
+          (bc(m,k) * bc(total-m,n-k)).quo(bc(total,n))
+        end
+        
+        
+        
+        def pdf_with_den(k,m,n,total,den)
+          (bc(m,k) * bc(total-m,n-k)).quo(den)
         end
 
         # p-value: 
        
         def p_value(pr, m, n, total)
           ac=0
+          den=bc(total,n)
+          
           (0..total).each do |i|
-            ac+=pdf(i,m,n,total)
+            ac+=pdf_with_den(i,m,n,total,den)
             return i if ac>=pr
           end
         end
-
         # Cumulative distribution function.
         # The probability of obtain, from a sample of
         # size +n+, +k+ or less elements
@@ -61,8 +49,17 @@ module Distribution
         def cdf(k, m, n, total)
           raise "k>m" if k>m
           raise "k>n" if k>n
-          (0..k).collect { |ki| pdf(ki,m,n,total) }.inject { |sum,v| sum+v}
+          # Store the den
+          den=bc(total,n)
+          (0..k).collect { |ki| pdf_with_den(ki,m,n,total,den) }.inject { |sum,v| sum+v}
         end
+        
+        
+        alias :exact_pdf :pdf 
+        alias :exact_p_value :p_value
+        alias :exact_cdf :cdf 
+
+        
       end
     end
   end

data/lib/distribution/math_extension.rb

@@ -1,4 +1,16 @@
-require 'prime'
+if RUBY_VERSION<"1.9"
+  require 'mathn'
+  def Prime.each(upper,&block) 
+    @primes=Prime.new
+    @primes.each do |prime|
+      break if prime > upper.to_i
+      block.call(prime)
+    end
+  end
+else
+  require 'prime'
+end
+
 require 'bigdecimal'
 require 'bigdecimal/math'
 
@@ -38,30 +50,31 @@ module Distribution
         return SmallOddSwing[n] if (n<33)
         sqrtN = Math.sqrt(n).floor
         count=0
+        
         Prime.each(n/3) do |prime|
           next if prime<3
           if (prime<=sqrtN)
             q=n
             _p=1
-            while((q/=prime)>0) do
-              if ((q&1)==1)
+            
+            while((q=(q/prime).truncate)>0) do
+              if((q%2)==1)
                 _p*=prime
               end
             end
-            
             if _p>1
               @prime_list[count]=_p
               count+=1
             end
             
           else
-            if ((n/prime)&1==1)
+            if ((n/prime).truncate%2==1)
               @prime_list[count]=prime
               count+=1
             end
           end
         end
-        prod=get_primorial(n/2+1,n)
+        prod=get_primorial((n/2).truncate+1,n)
         prod * @prime_list[0,count].inject(1) {|ac,v| ac*v}
       end
       def get_primorial(low,up)
@@ -152,6 +165,37 @@ module Distribution
     def beta(x,y)
       (gamma(x)*gamma(y)).quo(gamma(x+y))
     end
+    # I_x(a,b): Regularized incomplete beta function
+    #   
+    # Source:
+    #
+    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..n).inject(0) {|sum,j|
+        sum+(binomial_coefficient(n,j)* x**j * (1-x)**(n-j))
+      }
+
+    end
+    # B_x(a,b) : Incomplete beta function
+    # 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))
+    end
+    
+    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
@@ -192,17 +236,55 @@ module Distribution
       end
       Math.exp(loggamma(x))
     end
+    # Binomial coeffients, or:
+    # ( n )
+    # ( k )
+    # Gives the number of different k size subsets of a set size n
+    # 
+    # Replaces (n,k) for (n, n-k) if k>n-k
+    #
+    #  (n)   n^k'    (n)..(n-k+1)
+    #  ( ) = ---- =  ------------
+    #  (k)    k!          k!
+    #
+    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: 
+      # (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))
+      if (val.nan?)
+        lg=lgamma(n+1) - (lgamma(k+1)+lgamma(n-k+1))
+        val=Math.exp(lg)
+        # Crash again! We require BigDecimals
+        if val.infinite?
+          val=BigMath.exp(BigDecimal(lg.to_s),16)
+        end
+      end
+      
+      val
+    end
   end
 end
 
 module Math
   include Distribution::MathExtension
-  module_function :factorial, :beta, :gamma, :gosper, :loggamma, :fast_factorial
+  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
 end
 
 # Necessary on Ruby 1.9
 module CMath # :nodoc:
   include Distribution::MathExtension
-  module_function :factorial, :beta, :gamma, :gosper, :loggamma, :fast_factorial
+  module_function :factorial, :beta, :gosper, :loggamma,  :binomial_coefficient, :binomial_coefficient_gamma, :regularized_beta_function, :incomplete_beta, :permutations, :rising_factorial, :fast_factorial
 end
 

data/lib/distribution/normal.rb

@@ -1,6 +1,7 @@
 require 'distribution/normal/ruby'
 require 'distribution/normal/gsl'
 require 'distribution/normal/statistics2'
+require 'distribution/normal/java'
 
 module Distribution
   # From Wikipedia: 

data/lib/distribution/normal/java.rb

@@ -0,0 +1,9 @@
+module Distribution
+  module Normal
+    # TODO
+    module Java_
+      class << self
+      end
+    end
+  end
+end

data/lib/distribution/t.rb

@@ -1,6 +1,8 @@
 require 'distribution/t/ruby'
 require 'distribution/t/gsl'
 require 'distribution/t/statistics2'
+require 'distribution/t/java'
+
 module Distribution
 
     # Calculate statisticals for T Distribution.

data/lib/distribution/t/java.rb

@@ -0,0 +1,9 @@
+module Distribution
+  module T
+    # TODO
+    module Java_
+      class << self
+      end
+    end
+  end
+end

data/lib/distribution/t/statistics2.rb

@@ -11,7 +11,7 @@ module Distribution
       
        
       # There are some problem on i686 with t on statistics2
-      if !RbConfig::CONFIG['arch']=~/i686/
+      if true or !RbConfig::CONFIG['arch']=~/i686/
         # T cumulative distribution function (cdf).
         # 
         # Returns the integral of t-distribution 

data/spec/binomial_spec.rb

@@ -0,0 +1,118 @@
+require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
+  
+describe Distribution::Binomial do
+  
+shared_examples_for "binomial engine" do
+  it "should return correct pdf" do
+    if @engine.respond_to? :pdf
+      [10,100,1000].each do |n|
+        [1.quo(4),1.quo(2),3.quo(4)].each do |pr|
+          [0, 1,n/2,n-1].each do |x| 
+            exp=Math.binomial_coefficient(n,x)*pr**x*(1-pr)**(n-x)
+            obs=@engine.pdf(x,n,pr)
+            obs.should be_within(1e-5).of(exp), "For pdf(#{x},#{n},#{pr}) expected #{exp}, obtained #{obs}"
+            
+          end
+        end
+      end
+    else
+      pending("No #{@engine}.pdf")
+    end
+  end
+  it_only_with_gsl "should return correct cdf for n<=100" do
+     if @engine.respond_to? :pdf
+        [10,100].each do |n|
+          [0.25,0.5,0.75].each do |pr|
+            [1,n/2,n-1].each do |x| 
+              exp=GSL::Cdf.binomial_P(x,pr,n)
+              obs=@engine.cdf(x,n,pr)
+              exp.should be_within(1e-5).of(obs), "For cdf(#{x},#{n},#{pr}) expected #{exp}, obtained #{obs}"
+            end
+          end
+        end
+      else
+        pending("No #{@engine}.cdf")
+      end
+  end
+
+  
+  
+end
+
+  describe "singleton" do
+    before do
+      @engine=Distribution::Binomial
+    end
+    it_should_behave_like "binomial engine"
+    
+    
+    it {@engine.should respond_to(:exact_pdf) }
+    it {
+      pending("No exact_p_value")
+      @engine.should respond_to(:exact_p_value) 
+    }
+    
+    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)
+      @engine.exact_pdf(16, 80, 1.quo(2)).should_not be_a(Float)
+    end
+
+    
+    
+    
+  end
+  
+  describe Distribution::Binomial::Ruby_ do
+    before do
+      @engine=Distribution::Binomial::Ruby_
+    end
+    it_should_behave_like "binomial engine"
+    
+    it "should return correct cdf for n>100" do
+      pending("incomplete beta function is slow. Should be replaced for a faster one")
+    end
+    
+    it "should return correct p_value for n<=100" do
+      pending("Can't calculate with precision x using p")
+    [10,100].each do |n|
+      [0.25,0.5,0.75].each do |pr|
+        [n/2].each do |x| 
+          cdf=@engine.cdf(x,n,pr)
+          p_value=@engine.p_value(cdf,n,pr)
+          
+          p_value.should eq(x), "For p_value(#{cdf},#{n},#{pr}) expected #{x}, obtained #{p_value}"
+        end
+      end
+    end
+    end
+    
+  end
+  if Distribution.has_gsl?
+    describe Distribution::Binomial::GSL_ do
+      before do
+        @engine=Distribution::Binomial::GSL_
+      end
+    it_should_behave_like "binomial engine"
+    end
+  end
+  #if Distribution.has_statistics2?
+  #  describe Distribution::Binomial::Statistics2_ do
+  #    
+  #    before do
+  #      @engine=Distribution::Binomial::Statistics2_
+  #    end
+    #it_should_behave_like "binomial engine"
+  #  end  
+  #end
+  
+  if Distribution.has_java?
+    describe Distribution::Binomial::Java_ do
+      before do
+        @engine=Distribution::Binomial::Java_
+      end
+    it_should_behave_like "binomial engine"
+    
+    end  
+  end
+  
+end