distribution 0.5.0 → 0.6.0

data/lib/distribution/math_extension/exponential_integral.rb

@@ -0,0 +1,63 @@
+module Distribution
+  module MathExtension
+    # From GSL-1.9.
+    module ExponentialIntegral
+      class << self
+        def first_order x, scale = 0, with_error = false
+          xmaxt = -Math::LOG_FLOAT_MIN
+          xmax  = xmaxt - Math.log(xmaxt)
+          result = nil
+          error  = with_error ? nil : 0.0
+
+          if x < -xmax && !scale
+            raise("Overflow Error")
+          elsif x <= -10.0
+            s = 1.0 / x * ( scale ? 1.0 : Math.exp(-x))
+            result_c = ChebyshevSeries.eval(20.0/x+1.0, :ae11, with_error)
+            result_c, result_c_err = result_c if with_error
+            result   = s * (1.0 + result_c)
+            error  ||= (s * result_c_err) + 2.0*Float::EPSILON * (x.abs + 1.0) * result.abs
+          elsif x <= -4.0
+            s = 1.0 / x * (scale ? 1.0 : Math.exp(-x))
+            result_c = ChebyshevSeries.eval((40.0/x+7.0)/3.0, :ae12, with_error)
+            result_c, result_c_err = result_c if with_error
+            result   = s * (1.0 + result_c)
+            error  ||= (s * result_c_err) + 2.0*Float::EPSILON * result.abs
+          elsif x <= -1.0
+            ln_term = - Math.log(x.abs)
+            scale_factor = scale ? Math.exp(x) : 1.0
+            result_c = ChebyshevSeries.eval((2.0*x+5.0)/3.0, :e11, with_error)
+            result_c, result_c_err = result_c if with_error
+            result   = scale_factor * (ln_term + result_c)
+            error  ||= scale_factor * (result_c_err + Float::EPSILON * ln_term.abs) + 2.0*Float::EPSILON*result.abs
+          elsif x == 0.0
+            raise(ArgumentError, "Domain Error")
+          elsif x <= 1.0
+            ln_term = - Math.log(x.abs)
+            scale_factor = scale ? Math.exp(x) : 1.0
+            result_c = ChebyshevSeries.eval(x, :e12, with_error)
+            result_c, result_c_err = result_c if with_error
+            result   = scale_factor * (ln_term - 0.6875 + x + result_c)
+            error  ||= scale_factor * (result_c_err + Float::EPSILON * ln_term.abs) + 2.0*Float::EPSILON*result.abs
+          elsif x <= 4.0
+            s = 1.0 / x * (scale ? 1.0 : Math.exp(-x))
+            result_c = ChebyshevSeries.eval((8.0/x-5.0)/3.0, :ae13, with_error)
+            result_c, result_c_err = result_c if with_error
+            result   = s * (1.0 + result_c)
+            error  ||= (s * result_c_err) + 2.0*Float::EPSILON * result.abs
+          elsif x <= xmax || scale
+            s = 1.0 / x * (scale ? 1.0 : Math.exp(-x))
+            result_c = ChebyshevSeries.eval(8.0/x-1.0, :ae14, with_error)
+            result_c, result_c_err = result_c if with_error
+            result   = s * (1.0 + result_c)
+            error  ||= s * (Float::EPSILON + result_c_err) + 2.0*(x+1.0)*Float::EPSILON * result.abs
+            raise("Underflow Error") if result == 0.0
+          else
+            raise("Underflow Error")
+          end
+          with_error ? [result, error] : result
+        end
+      end
+    end
+  end
+end

data/lib/distribution/math_extension/gammastar.rb

@@ -0,0 +1,64 @@
+# Added by John O. Woods, SciRuby project.
+# Derived from GSL-1.9 source files in the specfunc/ dir.
+
+module Distribution
+  module MathExtension
+    # Derived from GSL-1.9.
+    module Gammastar
+      C0 =  1.quo(12)
+      C1 = -1.quo(360)
+      C2 =  1.quo(1260)
+      C3 = -1.quo(1680)
+      C4 =  1.quo(1188)
+      C5 = -691.quo(360360)
+      C6 =  1.quo(156)
+      C7 = -3617.quo(122400)
+
+      class << self
+
+        def series x, with_error = false
+          # Use the Stirling series for the correction to Log(Gamma(x)),
+          # which is better behaved and easier to compute than the
+          # regular Stirling series for Gamma(x).
+          y      = 1.quo(x*x)
+          ser    = C0 + y*(C1 + y*(C2 + y*(C3 + y*(C4 + y*(C5 + y*(C6 + y*C7))))))
+          result = Math.exp(ser/x)
+          with_error ? [result, 2.0 * Float::EPSILON * result * [1, ser/x].max] : result
+        end
+
+        def evaluate x, with_error = false
+          raise(ArgumentError, "x must be positive") if x <= 0
+          if x < 0.5
+            STDERR.puts("Warning: Don't know error on lg_x, error for this function will be incorrect") if with_error
+            lg = Math.lgamma(x).first
+            lg_err = Float::EPSILON # Guess
+            lx = Math.log(x)
+            c    = 0.5 * (LN2 + LNPI)
+            lnr_val = lg - (x-0.5)*lx + x - c
+            lnr_err = lg_err + 2.0*Float::EPSILON * ((x+0.5)*lx.abs + c)
+            with_error ? exp_err(lnr_val, lnr_err) : Math.exp(lnr_val)
+          elsif x < 2.0
+            t = 4.0/3.0*(x-0.5) - 1.0
+            ChebyshevSeries.evaluate(:gstar_a, t, with_error)
+          elsif x < 10.0
+            t = 0.25*(x-2.0) - 1.0
+            c = ChebyshevSeries.evaluate(:gstar_b, t, with_error)
+            c, c_err = c if with_error
+
+            result      = c / (x*x) + 1.0 + 1.0/(12.0*x)
+            with_error ? [result, c_err / (x*x) + 2.0*Float::EPSILON*result.abs] : result
+          elsif x < 1.0/Math::ROOT4_FLOAT_EPSILON
+            series x, with_error
+          elsif x < 1.0 / Float::EPSILON # Stirling
+            xi = 1.0 / x
+            result = 1.0 + xi/12.0*(1.0 + xi/24.0*(1.0 - xi*(139.0/180.0 + 571.0/8640.0*xi)))
+            result_err = 2.0 * Float::EPSILON * result.abs
+            with_error ? [result,result_err] : result
+          else
+            with_error ? [1.0,1.0/x] : 1.0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/distribution/math_extension/gsl_utilities.rb

@@ -0,0 +1,31 @@
+# Added by John O. Woods, SciRuby project.
+# Derived from GSL-1.9 source files, mostly in the specfunc/ dir.
+
+module Distribution
+  module MathExtension
+    LNPI                = 1.14472988584940017414342735135
+    LN2                 = 0.69314718055994530941723212146
+    SQRT2               = 1.41421356237309504880168872421
+    SQRTPI              = 1.77245385090551602729816748334
+
+    ROOT3_FLOAT_MIN     = Float::MIN ** (1/3.0)
+    ROOT3_FLOAT_EPSILON = Float::EPSILON ** (1/3.0)
+    ROOT4_FLOAT_MIN     = Float::MIN ** (1/4.0)
+    ROOT4_FLOAT_EPSILON = Float::EPSILON ** (1/4.0)
+    ROOT5_FLOAT_MIN     = Float::MIN ** (1/5.0)
+    ROOT5_FLOAT_EPSILON = Float::EPSILON ** (1/5.0)
+    ROOT6_FLOAT_MIN     = Float::MIN ** (1/6.0)
+    ROOT6_FLOAT_EPSILON = Float::EPSILON ** (1/6.0)
+    LOG_FLOAT_MIN       = Math.log(Float::MIN)
+    EULER               = 0.57721566490153286060651209008
+
+    # e^x taking into account the error thus far (I think)
+    # gsl_sf_exp_err_e
+    def exp_err(x, dx)
+      adx = dx.abs
+      raise("Overflow Error in exp_err: x + adx > LOG_FLOAT_MAX") if x + adx > LOG_FLOAT_MAX
+      raise("Underflow Error in exp_err: x - adx < LOG_FLOAT_MIN") if x - adx < LOG_FLOAT_MIN
+      [Math.exp(x), Math.exp(x) * [Float::EPSILON, Math.exp(adx) - 1.0/Math.exp(adx)] + 2.0 * Float::EPSILON * Math.exp(x).abs]
+    end
+  end
+end

data/lib/distribution/math_extension/incomplete_beta.rb

@@ -0,0 +1,213 @@
+# Added by John O. Woods, SciRuby project.
+# Derived from GSL-1.9 source files in the specfunc/ dir.
+
+module Distribution
+  module MathExtension
+    module Beta
+      class << self
+        # Based on gsl_sf_lnbeta_e and gsl_sf_lnbeta_sgn_e
+        # Returns result and sign in an array. If with_error is specified, also returns the error.
+        def log_beta(x,y, with_error=false)
+          sign = nil
+
+          raise(ArgumentError, "x and y must be nonzero") if x == 0.0 || y == 0.0
+          raise(ArgumentError, "not defined for negative integers") if [x,y].any? { |v| (v.is_a?(Fixnum) && v < 0) }
+
+          # See if we can handle the positive case with min/max < 0.2
+          if x > 0 && y > 0
+            min, max = [x,y].minmax
+            ratio    = min.quo(max)
+
+            if ratio < 0.2
+              gsx   = Gammastar.evaluate(x, with_error)
+              gsy   = Gammastar.evaluate(y, with_error)
+              gsxy  = Gammastar.evaluate(x+y, with_error)
+              lnopr = Log::log_1plusx(ratio, with_error)
+
+              gsx, gsx_err, gsy, gsy_err, gsxy, gsxy_err, lnopr, lnopr_err = [gsx,gsy,gsxy,lnopr].flatten if with_error
+
+              lnpre = Math.log((gsx*gsy).quo(gsxy) * Math::SQRT2 * Math::SQRTPI)
+              lnpre_err = gsx_err.quo(gsx) + gsy_err(gsy) + gsxy_err.quo(gsxy) if with_error
+
+              t1    = min * Math.log(ratio)
+              t2    = 0.5 * Math.log(min)
+              t3    = (x+y-0.5)*lnopr
+
+              lnpow       = t1 - t2 - t3
+              lnpow_err   = Float::EPSILON * (t1.abs + t2.abs + t3.abs) + (x+y-0.5).abs * lnopr_err if with_error
+
+              result      = lnpre + lnpow
+              error       = lnpre_err + lnpow_err + 2.0*Float::EPSILON*result.abs if with_error
+
+              return with_error ? [result, 1.0, error] : [result, 1.0]
+            end
+          end
+
+          # General case: fallback
+          lgx, sgx   = Math.lgamma(x)
+          lgy, sgy   = Math.lgamma(y)
+          lgxy, sgxy = Math.lgamma(x+y)
+          sgn        = sgx * sgy * sgxy
+
+          raise("Domain error: sign is -") if sgn == -1
+
+          result = lgx + lgy - lgxy
+          if with_error
+            lgx_err, lgy_err, lgxy_err = begin
+              STDERR.puts("Warning: Error is unknown for Math::lgamma, guessing.")
+              [Math::EPSILON, Math::EPSILON, Math::EPSILON]
+            end
+
+            error  = lgx_err + lgy_err + lgxy_err + Float::EPSILON*(lgx.abs+lgy.abs+lgxy.abs) + 2.0*(Float::EPSILON)*result.abs
+            return [result, sgn, error]
+          else
+            return [result, sgn]
+          end
+
+        end
+      end
+    end
+    # Calculate regularized incomplete beta function
+    module IncompleteBeta
+
+      MAX_ITER = 512
+      CUTOFF   = 2.0 * Float::MIN
+
+      class << self
+
+        # Evaluate aa * beta_inc(a,b,x) + yy
+        #
+        # No error mode available.
+        #
+        # From GSL-1.9: cdf/beta_inc.c, beta_inc_AXPY
+        def axpy(aa,yy,a,b,x)
+          return aa*0 + yy if x == 0.0
+          return aa*1 + yy if x == 1.0
+
+          ln_beta   = Math.logbeta(a, b)
+          ln_pre    = -ln_beta   +   a * Math.log(x)   +   b * Math::Log.log1p(-x)
+          prefactor = Math.exp(ln_pre)
+
+          if x < (a+1).quo(a+b+2)
+            # Apply continued fraction directly
+            epsabs  = yy.quo((aa * prefactor).quo(a)).abs * Float::EPSILON
+            cf      = continued_fraction(a, b, x, epsabs)
+            return  aa * (prefactor * cf).quo(a) + yy
+          else
+            # Apply continued fraction after hypergeometric transformation
+            epsabs = (aa + yy).quo( (aa*prefactor).quo(b) ) * Float::EPSILON
+            cf     = continued_fraction(b, a, 1-x, epsabs)
+            term   = (prefactor * cf).quo(b)
+            return aa == -yy ? -aa*term : aa*(1-term)+yy
+          end
+        end
+
+
+        # Evaluate the incomplete beta function
+        # gsl_sf_beta_inc_e
+        def evaluate(a,b,x,with_error=false)
+          raise(ArgumentError, "Domain error: a(#{a}), b(#{b}) must be positive; x(#{x}) must be between 0 and 1, inclusive") if a <= 0 || b <= 0 || x < 0 || x > 1
+          if x == 0
+            return with_error ? [0.0,0.0] : 0.0
+          elsif x == 1
+            return with_error ? [1.0,0.0] : 1.0
+          else
+
+            ln_beta = Beta.log_beta(a,b, with_error)
+            ln_1mx  = Log.log_1plusx(-x, with_error)
+            ln_x    = Math.log(x)
+
+            ln_beta, ln_beta_err, ln_1mx, ln_1mx_err, ln_x_err = begin
+              #STDERR.puts("Warning: Error is unknown for Math::log, guessing.")
+              [ln_beta,ln_1mx,Float::EPSILON].flatten
+            end
+
+            ln_pre      = -ln_beta + a*ln_x + b*ln_1mx
+            ln_pre_err  = ln_beta_err + (a*ln_x_err).abs + (b*ln_1mx_err).abs if with_error
+
+            prefactor, prefactor_err   = begin
+              if with_error
+                exp_err(ln_pre, ln_pre_err)
+              else
+                [Math.exp(ln_pre), nil]
+              end
+            end
+
+            if x < (a+1).quo(a+b+2)
+              # Apply continued fraction directly
+              
+              cf      = continued_fraction(a,b,x, nil, with_error)
+              cf,cf_err = cf if with_error
+              result  = (prefactor * cf).quo(a)
+              return with_error ? [result, ((prefactor_err*cf).abs + (prefactor*cf_err).abs).quo(a)] : result
+            else
+              # Apply continued fraction after hypergeometric transformation
+
+              cf      = continued_fraction(b, a, 1-x, nil)
+              cf,cf_err = cf if with_error
+              term    = (prefactor * cf).quo(b)
+              result  = 1 - term
+
+              return with_error ? [result, (prefactor_err*cf).quo(b) + (prefactor*cf_err).quo(b) + 2.0*Float::EPSILON*(1+term.abs)] : result
+            end
+
+          end
+        end
+
+
+        def continued_fraction_cutoff(epsabs)
+          return CUTOFF if epsabs.nil?
+          0.0/0 # NaN
+        end
+
+        # Continued fraction calculation of incomplete beta
+        # beta_cont_frac from GSL-1.9
+        #
+        # If epsabs is set, will execute the version of the GSL function in the cdf folder. Otherwise, does the
+        # basic one in specfunc.
+        def continued_fraction(a,b,x,epsabs=nil,with_error=false)
+          num_term = 1
+          den_term = 1 - (a+b)*x.quo(a+1)
+          k        = 0
+
+          den_term = continued_fraction_cutoff(epsabs) if den_term.abs < CUTOFF
+          den_term = 1.quo(den_term)
+          cf       = den_term
+
+          1.upto(MAX_ITER) do |k|
+            coeff      = k *(b-k)*x.quo(((a-1)+2*k)*(a+2*k)) # coefficient for step 1
+            delta_frac = nil
+            2.times do
+
+              den_term    = 1 + coeff*den_term
+              num_term    = 1 + coeff.quo(num_term)
+
+              den_term = continued_fraction_cutoff(epsabs) if den_term.abs < CUTOFF
+              num_term = continued_fraction_cutoff(epsabs) if num_term.abs < CUTOFF
+
+              den_term = 1.quo(den_term)
+
+              delta_frac  = den_term * num_term
+              cf         *= delta_frac
+
+              coeff = -(a+k)*(a+b+k)*x.quo((a+2*k)*(a+2*k+1)) # coefficient for step 2
+            end
+
+            break if (delta_frac-1).abs < 2.0*Float::EPSILON
+            break if !epsabs.nil? && (cf * (delta_frac-1).abs < epsabs)
+          end
+
+          if k > MAX_ITER
+            raise("Exceeded maximum number of iterations") if epsabs.nil?
+            return with_error ? [0.0/0, 0] : 0.0/0 # NaN if epsabs is set
+          end
+
+          with_error ? [cf, k * 4 * Float::EPSILON * cf.abs] : cf
+        end
+
+
+      end
+
+    end
+  end
+end

data/lib/distribution/math_extension/incomplete_gamma.rb

@@ -0,0 +1,424 @@
+# Added by John O. Woods, SciRuby project.
+# Derived from GSL-1.9 source files in the specfunc/ dir.
+
+# require "statsample"
+
+module Distribution
+  module MathExtension
+    module IncompleteGamma
+      NMAX  = 5000
+      SMALL = Float::EPSILON ** 3
+      PG21  = -2.404113806319188570799476 # PolyGamma[2,1]
+
+      class << self
+
+        # Helper function for plot
+        #def range_to_array r
+        #  r << (r.last - r.first)/100.0 if r.size == 2 # set dr as Dr/100.0
+        #  arr = []
+        #  pos = r[0]
+        #  while pos <= r[1]
+        #    arr << pos
+        #    pos += r[2]
+        #  end
+        #  arr
+        #end
+        #
+        #def plot a, x_range, fun = :p
+        #  x_range = range_to_array(x_range) if x_range.is_a?(Array)
+        #  y_range = x_range.collect { |x| self.send(fun, a, x) }
+        #  graph = Statsample::Graph::Scatterplot.new x_range.to_scale, y_range.to_scale
+        #  f = File.new("test.svg", "w")
+        #  f.puts(graph.to_svg)
+        #  f.close
+        #  `google-chrome test.svg`
+        #end
+
+        # The dominant part, D(a,x) := x^a e^(-x) / Gamma(a+1)
+        # gamma_inc_D in GSL-1.9.
+        def d(a, x, with_error = false)
+          error = nil
+          if a < 10.0
+            ln_a = Math.lgamma(a+1.0).first
+            lnr  = a * Math.log(x) - x - ln_a
+            result = Math.exp(lnr)
+            error = 2.0 * Float::EPSILON * (lnr.abs + 1.0) + result.abs if with_error
+            with_error ? [result,error] : result
+          else
+            ln_term = ln_term_error = nil
+            if x < 0.5*a
+              u       = x/a.to_f
+              ln_u    = Math.log(u)
+              ln_term = ln_u - u + 1.0
+              ln_term_error = (ln_u.abs + u.abs + 1.0) * Float::EPSILON if with_error
+            else
+              mu      = (x-a)/a.to_f
+              ln_term = Log::log_1plusx_minusx(mu, with_error)
+              ln_term, ln_term_error = ln_term if with_error
+            end
+            gstar = Gammastar.evaluate(a, with_error)
+            gstar,gstar_error = gstar if with_error
+            term1 = Math.exp(a*ln_term) / Math.sqrt(2.0*Math::PI*a)
+            result = term1/gstar
+            error  = 2.0*Float::EPSILON*((a*ln_term).abs+1.0) * result.abs + gstar_error/gstar.abs * result.abs if with_error
+            with_error ? [result,error] : result
+          end
+        end
+
+        # gamma_inc_P_series
+        def p_series(a,x,with_error=false)
+          d = d(a,x,with_error)
+          d, d_err = d if with_error
+          sum      = 1.0
+          term     = 1.0
+          n        = 1
+          1.upto(NMAX-1) do |n|
+            term *= x / (a+n).to_f
+            sum  += term
+            break if (term/sum).abs < Float::EPSILON
+          end
+
+          result   = d * sum
+
+          if n == NMAX
+            STDERR.puts("Error: n reached NMAX in p series")
+          else
+            return with_error ? [result,d_err * sum.abs + (1.0+n)*Float::EPSILON * result.abs] : result
+          end
+        end
+
+        # This function does not exist in GSL, but is nonetheless GSL code. It's for calculating two specific ranges of p.
+        def q_asymptotic_uniform_complement a,x,with_error=false
+          q = q_asymptotic_uniform(a, x, with_error)
+          q,q_err = q if with_error
+          result = 1.0 - q
+          return with_error ? [result, q_err + 2.0*Float::EPSILON*result.abs] : result
+        end
+
+        def q_continued_fraction_complement a,x,with_error=false
+          q = q_continued_fraction(a,x,with_error)
+          return with_error ? [1.0 - q.first, q.last + 2.0*Float::EPSILON*(1.0-q.first).abs] : 1.0 - q
+        end
+
+        def q_large_x_complement a,x,with_error=false
+          q = q_large_x(a,x,with_error)
+          return with_error ? [1.0 - q.first, q.last + 2.0*Float::EPSILON*(1.0-q.first).abs] : 1.0 - q
+        end
+
+        # The incomplete gamma function.
+        # gsl_sf_gamma_inc_P_e
+        def p a,x,with_error=false
+          raise(ArgumentError, "Range Error: a must be positive, x must be non-negative") if a <= 0.0 || x < 0.0
+          if x == 0.0
+            return with_error ? [0.0, 0.0] : 0.0
+          elsif x < 20.0 || x < 0.5*a
+            return p_series(a, x, with_error)
+          elsif a > 1e6 && (x-a)*(x-a) < a
+            return q_asymptotic_uniform_complement a, x, with_error
+          elsif a <= x
+            if a > 0.2*x
+              return q_continued_fraction_complement(a, x, with_error)
+            else
+              return q_large_x_complement(a, x, with_error)
+            end
+          elsif (x-a)*(x-a) < a
+            return q_asymptotic_uniform_complement a, x, with_error
+          else
+            return p_series(a, x, with_error)
+          end
+        end
+
+        # gamma_inc_Q_e
+        def q a,x,with_error=false
+          raise(ArgumentError, "Range Error: a and x must be non-negative") if (a < 0.0 || x < 0.0)
+          if x == 0.0
+            return with_error ? [1.0, 0.0] : 1.0
+          elsif a == 0.0
+            return with_error ? [0.0, 0.0] : 0.0
+          elsif x <= 0.5*a
+            # If series is quick, do that.
+            p = p_series(a,x, with_error)
+            p,p_err = p if with_error
+            result  = 1.0 - p
+            return with_error ? [result, p_err + 2.0*Float::EPSILON*result.abs] : result
+          elsif a >= 1.0e+06 && (x-a)*(x-a) < a # difficult asymptotic regime, only way to do this region
+            return q_asymptotic_uniform(a, x, with_error)
+          elsif a < 0.2 && x < 5.0
+            return q_series(a,x, with_error)
+          elsif a <= x
+            return x <= 1.0e+06 ? q_continued_fraction(a, x, with_error) : q_large_x(a, x, with_error)
+          else
+            if x > a-Math.sqrt(a)
+              return q_continued_fraction(a, x, with_error)
+            else
+              p = p_series(a, x, with_error)
+              p, p_err = p if with_error
+              result = 1.0 - p
+              return with_error ? [result, p_err + 2.0*Float::EPSILON*result.abs] : result
+            end
+          end
+        end
+
+        # gamma_inc_Q_CF
+        def q_continued_fraction a, x, with_error=false
+          d = d(a, x, with_error)
+          f = f_continued_fraction(a, x, with_error)
+
+          if with_error
+            [d.first*(a/x).to_f*f.first, d.last * ((a/x).to_f*f.first).abs + (d.first*a/x*f.last).abs]
+          else
+            d * (a/x).to_f * f
+          end
+        end
+
+        # gamma_inc_Q_large_x in GSL-1.9
+        def q_large_x a,x,with_error=false
+          d = d(a,x,with_error)
+          d,d_err = d if with_error
+          sum  = 1.0
+          term = 1.0
+          last = 1.0
+          n    = 1
+          1.upto(NMAX-1).each do |n|
+            term *= (a-n)/x
+            break if (term/last).abs > 1.0
+            break if (term/sum).abs < Float::EPSILON
+            sum  += term
+            last  = term
+          end
+
+          result = d*(a/x)*sum
+          error  = d_err * (a/x).abs * sum if with_error
+
+          if n == NMAX
+            STDERR.puts("Error: n reached NMAX in q_large_x")
+          else
+            return with_error ? [result,error] : result
+          end
+        end
+
+        # Uniform asymptotic for x near a, a and x large
+        # gamma_inc_Q_asymp_unif
+        def q_asymptotic_uniform(a, x, with_error = false)
+          rta = Math.sqrt(a)
+          eps = (x-a).quo(a)
+
+          ln_term = Log::log_1plusx_minusx(eps, with_error)
+          ln_term, ln_term_err = ln_term if with_error
+
+          eta     = (eps >= 0 ? 1 : -1) * Math.sqrt(-2*ln_term)
+
+          erfc    = Math.erfc_e(eta*rta/SQRT2, with_error)
+          erfc, erfc_err = erfc if with_error
+
+          c0 = c1 = nil
+          if eps.abs < ROOT5_FLOAT_EPSILON
+            c0 = -1.quo(3) + eps*(1.quo(12) - eps*(23.quo(540) - eps*(353.quo(12960) - eps*589.quo(30240))))
+            c1 = -1.quo(540) - eps.quo(288)
+          else
+            rt_term = Math.sqrt(-2 * ln_term.quo(eps*eps))
+            lam     = x.quo(a)
+            c0      = (1 - 1/rt_term)/eps
+            c1      = -(eta**3 * (lam*lam + 10*lam + 1) - 12*eps**3).quo(12 * eta**3 * eps**3)
+          end
+
+          r = Math.exp(-0.5*a*eta*eta) / (SQRT2*SQRTPI*rta) * (c0 + c1.quo(a))
+
+          result = 0.5 * erfc + r
+          with_error ? [result, Float::EPSILON + (r*0.5*a*eta*eta).abs + 0.5*erfc_err + 2.0*Float::EPSILON + result.abs] : result
+        end
+
+        # gamma_inc_F_CF
+        def f_continued_fraction a, x, with_error = false
+          hn = 1.0 # convergent
+          cn = 1.0 / SMALL
+          dn = 1.0
+          n  = 2
+          2.upto(NMAX-1).each do |n|
+            an = n.odd? ? 0.5*(n-1)/x : (0.5*n-a)/x
+            dn = 1.0 + an * dn
+            dn = SMALL if dn.abs < SMALL
+            cn = 1.0 + an / cn
+            cn = SMALL if cn.abs < SMALL
+            dn = 1.0 / dn
+            delta = cn * dn
+            hn *= delta
+            break if (delta-1.0).abs < Float::EPSILON
+          end
+
+          if n == NMAX
+            STDERR.puts("Error: n reached NMAX in f continued fraction")
+          else
+            with_error ? [hn,2.0*Float::EPSILON * hn.abs + Float::EPSILON*(2.0+0.5*n) * hn.abs] : hn
+          end
+        end
+
+        def q_series(a,x,with_error=false)
+          term1 = nil
+          sum   = nil
+          term2 = nil
+          begin
+            lnx  = Math.log(x)
+            el   = EULER + lnx
+            c1   = -el
+            c2   = Math::PI * Math::PI / 12.0 - 0.5*el*el
+            c3   = el*(Math::PI*Math::PI/12.0 - el*el/6.0) + PG21/6.0
+            c4   = -0.04166666666666666667 *
+                      (-1.758243446661483480 + lnx) *
+                      (-0.764428657272716373 + lnx) *
+                      ( 0.723980571623507657 + lnx) *
+                      ( 4.107554191916823640 + lnx)
+            c5 = -0.0083333333333333333 *
+                       (-2.06563396085715900 + lnx) *
+                       (-1.28459889470864700 + lnx) *
+                       (-0.27583535756454143 + lnx) *
+                       ( 1.33677371336239618 + lnx) *
+                       ( 5.17537282427561550 + lnx)
+            c6 = -0.0013888888888888889 *
+                         (-2.30814336454783200 + lnx) *
+                         (-1.65846557706987300 + lnx) *
+                         (-0.88768082560020400 + lnx) *
+                         ( 0.17043847751371778 + lnx) *
+                         ( 1.92135970115863890 + lnx) *
+                         ( 6.22578557795474900 + lnx)
+            c7 = -0.00019841269841269841
+                         (-2.5078657901291800 + lnx) *
+                         (-1.9478900888958200 + lnx) *
+                         (-1.3194837322612730 + lnx) *
+                         (-0.5281322700249279 + lnx) *
+                         ( 0.5913834939078759 + lnx) *
+                         ( 2.4876819633378140 + lnx) *
+                         ( 7.2648160783762400 + lnx)
+            c8 = -0.00002480158730158730 *
+                         (-2.677341544966400 + lnx) *
+                         (-2.182810448271700 + lnx) *
+                         (-1.649350342277400 + lnx) *
+                         (-1.014099048290790 + lnx) *
+                         (-0.191366955370652 + lnx) *
+                         ( 0.995403817918724 + lnx) *
+                         ( 3.041323283529310 + lnx) *
+                         ( 8.295966556941250 + lnx) *
+            c9 = -2.75573192239859e-6 *
+                         (-2.8243487670469080 + lnx) *
+                         (-2.3798494322701120 + lnx) *
+                         (-1.9143674728689960 + lnx) *
+                         (-1.3814529102920370 + lnx) *
+                         (-0.7294312810261694 + lnx) *
+                         ( 0.1299079285269565 + lnx) *
+                         ( 1.3873333251885240 + lnx) *
+                         ( 3.5857258865210760 + lnx) *
+                         ( 9.3214237073814600 + lnx) *
+            c10 = -2.75573192239859e-7 *
+                         (-2.9540329644556910 + lnx) *
+                         (-2.5491366926991850 + lnx) *
+                         (-2.1348279229279880 + lnx) *
+                         (-1.6741881076349450 + lnx) *
+                         (-1.1325949616098420 + lnx) *
+                         (-0.4590034650618494 + lnx) *
+                         ( 0.4399352987435699 + lnx) *
+                         ( 1.7702236517651670 + lnx) *
+                         ( 4.1231539047474080 + lnx) *
+                         ( 10.342627908148680 + lnx)
+            term1 = a*(c1+a*(c2+a*(c3+a*(c4+a*(c5+a*(c6+a*(c7+a*(c8+a*(c9+a*c10)))))))))
+          end
+
+          n   = 1
+          begin
+            t   = 1.0
+            sum = 1.0
+            1.upto(NMAX-1).each do |n|
+              t   *= -x/(n+1.0)
+              sum += (a+1.0) / (a+n+1.0) * t
+              break if (t/sum).abs < Float::EPSILON
+            end
+          end
+
+          if n == NMAX
+            STDERR.puts("Error: n reached NMAX in q_series")
+          else
+            term2 = (1.0 - term1) * a/(a+1.0) * x * sum
+            result = term1+term2
+            with_error ? [result, Float::EPSILON*term1.abs + 2.0*term2.abs + 2.0*Float::EPSILON*result.abs] : result
+          end
+        end
+
+        # gamma_inc_series
+        def series a,x,with_error = false
+          q = q_series(a,x,with_error)
+          g = Math.gamma(a)
+          STDERR.puts("Warning: Don't know error for Math.gamma. Error will be incorrect") if with_error
+          # When we get the error from Gamma, switch the comment on the next to lines
+          # with_error ? [q.first*g.first, (q.first*g.last).abs + (q.last*g.first).abs + 2.0*Float::EPSILON*(q.first*g.first).abs] : q*g
+          with_error ? [q.first*g, (q.first*Float::EPSILON).abs + (q.last*g.first).abs + 2.0*Float::EPSILON(q.first*g).abs] : q*g
+        end
+
+        # gamma_inc_a_gt_0
+        def a_greater_than_0 a, x, with_error = false
+          q       = q(a,x,with_error)
+          q,q_err = q if with_error
+          g       = Math.gamma(a)
+          STDERR.puts("Warning: Don't know error for Math.gamma. Error will be incorrect") if with_error
+          g_err   = Float::EPSILON
+          result  = g*q
+          error   = (g*q_err).abs + (g_err*q).abs if with_error
+          with_error ? [result,error] : result
+        end
+
+        # gamma_inc_CF
+        def continued_fraction a,x, with_error=false
+          f = f_continued_fraction(a,x,with_error)
+          f,f_error = f if with_error
+          pre = Math.exp((a-1.0)*Math.log(x) - x)
+          STDERR.puts("Warning: Don't know error for Math.exp. Error will be incorrect") if with_error
+          pre_error = Float::EPSILON
+          result    = f*pre
+          if with_error
+            error     = (f_error*pre).abs + (f*pre_error) + (2.0+a.abs)*Float::EPSILON*result.abs
+            [result,error]
+          else
+            result
+          end
+        end
+
+        # Unnormalized incomplete gamma function.
+        # gsl_sf_gamma_inc_e
+        def unnormalized a,x,with_error = false
+          raise(ArgumentError, "x cannot be negative") if x < 0.0
+
+          if x == 0.0
+            result  = Math.gamma(a.to_f)
+            STDERR.puts("Warning: Don't know error for Math.gamma. Error will be incorrect") if with_error
+            return with_error ? [result, Float::EPSILON] : result
+          elsif a == 0.0
+            return ExponentialIntegral.first_order(x.to_f, with_error)
+          elsif a > 0.0
+            return a_greater_than_0(a.to_f, x.to_f, with_error)
+          elsif x > 0.25
+            # continued fraction seems to fail for x too small
+            return continued_fraction(a.to_f, x.to_f, with_error)
+          elsif a.abs < 0.5
+            return series(a.to_f,x.to_f,with_error)
+          else
+            fa = a.floor.to_f
+            da = a - fa
+            g_da = da > 0.0 ? a_greater_than_0(da, x.to_f, with_error) : ExponentialIntegral.first_order(x.to_f, with_error)
+            g_da, g_da_err = g_da if with_error
+            alpha = da
+            gax = g_da
+
+            # Gamma(alpha-1,x) = 1/(alpha-1) (Gamma(a,x) - x^(alpha-1) e^-x)
+            begin
+              shift  = Math.exp(-x + (alpha-1.0)*Math.log(x))
+              gax    = (gax-shift) / (alpha-1.0)
+              alpha -= 1.0
+            end while alpha > a
+
+            result = gax
+            return with_error ? [result, 2.0*(1.0 + a.abs) * Float::EPSILON*gax.abs] : result
+          end
+        end
+
+      end
+    end
+  end
+end