For real integers n>0, the Gamma function is the same as the factorial,
The Gamma function is implemented as Gamma(x). At integer values n of the argument, Gamma(n) is computed exactly. For half-integer arguments it is also computed exactly, using the following identities (here n is a nonnegative integer):
For arbitrary complex arguments with nonnegative real part, the library function GammaNum(x) computes a uniform appoximation of Lanczos and Spouge (with the so-called "less precise coefficients of Spouge"). See: C. J. Lanczos, J. SIAM of Num. Anal. Ser. B, vol. 1, 86 (1964); J. L. Spouge, J. SIAM of Num. Anal., vol. 31, 931 (1994). See also: Paul Godfrey 2001 (unpublished): http://winnie.fit.edu/~gabdo/gamma.txt for some explanations on the method. The method gives the Gamma-function only for arguments with positive real part; at negative values of the real part of the argument, the Gamma-function is computed via the identity
The Lanczos-Spouge approximation formula depends on a parameter a,
The coefficients c[k] and the parameter a can be chosen to achieve a greater precision of the approximation formula. However, the recipe for the coefficients c[k] given in the paper by Lanczos is too complicated for practical calculations in arbitrary precision: the time it would take to compute the array of N coefficients c[k] grows as N^3. Therefore it is better to use less precise but much simpler formulae derived by Spouge.
In the calculation of the sum Sum(k,1,N,c[k]*(z+k)^(-1)), round-off error can lead to a serious loss of precision. At version 1.0.53, Yacas is limited in its internal arbitrary precision facility that does not support true floating-point computation but rather uses fixed-point logic; this hinders precise calculations with floating-point numbers. (This concern does not apply to Yacas linked with gmp.) In the current version of the GammaNum() function, two workarounds are implemented. First, a Horner scheme is used to compute the sum; this is somewhat faster and leads to smaller roundoff errors. Second, intermediate calculations are performed at 40% higher precision than requested. This is much slower but allows to obtain results at desired precision.
If the factorial of a large integer or half-integer n needs to be computed not exactly but only with a certain floating-point precision, it is faster (for large enough Abs(n)) not to evaluate an exact integer product, but to use the GammaNum approximation or Stirling's asymptotic formula,
The Stirling asymptotic series is
Using the identity x*Gamma(x)=Gamma(x+1), we can reduce the computation of Gamma(x) to Gamma(x+M) for some integer M. Then we can choose M to be large enough so that the Stirling asymptotic series gives the required precision when evaluated at x+M.
The second method for the Gamma function was used in Brent's Fortran MP package (R. P. Brent, A Fortran Multiple-Precision Arithmetic Package, ACM TOMS, Vol. 4, no. 1 (1978), p. 57). Brent refers to a 1963 paper by D. W. Sweeney for the origin of this method. Therefore we called this the "Sweeney-Brent" method.
The idea is to represent the Gamma function as a sum of two integrals,
The first integral in this equation can be found as a sum of the Taylor series (expanding Exp(-u) near u=0),
Calculations are faster if M is chosen as an integer value.
Computing gamma by the series in the definition is extremely slow. A much faster method can be used, based on some identities of Bessel functions. (See R. P. Brent and E. M. McMillan, Some new algorithms for high precision computation of Euler's constant, Math. Comp. v. 34 (1980), 305; and also the online paper by X. Gourdon and P. Sebah, The Euler constant, online at http://numbers.computation.free.fr/Constants/ (2001).
The basic formulae for the "fast" method (Brent's method "B1") are:
First, the sequence H[n] is defined as the partial sum of the harmonic series:
According to Brent's paper, the error of this approximation of gamma, assuming that S(n) and V(n) are computed exactly, is
The required number of terms k[max] in the summation over k to get S(n) and V(n) with this precision can be approximated as usual via Stirling's formula. It turns out that k[max] is also proportional to the number of digits, k[max]<=>2.07*P.
Therefore, this method of computing gamma has "linear convergence", i.e. the number of iterations is linear in the number of correct digits we need in the result. Of course, all calculations need to be performed with the working precision. The working precision must be a few digits more than P because we accumulate about Ln(k[max])/Ln(10) digits of roundoff error by performing k[max] arithmetic operations.
Brent mentions a small improvement on this method (his method "B3"). It consists of estimating the error of the approximation of gamma by an asymptotic series. Denote W(n) the function
Computation of S(n) seems to need H[k] first, and a long multiplication by H[k] at each term. To compute S(n) and V(n) faster and more accurately, Brent suggested the following trick that avoids this long multiplication and computes H[k] simultaneously with the series. Define the function U(n):=S(n)-Ln(n)*V(n). Then gamma<=>U(n)/V(n). The series for U(n) is U(n):=Sum(k,0,Infinity,A[k]), with
The time complexity of this method is O(P^2) where P is the required number of digits.
Also, it turns out that we can use a variant of the fast "rectangular method" to evaluate the series for U(n) and V(n) simultaneously. (We can consider these series as Taylor series in n^2.) This however does not speed up the evaluation of gamma. This happens because the rectangular method requires long multiplications and leads in this case to increased roundoff errors. The rectangular method for computing a power series in x is less efficient than a straightforward computation when x is a "short" rational or integer number.
Brent's "B1" method can be derived from the Taylor series for the modified Bessel function BesselI(nu,z),
The classic book of Bateman and Erdelyi, Higher Transcendental Functions, vol. 1, describes many results concerning analytic properties of zeta(s).
For the numerical evaluation of Riemann's Zeta function with arbitrary precision to become feasible, one needs special algorithms. Recently P. Borwein gave a simple and quick approximation algorithm for positive Re(s) (P. Borwein, An efficient algorithm for Riemann Zeta function (1995), published online and in Canadian Math. Soc. Conf. Proc., 27 (2000), 29-34.) See also: J. M. Borwein, D. M. Bradley, R. E. Crandall: Computation strategies for the Riemann Zeta function, preprint CECM-98-118, 1999, for a review of methods.
It is the "third" algorithm (the simplest one) from P. Borwein's paper which is implemented in Yacas. The approximation formula valid for Re(s)> -(n-1) is
The function Zeta(s) calls ZetaNum(s) to compute this approximation formula for Re(s)>1/2 and uses the identity above to get the value for other s.
For very large values of s, it is faster to use more direct methods implemented in the routines ZetaNum1(s,N) and ZetaNum2(s,N). If the required precision is P digits and s>1+Ln(10)/Ln(P)*P, then it is enough to compute the defining series for zeta(n),
Alternatively, one can use ZetaNum2(n,N) which computes the infinite product over prime numbers p[i]
Asymptotics of Lambert's W function are
One can also find uniform rational approximations, e.g.:
There exists a uniform approximation of the form
The numerical procedure uses Halley's method. Halley's iteration for the equation W*Exp(W)=x can be written as
The initial value is computed using one of the uniform approximation formulae. The good precision of the uniform approximation guarantees rapid convergence of the iteration scheme to the correct root of the equation, even for complex arguments x.
For large values of Abs(x), there is the following asymptotic series:
The error of a truncated asymptotic series is not larger than the first discarded term if the number of terms is larger than n-1/2. (See the book: F. W. J. Olver, Asymptotic and special functions, Academic Press, 1974.)
Currently Yacas can compute BesselJ(n,x) for all x where n is an integer and for Abs(x)<=2*Gamma(n) when n is a real number. Yacas currently uses the Taylor series when Abs(x)<=2*Gamma(n) to compute the numerical value:
If Abs(x)>2*Gamma(n) and n is an integer, then Yacas uses the forward recurrence relation:
We see from the definition that when Abs(x)<=2*Gamma(n), the absolute value of each term is always decreasing (which is called absolutely monotonely decreasing.) From this we know that if we stop after i iterations, the error will be bounded by the absolute value of the next term. So given a set precision, turn this into a value epsilon, so that we can check if the current term will contribute to the sum at the prescribed precision. Before doing this, Yacas currently increases the precision by 20% to do interim calculations. This is a heuristic that works, it is not backed by theory. The value epsilon is given by epsilon:=5*10^(-prec), where prec was the previous precision. This is directly from the definition of floating point number which is correct to prec digits: A number correct to prec digits has a rounding error no greater than 5*10^(-prec). Beware that some books incorrectly have .5 instead of 5.
Bug: Something is not right with complex numbers, but pure imaginary are OK.
Bernoulli numbers and polynomials are used in various Taylor series expansions, in the Euler-Maclauren series resummation formula, in Riemann's Zeta function and so on. For example, the sum of (integer) p-th powers of consecutive integers is given by
The Bernoulli polynomials B(x)[n] can be found by first computing an array of Bernoulli numbers up to B[n] and then applying the above formula for the coefficients.
In this definition, the first Bernoulli numbers are B[0]=1, B[1]= -1/2, B[2]=4, B[3]=0, B[4]= -1/30.
We consider two distinct computational tasks: evaluate a Bernoulli number exactly as a rational, or find it approximately to a specified floating-point precision. There are also two possible problem settings: either we need to evaluate all Bernoulli numbers B[n] up to some n, or we only need one isolated value B[n] for some n. Depending on how large n is, different algorithms need to be used in these cases.
Here is an estimate of the cost of BernoullliArray. Suppose M(P) is the time needed to multiply P-digit integers. The required number of digits P to store the numerator of B[n] is asymptotically P<>n*Ln(n). At each of the n iterations we need to multiply O(n) large rational numbers by large coefficients and take a GCD to simplify the resulting fractions. The time for GCD is logarithmic in P. So the complexity of this algorithm is O(n^2*M(P)*Ln(P)) with P<>n*Ln(n).
For large (even) values of the index n, the Bernoulli numbers B[n] are computed by a more efficient procedure: the integer part and the fractional part of B[n] are found separately.
First, by the theorem of Clausen -- von Staudt, the fractional part of (-B[n]) is the same as the fractional part of the sum of all inverse prime numbers p such that n is divisible by p-1. To illustrate the theorem, take n=10 with B[10]=5/66. The number n=10 is divisible only by 1, 2, 5, and 10; this corresponds to p=2, 3, 6 and 11. Of these, 6 is not a prime. Therefore, we exclude 6 and take the sum 1/2+1/3+1/11=61/66. The theorem now says that 61/66 has the same fractional part as -B[10]; in other words, -B[10]=i+f where i is some unknown integer and the fractional part f is a nonnegative rational number, 0<=f<1, which is now known to be 61/66. Indeed -B[10]= -1+61/66. So one can find the fractional part of the Bernoulli number relatively quickly by just checking the numbers that might divide n.
Now one needs to obtain the integer part of B[n]. The number B[n] is positive if Mod(n,4)=2 and negative if Mod(n,4)=0. One can use Riemann's Zeta function identity for even integer values of the argument and compute the value zeta(n) precisely enough so that the integer part of the Bernoulli number is determined. The required precision is found by estimating the Bernoulli number from the same identity in which one approximates zeta(n)=1, i.e.
At such large values of the argument n, it is feasible to use the routines ZetaNum1(n, N) or ZetaNum2(n,N) to compute the zeta function. These routines approximate zeta(n) by the defining series
For example, let us compute B[20] using this method.
In> 1/2 + 1/3 + 1/5 + 1/11; Out> 371/330; |
In> N(1+1/2^20) Out> 1.0000009536; |
In> N( 2*20! /(2*Pi)^20*1.0000009536 ) Out> 529.1242423667; |
In> -(529+41/330); Out> -174611/330; |
All these steps are implemented in the routine Bernoulli1. The variable Bernoulli1Threshold determines the smallest n for which B[n] is to be computed via this routine instead of the recursion relation. Its current value is 20.
The complexity of Bernoulli1 is estimated as the complexity of finding all primes up to n plus the complexity of computing the factorial, the power and the Zeta function. Finding the prime numbers up to n by checking all potential divisors up to Sqrt(n) requires O(n^(3/2)*M(Ln(n))) operations with precision O(Ln(n)) digits. For the second step we need to evaluate n!, Pi^n and zeta(n) with precision of P=O(n*Ln(n)) digits. The factorial is found in n short multiplications with P-digit numbers (giving O(n*P)), the power of pi in Ln(n) long multiplications (giving O(M(P)*Ln(n))), and ZetaNum2(n) (the asymptotically faster algorithm) requires O(n*M(P)) operations. The Zeta function calculation dominates the total cost because M(P) is slower than O(P). So the total complexity of Bernoulli1 is O(n*M(P)) with P<>n*Ln(n).
Note that this is the cost of finding just one Bernoulli number, as opposed to the O(n^2*M(P)*Ln(P)) cost of finding all Bernoulli numbers up to B[n] using the first algorithm BernoulliArray. If we need a complete table of Bernoulli numbers, then BernoulliArray is only marginally (logarithmically) slower. So for finding complete Bernoulli tables, Bernoulli1 is better only for very large n.
However, the recurrence relation used in BernoulliArray turns out to be numerically unstable and needs to be replaced by another (R. P. Brent, "A FORTRAN multiple-precision arithmetic package", ACM TOMS vol. 4, no. 1 (1978), p. 57). Brent's algorithm computes the Bernoulli numbers divided by factorials, C[n]:=B[2*n]/(2*n)! using a (numerically stable) recurrence relation
The numerical instability of the usual recurrence relation
The eigenvalue of the sequence e[k] can be found approximately for large k if we notice that the recurrence relation for e[k] is similar to the truncated Taylor series for Sin(x). Substituting e[k]=lambda^k into it and disregarding a very small number (2*Pi)^(-2*k) on the right hand side, we find
By a very similar calculation one finds that the inverse powers of 4 in Brent's recurrence make the largest eigenvalue of the error sequence e[k] almost equal to 1 and therefore the recurrence is stable. Brent gives the relative error in the computed C[k] as O(k^2) times the roundoff error in the last digit of precision.
The complexity of Brent's method is given as O(n^2*P+n*M(P)) for finding all Bernoulli numbers up to B[n] with precision P digits. This computation time can be achieved if we compute the inverse factorials and powers of 4 approximately by floating-point routines that know how much precision is needed for each term in the recurrence relation. The final long multiplication by (2*k)! computed to precision P adds M(P) to each Bernoulli number.
The non-iterative method using the Zeta function does not perform much better if a Bernoulli number B[n] has to be computed with significantly fewer digits P than the full O(n*Ln(n)) digits needed to represent the integer part of B[n]. (The fractional part of B[n] can always be computed relatively quickly.) The Zeta function needs 10^(P/n) terms, so its complexity is O(10^(P/n)*M(P)) (here by assumption P is not very large so 10^(P/n)<n/(2*Pi*e); if n>P we can disregard the power of 10 in the complexity formula). We should also add O(Ln(n)*M(P)) needed to compute the power of 2*Pi. The total complexity of Bernoulli1 is therefore O(Ln(n)*M(P)+10^(P/n)*M(P)).
If only one Bernoulli number is required, then Bernoulli1 is always faster. If all Bernoulli numbers up to a given n are required, then Brent's recurrence is faster for certain (small enough) n.
Currently Brent's recurrence is implemented as BernoulliArray1() but it is not used by Bernoulli because the internal arithmetic is not yet able to correctly compute with floating-point precision.
The complementary error function Erfc(x) is defined for real x as
The imaginary error function Erfi(x) is defined for real x as
Numerical computation of the error function Erf(z) needs to be performed by different methods depending on the value of z and its position in the complex plane, and on the required precision. We follow the book: Shulim E. Tsimring, Handbook of special functions and definite integrals: algorithms and programs for calculators, Radio and communications (publisher), Moscow, 1988 (in Russian), and the paper: Henry C. Thacher, Jr., Algorithm 180, Error function for large real X, Communications of the ACM, vol. 6, no. 6, 1963, p. 314. (These texts, however, do not describe arbitrary-precision computations.)
The function Erf(z) has the following approximations that are useful for its numerical computation:
Here we shall analyze the convergence and precision of these methods and show which one has to be chosen to compute Erf(z) with (relative) precision P decimal digits for a given (complex) number z, and obtain estimates for the necessary number of terms to take.
Both Taylor series converge absolutely for all z, but they do not converge uniformly fast; in fact these series are not very useful for large z because a very large number of slowly decreasing terms gives a significant contribution to the result, and the roundoff error (especially for the first series with the alternating signs) becomes too high. Both series converge well for Abs(z)<1.
Consider method 1 (the first Taylor series). We shall use the method 1 only for Abs(z)<=1. If the absolute error of the truncated Taylor series is estimated as the first discarded term, the precision after taking all terms up to and including z^(2*n) is approximately z^(2*n+2)/(n+2)!. The factorial can be approximated by Stirling's formula, n! <=>n^n*e^(-n). The value of Erf(z) at small z is of order 1, so we can take the absolute error to be equal to the relative error of the series that starts with 1. Therefore, to obtain P decimal digits of precision, we need the number of terms n that satisfies the inequality
Consider method 3 (the asymptotic series). Due to limitations of the asymptotic series, we shall use the method 3 only for large enough values of z and small enough precision.
There are two important cases when calculating Erf(z) for large (complex) z: the case of z^2>0 and the case of z^2<0. In the first case (e.g. a real z), the function Erf(z) is approximately 1 for large Abs(z) (if Re(z)>0, and approximately -1 if Re(z)<0). In the second case (e.g. pure imaginary z=I*t) the function Erf(z) rapidly grows as Exp(-z^2)/z at large Abs(z).