1 /* $NetBSD: n_jn.c,v 1.7 2011/11/02 02:34:56 christos Exp $ */
2 /*-
3 * Copyright (c) 1992, 1993
4 * The Regents of the University of California. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. Neither the name of the University nor the names of its contributors
15 * may be used to endorse or promote products derived from this software
16 * without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31 #ifndef lint
32 #if 0
33 static char sccsid[] = "@(#)jn.c 8.2 (Berkeley) 11/30/93";
34 #endif
35 #endif /* not lint */
36
37 /*
38 * 16 December 1992
39 * Minor modifications by Peter McIlroy to adapt non-IEEE architecture.
40 */
41
42 /*
43 * ====================================================
44 * Copyright (C) 1992 by Sun Microsystems, Inc.
45 *
46 * Developed at SunPro, a Sun Microsystems, Inc. business.
47 * Permission to use, copy, modify, and distribute this
48 * software is freely granted, provided that this notice
49 * is preserved.
50 * ====================================================
51 *
52 * ******************* WARNING ********************
53 * This is an alpha version of SunPro's FDLIBM (Freely
54 * Distributable Math Library) for IEEE double precision
55 * arithmetic. FDLIBM is a basic math library written
56 * in C that runs on machines that conform to IEEE
57 * Standard 754/854. This alpha version is distributed
58 * for testing purpose. Those who use this software
59 * should report any bugs to
60 *
61 * fdlibm-comments@sunpro.eng.sun.com
62 *
63 * -- K.C. Ng, Oct 12, 1992
64 * ************************************************
65 */
66
67 /*
68 * jn(int n, double x), yn(int n, double x)
69 * floating point Bessel's function of the 1st and 2nd kind
70 * of order n
71 *
72 * Special cases:
73 * y0(0)=y1(0)=yn(n,0) = -inf with division by zero signal;
74 * y0(-ve)=y1(-ve)=yn(n,-ve) are NaN with invalid signal.
75 * Note 2. About jn(n,x), yn(n,x)
76 * For n=0, j0(x) is called,
77 * for n=1, j1(x) is called,
78 * for n<x, forward recursion us used starting
79 * from values of j0(x) and j1(x).
80 * for n>x, a continued fraction approximation to
81 * j(n,x)/j(n-1,x) is evaluated and then backward
82 * recursion is used starting from a supposed value
83 * for j(n,x). The resulting value of j(0,x) is
84 * compared with the actual value to correct the
85 * supposed value of j(n,x).
86 *
87 * yn(n,x) is similar in all respects, except
88 * that forward recursion is used for all
89 * values of n>1.
90 *
91 */
92
93 #include "mathimpl.h"
94 #include <float.h>
95 #include <errno.h>
96
97 #if defined(__vax__) || defined(tahoe)
98 #define _IEEE 0
99 #else
100 #define _IEEE 1
101 #define infnan(x) (0.0)
102 #endif
103
104 static const double
105 invsqrtpi= 5.641895835477562869480794515607725858441e-0001,
106 two = 2.0,
107 zero = 0.0,
108 one = 1.0;
109
110 double
jn(int n,double x)111 jn(int n, double x)
112 {
113 int i, sgn;
114 double a, b, temp;
115 double z, w;
116
117 /* J(-n,x) = (-1)^n * J(n, x), J(n, -x) = (-1)^n * J(n, x)
118 * Thus, J(-n,x) = J(n,-x)
119 */
120 /* if J(n,NaN) is NaN */
121 #if _IEEE
122 if (snan(x)) return x+x;
123 #endif
124 if (n<0){
125 n = -n;
126 x = -x;
127 }
128 if (n==0) return(j0(x));
129 if (n==1) return(j1(x));
130 sgn = (n&1)&(x < zero); /* even n -- 0, odd n -- sign(x) */
131 x = fabs(x);
132 if (x == 0 || !finite (x)) /* if x is 0 or inf */
133 b = zero;
134 else if ((double) n <= x) {
135 /* Safe to use J(n+1,x)=2n/x *J(n,x)-J(n-1,x) */
136 #if _IEEE
137 if (x >= 8.148143905337944345e+090) {
138 /* x >= 2**302 */
139 /* (x >> n**2)
140 * Jn(x) = cos(x-(2n+1)*pi/4)*sqrt(2/x*pi)
141 * Yn(x) = sin(x-(2n+1)*pi/4)*sqrt(2/x*pi)
142 * Let s=sin(x), c=cos(x),
143 * xn=x-(2n+1)*pi/4, sqt2 = sqrt(2),then
144 *
145 * n sin(xn)*sqt2 cos(xn)*sqt2
146 * ----------------------------------
147 * 0 s-c c+s
148 * 1 -s-c -c+s
149 * 2 -s+c -c-s
150 * 3 s+c c-s
151 */
152 switch(n&3) {
153 case 0: temp = cos(x)+sin(x); break;
154 case 1: temp = -cos(x)+sin(x); break;
155 case 2: temp = -cos(x)-sin(x); break;
156 case 3: temp = cos(x)-sin(x); break;
157 }
158 b = invsqrtpi*temp/sqrt(x);
159 } else
160 #endif
161 {
162 a = j0(x);
163 b = j1(x);
164 for(i=1;i<n;i++){
165 temp = b;
166 b = b*((double)(i+i)/x) - a; /* avoid underflow */
167 a = temp;
168 }
169 }
170 } else {
171 if (x < 1.86264514923095703125e-009) { /* x < 2**-29 */
172 /* x is tiny, return the first Taylor expansion of J(n,x)
173 * J(n,x) = 1/n!*(x/2)^n - ...
174 */
175 if (n > 33) /* underflow */
176 b = zero;
177 else {
178 temp = x*0.5; b = temp;
179 for (a=one,i=2;i<=n;i++) {
180 a *= (double)i; /* a = n! */
181 b *= temp; /* b = (x/2)^n */
182 }
183 b = b/a;
184 }
185 } else {
186 /* use backward recurrence */
187 /* x x^2 x^2
188 * J(n,x)/J(n-1,x) = ---- ------ ------ .....
189 * 2n - 2(n+1) - 2(n+2)
190 *
191 * 1 1 1
192 * (for large x) = ---- ------ ------ .....
193 * 2n 2(n+1) 2(n+2)
194 * -- - ------ - ------ -
195 * x x x
196 *
197 * Let w = 2n/x and h=2/x, then the above quotient
198 * is equal to the continued fraction:
199 * 1
200 * = -----------------------
201 * 1
202 * w - -----------------
203 * 1
204 * w+h - ---------
205 * w+2h - ...
206 *
207 * To determine how many terms needed, let
208 * Q(0) = w, Q(1) = w(w+h) - 1,
209 * Q(k) = (w+k*h)*Q(k-1) - Q(k-2),
210 * When Q(k) > 1e4 good for single
211 * When Q(k) > 1e9 good for double
212 * When Q(k) > 1e17 good for quadruple
213 */
214 /* determine k */
215 double t,v;
216 double q0,q1,h,tmp; int k,m;
217 w = (n+n)/(double)x; h = 2.0/(double)x;
218 q0 = w; z = w+h; q1 = w*z - 1.0; k=1;
219 while (q1<1.0e9) {
220 k += 1; z += h;
221 tmp = z*q1 - q0;
222 q0 = q1;
223 q1 = tmp;
224 }
225 m = n+n;
226 for(t=zero, i = 2*(n+k); i>=m; i -= 2) t = one/(i/x-t);
227 a = t;
228 b = one;
229 /* estimate log((2/x)^n*n!) = n*log(2/x)+n*ln(n)
230 * Hence, if n*(log(2n/x)) > ...
231 * single 8.8722839355e+01
232 * double 7.09782712893383973096e+02
233 * long double 1.1356523406294143949491931077970765006170e+04
234 * then recurrent value may overflow and the result will
235 * likely underflow to zero
236 */
237 tmp = n;
238 v = two/x;
239 tmp = tmp*log(fabs(v*tmp));
240 for (i=n-1;i>0;i--){
241 temp = b;
242 b = ((i+i)/x)*b - a;
243 a = temp;
244 /* scale b to avoid spurious overflow */
245 # if defined(__vax__) || defined(tahoe)
246 # define BMAX 1e13
247 # else
248 # define BMAX 1e100
249 # endif /* defined(__vax__) || defined(tahoe) */
250 if (b > BMAX) {
251 a /= b;
252 t /= b;
253 b = one;
254 }
255 }
256 b = (t*j0(x)/b);
257 }
258 }
259 return ((sgn == 1) ? -b : b);
260 }
261
262 double
yn(int n,double x)263 yn(int n, double x)
264 {
265 int i, sign;
266 double a, b, temp;
267
268 /* Y(n,NaN), Y(n, x < 0) is NaN */
269 if (x <= 0 || (_IEEE && x != x))
270 if (_IEEE && x < 0) return zero/zero;
271 else if (x < 0) return (infnan(EDOM));
272 else if (_IEEE) return -one/zero;
273 else return(infnan(-ERANGE));
274 else if (!finite(x)) return(0);
275 sign = 1;
276 if (n<0){
277 n = -n;
278 sign = 1 - ((n&1)<<2);
279 }
280 if (n == 0) return(y0(x));
281 if (n == 1) return(sign*y1(x));
282 #if _IEEE
283 if(x >= 8.148143905337944345e+090) { /* x > 2**302 */
284 /* (x >> n**2)
285 * Jn(x) = cos(x-(2n+1)*pi/4)*sqrt(2/x*pi)
286 * Yn(x) = sin(x-(2n+1)*pi/4)*sqrt(2/x*pi)
287 * Let s=sin(x), c=cos(x),
288 * xn=x-(2n+1)*pi/4, sqt2 = sqrt(2),then
289 *
290 * n sin(xn)*sqt2 cos(xn)*sqt2
291 * ----------------------------------
292 * 0 s-c c+s
293 * 1 -s-c -c+s
294 * 2 -s+c -c-s
295 * 3 s+c c-s
296 */
297 switch (n&3) {
298 case 0: temp = sin(x)-cos(x); break;
299 case 1: temp = -sin(x)-cos(x); break;
300 case 2: temp = -sin(x)+cos(x); break;
301 case 3: temp = sin(x)+cos(x); break;
302 }
303 b = invsqrtpi*temp/sqrt(x);
304 } else
305 #endif
306 {
307 a = y0(x);
308 b = y1(x);
309 /* quit if b is -inf */
310 for (i = 1; i < n && !finite(b); i++){
311 temp = b;
312 b = ((double)(i+i)/x)*b - a;
313 a = temp;
314 }
315 }
316 if (!_IEEE && !finite(b))
317 return (infnan(-sign * ERANGE));
318 return ((sign > 0) ? b : -b);
319 }
320