1
2 /*
3 * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation. Oracle designates this
9 * particular file as subject to the "Classpath" exception as provided
10 * by Oracle in the LICENSE file that accompanied this code.
11 *
12 * This code is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 * version 2 for more details (a copy is included in the LICENSE file that
16 * accompanied this code).
17 *
18 * You should have received a copy of the GNU General Public License version
19 * 2 along with this work; if not, write to the Free Software Foundation,
20 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
21 *
22 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
23 * or visit www.oracle.com if you need additional information or have any
24 * questions.
25 */
26
27 /*
28 * __kernel_rem_pio2(x,y,e0,nx,prec,ipio2)
29 * double x[],y[]; int e0,nx,prec; int ipio2[];
30 *
31 * __kernel_rem_pio2 return the last three digits of N with
32 * y = x - N*pi/2
33 * so that |y| < pi/2.
34 *
35 * The method is to compute the integer (mod 8) and fraction parts of
36 * (2/pi)*x without doing the full multiplication. In general we
37 * skip the part of the product that are known to be a huge integer (
38 * more accurately, = 0 mod 8 ). Thus the number of operations are
39 * independent of the exponent of the input.
40 *
41 * (2/pi) is represented by an array of 24-bit integers in ipio2[].
42 *
43 * Input parameters:
44 * x[] The input value (must be positive) is broken into nx
45 * pieces of 24-bit integers in double precision format.
46 * x[i] will be the i-th 24 bit of x. The scaled exponent
47 * of x[0] is given in input parameter e0 (i.e., x[0]*2^e0
48 * match x's up to 24 bits.
49 *
50 * Example of breaking a double positive z into x[0]+x[1]+x[2]:
51 * e0 = ilogb(z)-23
52 * z = scalbn(z,-e0)
53 * for i = 0,1,2
54 * x[i] = floor(z)
55 * z = (z-x[i])*2**24
56 *
57 *
58 * y[] output result in an array of double precision numbers.
59 * The dimension of y[] is:
60 * 24-bit precision 1
61 * 53-bit precision 2
62 * 64-bit precision 2
63 * 113-bit precision 3
64 * The actual value is the sum of them. Thus for 113-bit
65 * precison, one may have to do something like:
66 *
67 * long double t,w,r_head, r_tail;
68 * t = (long double)y[2] + (long double)y[1];
69 * w = (long double)y[0];
70 * r_head = t+w;
71 * r_tail = w - (r_head - t);
72 *
73 * e0 The exponent of x[0]
74 *
75 * nx dimension of x[]
76 *
77 * prec an integer indicating the precision:
78 * 0 24 bits (single)
79 * 1 53 bits (double)
80 * 2 64 bits (extended)
81 * 3 113 bits (quad)
82 *
83 * ipio2[]
84 * integer array, contains the (24*i)-th to (24*i+23)-th
85 * bit of 2/pi after binary point. The corresponding
86 * floating value is
87 *
88 * ipio2[i] * 2^(-24(i+1)).
89 *
90 * External function:
91 * double scalbn(), floor();
92 *
93 *
94 * Here is the description of some local variables:
95 *
96 * jk jk+1 is the initial number of terms of ipio2[] needed
97 * in the computation. The recommended value is 2,3,4,
98 * 6 for single, double, extended,and quad.
99 *
100 * jz local integer variable indicating the number of
101 * terms of ipio2[] used.
102 *
103 * jx nx - 1
104 *
105 * jv index for pointing to the suitable ipio2[] for the
106 * computation. In general, we want
107 * ( 2^e0*x[0] * ipio2[jv-1]*2^(-24jv) )/8
108 * is an integer. Thus
109 * e0-3-24*jv >= 0 or (e0-3)/24 >= jv
110 * Hence jv = max(0,(e0-3)/24).
111 *
112 * jp jp+1 is the number of terms in PIo2[] needed, jp = jk.
113 *
114 * q[] double array with integral value, representing the
115 * 24-bits chunk of the product of x and 2/pi.
116 *
117 * q0 the corresponding exponent of q[0]. Note that the
118 * exponent for q[i] would be q0-24*i.
119 *
120 * PIo2[] double precision array, obtained by cutting pi/2
121 * into 24 bits chunks.
122 *
123 * f[] ipio2[] in floating point
124 *
125 * iq[] integer array by breaking up q[] in 24-bits chunk.
126 *
127 * fq[] final product of x*(2/pi) in fq[0],..,fq[jk]
128 *
129 * ih integer. If >0 it indicates q[] is >= 0.5, hence
130 * it also indicates the *sign* of the result.
131 *
132 */
133
134
135 /*
136 * Constants:
137 * The hexadecimal values are the intended ones for the following
138 * constants. The decimal values may be used, provided that the
139 * compiler will convert from decimal to binary accurately enough
140 * to produce the hexadecimal values shown.
141 */
142
143 #include "fdlibm.h"
144
145 #ifdef __STDC__
146 static const int init_jk[] = {2,3,4,6}; /* initial value for jk */
147 #else
148 static int init_jk[] = {2,3,4,6};
149 #endif
150
151 #ifdef __STDC__
152 static const double PIo2[] = {
153 #else
154 static double PIo2[] = {
155 #endif
156 1.57079625129699707031e+00, /* 0x3FF921FB, 0x40000000 */
157 7.54978941586159635335e-08, /* 0x3E74442D, 0x00000000 */
158 5.39030252995776476554e-15, /* 0x3CF84698, 0x80000000 */
159 3.28200341580791294123e-22, /* 0x3B78CC51, 0x60000000 */
160 1.27065575308067607349e-29, /* 0x39F01B83, 0x80000000 */
161 1.22933308981111328932e-36, /* 0x387A2520, 0x40000000 */
162 2.73370053816464559624e-44, /* 0x36E38222, 0x80000000 */
163 2.16741683877804819444e-51, /* 0x3569F31D, 0x00000000 */
164 };
165
166 #ifdef __STDC__
167 static const double
168 #else
169 static double
170 #endif
171 zero = 0.0,
172 one = 1.0,
173 two24 = 1.67772160000000000000e+07, /* 0x41700000, 0x00000000 */
174 twon24 = 5.96046447753906250000e-08; /* 0x3E700000, 0x00000000 */
175
176 #ifdef __STDC__
177 int __kernel_rem_pio2(double *x, double *y, int e0, int nx, int prec, const int *ipio2)
178 #else
179 int __kernel_rem_pio2(x,y,e0,nx,prec,ipio2)
180 double x[], y[]; int e0,nx,prec; int ipio2[];
181 #endif
182 {
183 int jz,jx,jv,jp,jk,carry,n,iq[20],i,j,k,m,q0,ih;
184 double z,fw,f[20],fq[20],q[20];
185
186 /* initialize jk*/
187 jk = init_jk[prec];
188 jp = jk;
189
190 /* determine jx,jv,q0, note that 3>q0 */
191 jx = nx-1;
192 jv = (e0-3)/24; if(jv<0) jv=0;
193 q0 = e0-24*(jv+1);
194
195 /* set up f[0] to f[jx+jk] where f[jx+jk] = ipio2[jv+jk] */
196 j = jv-jx; m = jx+jk;
197 for(i=0;i<=m;i++,j++) f[i] = (j<0)? zero : (double) ipio2[j];
198
199 /* compute q[0],q[1],...q[jk] */
200 for (i=0;i<=jk;i++) {
201 for (j=0,fw=0.0;j<=jx;j++) {
202 fw += x[j]*f[jx+i-j]; q[i] = fw;
203 }
204 }
205
206 jz = jk;
207 recompute:
208 /* distill q[] into iq[] reversingly */
209 for(i=0,j=jz,z=q[jz];j>0;i++,j--) {
210 fw = (double)((int)(twon24* z));
211 iq[i] = (int)(z-two24*fw);
212 z = q[j-1]+fw;
213 }
214
215 /* compute n */
216 z = scalbn(z,q0); /* actual value of z */
217 z -= 8.0*floor(z*0.125); /* trim off integer >= 8 */
218 n = (int) z;
219 z -= (double)n;
220 ih = 0;
221 if(q0>0) { /* need iq[jz-1] to determine n */
222 i = (iq[jz-1]>>(24-q0)); n += i;
223 iq[jz-1] -= i<<(24-q0);
224 ih = iq[jz-1]>>(23-q0);
225 }
226 else if(q0==0) ih = iq[jz-1]>>23;
227 else if(z>=0.5) ih=2;
228
229 if(ih>0) { /* q > 0.5 */
230 n += 1; carry = 0;
231 for(i=0;i<jz ;i++) { /* compute 1-q */
232 j = iq[i];
233 if(carry==0) {
234 if(j!=0) {
235 carry = 1; iq[i] = 0x1000000- j;
236 }
237 } else iq[i] = 0xffffff - j;
238 }
239 if(q0>0) { /* rare case: chance is 1 in 12 */
240 switch(q0) {
241 case 1:
242 iq[jz-1] &= 0x7fffff; break;
243 case 2:
244 iq[jz-1] &= 0x3fffff; break;
245 }
246 }
247 if(ih==2) {
248 z = one - z;
249 if(carry!=0) z -= scalbn(one,q0);
250 }
251 }
252
253 /* check if recomputation is needed */
254 if(z==zero) {
255 j = 0;
256 for (i=jz-1;i>=jk;i--) j |= iq[i];
257 if(j==0) { /* need recomputation */
258 for(k=1;iq[jk-k]==0;k++); /* k = no. of terms needed */
259
260 for(i=jz+1;i<=jz+k;i++) { /* add q[jz+1] to q[jz+k] */
261 f[jx+i] = (double) ipio2[jv+i];
262 for(j=0,fw=0.0;j<=jx;j++) fw += x[j]*f[jx+i-j];
263 q[i] = fw;
264 }
265 jz += k;
266 goto recompute;
267 }
268 }
269
270 /* chop off zero terms */
271 if(z==0.0) {
272 jz -= 1; q0 -= 24;
273 while(iq[jz]==0) { jz--; q0-=24;}
274 } else { /* break z into 24-bit if necessary */
275 z = scalbn(z,-q0);
276 if(z>=two24) {
277 fw = (double)((int)(twon24*z));
278 iq[jz] = (int)(z-two24*fw);
279 jz += 1; q0 += 24;
280 iq[jz] = (int) fw;
281 } else iq[jz] = (int) z ;
282 }
283
284 /* convert integer "bit" chunk to floating-point value */
285 fw = scalbn(one,q0);
286 for(i=jz;i>=0;i--) {
287 q[i] = fw*(double)iq[i]; fw*=twon24;
288 }
289
290 /* compute PIo2[0,...,jp]*q[jz,...,0] */
291 for(i=jz;i>=0;i--) {
292 for(fw=0.0,k=0;k<=jp&&k<=jz-i;k++) fw += PIo2[k]*q[i+k];
293 fq[jz-i] = fw;
294 }
295
296 /* compress fq[] into y[] */
297 switch(prec) {
298 case 0:
299 fw = 0.0;
300 for (i=jz;i>=0;i--) fw += fq[i];
301 y[0] = (ih==0)? fw: -fw;
302 break;
303 case 1:
304 case 2:
305 fw = 0.0;
306 for (i=jz;i>=0;i--) fw += fq[i];
307 y[0] = (ih==0)? fw: -fw;
308 fw = fq[0]-fw;
309 for (i=1;i<=jz;i++) fw += fq[i];
310 y[1] = (ih==0)? fw: -fw;
311 break;
312 case 3: /* painful */
313 for (i=jz;i>0;i--) {
314 fw = fq[i-1]+fq[i];
315 fq[i] += fq[i-1]-fw;
316 fq[i-1] = fw;
317 }
318 for (i=jz;i>1;i--) {
319 fw = fq[i-1]+fq[i];
320 fq[i] += fq[i-1]-fw;
321 fq[i-1] = fw;
322 }
323 for (fw=0.0,i=jz;i>=2;i--) fw += fq[i];
324 if(ih==0) {
325 y[0] = fq[0]; y[1] = fq[1]; y[2] = fw;
326 } else {
327 y[0] = -fq[0]; y[1] = -fq[1]; y[2] = -fw;
328 }
329 }
330 return n&7;
331 }