distribution 0.7.3 → 0.8.0

data/lib/distribution/math_extension/erfc.rb

@@ -3,36 +3,35 @@
 
 module Distribution
   module MathExtension
-
     # Error function from GSL-1.9, with epsilon information. Access it using Math.erfc_e
     module Erfc
-      P = [ 2.97886562639399288862,
-            7.409740605964741794425,
-            6.1602098531096305440906,
-            5.019049726784267463450058,
-            1.275366644729965952479585264,
-            0.5641895835477550741253201704 ]
-      Q = [ 3.3690752069827527677,
-            9.608965327192787870698,
-            17.08144074746600431571095,
-            12.0489519278551290360340491,
-            9.396034016235054150430579648,
-            2.260528520767326969591866945,
-            1.0 ]
+      P = [2.97886562639399288862,
+           7.409740605964741794425,
+           6.1602098531096305440906,
+           5.019049726784267463450058,
+           1.275366644729965952479585264,
+           0.5641895835477550741253201704]
+      Q = [3.3690752069827527677,
+           9.608965327192787870698,
+           17.08144074746600431571095,
+           12.0489519278551290360340491,
+           9.396034016235054150430579648,
+           2.260528520767326969591866945,
+           1.0]
 
       class << self
         # Estimates erfc(x) valid for 8 < x < 100
         # erfc8_sum from GSL-1.9
         def erfc8_sum(x)
           num = P[5]
-          4.downto(0) { |i| num = x*num + P[i] }
+          4.downto(0) { |i| num = x * num + P[i] }
           den = Q[6]
-          5.downto(0) { |i| den = x*den + Q[i] }
+          5.downto(0) { |i| den = x * den + Q[i] }
           num / den
         end
 
         def erfc8(x)
-          erfc8_sum(x) * Math.exp(-x*x)
+          erfc8_sum(x) * Math.exp(-x * x)
         end
 
         # gsl_sf_erfc_e
@@ -41,39 +40,37 @@ module Distribution
           e = nil
 
           if ax <= 1.0
-            t = 2*ax-1
+            t = 2 * ax - 1
             e = ChebyshevSeries.evaluate(:erfc_xlt1, t, with_error)
           elsif ax <= 5.0
-            ex2 = Math.exp(-x*x)
-            t   = (ax-3).quo(2)
+            ex2 = Math.exp(-x * x)
+            t   = (ax - 3).quo(2)
             e   = ChebyshevSeries.evaluate(:erfc_x15, t, with_error)
             if with_error
               e[0] *= ex2
-              e[1] = ex2 * (e[1] + 2*x.abs*Float::EPSILON)
+              e[1] = ex2 * (e[1] + 2 * x.abs * Float::EPSILON)
             else
               e *= ex2
             end
           elsif ax < 10.0
-            exterm = Math.exp(-x*x) / ax
-            t      = (2*ax-15).quo(5)
+            exterm = Math.exp(-x * x) / ax
+            t      = (2 * ax - 15).quo(5)
             e = ChebyshevSeries.evaluate(:erfc_x510, t, with_error)
             if with_error
               e[0] *= exterm
-              e[1] = exterm * (e[1] + 2*x.abs*Float::EPSILON + Float::EPSILON)
+              e[1] = exterm * (e[1] + 2 * x.abs * Float::EPSILON + Float::EPSILON)
             else
               e *= exterm
             end
           else
             e8 = erfc8(ax)
-            e = with_error ? [e8, (x*x + 1) * Float::EPSILON * e8.abs] : e8
+            e = with_error ? [e8, (x * x + 1) * Float::EPSILON * e8.abs] : e8
           end
 
           result = x < 0 ? 2 - (with_error ? e.first : e) : (with_error ? e.first : e)
-          with_error ? [result, e.last + 2*Float::EPSILON*result.abs] : result
+          with_error ? [result, e.last + 2 * Float::EPSILON * result.abs] : result
         end
       end
-
     end
-
   end
-end
+end

data/lib/distribution/math_extension/exponential_integral.rb

@@ -3,57 +3,57 @@ module Distribution
     # From GSL-1.9.
     module ExponentialIntegral
       class << self
-        def first_order x, scale = 0, with_error = false
+        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")
+            fail('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)
+            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
+            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 = 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
+            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 = 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
+            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")
+            fail(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
+            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 = 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
+            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 = 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
+            error ||= s * (Float::EPSILON + result_c_err) + 2.0 * (x + 1.0) * Float::EPSILON * result.abs
+            fail('Underflow Error') if result == 0.0
           else
-            raise("Underflow Error")
+            fail('Underflow Error')
           end
           with_error ? [result, error] : result
         end

data/lib/distribution/math_extension/gammastar.rb

@@ -10,52 +10,51 @@ module Distribution
       C2 =  1.quo(1260)
       C3 = -1.quo(1680)
       C4 =  1.quo(1188)
-      C5 = -691.quo(360360)
+      C5 = -691.quo(360_360)
       C6 =  1.quo(156)
-      C7 = -3617.quo(122400)
+      C7 = -3617.quo(122_400)
 
       class << self
-
-        def series x, with_error = false
+        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
+          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
+        def evaluate(x, with_error = false)
+          fail(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)
+            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
+            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
+            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
+            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 = 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
+            with_error ? [result, result_err] : result
           else
-            with_error ? [1.0,1.0/x] : 1.0
+            with_error ? [1.0, 1.0 / x] : 1.0
           end
         end
       end

data/lib/distribution/math_extension/gsl_utilities.rb

@@ -8,14 +8,14 @@ module Distribution
     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)
+    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
 
@@ -23,9 +23,9 @@ module Distribution
     # 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]
+      fail('Overflow Error in exp_err: x + adx > LOG_FLOAT_MAX') if x + adx > LOG_FLOAT_MAX
+      fail('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
+end

data/lib/distribution/math_extension/incomplete_beta.rb

@@ -7,37 +7,37 @@ module Distribution
       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)
+        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) }
+          fail(ArgumentError, 'x and y must be nonzero') if x == 0.0 || y == 0.0
+          fail(ArgumentError, 'not defined for negative integers') if [x, y].any? { |v| 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
+            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)
+              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
+              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 = 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
+              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
+              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
+              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
@@ -46,84 +46,80 @@ module Distribution
           # General case: fallback
           lgx, sgx   = Math.lgamma(x)
           lgy, sgy   = Math.lgamma(y)
-          lgxy, sgxy = Math.lgamma(x+y)
+          lgxy, sgxy = Math.lgamma(x + y)
           sgn        = sgx * sgy * sgxy
 
-          raise("Domain error: sign is -") if sgn == -1
+          fail('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.")
+              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
+            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
+        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)
+          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)
+          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)
+            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
+            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
+        def evaluate(a, b, x, with_error = false)
+          fail(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
+            return with_error ? [0.0, 0.0] : 0.0
           elsif x == 1
-            return with_error ? [1.0,0.0] : 1.0
+            return with_error ? [1.0, 0.0] : 1.0
           else
 
-            ln_beta = Beta.log_beta(a,b, with_error)
+            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
+              # 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
+            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
@@ -133,31 +129,30 @@ module Distribution
               end
             end
 
-            if x < (a+1).quo(a+b+2)
+            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
+
+              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
+              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
+              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
+              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
+          0.0 / 0 # NaN
         end
 
         # Continued fraction calculation of incomplete beta
@@ -165,9 +160,9 @@ module Distribution
         #
         # 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)
+        def continued_fraction(a, b, x, epsabs = nil, with_error = false)
           num_term = 1
-          den_term = 1 - (a+b)*x.quo(a+1)
+          den_term = 1 - (a + b) * x.quo(a + 1)
           k        = 0
 
           den_term = continued_fraction_cutoff(epsabs) if den_term.abs < CUTOFF
@@ -175,11 +170,10 @@ module Distribution
           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
+            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
+              den_term    = 1 + coeff * den_term
               num_term    = 1 + coeff.quo(num_term)
 
               den_term = continued_fraction_cutoff(epsabs) if den_term.abs < CUTOFF
@@ -188,26 +182,23 @@ module Distribution
               den_term = 1.quo(den_term)
 
               delta_frac  = den_term * num_term
-              cf         *= delta_frac
+              cf *= delta_frac
 
-              coeff = -(a+k)*(a+b+k)*x.quo((a+2*k)*(a+2*k+1)) # coefficient for step 2
+              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)
+            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
+            fail('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
+end