Tài liệu Special Functions part 6 pdf

230
Chapter 6. Special Functions
Sample page from NUMERICAL RECIPES IN C: THE ART OF SCIENTIFIC COMPUTING (ISBN 0-521-43108-5)
Copyright (C) 1988-1992 by Cambridge University Press.Programs Copyright (C) 1988-1992 by Numerical Recipes Software.
Permission is granted for internet users to make one paper copy for their own personal use. Further reproduction, or any copying of machine-
readable files (including this one) to any servercomputer, is strictly prohibited. To order Numerical Recipes books,diskettes, or CDROMs
visit website or call 1-800-872-7423 (North America only),or send email to (outside North America).
6.5 Bessel Functions of Integer Order
This section and the next one present practical algorithmsfor computing various
kinds of Bessel functions of integer order. In §6.7 we deal with fractional order. In
fact, the more complicated routines for fractional order work fine for integer order
too. For integer order, however, the routines in this section (and §6.6) are simpler
and faster. Their only drawback is that they are limited by the precision of the
underlyingrational approximations. For full double precision, it is best to work with
the routines for fractional order in §6.7.
For any real ν, the Bessel function J
ν
(x) can be defined by the series
representation
J
ν
(x)=

1
2
x

ν
∞

k=0

(−
1
4
x
2
)
k
k!Γ(ν + k +1)
(6.5.1)
The series converges for all x, but it is not computationally very useful for x  1.
For ν not an integer the Bessel function Y
ν
(x) is given by
Y
ν
(x)=
J
ν
(x)cos(νπ)−J
−ν
(x)
sin(νπ)
(6.5.2)
The right-hand side goes to the correct limiting value Y
n
(x) as ν goes to some
integer n, but this is also not computationally useful.
For arguments x<ν, both Bessel functions look qualitatively like simple
power laws, with the asymptotic forms for 0 <xν
J

ν
(x)∼
1
Γ(ν +1)

1
2
x

ν
ν≥0
Y
0
(x)∼
2
π
ln(x)
Y
ν
(x) ∼−
Γ(ν)
π

1
2
x

−ν
ν>0
(6.5.3)

For x>ν, both Bessel functions look qualitatively like sine or cosine waves whose
amplitude decays as x
−1/2
. The asymptotic forms for x  ν are
J
ν
(x) ∼

2
πx
cos

x −
1
2
νπ −
1
4
π

Y
ν
(x) ∼

2
πx
sin

x −
1

2
νπ −
1
4
π

(6.5.4)
In the transition region where x ∼ ν, the typical amplitudes of the Bessel functions
are on the order
J
ν
(ν) ∼
2
1/3
3
2/3
Γ(
2
3
)
1
ν
1/3
∼
0.4473
ν
1/3
Y
ν
(ν) ∼−

2
1/3
3
1/6
Γ(
2
3
)
1
ν
1/3
∼−
0.7748
ν
1/3
(6.5.5)
6.5 Bessel Functions of Integer Order
231
Sample page from NUMERICAL RECIPES IN C: THE ART OF SCIENTIFIC COMPUTING (ISBN 0-521-43108-5)
Copyright (C) 1988-1992 by Cambridge University Press.Programs Copyright (C) 1988-1992 by Numerical Recipes Software.
Permission is granted for internet users to make one paper copy for their own personal use. Further reproduction, or any copying of machine-
readable files (including this one) to any servercomputer, is strictly prohibited. To order Numerical Recipes books,diskettes, or CDROMs
visit website or call 1-800-872-7423 (North America only),or send email to (outside North America).
Bessel functions

1
.5
0
−.5
−1

−1.5
−2
2468100
Y
0
Y
1
Y
2
J
0
J
1
J
2
J
3
x
Figure 6.5.1. Bessel functions J
0
(x) through J
3
(x) and Y
0
(x) through Y
2
(x).
which holds asymptotically for large ν. Figure 6.5.1 plots the first few Bessel
functions of each kind.
The Bessel functions satisfy the recurrence relations

J
n+1
(x)=
2n
x
J
n
(x)−J
n−1
(x)(6.5.6)
and
Y
n+1
(x)=
2n
x
Y
n
(x)−Y
n−1
(x)(6.5.7)
As already mentioned in §5.5, only the second of these (6.5.7) is stable in the
direction of increasing n for x<n. The reason that (6.5.6) is unstable in the
direction of increasing n is simply that it is the same recurrence as (6.5.7): A small
amount of “polluting” Y
n
introduced by roundoff error will quickly come to swamp
the desired J
n
, according to equation (6.5.3).

A practical strategy for computing the Bessel functions of integer order divides
into two tasks: first, how to compute J
0
,J
1
,Y
0
,andY
1
, and second, how to use the
recurrence relations stably to find other J’s and Y ’s. We treat the first task first:
For x between zero and some arbitrary value (we will use the value 8),
approximate J
0
(x) and J
1
(x) by rational functions in x. Likewise approximate by
rational functions the “regular part” of Y
0
(x) and Y
1
(x),definedas
Y
0
(x)−
2
π
J
0
(x)ln(x) and Y

1
(x) −
2
π

J
1
(x)ln(x)−
1
x

(6.5.8)
For 8 <x<∞, use the approximating forms (n =0,1)
J
n
(x)=

2
πx

P
n

8
x

cos(X
n
) − Q
n


8
x

sin(X
n
)

(6.5.9)
232
Chapter 6. Special Functions
Sample page from NUMERICAL RECIPES IN C: THE ART OF SCIENTIFIC COMPUTING (ISBN 0-521-43108-5)
Copyright (C) 1988-1992 by Cambridge University Press.Programs Copyright (C) 1988-1992 by Numerical Recipes Software.
Permission is granted for internet users to make one paper copy for their own personal use. Further reproduction, or any copying of machine-
readable files (including this one) to any servercomputer, is strictly prohibited. To order Numerical Recipes books,diskettes, or CDROMs
visit website or call 1-800-872-7423 (North America only),or send email to (outside North America).
Y
n
(x)=

2
πx

P
n

8
x

sin(X

n
)+Q
n

8
x

cos(X
n
)

(6.5.10)
where
X
n
≡ x −
2n +1
4
π (6.5.11)
and where P
0
,P
1
,Q
0
,andQ
1
are each polynomials in their arguments, for 0 <
8/x < 1.TheP’s are even polynomials, the Q’s odd.
Coefficients of the various rational functions and polynomials are given by

Hart
[1]
, for various levels of desired accuracy. A straightforward implementation is
#include <math.h>
float bessj0(float x)
Returns the Bessel function J
0
(x) for any real x.
{
float ax,z;
double xx,y,ans,ans1,ans2; Accumulate polynomials in double precision.
if ((ax=fabs(x)) < 8.0) { Direct rational function fit.
y=x*x;
ans1=57568490574.0+y*(-13362590354.0+y*(651619640.7
+y*(-11214424.18+y*(77392.33017+y*(-184.9052456)))));
ans2=57568490411.0+y*(1029532985.0+y*(9494680.718
+y*(59272.64853+y*(267.8532712+y*1.0))));
ans=ans1/ans2;
} else { Fitting function (6.5.9).
z=8.0/ax;
y=z*z;
xx=ax-0.785398164;
ans1=1.0+y*(-0.1098628627e-2+y*(0.2734510407e-4
+y*(-0.2073370639e-5+y*0.2093887211e-6)));
ans2 = -0.1562499995e-1+y*(0.1430488765e-3
+y*(-0.6911147651e-5+y*(0.7621095161e-6
-y*0.934935152e-7)));
ans=sqrt(0.636619772/ax)*(cos(xx)*ans1-z*sin(xx)*ans2);
}
return ans;

}
#include <math.h>
float bessy0(float x)
Returns the Bessel function Y
0
(x) for positive x.
{
float bessj0(float x);
float z;
double xx,y,ans,ans1,ans2; Accumulate polynomials in double precision.
if (x < 8.0) { Rational function approximation of (6.5.8).
y=x*x;
ans1 = -2957821389.0+y*(7062834065.0+y*(-512359803.6
+y*(10879881.29+y*(-86327.92757+y*228.4622733))));
ans2=40076544269.0+y*(745249964.8+y*(7189466.438
+y*(47447.26470+y*(226.1030244+y*1.0))));
ans=(ans1/ans2)+0.636619772*bessj0(x)*log(x);
} else { Fitting function (6.5.10).
6.5 Bessel Functions of Integer Order
233
Sample page from NUMERICAL RECIPES IN C: THE ART OF SCIENTIFIC COMPUTING (ISBN 0-521-43108-5)
Copyright (C) 1988-1992 by Cambridge University Press.Programs Copyright (C) 1988-1992 by Numerical Recipes Software.
Permission is granted for internet users to make one paper copy for their own personal use. Further reproduction, or any copying of machine-
readable files (including this one) to any servercomputer, is strictly prohibited. To order Numerical Recipes books,diskettes, or CDROMs
visit website or call 1-800-872-7423 (North America only),or send email to (outside North America).
z=8.0/x;
y=z*z;
xx=x-0.785398164;
ans1=1.0+y*(-0.1098628627e-2+y*(0.2734510407e-4
+y*(-0.2073370639e-5+y*0.2093887211e-6)));

ans2 = -0.1562499995e-1+y*(0.1430488765e-3
+y*(-0.6911147651e-5+y*(0.7621095161e-6
+y*(-0.934945152e-7))));
ans=sqrt(0.636619772/x)*(sin(xx)*ans1+z*cos(xx)*ans2);
}
return ans;
}
#include <math.h>
float bessj1(float x)
Returns the Bessel function J
1
(x) for any real x.
{
float ax,z;
double xx,y,ans,ans1,ans2; Accumulate polynomials in double precision.
if ((ax=fabs(x)) < 8.0) { Direct rational approximation.
y=x*x;
ans1=x*(72362614232.0+y*(-7895059235.0+y*(242396853.1
+y*(-2972611.439+y*(15704.48260+y*(-30.16036606))))));
ans2=144725228442.0+y*(2300535178.0+y*(18583304.74
+y*(99447.43394+y*(376.9991397+y*1.0))));
ans=ans1/ans2;
} else { Fitting function (6.5.9).
z=8.0/ax;
y=z*z;
xx=ax-2.356194491;
ans1=1.0+y*(0.183105e-2+y*(-0.3516396496e-4
+y*(0.2457520174e-5+y*(-0.240337019e-6))));
ans2=0.04687499995+y*(-0.2002690873e-3
+y*(0.8449199096e-5+y*(-0.88228987e-6

+y*0.105787412e-6)));
ans=sqrt(0.636619772/ax)*(cos(xx)*ans1-z*sin(xx)*ans2);
if (x < 0.0) ans = -ans;
}
return ans;
}
#include <math.h>
float bessy1(float x)
Returns the Bessel function Y
1
(x) for positive x.
{
float bessj1(float x);
float z;
double xx,y,ans,ans1,ans2; Accumulate polynomials in double precision.
if (x < 8.0) { Rational function approximation of (6.5.8).
y=x*x;
ans1=x*(-0.4900604943e13+y*(0.1275274390e13
+y*(-0.5153438139e11+y*(0.7349264551e9
+y*(-0.4237922726e7+y*0.8511937935e4)))));
ans2=0.2499580570e14+y*(0.4244419664e12
+y*(0.3733650367e10+y*(0.2245904002e8
+y*(0.1020426050e6+y*(0.3549632885e3+y)))));
234
Chapter 6. Special Functions
Sample page from NUMERICAL RECIPES IN C: THE ART OF SCIENTIFIC COMPUTING (ISBN 0-521-43108-5)
Copyright (C) 1988-1992 by Cambridge University Press.Programs Copyright (C) 1988-1992 by Numerical Recipes Software.
Permission is granted for internet users to make one paper copy for their own personal use. Further reproduction, or any copying of machine-
readable files (including this one) to any servercomputer, is strictly prohibited. To order Numerical Recipes books,diskettes, or CDROMs
visit website or call 1-800-872-7423 (North America only),or send email to (outside North America).

ans=(ans1/ans2)+0.636619772*(bessj1(x)*log(x)-1.0/x);
} else { Fitting function (6.5.10).
z=8.0/x;
y=z*z;
xx=x-2.356194491;
ans1=1.0+y*(0.183105e-2+y*(-0.3516396496e-4
+y*(0.2457520174e-5+y*(-0.240337019e-6))));
ans2=0.04687499995+y*(-0.2002690873e-3
+y*(0.8449199096e-5+y*(-0.88228987e-6
+y*0.105787412e-6)));
ans=sqrt(0.636619772/x)*(sin(xx)*ans1+z*cos(xx)*ans2);
}
return ans;
}
We now turn to the second task, namely how to use the recurrence formulas
(6.5.6) and (6.5.7) to get the Bessel functions J
n
(x) and Y
n
(x) for n ≥ 2. The latter
of these is straightforward, since its upward recurrence is always stable:
float bessy(int n, float x)
Returns the Bessel function Y
n
(x) for positive x and n ≥ 2.
{
float bessy0(float x);
float bessy1(float x);
void nrerror(char error_text[]);
int j;

float by,bym,byp,tox;
if (n < 2) nrerror("Index n less than 2 in bessy");
tox=2.0/x;
by=bessy1(x); Starting values for the recurrence.
bym=bessy0(x);
for (j=1;j<n;j++) { Recurrence (6.5.7).
byp=j*tox*by-bym;
bym=by;
by=byp;
}
return by;
}
The cost of this algorithm is the call to bessy1 and bessy0 (which generate a
call to each of bessj1 and bessj0), plus O(n) operations in the recurrence.
As for J
n
(x), things are a bit more complicated. We can start the recurrence
upward on n from J
0
and J
1
, but it will remain stable only while n does not exceed
x. This is, however, just fine for calls with large x and small n, a case which
occurs frequently in practice.
The harder case to provide for is that with x<n. The best thing to do here
is to use Miller’s algorithm (see discussion preceding equation 5.5.16), applying
the recurrence downward from some arbitrary starting value and making use of the
upward-unstable nature of the recurrence to put us onto the correct solution. When
we finally arrive at J
0

or J
1
we are able to normalize the solution with the sum
(5.5.16) accumulated along the way.
The only subtlety is in deciding at how large an n we need start the downward
recurrence so as to obtain a desired accuracy by the time we reach the n that we
really want. If you play with the asymptotic forms (6.5.3) and (6.5.5), you should
be able to convince yourself that the answer is to start larger than the desired n by
6.5 Bessel Functions of Integer Order
235
Sample page from NUMERICAL RECIPES IN C: THE ART OF SCIENTIFIC COMPUTING (ISBN 0-521-43108-5)
Copyright (C) 1988-1992 by Cambridge University Press.Programs Copyright (C) 1988-1992 by Numerical Recipes Software.
Permission is granted for internet users to make one paper copy for their own personal use. Further reproduction, or any copying of machine-
readable files (including this one) to any servercomputer, is strictly prohibited. To order Numerical Recipes books,diskettes, or CDROMs
visit website or call 1-800-872-7423 (North America only),or send email to (outside North America).
an additive amount of order [constant ×n]
1/2
, where the square root of the constant
is, very roughly, the number of significant figures of accuracy.
The above considerations lead to the following function.
#include <math.h>
#define ACC 40.0 Make larger to increase accuracy.
#define BIGNO 1.0e10
#define BIGNI 1.0e-10
float bessj(int n, float x)
Returns the Bessel function J
n
(x) for any real x and n ≥ 2.
{
float bessj0(float x);

float bessj1(float x);
void nrerror(char error_text[]);
int j,jsum,m;
float ax,bj,bjm,bjp,sum,tox,ans;
if (n < 2) nrerror("Index n less than 2 in bessj");
ax=fabs(x);
if (ax == 0.0)
return 0.0;
else if (ax > (float) n) { Upwards recurrence from J
0
and J
1
.
tox=2.0/ax;
bjm=bessj0(ax);
bj=bessj1(ax);
for (j=1;j<n;j++) {
bjp=j*tox*bj-bjm;
bjm=bj;
bj=bjp;
}
ans=bj;
} else { Downwards recurrence from an even m here com-
puted.tox=2.0/ax;
m=2*((n+(int) sqrt(ACC*n))/2);
jsum=0; jsum will alternate between 0 and 1; when it is
1, we accumulate in sum the even terms in
(5.5.16).
bjp=ans=sum=0.0;
bj=1.0;

for (j=m;j>0;j ) { The downward recurrence.
bjm=j*tox*bj-bjp;
bjp=bj;
bj=bjm;
if (fabs(bj) > BIGNO) { Renormalize to prevent overflows.
bj *= BIGNI;
bjp *= BIGNI;
ans *= BIGNI;
sum *= BIGNI;
}
if (jsum) sum += bj; Accumulate the sum.
jsum=!jsum; Change0to1orviceversa.
if (j == n) ans=bjp; Save the unnormalized answer.
}
sum=2.0*sum-bj; Compute (5.5.16)
ans /= sum; and use it to normalize the answer.
}
return x < 0.0 && (n & 1) ? -ans : ans;
}
236
Chapter 6. Special Functions
Sample page from NUMERICAL RECIPES IN C: THE ART OF SCIENTIFIC COMPUTING (ISBN 0-521-43108-5)
Copyright (C) 1988-1992 by Cambridge University Press.Programs Copyright (C) 1988-1992 by Numerical Recipes Software.
Permission is granted for internet users to make one paper copy for their own personal use. Further reproduction, or any copying of machine-
readable files (including this one) to any servercomputer, is strictly prohibited. To order Numerical Recipes books,diskettes, or CDROMs
visit website or call 1-800-872-7423 (North America only),or send email to (outside North America).
CITED REFERENCES AND FURTHER READING:
Abramowitz, M., and Stegun, I.A. 1964,
Handbook of Mathematical Functions
, Applied Mathe-

matics Series, Volume 55 (Washington: National Bureau of Standards; reprinted 1968 by
Dover Publications, New York), Chapter 9.
Hart, J.F., et al. 1968,
Computer Approximations
(New York: Wiley), §6.8, p. 141. [1]
6.6 Modified Bessel Functions of Integer Order
The modified Bessel functions I
n
(x) and K
n
(x) are equivalent to the usual
Bessel functions J
n
and Y
n
evaluated for purely imaginary arguments. In detail,
the relationship is
I
n
(x)=(−i)
n
J
n
(ix)
K
n
(x)=
π
2
i

n+1
[J
n
(ix)+iY
n
(ix)]
(6.6.1)
The particular choice of prefactor and of the linear combination of J
n
and Y
n
to form
K
n
are simply choices that make the functions real-valued for real arguments x.
For small arguments x  n, both I
n
(x) and K
n
(x) become, asymptotically,
simple powers of their argument
I
n
(x) ≈
1
n!

x
2


n
n ≥ 0
K
0
(x) ≈−ln(x)
K
n
(x) ≈
(n −1)!
2

x
2

−n
n>0
(6.6.2)
These expressions are virtuallyidentical to those for J
n
(x) and Y
n
(x) in this region,
except for the factor of −2/π difference between Y
n
(x) and K
n
(x). In the region
x  n, however, the modified functions have quite different behavior than the
Bessel functions,
I

n
(x) ≈
1
√
2πx
exp(x)
K
n
(x) ≈
π
√
2πx
exp(−x)
(6.6.3)
The modified functions evidently have exponential rather than sinusoidal
behavior for large arguments (see Figure 6.6.1). The smoothness of the modified
Bessel functions, once the exponentialfactor is removed, makes a simple polynomial
approximation of a few terms quite suitable for the functions I
0
, I
1
, K
0
,andK
1
.
The following routines, based on polynomial coefficients given by Abramowitz and
Stegun
[1]
, evaluate these four functions, and will provide the basis for upward

recursion for n>1when x>n.