rubystats 0.1.0

data/lib/modules/extra_math.rb

@@ -0,0 +1,7 @@
+module ExtraMath
+
+	def binomial (n, k)
+		return Math.exp(log_gamma(n + 1.0) - log_gamma(k + 1.0) - log_gamma(n - k + 1.0))
+	end
+
+end

data/lib/modules/numerical_constants.rb

@@ -0,0 +1,17 @@
+module NumericalConstants
+	Max_float = 3.40282346638528860e292
+	Eps = 2.22e-16
+	Max_value = 1.2e290
+	Log_gamma_x_max_value = 2.55e292
+	Gamma_x_max_value = 171.624
+	Sqrt2pi = 2.5066282746310005024157652848110452530069867406099
+	Sqrt2 = 1.4142135623730950488016887242096980785696718753769
+	Xminin = 2.23e-303
+	Max_iterations = 1000
+	Precision = 8.88e-016
+	Two_pi = 6.2831853071795864769252867665590057683943387987502
+	Gamma = 0.57721566490153286060651209008240243104215933593992
+	Golden_ratio = 1.6180339887498948482045868343656381177203091798058
+end
+
+

data/lib/modules/special_math.rb

@@ -0,0 +1,721 @@
+require 'modules/numerical_constants'
+
+# Ruby port of SpecialMath.php from PHPMath, which is
+# a port of JSci methods found in SpecialMath.java.
+#
+#
+# Ruby port by Bryan Donovan Bryan.Donovan@sun.com
+#
+# Author:: Jaco van Kooten
+# Author:: Paul Meagher
+# Author:: Bryan Donovan
+
+module SpecialMath
+
+	include NumericalConstants
+
+	@logGammaCache_res = 0.0
+	@logGammaCache_x = 0.0
+	@logBetaCache_res = 0.0
+	@logBetaCache_p   = 0.0
+	@logBetaCache_q   = 0.0
+
+
+	def log_beta(p,q)
+		if p != @logBetaCache_p || q != @logBetaCache_q 
+			logBetaCache_p = p
+			logBetaCache_q = q
+			if p <= 0.0 || q <= 0.0 || (p + q) > Log_gamma_x_max_value
+				logBetaCache_res = 0.0
+			else
+				logBetaCache_res = log_gamma(p) + log_gamma(q) - log_gamma(p + q)
+			end
+			return logBetaCache_res
+		end
+	end
+
+	# Gamma function.
+	# Based on public domain NETLIB (Fortran) code by W. J. Cody and L. Stoltz<BR>
+	# Applied Mathematics Division<BR>
+	# Argonne National Laboratory<BR>
+	# Argonne, IL 60439<BR>
+	# <P>
+	# References:
+	# <OL>
+	# <LI>"An Overview of Software Development for Special Functions", W. J. Cody, Lecture Notes in Mathematics, 506, Numerical Analysis Dundee, 1975, G. A. Watson (ed.), Springer Verlag, Berlin, 1976.
+	# <LI>Computer Approximations, Hart, Et. Al., Wiley and sons, New York, 1968.
+	# </OL></P><P>
+	# From the original documentation:
+	# </P><P>
+	# This routine calculates the GAMMA function for a real argument X.
+	# Computation is based on an algorithm outlined in reference 1.
+	# The program uses rational functions that approximate the GAMMA
+	# function to at least 20 significant decimal digits.  Coefficients
+	# for the approximation over the interval (1,2) are unpublished.
+	# Those for the approximation for X .GE. 12 are from reference 2.
+	# The accuracy achieved depends on the arithmetic system, the
+	# compiler, the intrinsic functions, and proper selection of the
+	# machine-dependent constants.
+	# </P><P>
+	# Error returns:<BR>
+	# The program returns the value XINF for singularities or when overflow would occur.
+	# The computation is believed to be free of underflow and overflow.
+	# </P>
+	# Author:: Jaco van Kooten
+
+	def gamma(x) 
+		# gamma related constants
+		g_p = [ -1.71618513886549492533811, 24.7656508055759199108314,
+			-379.804256470945635097577, 629.331155312818442661052,
+			866.966202790413211295064, -31451.2729688483675254357,
+			-36144.4134186911729807069, 66456.1438202405440627855 ]
+		g_q = [-30.8402300119738975254353, 315.350626979604161529144,
+			-1015.15636749021914166146, -3107.77167157231109440444,
+			22538.1184209801510330112, 4755.84627752788110767815,
+			-134659.959864969306392456, -115132.259675553483497211 ] 
+		g_c = [-0.001910444077728, 8.4171387781295e-4, -5.952379913043012e-4,
+			7.93650793500350248e-4, -0.002777777777777681622553,
+			0.08333333333333333331554247, 0.0057083835261 ]
+		fact=1.0
+		i=0
+		n=0
+		y=x
+		parity=false
+		if y <= 0.0 
+			# ----------------------------------------------------------------------
+			#  Argument is negative
+			# ----------------------------------------------------------------------
+			y = -(x)
+			y1 = y.to_i
+			res = y - y1
+			if res != 0.0 
+				if y1 != (((y1*0.5).to_i) * 2.0)
+					parity = true
+					fact = -M_pi/sin(M_pi * res)
+					y += 1
+				end
+			else
+				return Max_value
+			end
+		end
+
+		# ----------------------------------------------------------------------
+		#  Argument is positive
+		# ----------------------------------------------------------------------
+		if y < Eps
+			# ----------------------------------------------------------------------
+			#  Argument .LT. EPS
+			# ----------------------------------------------------------------------
+			if y >= Xminin
+				res = 1.0 / y
+			else
+				return Max_value
+			end
+		elsif y < 12.0
+			y1 = y
+			#end
+			if y < 1.0
+				# ----------------------------------------------------------------------
+				#  0.0 .LT. argument .LT. 1.0
+				# ----------------------------------------------------------------------
+				z = y
+				y += 1
+			else 
+				# ----------------------------------------------------------------------
+				#  1.0 .LT. argument .LT. 12.0, reduce argument if necessary
+				# ----------------------------------------------------------------------
+				n = y.to_i - 1
+				y -= n.to_f
+				z = y - 1.0
+			end
+			# ----------------------------------------------------------------------
+			#  Evaluate approximation for 1.0 .LT. argument .LT. 2.0
+			# ----------------------------------------------------------------------
+			xnum = 0.0
+			xden = 1.0
+			for i in (0...8) 
+				xnum = (xnum + g_p[i]) * z
+				xden = xden * z + g_q[i]
+			end
+			res = xnum / xden + 1.0
+			if y1 < y
+				# ----------------------------------------------------------------------
+				#  Adjust result for case  0.0 .LT. argument .LT. 1.0
+				# ----------------------------------------------------------------------
+				res /= y1
+			elsif y1 > y 
+				# ----------------------------------------------------------------------
+				#  Adjust result for case  2.0 .LT. argument .LT. 12.0
+				# ----------------------------------------------------------------------
+				for i in (0...n)
+					res *= y
+					y += 1
+				end
+			end
+		else 
+			# ----------------------------------------------------------------------
+			#  Evaluate for argument .GE. 12.0
+			# ----------------------------------------------------------------------
+			if y <= Gamma_x_max_value
+				ysq = y * y
+				sum = g_c[6]
+				for i in(0...6) 
+					sum = sum / ysq + g_c[i]
+					sum = sum / y - y + log(sqrt2pi)
+					sum += (y - 0.5) * log(y)
+					res = Math.exp(sum)
+				end
+			else
+				return Max_value
+			end
+			# ----------------------------------------------------------------------
+			#  Final adjustments and return
+			# ----------------------------------------------------------------------
+			if parity
+				res = -res
+				if fact != 1.0
+					res = fact / res
+					return res
+				end
+			end
+		end
+	end
+
+	def log_gamma(x)
+		logGammaCache_res = @logGammaCache_res
+		logGammaCache_x = @logGammaCache_x
+
+		lg_d1 = -0.5772156649015328605195174
+		lg_d2 = 0.4227843350984671393993777
+		lg_d4 = 1.791759469228055000094023
+
+		lg_p1 = [ 4.945235359296727046734888,
+			201.8112620856775083915565, 2290.838373831346393026739,
+			11319.67205903380828685045, 28557.24635671635335736389,
+			38484.96228443793359990269, 26377.48787624195437963534,
+			7225.813979700288197698961 ]
+
+		lg_p2 = [ 4.974607845568932035012064,
+			542.4138599891070494101986, 15506.93864978364947665077,
+			184793.2904445632425417223, 1088204.76946882876749847,
+			3338152.967987029735917223, 5106661.678927352456275255,
+			3074109.054850539556250927 ]
+
+		lg_p4 = [ 14745.02166059939948905062,
+			2426813.369486704502836312, 121475557.4045093227939592,
+			2663432449.630976949898078, 29403789566.34553899906876,
+			170266573776.5398868392998, 492612579337.743088758812,
+			560625185622.3951465078242 ]
+
+		lg_q1 = [ 67.48212550303777196073036,
+			1113.332393857199323513008, 7738.757056935398733233834,
+			27639.87074403340708898585, 54993.10206226157329794414,
+			61611.22180066002127833352, 36351.27591501940507276287,
+			8785.536302431013170870835 ]
+
+		lg_q2 = [ 183.0328399370592604055942,
+			7765.049321445005871323047, 133190.3827966074194402448,
+			1136705.821321969608938755, 5267964.117437946917577538,
+			13467014.54311101692290052, 17827365.30353274213975932,
+			9533095.591844353613395747 ]
+
+		lg_q4 = [ 2690.530175870899333379843,
+			639388.5654300092398984238, 41355999.30241388052042842,
+			1120872109.61614794137657, 14886137286.78813811542398,
+			101680358627.2438228077304, 341747634550.7377132798597,
+			446315818741.9713286462081 ]
+
+		lg_c  = [ -0.001910444077728,8.4171387781295e-4,
+			-5.952379913043012e-4, 7.93650793500350248e-4,
+			-0.002777777777777681622553, 0.08333333333333333331554247,
+			0.0057083835261 ]
+
+		# Rough estimate of the fourth root of logGamma_xBig
+		lg_frtbig = 2.25e76
+		pnt68     = 0.6796875
+
+		if x == logGammaCache_x
+			return logGammaCache_res
+		end
+
+		y = x
+		if y > 0.0 && y <= Log_gamma_x_max_value
+			if y <= Eps
+				res = -Math.log(y)
+			elsif y <= 1.5
+				# EPS .LT. X .LE. 1.5
+				if y < pnt68
+					corr = -Math.log(y)
+					# xm1 is x-m-one, not x-m-L
+					xm1 = y
+				else
+					corr = 0.0
+					xm1 = y - 1.0
+				end
+				if y <= 0.5 || y >= pnt68
+					xden = 1.0
+					xnum = 0.0
+					for i in (0...8)
+						xnum = xnum * xm1 + lg_p1[i]
+						xden = xden * xm1 + lg_q1[i]
+					end
+					res = corr * xm1 * (lg_d1 + xm1 * (xnum / xden))
+				else
+					xm2 = y - 1.0
+					xden = 1.0
+					xnum = 0.0
+					for i in (0 ... 8)
+						xnum = xnum * xm2 + lg_p2[i]
+						xden = xden * xm2 + lg_q2[i]
+					end
+					res = corr + xm2 * (lg_d2 + xm2 * (xnum / xden))
+				end
+			elsif y <= 4.0
+				# 1.5 .LT. X .LE. 4.0
+				xm2 = y - 2.0
+				xden = 1.0
+				xnum = 0.0
+				for i in (0 ... 8)
+					xnum = xnum * xm2 + lg_p2[i]
+					xden = xden * xm2 + lg_q2[i]
+				end
+				res = xm2 * (lg_d2 + xm2 * (xnum / xden))
+			elsif y <= 12.0
+				# 4.0 .LT. X .LE. 12.0
+				xm4 = y - 4.0
+				xden = -1.0
+				xnum = 0.0
+				for i in (0 ... 8)
+					xnum = xnum * xm4 + lg_p4[i]
+					xden = xden * xm4 + lg_q4[i]
+				end
+				res = lg_d4 + xm4 * (xnum / xden)
+			else
+				# Evaluate for argument .GE. 12.0
+				res = 0.0
+				if y <= lg_frtbig
+					res = lg_c[6]
+					ysq = y * y
+					for i in (0...6)
+						res = res / ysq + lg_c[i]
+					end
+				end
+				res = res/y
+				corr = Math.log(y)
+				res = res + Math.log(Sqrt2pi) - 0.5 * corr
+				res = res + y * (corr - 1.0)
+			end
+		else
+			#return for bad arguments
+			res = Max_value
+		end
+		# final adjustments and return
+		logGammaCache_x = x
+		logGammaCache_res = res
+		return res
+	end
+
+
+	# Incomplete gamma function.
+	# The computation is based on approximations presented in 
+	# Numerical Recipes, Chapter 6.2 (W.H. Press et al, 1992).
+	# @param a require a>=0
+	# @param x require x>=0
+	# @return 0 if x<0, a<=0 or a>2.55E305 to avoid errors and over/underflow
+	# @author Jaco van Kooten
+
+	def incomplete_gamma(a, x) 
+		if x <= 0.0 || a <= 0.0 || a > Log_gamma_x_max_value
+			return 0.0
+		elsif x < (a + 1.0)
+			return gamma_series_expansion(a, x)
+		else
+			return 1.0-gamma_fraction(a, x)
+		end
+	end
+
+	# Author:: Jaco van Kooten
+	def gamma_series_expansion(a, x)
+		ap  = a
+		del = 1.0 / a
+		sum = del
+		for n in (1...Max_iterations)
+			ap += 1
+			del *= x / ap
+			sum += del
+			if del < sum * Precision
+				return sum * Math.exp(-x + a * Math.log(x) - log_gamma(a))
+			end
+		end
+		return "Maximum iterations exceeded: please file a bug report."
+	end
+
+	# Author:: Jaco van Kooten
+	def gamma_fraction(a, x) 
+		b  = x + 1.0 - a
+		c  = 1.0 / Xminin
+		d  = 1.0 / b
+		h  = d
+		del= 0.0
+		an = 0.0
+		for i in (1...Max_iterations) 
+			if (del-1.0).abs > Precision
+				an = -i * (i - a)
+				b += 2.0
+				d  = an * d + b
+				c  = b + an / c
+				if c.abs < Xminin
+					c = Xminin
+					if d.abs < Xminin
+						c = Xminin
+						d   = 1.0 / d
+						del = d * c
+						h  *= del
+					end
+				end
+			end
+			return Math.exp(-x + a * Math.log(x) - log_gamma(a)) * h
+		end
+	end
+
+	# Beta function.
+	#
+	# Author:: Jaco van Kooten
+
+	def beta(p, q) 
+		if p <= 0.0 || q <= 0.0 || (p + q) > Log_gamma_x_max_value
+			return 0.0
+		else 
+			return Math.exp(log_beta(p, q))
+		end
+	end
+
+	# Incomplete Beta function.
+	#
+	# Author:: Jaco van Kooten
+	# Author:: Paul Meagher
+	#
+	#  The computation is based on formulas from Numerical Recipes, 
+	#  Chapter 6.4 (W.H. Press et al, 1992).
+
+	def incomplete_beta(x, p, q) 
+		if x <= 0.0
+			return 0.0
+		elsif x >= 1.0
+			return 1.0
+		elsif p <= 0.0 || q <= 0.0 || (p + q) > Log_gamma_x_max_value
+			return 0.0
+		else 
+			beta_gam = Math.exp( -log_beta(p, q) + p * Math.log(x) + q * Math.log(1.0 - x) )
+			if x < (p + 1.0) / (p + q + 2.0)
+				return beta_gam * beta_fraction(x, p, q) / p
+			else
+				beta_frac = beta_fraction(1.0 - x, p, q)
+				return 1.0 - (beta_gam * beta_fraction(1.0 - x, q, p) / q)
+			end
+		end
+	end
+
+
+	# Evaluates of continued fraction part of incomplete beta function.
+	# Based on an idea from Numerical Recipes (W.H. Press et al, 1992).
+	# Author:: Jaco van Kooten
+
+	def beta_fraction(x, p, q) 
+		c = 1.0
+		sum_pq  = p + q
+		p_plus  = p + 1.0
+		p_minus = p - 1.0
+		h = 1.0 - sum_pq * x / p_plus
+		if h.abs < Xminin 
+			h = Xminin
+		end
+		h     = 1.0 / h
+		frac  = h
+		m     = 1
+		delta = 0.0
+
+		while (m <= Max_iterations) && ((delta - 1.0).abs > Precision) 
+			m2 = 2 * m
+			# even index for d
+			d = m * (q - m) * x / ( (p_minus + m2) * (p + m2))
+			h = 1.0 + d * h
+			if h.abs < Xminin
+				h = Xminin
+			end
+			h = 1.0 / h
+			c = 1.0 + d / c
+			if c.abs < Xminin
+				c = Xminin
+			end
+			frac *= h * c
+			# odd index for d
+			d = -(p + m) * (sum_pq + m) * x / ((p + m2) * (p_plus + m2))
+			h = 1.0 + d * h
+			if h.abs < Xminin
+				h = Xminin
+			end
+			h = 1.0 / h
+			c = 1.0 + d / c
+			if c.abs < Xminin
+				c = Xminin
+			end
+			delta = h * c
+			frac *= delta
+			m += 1
+		end
+		return frac
+	end
+
+
+
+	# Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+	#
+	# Developed at SunSoft, a Sun Microsystems, Inc. business.
+	# Permission to use, copy, modify, and distribute this
+	# software is freely granted, provided that this notice
+	# is preserved.
+	#
+	#                 x
+	#              2      |\
+	#     erf(x)  =  ---------  | exp(-t*t)dt
+	#            sqrt(pi) \|
+	#                 0
+	#
+	#     erfc(x) =  1-erf(x)
+	#  Note that
+	#        erf(-x) = -erf(x)
+	#        erfc(-x) = 2 - erfc(x)
+	#
+	# Method:
+	#    1. For |x| in [0, 0.84375]
+	#        erf(x)  = x + x*R(x^2)
+	#          erfc(x) = 1 - erf(x)           if x in [-.84375,0.25]
+	#                  = 0.5 + ((0.5-x)-x*R)  if x in [0.25,0.84375]
+	#       where R = P/Q where P is an odd poly of degree 8 and
+	#       Q is an odd poly of degree 10.
+	#                         -57.90
+	#            | R - (erf(x)-x)/x | <= 2
+	#
+	#
+	#       Remark. The formula is derived by noting
+	#          erf(x) = (2/sqrt(pi))*(x - x^3/3 + x^5/10 - x^7/42 + ....)
+	#       and that
+	#          2/sqrt(pi) = 1.128379167095512573896158903121545171688
+	#       is close to one. The interval is chosen because the fix
+	#       point of erf(x) is near 0.6174 (i.e., erf(x)=x when x is
+	#       near 0.6174), and by some experiment, 0.84375 is chosen to
+	#        guarantee the error is less than one ulp for erf.
+	#
+	#      2. For |x| in [0.84375,1.25], let s = |x| - 1, and
+	#         c = 0.84506291151 rounded to single (24 bits)
+	#             erf(x)  = sign(x) * (c  + P1(s)/Q1(s))
+	#             erfc(x) = (1-c)  - P1(s)/Q1(s) if x > 0
+	#              1+(c+P1(s)/Q1(s))    if x < 0
+	#             |P1/Q1 - (erf(|x|)-c)| <= 2**-59.06
+	#       Remark: here we use the taylor series expansion at x=1.
+	#        erf(1+s) = erf(1) + s*Poly(s)
+	#             = 0.845.. + P1(s)/Q1(s)
+	#              That is, we use rational approximation to approximate
+	#                 erf(1+s) - (c = (single)0.84506291151)
+	#            Note that |P1/Q1|< 0.078 for x in [0.84375,1.25]
+	#            where
+	#             P1(s) = degree 6 poly in s
+	#             Q1(s) = degree 6 poly in s
+	#     
+	#           3. For x in [1.25,1/0.35(~2.857143)],
+	#                  erfc(x) = (1/x)*exp(-x*x-0.5625+R1/S1)
+	#                  erf(x)  = 1 - erfc(x)
+	#            where
+	#             R1(z) = degree 7 poly in z, (z=1/x^2)
+	#             S1(z) = degree 8 poly in z
+	#     
+	#           4. For x in [1/0.35,28]
+	#                  erfc(x) = (1/x)*exp(-x*x-0.5625+R2/S2) if x > 0
+	#                 = 2.0 - (1/x)*exp(-x*x-0.5625+R2/S2) if -6<x<0
+	#                 = 2.0 - tiny        (if x <= -6)
+	#                  erf(x)  = sign(x)*(1.0 - erfc(x)) if x < 6, else
+	#                  erf(x)  = sign(x)*(1.0 - tiny)
+	#            where
+	#             R2(z) = degree 6 poly in z, (z=1/x^2)
+	#             S2(z) = degree 7 poly in z
+	#     
+	#           Note1:
+	#            To compute exp(-x*x-0.5625+R/S), let s be a single
+	#            precision number and s := x then
+	#             -x*x = -s*s + (s-x)*(s+x)
+	#                 exp(-x*x-0.5626+R/S) =
+	#                 exp(-s*s-0.5625)*exp((s-x)*(s+x)+R/S)
+	#           Note2:
+	#            Here 4 and 5 make use of the asymptotic series
+	#                   exp(-x*x)
+	#             erfc(x) ~ ---------- * ( 1 + Poly(1/x^2) )
+	#                   x*sqrt(pi)
+	#            We use rational approximation to approximate
+	#               g(s)=f(1/x^2) = log(erfc(x)*x) - x*x + 0.5625
+	#            Here is the error bound for R1/S1 and R2/S2
+	#               |R1/S1 - f(x)|  < 2**(-62.57)
+	#               |R2/S2 - f(x)|  < 2**(-61.52)
+	#
+	#            5. For inf > x >= 28
+	#                             erf(x)  = sign(x) *(1 - tiny)  (raise inexact)
+	#                             erfc(x) = tiny*tiny (raise underflow) if x > 0
+	#                           = 2 - tiny if x<0
+	#                
+	#            7. Special case:
+	#                             erf(0)  = 0, erf(inf)  = 1, erf(-inf) = -1,
+	#                             erfc(0) = 1, erfc(inf) = 0, erfc(-inf) = 2,
+	#                           erfc/erf(NaN) is NaN
+	#               
+	#               $efx8 = 1.02703333676410069053e00
+	#                
+	#                 Coefficients for approximation to erf on [0,0.84375]
+	#                
+
+	# Error function.
+	# Based on C-code for the error function developed at Sun Microsystems.
+	# Author:: Jaco van Kooten
+
+	def error(x)
+		e_efx = 1.28379167095512586316e-01
+
+		ePp = [ 1.28379167095512558561e-01,
+			-3.25042107247001499370e-01,
+			-2.84817495755985104766e-02,
+			-5.77027029648944159157e-03,
+			-2.37630166566501626084e-05 ]
+
+		eQq = [ 3.97917223959155352819e-01,
+			6.50222499887672944485e-02,
+			5.08130628187576562776e-03,
+			1.32494738004321644526e-04,
+			-3.96022827877536812320e-06 ]
+
+		# Coefficients for approximation to erf in [0.84375,1.25]
+		ePa = [-2.36211856075265944077e-03,
+			4.14856118683748331666e-01,
+			-3.72207876035701323847e-01,
+			3.18346619901161753674e-01,
+			-1.10894694282396677476e-01,
+			3.54783043256182359371e-02,
+			-2.16637559486879084300e-03 ]
+
+		eQa = [ 1.06420880400844228286e-01,
+			5.40397917702171048937e-01,
+			7.18286544141962662868e-02,
+			1.26171219808761642112e-01,
+			1.36370839120290507362e-02,
+			1.19844998467991074170e-02 ]
+
+		e_erx = 8.45062911510467529297e-01
+
+		abs_x = (if x >= 0.0 then x else -x end)
+		# 0 < |x| < 0.84375
+		if abs_x < 0.84375
+			#|x| < 2**-28
+			if abs_x < 3.7252902984619141e-9 
+				retval = abs_x + abs_x * e_efx
+			else
+				s = x * x
+				p = ePp[0] + s * (ePp[1] + s * (ePp[2] + s * (ePp[3] + s * ePp[4])))
+
+				q = 1.0 + s * (eQq[0] + s * (eQq[1] + s *
+																		 ( eQq[2] + s * (eQq[3] + s * eQq[4]))))
+				retval = abs_x + abs_x * (p / q)
+			end
+		elsif abs_x < 1.25
+			s = abs_x - 1.0
+			p = ePa[0] + s * (ePa[1] + s * 
+												(ePa[2] + s * (ePa[3] + s * 
+				 (ePa[4] + s * (ePa[5] + s * ePa[6])))))
+
+			q = 1.0 + s * (eQa[0] + s * 
+										 (eQa[1] + s * (eQa[2] + s * 
+				 (eQa[3] + s * (eQa[4] + s * eQa[5])))))
+			retval = e_erx + p / q
+
+		elsif abs_x >= 6.0
+			retval = 1.0
+		else
+			retval = 1.0 - complementary_error(abs_x)
+		end
+		return (if x >= 0.0 then retval else -retval end)
+  end
+
+# Complementary error function.
+# Based on C-code for the error function developed at Sun Microsystems.
+# author Jaco van Kooten
+
+ def complementary_error(x)
+	# Coefficients for approximation of erfc in [1.25,1/.35]
+
+	eRa = [-9.86494403484714822705e-03,
+		-6.93858572707181764372e-01,
+		-1.05586262253232909814e01,
+		-6.23753324503260060396e01,
+		-1.62396669462573470355e02,
+		-1.84605092906711035994e02,
+		-8.12874355063065934246e01,
+		-9.81432934416914548592e00 ]
+
+	eSa = [ 1.96512716674392571292e01,
+		1.37657754143519042600e02,
+		4.34565877475229228821e02,
+		6.45387271733267880336e02,
+		4.29008140027567833386e02,
+		1.08635005541779435134e02,
+		6.57024977031928170135e00,
+		-6.04244152148580987438e-02 ]
+
+	# Coefficients for approximation to erfc in [1/.35,28]
+
+	eRb = [-9.86494292470009928597e-03,
+		-7.99283237680523006574e-01,
+		-1.77579549177547519889e01,
+		-1.60636384855821916062e02,
+		-6.37566443368389627722e02,
+		-1.02509513161107724954e03,
+		-4.83519191608651397019e02 ]
+
+	eSb = [ 3.03380607434824582924e01,
+		3.25792512996573918826e02,
+		1.53672958608443695994e03,
+		3.19985821950859553908e03,
+		2.55305040643316442583e03,
+		4.74528541206955367215e02,
+		-2.24409524465858183362e01 ]
+
+	abs_x = (if x >= 0.0 then x else -x end)
+	if abs_x < 1.25
+		retval = 1.0 - error(abs_x)
+	elsif abs_x > 28.0
+		retval = 0.0
+
+		# 1.25 < |x| < 28
+	else
+		s = 1.0/(abs_x * abs_x)
+		if abs_x < 2.8571428
+			r = eRa[0] + s * (eRa[1] + s * 
+												(eRa[2] + s * (eRa[3] + s * (eRa[4] + s * 
+																										 (eRa[5] + s *(eRa[6] + s * eRa[7])
+																										 )))))
+
+																										 s = 1.0 + s * (eSa[0] + s * (eSa[1] + s * 
+																				(eSa[2] + s * (eSa[3] + s * (eSa[4] + s * 
+												 (eSa[5] + s * (eSa[6] + s * eSa[7])))))))
+
+		else
+			r = eRb[0] + s * (eRb[1] + s * 
+												(eRb[2] + s * (eRb[3] + s * (eRb[4] + s * 
+					 (eRb[5] + s * eRb[6])))))
+
+			s = 1.0 + s * (eSb[0] + s * 
+										 (eSb[1] + s * (eSb[2] + s * (eSb[3] + s * 
+					 (eSb[4] + s * (eSb[5] + s * eSb[6]))))))
+		end
+		retval =  Math.exp(-x * x - 0.5625 + r/s) / abs_x
+	end
+	return ( if x >= 0.0 then retval else 2.0 - retval end )
+	end
+end
+