Update.
[glibc.git] / sysdeps / libm-ieee754 / e_pow.c
blob1e1496f00d147b6f8ed8a98b047c1af21c633b93
1 /* @(#)e_pow.c 5.1 93/09/24 */
2 /*
3 * ====================================================
4 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
6 * Developed at SunPro, a Sun Microsystems, Inc. business.
7 * Permission to use, copy, modify, and distribute this
8 * software is freely granted, provided that this notice
9 * is preserved.
10 * ====================================================
12 /* Modified by Naohiko Shimizu/Tokai University, Japan 1997/08/25,
13 for performance improvement on pipelined processors.
16 #if defined(LIBM_SCCS) && !defined(lint)
17 static char rcsid[] = "$NetBSD: e_pow.c,v 1.9 1995/05/12 04:57:32 jtc Exp $";
18 #endif
20 /* __ieee754_pow(x,y) return x**y
22 * n
23 * Method: Let x = 2 * (1+f)
24 * 1. Compute and return log2(x) in two pieces:
25 * log2(x) = w1 + w2,
26 * where w1 has 53-24 = 29 bit trailing zeros.
27 * 2. Perform y*log2(x) = n+y' by simulating muti-precision
28 * arithmetic, where |y'|<=0.5.
29 * 3. Return x**y = 2**n*exp(y'*log2)
31 * Special cases:
32 * 1. (anything) ** 0 is 1
33 * 2. (anything) ** 1 is itself
34 * 3. (anything) ** NAN is NAN
35 * 4. NAN ** (anything except 0) is NAN
36 * 5. +-(|x| > 1) ** +INF is +INF
37 * 6. +-(|x| > 1) ** -INF is +0
38 * 7. +-(|x| < 1) ** +INF is +0
39 * 8. +-(|x| < 1) ** -INF is +INF
40 * 9. +-1 ** +-INF is NAN
41 * 10. +0 ** (+anything except 0, NAN) is +0
42 * 11. -0 ** (+anything except 0, NAN, odd integer) is +0
43 * 12. +0 ** (-anything except 0, NAN) is +INF
44 * 13. -0 ** (-anything except 0, NAN, odd integer) is +INF
45 * 14. -0 ** (odd integer) = -( +0 ** (odd integer) )
46 * 15. +INF ** (+anything except 0,NAN) is +INF
47 * 16. +INF ** (-anything except 0,NAN) is +0
48 * 17. -INF ** (anything) = -0 ** (-anything)
49 * 18. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer)
50 * 19. (-anything except 0 and inf) ** (non-integer) is NAN
52 * Accuracy:
53 * pow(x,y) returns x**y nearly rounded. In particular
54 * pow(integer,integer)
55 * always returns the correct integer provided it is
56 * representable.
58 * Constants :
59 * The hexadecimal values are the intended ones for the following
60 * constants. The decimal values may be used, provided that the
61 * compiler will convert from decimal to binary accurately enough
62 * to produce the hexadecimal values shown.
65 #include "math.h"
66 #include "math_private.h"
67 #define zero C[0]
68 #define one C[1]
69 #define two C[2]
70 #define two53 C[3]
71 #define huge C[4]
72 #define tiny C[5]
73 #define L1 C[6]
74 #define L2 C[7]
75 #define L3 C[8]
76 #define L4 C[9]
77 #define L5 C[10]
78 #define L6 C[11]
79 #define P1 C[12]
80 #define P2 C[13]
81 #define P3 C[14]
82 #define P4 C[15]
83 #define P5 C[16]
84 #define lg2 C[17]
85 #define lg2_h C[18]
86 #define lg2_l C[19]
87 #define ovt C[20]
88 #define cp C[21]
89 #define cp_h C[22]
90 #define cp_l C[23]
91 #define ivln2 C[24]
92 #define ivln2_h C[25]
93 #define ivln2_l C[26]
95 #ifdef __STDC__
96 static const double
97 #else
98 static double
99 #endif
100 bp[] = {1.0, 1.5,},
101 dp_h[] = { 0.0, 5.84962487220764160156e-01,}, /* 0x3FE2B803, 0x40000000 */
102 dp_l[] = { 0.0, 1.35003920212974897128e-08,}, /* 0x3E4CFDEB, 0x43CFD006 */
103 C[] = {
104 0.0,
105 1.0,
106 2.0,
107 9007199254740992.0 ,
108 1.0e300,
109 1.0e-300,
110 5.99999999999994648725e-01 ,
111 4.28571428578550184252e-01 ,
112 3.33333329818377432918e-01 ,
113 2.72728123808534006489e-01 ,
114 2.30660745775561754067e-01 ,
115 2.06975017800338417784e-01 ,
116 1.66666666666666019037e-01 ,
117 -2.77777777770155933842e-03 ,
118 6.61375632143793436117e-05 ,
119 -1.65339022054652515390e-06 ,
120 4.13813679705723846039e-08 ,
121 6.93147180559945286227e-01 ,
122 6.93147182464599609375e-01 ,
123 -1.90465429995776804525e-09 ,
124 8.0085662595372944372e-0017 ,
125 9.61796693925975554329e-01 ,
126 9.61796700954437255859e-01 ,
127 -7.02846165095275826516e-09 ,
128 1.44269504088896338700e+00 ,
129 1.44269502162933349609e+00 ,
130 1.92596299112661746887e-08 };
132 #ifdef __STDC__
133 double __ieee754_pow(double x, double y)
134 #else
135 double __ieee754_pow(x,y)
136 double x, y;
137 #endif
139 double z,ax,z_h,z_l,p_h,p_l;
140 double y1,t1,t2,r,s,t,u,v,w, t12,t14,r_1,r_2,r_3;
141 int32_t i,j,k,yisint,n;
142 int32_t hx,hy,ix,iy;
143 u_int32_t lx,ly;
145 EXTRACT_WORDS(hx,lx,x);
146 EXTRACT_WORDS(hy,ly,y);
147 ix = hx&0x7fffffff; iy = hy&0x7fffffff;
149 /* y==zero: x**0 = 1 */
150 if((iy|ly)==0) return C[1];
152 /* +-NaN return x+y */
153 if(ix > 0x7ff00000 || ((ix==0x7ff00000)&&(lx!=0)) ||
154 iy > 0x7ff00000 || ((iy==0x7ff00000)&&(ly!=0)))
155 return x+y;
157 /* determine if y is an odd int when x < 0
158 * yisint = 0 ... y is not an integer
159 * yisint = 1 ... y is an odd int
160 * yisint = 2 ... y is an even int
162 yisint = 0;
163 if(hx<0) {
164 if(iy>=0x43400000) yisint = 2; /* even integer y */
165 else if(iy>=0x3ff00000) {
166 k = (iy>>20)-0x3ff; /* exponent */
167 if(k>20) {
168 j = ly>>(52-k);
169 if((u_int32_t)(j<<(52-k))==ly) yisint = 2-(j&1);
170 } else if(ly==0) {
171 j = iy>>(20-k);
172 if((int32_t)(j<<(20-k))==iy) yisint = 2-(j&1);
177 /* special value of y */
178 if(ly==0) {
179 if (iy==0x7ff00000) { /* y is +-inf */
180 if(((ix-0x3ff00000)|lx)==0)
181 return y - y; /* inf**+-1 is NaN */
182 else if (ix >= 0x3ff00000)/* (|x|>1)**+-inf = inf,0 */
183 return (hy>=0)? y: C[0];
184 else /* (|x|<1)**-,+inf = inf,0 */
185 return (hy<0)?-y: C[0];
187 if(iy==0x3ff00000) { /* y is +-1 */
188 if(hy<0) return C[1]/x; else return x;
190 if(hy==0x40000000) return x*x; /* y is 2 */
191 if(hy==0x3fe00000) { /* y is 0.5 */
192 if(hx>=0) /* x >= +0 */
193 return __ieee754_sqrt(x);
197 ax = fabs(x);
198 /* special value of x */
199 if(lx==0) {
200 if(ix==0x7ff00000||ix==0||ix==0x3ff00000){
201 z = ax; /*x is +-0,+-inf,+-1*/
202 if(hy<0) z = C[1]/z; /* z = (1/|x|) */
203 if(hx<0) {
204 if(((ix-0x3ff00000)|yisint)==0) {
205 z = (z-z)/(z-z); /* (-1)**non-int is NaN */
206 } else if(yisint==1)
207 z = -z; /* (x<0)**odd = -(|x|**odd) */
209 return z;
213 /* (x<0)**(non-int) is NaN */
214 if(((((u_int32_t)hx>>31)-1)|yisint)==0) return (x-x)/(x-x);
216 /* |y| is huge */
217 if(iy>0x41e00000) { /* if |y| > 2**31 */
218 if(iy>0x43f00000){ /* if |y| > 2**64, must o/uflow */
219 if(ix<=0x3fefffff) return (hy<0)? C[4]*C[4]:C[5]*C[5];
220 if(ix>=0x3ff00000) return (hy>0)? C[4]*C[4]:C[5]*C[5];
222 /* over/underflow if x is not close to one */
223 if(ix<0x3fefffff) return (hy<0)? C[4]*C[4]:C[5]*C[5];
224 if(ix>0x3ff00000) return (hy>0)? C[4]*C[4]:C[5]*C[5];
225 /* now |1-x| is tiny <= 2**-20, suffice to compute
226 log(x) by x-x^2/2+x^3/3-x^4/4 */
227 t = x-1; /* t has 20 trailing zeros */
228 w = (t*t)*(0.5-t*(0.3333333333333333333333-t*0.25));
229 u = C[25]*t; /* ivln2_h has 21 sig. bits */
230 v = t*C[26]-w*C[24];
231 t1 = u+v;
232 SET_LOW_WORD(t1,0);
233 t2 = v-(t1-u);
234 } else {
235 double s2,s_h,s_l,t_h,t_l,s22,s24,s26,r1,r2,r3;
236 n = 0;
237 /* take care subnormal number */
238 if(ix<0x00100000)
239 {ax *= C[3]; n -= 53; GET_HIGH_WORD(ix,ax); }
240 n += ((ix)>>20)-0x3ff;
241 j = ix&0x000fffff;
242 /* determine interval */
243 ix = j|0x3ff00000; /* normalize ix */
244 if(j<=0x3988E) k=0; /* |x|<sqrt(3/2) */
245 else if(j<0xBB67A) k=1; /* |x|<sqrt(3) */
246 else {k=0;n+=1;ix -= 0x00100000;}
247 SET_HIGH_WORD(ax,ix);
249 /* compute s = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) */
250 u = ax-bp[k]; /* bp[0]=1.0, bp[1]=1.5 */
251 v = C[1]/(ax+bp[k]);
252 s = u*v;
253 s_h = s;
254 SET_LOW_WORD(s_h,0);
255 /* t_h=ax+bp[k] High */
256 t_h = C[0];
257 SET_HIGH_WORD(t_h,((ix>>1)|0x20000000)+0x00080000+(k<<18));
258 t_l = ax - (t_h-bp[k]);
259 s_l = v*((u-s_h*t_h)-s_h*t_l);
260 /* compute log(ax) */
261 s2 = s*s;
262 #ifdef DO_NOT_USE_THIS
263 r = s2*s2*(L1+s2*(L2+s2*(L3+s2*(L4+s2*(L5+s2*L6)))));
264 #else
265 r1 = C[10]+s2*C[11]; s22=s2*s2;
266 r2 = C[8]+s2*C[9]; s24=s22*s22;
267 r3 = C[6]+s2*C[7]; s26=s24*s22;
268 r = r3*s22 + r2*s24 + r1*s26;
269 #endif
270 r += s_l*(s_h+s);
271 s2 = s_h*s_h;
272 t_h = 3.0+s2+r;
273 SET_LOW_WORD(t_h,0);
274 t_l = r-((t_h-3.0)-s2);
275 /* u+v = s*(1+...) */
276 u = s_h*t_h;
277 v = s_l*t_h+t_l*s;
278 /* 2/(3log2)*(s+...) */
279 p_h = u+v;
280 SET_LOW_WORD(p_h,0);
281 p_l = v-(p_h-u);
282 z_h = C[22]*p_h; /* cp_h+cp_l = 2/(3*log2) */
283 z_l = C[23]*p_h+p_l*C[21]+dp_l[k];
284 /* log2(ax) = (s+..)*2/(3*log2) = n + dp_h + z_h + z_l */
285 t = (double)n;
286 t1 = (((z_h+z_l)+dp_h[k])+t);
287 SET_LOW_WORD(t1,0);
288 t2 = z_l-(((t1-t)-dp_h[k])-z_h);
291 s = C[1]; /* s (sign of result -ve**odd) = -1 else = 1 */
292 if(((((u_int32_t)hx>>31)-1)|(yisint-1))==0)
293 s = -C[1];/* (-ve)**(odd int) */
295 /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */
296 y1 = y;
297 SET_LOW_WORD(y1,0);
298 p_l = (y-y1)*t1+y*t2;
299 p_h = y1*t1;
300 z = p_l+p_h;
301 EXTRACT_WORDS(j,i,z);
302 if (j>=0x40900000) { /* z >= 1024 */
303 if(((j-0x40900000)|i)!=0) /* if z > 1024 */
304 return s*C[4]*C[4]; /* overflow */
305 else {
306 if(p_l+C[20]>z-p_h) return s*C[4]*C[4]; /* overflow */
308 } else if((j&0x7fffffff)>=0x4090cc00 ) { /* z <= -1075 */
309 if(((j-0xc090cc00)|i)!=0) /* z < -1075 */
310 return s*C[5]*C[5]; /* underflow */
311 else {
312 if(p_l<=z-p_h) return s*C[5]*C[5]; /* underflow */
316 * compute 2**(p_h+p_l)
318 i = j&0x7fffffff;
319 k = (i>>20)-0x3ff;
320 n = 0;
321 if(i>0x3fe00000) { /* if |z| > 0.5, set n = [z+0.5] */
322 n = j+(0x00100000>>(k+1));
323 k = ((n&0x7fffffff)>>20)-0x3ff; /* new k for n */
324 t = C[0];
325 SET_HIGH_WORD(t,n&~(0x000fffff>>k));
326 n = ((n&0x000fffff)|0x00100000)>>(20-k);
327 if(j<0) n = -n;
328 p_h -= t;
330 t = p_l+p_h;
331 SET_LOW_WORD(t,0);
332 u = t*C[18];
333 v = (p_l-(t-p_h))*C[17]+t*C[19];
334 z = u+v;
335 w = v-(z-u);
336 t = z*z;
337 #ifdef DO_NOT_USE_THIS
338 t1 = z - t*(C[12]+t*(C[13]+t*(C[14]+t*(C[15]+t*C[16]))));
339 #else
340 r_1 = C[15]+t*C[16]; t12 = t*t;
341 r_2 = C[13]+t*C[14]; t14 = t12*t12;
342 r_3 = t*C[12];
343 t1 = z - r_3 - t12*r_2 - t14*r_1;
344 #endif
345 r = (z*t1)/(t1-C[2])-(w+z*w);
346 z = C[1]-(r-z);
347 GET_HIGH_WORD(j,z);
348 j += (n<<20);
349 if((j>>20)<=0) z = __scalbn(z,n); /* subnormal output */
350 else SET_HIGH_WORD(z,j);
351 return s*z;