distribution 0.5.0 → 0.6.0

data/lib/distribution/math_extension/log_utilities.rb

@@ -0,0 +1,80 @@
+# Added by John O. Woods, SciRuby project.
+# Derived from GSL-1.9 source files in the specfunc/ dir.
+
+module Distribution
+  module MathExtension
+    # Various logarithm shortcuts, adapted from GSL-1.9.
+    module Log
+      C1 = -1.quo(2)
+      C2 =  1.quo(3)
+      C3 = -1.quo(4)
+      C4 =  1.quo(5)
+      C5 = -1.quo(6)
+      C6 =  1.quo(7)
+      C7 = -1.quo(8)
+      C8 =  1.quo(9)
+      C9 = -1.quo(10)
+      class << self
+
+        # gsl_log1p from GSL-1.9 sys/log1p.c
+        # log for very small x
+        def log1p x
+          # in C, this is volatile double y.
+          # Not sure how to reproduce that in Ruby.
+          y = 1+x
+          Math.log(y) - ((y-1)-x).quo(y) # cancel errors with IEEE arithmetic
+        end
+
+        # \log(1+x) for x > -1
+        # gsl_sf_log_1plusx_e
+        def log_1plusx(x, with_error = false)
+          raise(ArgumentError, "Range error: x must be > -1") if x <= -1
+
+          if x.abs < Math::ROOT6_FLOAT_EPSILON
+            result = x * (1.0 + x * (C1 + x*(C2 + x*(C3 + x*(C4 + x*begin
+                       C5 + x*(C6 + x*(C7 + x*(C8 + x*C9))) # formerly t = this
+            end)))))
+            return with_error ? [result, Float::EPSILON * result.abs] : result
+          elsif x.abs < 0.5
+            c = ChebyshevSeries.evaluate(:lopx, (8*x + 1).quo(2*x+4), with_error)
+            return with_error ? [x * c.first, x * c.last] : x*c
+          else
+            result = Math.log(1+x)
+            return with_error ? [result, Float::EPSILON*result.abs] : result
+          end
+        end
+
+
+        # \log(1+x)-x for x > -1
+        # gsl_sf_log_1plusx_mx_e
+        def log_1plusx_minusx x, with_error = false
+          raise(ArgumentError, "Range error: x must be > -1") if x <= -1
+
+          if x.abs < Math::ROOT5_FLOAT_EPSILON
+            result = x*x * (C1 + x*(C2 + x*(C3 + x*(C4 + x*begin
+                       C5 + x*(C6 + x*(C7 + x*(C8 + x*C9))) # formerly t = this
+            end))))
+            return with_error ? [result, Float::EPSILON * result.abs] : result
+          elsif x.abs < 0.5
+            c = ChebyshevSeries.evaluate(:lopxmx, (8*x + 1).quo(2*x+4), with_error)
+            return with_error ? [x*x * c.first, x*x * c.last] : x*x*c
+          else
+            lterm = Math.log(1.0+x)
+            error = Float::EPSILON * (lterm.abs + x.abs) if with_error
+            result = lterm - x
+            return with_error ? [result, error] : result
+          end
+        end
+
+      protected
+
+        # Abstracted from other log helper functions in GSL-1.9.
+        def x_less_than_root_epsilon x, with_error
+          result  = square_x ? x*x : x
+
+          with_error ? [result, Float::EPSILON * result.abs] : result
+        end
+      end
+    end
+  end
+end

data/lib/distribution/t/ruby.rb

@@ -15,7 +15,8 @@ module Distribution
       # (-\infty, x]
       def p_t(df, t)
         if df.to_i!=df
-          raise "Can't calculate not integer df"
+          x=(t+Math.sqrt(t**2+df)) / (2*Math.sqrt(t**2+df))
+          return Math.regularized_beta(x,df/2.0,df/2.0)
         end
         df=df.to_i
         c2 = df.to_f / (df + t * t);

data/spec/beta_spec.rb

@@ -0,0 +1,82 @@
+require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
+include ExampleWithGSL
+describe Distribution::Beta do
+
+ shared_examples_for "Beta engine" do
+   it_only_with_gsl "should return correct pdf" do
+      if @engine.respond_to? :pdf
+        1.upto(101) do |x|
+          a=rand * x
+          b=1 + rand * 5
+          g=GSL::Ran.beta_pdf(x,a,b)
+          @engine.pdf(x,a,b).should be_within(1e-10).of(g)
+        end
+      else
+        pending("No #{@engine}.pdf")
+      end
+    end
+
+  it_only_with_gsl "should return correct cdf" do
+    if @engine.respond_to? :cdf
+      # From GSL-1.9.
+      TOL = 1048576.0*Float::EPSILON
+      @engine.cdf(0.0, 1.2, 1.3).should eq(0.0)
+      @engine.cdf(1e-100, 1.2, 1.3).should be_within(TOL).of(1.34434944656489596e-120)
+      @engine.cdf(0.001, 1.2, 1.3).should be_within(TOL).of(3.37630042504535813e-4)
+      @engine.cdf(0.01, 1.2, 1.3).should be_within(TOL).of(5.34317264038929473e-3)
+      @engine.cdf(0.1, 1.2, 1.3).should be_within(TOL).of(8.33997828306748346e-2)
+      @engine.cdf(0.325, 1.2, 1.3).should be_within(TOL).of(3.28698654180583916e-1)
+      @engine.cdf(0.5, 1.2, 1.3).should be_within(TOL).of(5.29781429451299081e-1)
+      @engine.cdf(0.9, 1.2, 1.3).should be_within(TOL).of(9.38529397224430659e-1)
+      @engine.cdf(0.99, 1.2, 1.3).should be_within(TOL).of(9.96886438341254380e-1)
+      @engine.cdf(0.999, 1.2, 1.3).should be_within(TOL).of(9.99843792833067634e-1)
+      @engine.cdf(1.0, 1.2, 1.3).should be_within(TOL).of(1.0)
+    else
+      pending("No #{@engine}.cdf")
+    end
+  end
+  it "should return correct p_value" do
+    if @engine.respond_to? :p_value
+      2.upto(99) do |x|
+        a=rand() * x
+        b=1 + rand() * 5
+        pr=@engine.cdf(x/100.0,a,b)
+        @engine.p_value(pr,a, b).should be_within(1e-10).of(x/100.0)
+       end
+    else
+      pending("No #{@engine}.p_value")
+    end
+  end
+end
+
+  describe "singleton" do
+    before do
+      @engine=Distribution::Beta
+    end
+    it_should_behave_like "Beta engine"
+  end
+  
+  describe Distribution::Beta::Ruby_ do
+    before do
+      @engine=Distribution::Beta::Ruby_
+    end
+    it_should_behave_like "Beta engine"
+  end
+  if Distribution.has_gsl?
+    describe Distribution::Beta::GSL_ do
+      before do
+        @engine=Distribution::Beta::GSL_
+      end
+    it_should_behave_like "Beta engine"
+    end
+  end
+  if Distribution.has_java?
+    describe Distribution::Beta::Java_ do
+      before do
+        @engine=Distribution::Beta::Java_
+      end
+    it_should_behave_like "Beta engine"
+    end  
+  end
+  
+end

data/spec/binomial_spec.rb

@@ -1,5 +1,5 @@
 require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
-  
+include ExampleWithGSL
 describe Distribution::Binomial do
   
 shared_examples_for "binomial engine" do

data/spec/gamma_spec.rb

@@ -0,0 +1,85 @@
+require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
+include ExampleWithGSL
+describe Distribution::Gamma do
+
+  
+shared_examples_for "Gamma engine" do
+  it_only_with_gsl "should return correct pdf" do
+      if @engine.respond_to? :pdf
+        1.upto(101) do |x|
+          a=rand * x
+          b=1 + rand * 5
+          g=GSL::Ran.gamma_pdf(x,a,b)
+          @engine.pdf(x,a,b).should be_within(1e-10).of(g)
+        end
+      else
+        pending("No #{@engine}.pdf")
+      end
+    end
+  it_only_with_gsl "should return correct cdf" do
+    if @engine.respond_to? :cdf
+      # From GSL-1.9.
+      TOL = 1048576.0*Float::EPSILON
+      @engine.cdf(0.0, 1.0, 1.0).should eq(0.0)
+      @engine.cdf(1e-100, 1.0, 1.0).should be_within(TOL).of(1e-100)
+      @engine.cdf(0.001, 1.0, 1.0).should be_within(TOL).of(9.99500166625008332e-4)
+      @engine.cdf(0.01, 1.0, 1.0).should be_within(TOL).of(9.95016625083194643e-3)
+      @engine.cdf(0.1, 1.0, 1.0).should be_within(TOL).of(9.51625819640404268e-2)
+      @engine.cdf(0.325, 1.0, 1.0).should be_within(TOL).of(2.77472646357927811e-1)
+      @engine.cdf(1.0, 1.0, 1.0).should be_within(TOL).of(6.32120558828557678e-1)
+      @engine.cdf(1.5, 1.0, 1.0).should be_within(TOL).of(7.76869839851570171e-1)
+      @engine.cdf(2.0, 1.0, 1.0).should be_within(TOL).of(8.64664716763387308e-1)
+      @engine.cdf(10.0, 1.0, 1.0).should be_within(TOL).of(9.99954600070237515e-1)
+      @engine.cdf(20.0, 1.0, 1.0).should be_within(TOL).of(9.99999997938846378e-1)
+      @engine.cdf(100.0, 1.0, 1.0).should be_within(TOL).of(1e0)
+      @engine.cdf(1000.0, 1.0, 1.0).should be_within(TOL).of(1e0)
+      @engine.cdf(10000.0, 1.0, 1.0).should be_within(TOL).of(1e0)
+    else
+      pending("No #{@engine}.cdf")
+    end
+  end
+  it "should return correct p_value" do
+    if @engine.respond_to? :p_value
+      1.upto(20) do |x|
+        a=rand()*0.5
+        b=1 + rand() * 5
+        pr=@engine.cdf(x,a,b)
+        @engine.p_value(pr,a,b).should be_within(1e-3).of(x)
+       end
+    else
+      pending("No #{@engine}.p_value")
+    end
+  end
+end
+
+  describe "singleton" do
+    before do
+      @engine=Distribution::Gamma
+    end
+    it_should_behave_like "Gamma engine"
+  end
+  
+  describe Distribution::Gamma::Ruby_ do
+    before do
+      @engine=Distribution::Gamma::Ruby_
+    end
+    it_should_behave_like "Gamma engine"
+  end
+  if Distribution.has_gsl?
+    describe Distribution::Gamma::GSL_ do
+      before do
+        @engine=Distribution::Gamma::GSL_
+      end
+    it_should_behave_like "Gamma engine"
+    end
+  end
+  if Distribution.has_java?
+    describe Distribution::Gamma::Java_ do
+      before do
+        @engine=Distribution::Gamma::Java_
+      end
+    it_should_behave_like "Gamma engine"
+    end  
+  end
+  
+end

data/spec/logistic_spec.rb

@@ -9,12 +9,12 @@ describe Distribution::Logistic do
 	u=rand()
         s=rand()+1
         x=rand()*100-50
-	exp=Math.exp(-(x-u)/s)/(s*(1+Math.exp(-(x-u)/s)**2))
-	@engine.pdf(x,u,s).should eq(exp)
+        exp=Math.exp(-(x-u) / s) / (s*(1+Math.exp(-(x-u) / s)**2))
+        @engine.pdf(x,u,s).should eq(exp)
         }
       else
         pending("No #{@engine}.pdf")
-      end
+       end
     end
     
     it "should return correct cdf" do

data/spec/math_extension_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__)+"/spec_helper.rb")
+include ExampleWithGSL
 describe Distribution::MathExtension do
   it "binomial coefficient should be correctly calculated" do
     
@@ -7,8 +8,186 @@ describe Distribution::MathExtension do
       Math.binomial_coefficient(n,k).should eq(Math.factorial(n).quo(Math.factorial(k)*Math.factorial(n-k)))
     end
   end
+
+  it "ChebyshevSeries for :sin should return correct values" do
+    #Math::SIN_CS.evaluate()
+  end
+
+  it "log_1plusx_minusx should return correct values" do
+    # Tests from GSL-1.9
+    Math::Log.log_1plusx_minusx(1.0e-10).should be_within(1e-10).of(-4.999999999666666667e-21)
+    Math::Log.log_1plusx_minusx(1.0e-8).should  be_within(1e-10).of(-4.999999966666666917e-17)
+    Math::Log.log_1plusx_minusx(1.0e-4).should  be_within(1e-10).of(-4.999666691664666833e-09)
+    Math::Log.log_1plusx_minusx(0.1).should     be_within(1e-10).of(-0.004689820195675139956)
+    Math::Log.log_1plusx_minusx(0.49).should    be_within(1e-10).of(-0.09122388004263222704)
+
+    Math::Log.log_1plusx_minusx(-0.49).should   be_within(1e-10).of(-0.18334455326376559639)
+    Math::Log.log_1plusx_minusx(1.0).should     be_within(1e-10).of(Math::LN2 - 1.0)
+    Math::Log.log_1plusx_minusx(-0.99).should   be_within(1e-10).of(-3.615170185988091368)
+  end
+
+  it "log_1plusx should return correct values" do
+    # Tests from GSL-1.9
+    Math::Log.log_1plusx(1.0e-10).should be_within(1e-10).of(9.999999999500000000e-11)
+    Math::Log.log_1plusx(1.0e-8).should  be_within(1e-10).of(9.999999950000000333e-09)
+    Math::Log.log_1plusx(1.0e-4).should  be_within(1e-10).of(0.00009999500033330833533)
+    Math::Log.log_1plusx(0.1).should     be_within(1e-10).of(0.09531017980432486004)
+    Math::Log.log_1plusx(0.49).should    be_within(1e-10).of(0.3987761199573677730)
+
+    Math::Log.log_1plusx(-0.49).should   be_within(1e-10).of(-0.6733445532637655964)
+    Math::Log.log_1plusx(1.0).should     be_within(1e-10).of(Math::LN2)
+    Math::Log.log_1plusx(-0.99).should   be_within(1e-10).of(-4.605170185988091368)
+  end
+
+  it "log_beta should return correct values" do
+    Math::Beta.log_beta(1.0e-8, 1.0e-8).first.should be_within(1e-10).of(19.113827924512310617)
+    Math::Beta.log_beta(1.0e-8, 0.01).first.should be_within(1e-10).of(18.420681743788563403)
+    Math::Beta.log_beta(1.0e-8, 1.0).first.should be_within(1e-10).of(18.420680743952365472)
+    Math::Beta.log_beta(1.0e-8, 10.0).first.should be_within(1e-10).of(18.420680715662683009)
+    Math::Beta.log_beta(1.0e-8, 1000.0).first.should be_within(1e-10).of(18.420680669107656949)
+    Math::Beta.log_beta(0.1, 0.1).first.should be_within(1e-10).of(2.9813614810376273949)
+    Math::Beta.log_beta(0.1, 1.0).first.should be_within(1e-10).of(2.3025850929940456840)
+    Math::Beta.log_beta(0.1, 100.0).first.should be_within(1e-10).of(1.7926462324527931217)
+    Math::Beta.log_beta(0.1, 1000).first.should be_within(1e-10).of(1.5619821298353164928)
+    Math::Beta.log_beta(1.0, 1.00025).first.should be_within(1e-10).of(-0.0002499687552073570)
+    Math::Beta.log_beta(1.0, 1.01).first.should be_within(1e-10).of(-0.009950330853168082848)
+    Math::Beta.log_beta(1.0, 1000.0).first.should be_within(1e-10).of(-6.907755278982137052)
+    Math::Beta.log_beta(100.0, 100.0).first.should be_within(1e-10).of(-139.66525908670663927)
+    Math::Beta.log_beta(100.0, 1000.0).first.should be_within(1e-10).of(-336.4348576477366051)
+    Math::Beta.log_beta(100.0, 1.0e+8).first.should be_within(1e-10).of(-1482.9339185256447309)
+  end
+
+  it "regularized_beta should return correct values" do
+    Math.regularized_beta(0.0,1.0, 1.0).should be_within(1e-10).of(0.0)
+    Math.regularized_beta(1.0, 1.0, 1.0).should be_within(1e-10).of(1.0)
+    Math.regularized_beta(1.0, 0.1, 0.1).should be_within(1e-10).of(1.0)
+    Math.regularized_beta(0.5, 1.0,  1.0).should be_within(1e-10).of(0.5)
+    Math.regularized_beta(0.5, 0.1,  1.0).should be_within(1e-10).of(0.9330329915368074160)
+    Math.regularized_beta(0.5, 10.0,  1.0).should be_within(1e-10).of(0.0009765625000000000000)
+    Math.regularized_beta(0.5, 50.0,  1.0).should be_within(1e-10).of(8.881784197001252323e-16)
+    Math.regularized_beta(0.5, 1.0,  0.1).should be_within(1e-10).of(0.06696700846319258402)
+    Math.regularized_beta(0.5, 1.0, 10.0).should be_within(1e-10).of(0.99902343750000000000)
+    Math.regularized_beta(0.5, 1.0, 50.0).should be_within(1e-10).of(0.99999999999999911180)
+    Math.regularized_beta(0.1, 1.0,  1.0).should be_within(1e-10).of(0.10)
+    Math.regularized_beta(0.1, 1.0,  2.0).should be_within(1e-10).of(0.19)
+    Math.regularized_beta(0.9, 1.0,  2.0).should be_within(1e-10).of(0.99)
+    Math.regularized_beta(0.5, 50.0, 60.0).should be_within(1e-10).of(0.8309072939016694143)
+    Math.regularized_beta(0.5, 90.0, 90.0).should be_within(1e-10).of(0.5)
+    Math.regularized_beta(0.5, 500.0,  500.0).should be_within(1e-10).of(0.5)
+    Math.regularized_beta(0.4, 5000.0, 5000.0).should be_within(1e-10).of(4.518543727260666383e-91)
+    Math.regularized_beta(0.6, 5000.0, 5000.0).should be_within(1e-10).of(1.0)
+    Math.regularized_beta(0.6, 5000.0, 2000.0).should be_within(1e-10).of(8.445388773903332659e-89)
+  end
+  it_only_with_gsl "incomplete_beta should return correct values" do
+    
+    a=rand()*10+1
+    b=rand()*10+1
+    ib = GSL::Function.alloc { |t|  t**(a-1)*(1-t)**(b-1)}
+    w = GSL::Integration::Workspace.alloc(1000)
+    1.upto(10) {|x|
+      inte=ib.qag([0,x / 10.0],w)
+      Math.incomplete_beta(x/10.0, a ,b).should be_within(1e-10).of(inte[0])
+    }
+  end
+
+  it "gammastar should return correct values" do
+    # Tests from GSL-1.9
+    Math::Gammastar.evaluate(1.0e-08).should        be_within(1e-10).of(3989.423555759890865)
+    Math::Gammastar.evaluate(1.0e-05).should        be_within(1e-10).of(126.17168469882690233)
+    Math::Gammastar.evaluate(0.001).should          be_within(1e-10).of(12.708492464364073506)
+    Math::Gammastar.evaluate(1.5).should            be_within(1e-10).of(1.0563442442685598666)
+    Math::Gammastar.evaluate(3.0).should            be_within(1e-10).of(1.0280645179187893045)
+    Math::Gammastar.evaluate(9.0).should            be_within(1e-10).of(1.0092984264218189715)
+    Math::Gammastar.evaluate(11.0).should           be_within(1e-10).of(1.0076024283104962850)
+    Math::Gammastar.evaluate(100.0).should          be_within(1e-10).of(1.0008336778720121418)
+    Math::Gammastar.evaluate(1.0e+05).should        be_within(1e-10).of(1.0000008333336805529)
+    Math::Gammastar.evaluate(1.0e+20).should        be_within(1e-10).of(1.0)
+  end
+
+  it "erfc_e should return correct values" do
+    # From GSL-1.9. For troubleshooting gammq.
+    Math::erfc_e(-10.0).should be_within(1e-10).of(2.0)
+    Math::erfc_e(-5.0000002).should be_within(1e-10).of(1.9999999999984625433)
+    Math::erfc_e(-5.0).should be_within(1e-10).of(1.9999999999984625402)
+    Math::erfc_e(-1.0).should be_within(1e-10).of(1.8427007929497148693)
+    Math::erfc_e(-0.5).should be_within(1e-10).of(1.5204998778130465377)
+    Math::erfc_e(1.0).should be_within(1e-10).of(0.15729920705028513066)
+    Math::erfc_e(3.0).should be_within(1e-10).of(0.000022090496998585441373)
+    Math::erfc_e(7.0).should be_within(1e-10).of(4.183825607779414399e-23)
+    Math::erfc_e(10.0).should be_within(1e-10).of(2.0884875837625447570e-45)
+  end
+
+
+  it "unnormalized_incomplete_gamma with x=0 should return correct values" do
+    Math.unnormalized_incomplete_gamma(-1.5, 0).should be_within(1e-10).of(4.0*Math.sqrt(Math::PI)/3.0)
+    Math.unnormalized_incomplete_gamma(-0.5, 0).should be_within(1e-10).of(-2*Math.sqrt(Math::PI))
+    Math.unnormalized_incomplete_gamma(0.5, 0).should be_within(1e-10).of(Math.sqrt(Math::PI))
+    Math.unnormalized_incomplete_gamma(1.0, 0).should eq 1.0
+    Math.unnormalized_incomplete_gamma(1.5, 0).should be_within(1e-10).of(Math.sqrt(Math::PI)/2.0)
+    Math.unnormalized_incomplete_gamma(2.0, 0).should eq 1.0
+    Math.unnormalized_incomplete_gamma(2.5, 0).should be_within(1e-10).of(0.75*Math.sqrt(Math::PI))
+    Math.unnormalized_incomplete_gamma(3.0, 0).should eq 2.0
+    Math.unnormalized_incomplete_gamma(3.5, 0).should be_within(1e-10).of(15.0*Math.sqrt(Math::PI) / 8.0)
+    Math.unnormalized_incomplete_gamma(4.0, 0).should eq 6.0
+  end
+
+  it "incomplete_gamma should return correct values" do
+    # Tests from GSL-1.9
+    Math.incomplete_gamma(1e-100, 0.001).should be_within(1e-10).of(1.0)
+    Math.incomplete_gamma(0.001, 0.001).should be_within(1e-10).of(0.9936876467088602902)
+    Math.incomplete_gamma(0.001, 1.0).should be_within(1e-10).of(0.9997803916424144436)
+    Math.incomplete_gamma(0.001, 10.0).should be_within(1e-10).of(0.9999999958306921828)
+    Math.incomplete_gamma(1.0, 0.001).should be_within(1e-10).of(0.0009995001666250083319)
+    Math.incomplete_gamma(1.0, 1.01).should be_within(1e-10).of(0.6357810204284766802)
+    Math.incomplete_gamma(1.0, 10.0).should be_within(1e-10).of(0.9999546000702375151)
+    Math.incomplete_gamma(10.0, 10.01).should be_within(1e-10).of(0.5433207586693410570)
+    Math.incomplete_gamma(10.0, 20.0).should be_within(1e-10).of(0.9950045876916924128)
+    Math.incomplete_gamma(1000.0, 1000.1).should be_within(1e-10).of(0.5054666401440661753)
+    Math.incomplete_gamma(1000.0, 2000.0).should be_within(1e-10).of(1.0)
+
+    # designed to trap the a-x=1 problem
+    # These next two are 1e-7 because they give the same output as GSL, but GSL is apparently not totally accurate here.
+    # It's a problem with log_1plusx_mx (log_1plusx_minusx in my code)
+    Math.incomplete_gamma(100,  99.0).should be_within(1e-7).of(0.4733043303994607)
+    Math.incomplete_gamma(200, 199.0).should be_within(1e-7).of(0.4811585880878718)
+
+    # Test for x86 cancellation problems
+    Math.incomplete_gamma(5670, 4574).should be_within(1e-10).of(3.063972328743934e-55)
+  end
+
+  it "gammq should return correct values" do
+    # Tests from GSL-1.9
+    Math.gammq(0.0, 0.001).should be_within(1e-10).of(0.0)
+    Math.gammq(0.001, 0.001).should be_within(1e-10).of(0.006312353291139709793)
+    Math.gammq(0.001, 1.0).should be_within(1e-10).of(0.00021960835758555639171)
+    Math.gammq(0.001, 2.0).should be_within(1e-10).of(0.00004897691783098147880)
+    Math.gammq(0.001, 5.0).should be_within(1e-10).of(1.1509813397308608541e-06)
+    Math.gammq(1.0, 0.001).should be_within(1e-10).of(0.9990004998333749917)
+    Math.gammq(1.0, 1.01).should be_within(1e-10).of(0.3642189795715233198)
+    Math.gammq(1.0, 10.0).should be_within(1e-10).of(0.00004539992976248485154)
+    Math.gammq(10.0, 10.01).should be_within(1e-10).of(0.4566792413306589430)
+    Math.gammq(10.0, 100.0).should be_within(1e-10).of(1.1253473960842733885e-31)
+    Math.gammq(1000.0, 1000.1).should be_within(1e-10).of(0.4945333598559338247)
+    Math.gammq(1000.0, 2000.0).should be_within(1e-10).of(6.847349459614753180e-136)
+
+    # designed to trap the a-x=1 problem
+    Math.gammq(100,  99.0).should be_within(1e-10).of(0.5266956696005394)
+    Math.gammq(200, 199.0).should be_within(1e-10).of(0.5188414119121281)
   
-  
+    # Test for x86 cancellation problems
+    Math.gammq(5670, 4574).should be_within(1e-10).of(1.0000000000000000)
+
+
+    # test suggested by Michel Lespinasse [gsl-discuss Sat, 13 Nov 2004]
+    Math.gammq(1.0e+06-1.0, 1.0e+06-2.0).should be_within(1e-10).of(0.50026596175224547004)
+
+    # tests in asymptotic regime related to Lespinasse test
+    Math.gammq(1.0e+06+2.0, 1.0e+06+1.0).should be_within(1e-10).of(0.50026596135330304336)
+    Math.gammq(1.0e+06, 1.0e+06-2.0).should be_within(1e-10).of(0.50066490399940144811)
+    Math.gammq(1.0e+07, 1.0e+07-2.0).should be_within(1e-10).of(0.50021026104978614908)
+  end
+
+
   it "rising_factorial should return correct values" do
     
     x=rand(10)+1
@@ -30,24 +209,20 @@ describe Distribution::MathExtension do
     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)
-    Math.incomplete_beta(0.6,5,6).should be_within(1e-6).of(Math.beta(5,6)*0.0006617154)
-  end
-  it "regularized incomplete beta should behave properly" do
+  
+  it "exact regularized incomplete beta should behave properly" do
 
-    Math.regularized_beta_function(0.5,5,5).should eq 0.5
-    Math.regularized_beta_function(0.5,5,6).should be_within(1e-6).of(0.6230469)
-    Math.regularized_beta_function(0.5,5,7).should  be_within(1e-6).of(0.725586)
+    Math.exact_regularized_beta(0.5,5,5).should be_within(1e-6).of(0.5)
+    Math.exact_regularized_beta(0.5,5,6).should be_within(1e-6).of(0.6230469)
+    Math.exact_regularized_beta(0.5,5,7).should  be_within(1e-6).of(0.725586)
     
     a=5
     b=5
-    Math.regularized_beta_function(0,a,b).should eq 0
-    Math.regularized_beta_function(1,a,b).should eq 1
+    Math.exact_regularized_beta(0,a,b).should eq 0
+    Math.exact_regularized_beta(1,a,b).should eq 1
     x=rand()
     
-    Math.regularized_beta_function(x,a,b).should be_within(1e-6). of(1-Math.regularized_beta_function(1-x,b,a))
+    Math.exact_regularized_beta(x,a,b).should be_within(1e-6). of(1-Math.regularized_beta(1-x,b,a))
     
     
   end