Updated math code from the uClibc 0.9.33 release
Sam Lantinga
parent
34502143d9
commit
6cf065753c
|
|
@ -57,8 +57,8 @@ double attribute_hidden __ieee754_atan2(double y, double x)
|
|||
ix = hx&0x7fffffff;
|
||||
EXTRACT_WORDS(hy,ly,y);
|
||||
iy = hy&0x7fffffff;
|
||||
if(((ix|((lx|-(int32_t)lx)>>31))>0x7ff00000)||
|
||||
((iy|((ly|-(int32_t)ly)>>31))>0x7ff00000)) /* x or y is NaN */
|
||||
if(((ix|((lx|-lx)>>31))>0x7ff00000)||
|
||||
((iy|((ly|-ly)>>31))>0x7ff00000)) /* x or y is NaN */
|
||||
return x+y;
|
||||
if(((hx-0x3ff00000)|lx)==0) return atan(y); /* x=1.0 */
|
||||
m = ((hy>>31)&1)|((hx>>30)&2); /* 2*sign(x)+sign(y) */
|
||||
|
|
@ -114,3 +114,21 @@ double attribute_hidden __ieee754_atan2(double y, double x)
|
|||
return (z-pi_lo)-pi;/* atan(-,-) */
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* wrapper atan2(y,x)
|
||||
*/
|
||||
#ifndef _IEEE_LIBM
|
||||
double atan2(double y, double x)
|
||||
{
|
||||
double z = __ieee754_atan2(y, x);
|
||||
if (_LIB_VERSION == _IEEE_ || isnan(x) || isnan(y))
|
||||
return z;
|
||||
if (x == 0.0 && y == 0.0)
|
||||
return __kernel_standard(y,x,3); /* atan2(+-0,+-0) */
|
||||
return z;
|
||||
}
|
||||
#else
|
||||
strong_alias(__ieee754_atan2, atan2)
|
||||
#endif
|
||||
libm_hidden_def(atan2)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
/* @(#)e_log.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
|
|
@ -10,11 +9,6 @@
|
|||
* ====================================================
|
||||
*/
|
||||
|
||||
#if defined(LIBM_SCCS) && !defined(lint)
|
||||
static const char rcsid[] =
|
||||
"$NetBSD: e_log.c,v 1.8 1995/05/10 20:45:49 jtc Exp $";
|
||||
#endif
|
||||
|
||||
/* __ieee754_log(x)
|
||||
* Return the logrithm of x
|
||||
*
|
||||
|
|
@ -69,11 +63,7 @@ static const char rcsid[] =
|
|||
#include "math_libm.h"
|
||||
#include "math_private.h"
|
||||
|
||||
#ifdef __STDC__
|
||||
static const double
|
||||
#else
|
||||
static double
|
||||
#endif
|
||||
ln2_hi = 6.93147180369123816490e-01, /* 3fe62e42 fee00000 */
|
||||
ln2_lo = 1.90821492927058770002e-10, /* 3dea39ef 35793c76 */
|
||||
two54 = 1.80143985094819840000e+16, /* 43500000 00000000 */
|
||||
|
|
@ -85,20 +75,9 @@ static double
|
|||
Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */
|
||||
Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
|
||||
|
||||
#ifdef __STDC__
|
||||
static const double zero = 0.0;
|
||||
#else
|
||||
static double zero = 0.0;
|
||||
#endif
|
||||
|
||||
#ifdef __STDC__
|
||||
double attribute_hidden
|
||||
__ieee754_log(double x)
|
||||
#else
|
||||
double attribute_hidden
|
||||
__ieee754_log(x)
|
||||
double x;
|
||||
#endif
|
||||
double attribute_hidden __ieee754_log(double x)
|
||||
{
|
||||
double hfsq,f,s,z,R,w,t1,t2,dk;
|
||||
int32_t k,hx,i,j;
|
||||
|
|
@ -110,14 +89,11 @@ __ieee754_log(x)
|
|||
if (hx < 0x00100000) { /* x < 2**-1022 */
|
||||
if (((hx&0x7fffffff)|lx)==0)
|
||||
return -two54/zero; /* log(+-0)=-inf */
|
||||
if (hx < 0)
|
||||
return (x - x) / zero; /* log(-#) = NaN */
|
||||
k -= 54;
|
||||
x *= two54; /* subnormal number, scale up x */
|
||||
if (hx<0) return (x-x)/zero; /* log(-#) = NaN */
|
||||
k -= 54; x *= two54; /* subnormal number, scale up x */
|
||||
GET_HIGH_WORD(hx,x);
|
||||
}
|
||||
if (hx >= 0x7ff00000)
|
||||
return x + x;
|
||||
if (hx >= 0x7ff00000) return x+x;
|
||||
k += (hx>>20)-1023;
|
||||
hx &= 0x000fffff;
|
||||
i = (hx+0x95f64)&0x100000;
|
||||
|
|
@ -125,21 +101,12 @@ __ieee754_log(x)
|
|||
k += (i>>20);
|
||||
f = x-1.0;
|
||||
if((0x000fffff&(2+hx))<3) { /* |f| < 2**-20 */
|
||||
if (f == zero) {
|
||||
if (k == 0)
|
||||
return zero;
|
||||
else {
|
||||
dk = (double) k;
|
||||
return dk * ln2_hi + dk * ln2_lo;
|
||||
}
|
||||
if(f==zero) {if(k==0) return zero; else {dk=(double)k;
|
||||
return dk*ln2_hi+dk*ln2_lo;}
|
||||
}
|
||||
R = f*f*(0.5-0.33333333333333333*f);
|
||||
if (k == 0)
|
||||
return f - R;
|
||||
else {
|
||||
dk = (double) k;
|
||||
return dk * ln2_hi - ((R - dk * ln2_lo) - f);
|
||||
}
|
||||
if(k==0) return f-R; else {dk=(double)k;
|
||||
return dk*ln2_hi-((R-dk*ln2_lo)-f);}
|
||||
}
|
||||
s = f/(2.0+f);
|
||||
dk = (double)k;
|
||||
|
|
@ -153,15 +120,28 @@ __ieee754_log(x)
|
|||
R = t2+t1;
|
||||
if(i>0) {
|
||||
hfsq=0.5*f*f;
|
||||
if (k == 0)
|
||||
return f - (hfsq - s * (hfsq + R));
|
||||
else
|
||||
return dk * ln2_hi - ((hfsq - (s * (hfsq + R) + dk * ln2_lo)) -
|
||||
f);
|
||||
if(k==0) return f-(hfsq-s*(hfsq+R)); else
|
||||
return dk*ln2_hi-((hfsq-(s*(hfsq+R)+dk*ln2_lo))-f);
|
||||
} else {
|
||||
if (k == 0)
|
||||
return f - s * (f - R);
|
||||
else
|
||||
if(k==0) return f-s*(f-R); else
|
||||
return dk*ln2_hi-((s*(f-R)-dk*ln2_lo)-f);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* wrapper log(x)
|
||||
*/
|
||||
#ifndef _IEEE_LIBM
|
||||
double log(double x)
|
||||
{
|
||||
double z = __ieee754_log(x);
|
||||
if (_LIB_VERSION == _IEEE_ || isnan(x) || x > 0.0)
|
||||
return z;
|
||||
if (x == 0.0)
|
||||
return __kernel_standard(x, x, 16); /* log(0) */
|
||||
return __kernel_standard(x, x, 17); /* log(x<0) */
|
||||
}
|
||||
#else
|
||||
strong_alias(__ieee754_log, log)
|
||||
#endif
|
||||
libm_hidden_def(log)
|
||||
|
|
|
|||
204
src/libm/e_pow.c
204
src/libm/e_pow.c
|
|
@ -1,4 +1,3 @@
|
|||
/* @(#)e_pow.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
|
|
@ -10,10 +9,6 @@
|
|||
* ====================================================
|
||||
*/
|
||||
|
||||
#if defined(LIBM_SCCS) && !defined(lint)
|
||||
static char rcsid[] = "$NetBSD: e_pow.c,v 1.9 1995/05/12 04:57:32 jtc Exp $";
|
||||
#endif
|
||||
|
||||
/* __ieee754_pow(x,y) return x**y
|
||||
*
|
||||
* n
|
||||
|
|
@ -26,25 +21,26 @@ static char rcsid[] = "$NetBSD: e_pow.c,v 1.9 1995/05/12 04:57:32 jtc Exp $";
|
|||
* 3. Return x**y = 2**n*exp(y'*log2)
|
||||
*
|
||||
* Special cases:
|
||||
* 1. (anything) ** 0 is 1
|
||||
* 2. (anything) ** 1 is itself
|
||||
* 3. (anything) ** NAN is NAN
|
||||
* 4. NAN ** (anything except 0) is NAN
|
||||
* 5. +-(|x| > 1) ** +INF is +INF
|
||||
* 6. +-(|x| > 1) ** -INF is +0
|
||||
* 7. +-(|x| < 1) ** +INF is +0
|
||||
* 8. +-(|x| < 1) ** -INF is +INF
|
||||
* 9. +-1 ** +-INF is NAN
|
||||
* 10. +0 ** (+anything except 0, NAN) is +0
|
||||
* 11. -0 ** (+anything except 0, NAN, odd integer) is +0
|
||||
* 12. +0 ** (-anything except 0, NAN) is +INF
|
||||
* 13. -0 ** (-anything except 0, NAN, odd integer) is +INF
|
||||
* 14. -0 ** (odd integer) = -( +0 ** (odd integer) )
|
||||
* 15. +INF ** (+anything except 0,NAN) is +INF
|
||||
* 16. +INF ** (-anything except 0,NAN) is +0
|
||||
* 17. -INF ** (anything) = -0 ** (-anything)
|
||||
* 18. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer)
|
||||
* 19. (-anything except 0 and inf) ** (non-integer) is NAN
|
||||
* 1. +-1 ** anything is 1.0
|
||||
* 2. +-1 ** +-INF is 1.0
|
||||
* 3. (anything) ** 0 is 1
|
||||
* 4. (anything) ** 1 is itself
|
||||
* 5. (anything) ** NAN is NAN
|
||||
* 6. NAN ** (anything except 0) is NAN
|
||||
* 7. +-(|x| > 1) ** +INF is +INF
|
||||
* 8. +-(|x| > 1) ** -INF is +0
|
||||
* 9. +-(|x| < 1) ** +INF is +0
|
||||
* 10 +-(|x| < 1) ** -INF is +INF
|
||||
* 11. +0 ** (+anything except 0, NAN) is +0
|
||||
* 12. -0 ** (+anything except 0, NAN, odd integer) is +0
|
||||
* 13. +0 ** (-anything except 0, NAN) is +INF
|
||||
* 14. -0 ** (-anything except 0, NAN, odd integer) is +INF
|
||||
* 15. -0 ** (odd integer) = -( +0 ** (odd integer) )
|
||||
* 16. +INF ** (+anything except 0,NAN) is +INF
|
||||
* 17. +INF ** (-anything except 0,NAN) is +0
|
||||
* 18. -INF ** (anything) = -0 ** (-anything)
|
||||
* 19. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer)
|
||||
* 20. (-anything except 0 and inf) ** (non-integer) is NAN
|
||||
*
|
||||
* Accuracy:
|
||||
* pow(x,y) returns x**y nearly rounded. In particular
|
||||
|
|
@ -62,21 +58,16 @@ static char rcsid[] = "$NetBSD: e_pow.c,v 1.9 1995/05/12 04:57:32 jtc Exp $";
|
|||
#include "math_libm.h"
|
||||
#include "math_private.h"
|
||||
|
||||
libm_hidden_proto(scalbn)
|
||||
libm_hidden_proto(fabs)
|
||||
#ifdef __STDC__
|
||||
static const double
|
||||
#else
|
||||
static double
|
||||
#endif
|
||||
bp[] = { 1.0, 1.5, }, dp_h[] = {
|
||||
0.0, 5.84962487220764160156e-01,}, /* 0x3FE2B803, 0x40000000 */
|
||||
|
||||
dp_l[] = {
|
||||
0.0, 1.35003920212974897128e-08,}, /* 0x3E4CFDEB, 0x43CFD006 */
|
||||
|
||||
zero = 0.0, one = 1.0, two = 2.0, two53 = 9007199254740992.0, /* 0x43400000, 0x00000000 */
|
||||
huge_val = 1.0e300, tiny = 1.0e-300,
|
||||
bp[] = {1.0, 1.5,},
|
||||
dp_h[] = { 0.0, 5.84962487220764160156e-01,}, /* 0x3FE2B803, 0x40000000 */
|
||||
dp_l[] = { 0.0, 1.35003920212974897128e-08,}, /* 0x3E4CFDEB, 0x43CFD006 */
|
||||
zero = 0.0,
|
||||
one = 1.0,
|
||||
two = 2.0,
|
||||
two53 = 9007199254740992.0, /* 0x43400000, 0x00000000 */
|
||||
huge = 1.0e300,
|
||||
tiny = 1.0e-300,
|
||||
/* poly coefs for (3/2)*(log(x)-2s-2/3*s**3 */
|
||||
L1 = 5.99999999999994648725e-01, /* 0x3FE33333, 0x33333303 */
|
||||
L2 = 4.28571428578550184252e-01, /* 0x3FDB6DB6, 0xDB6FABFF */
|
||||
|
|
@ -100,12 +91,7 @@ libm_hidden_proto(scalbn)
|
|||
ivln2_h = 1.44269502162933349609e+00, /* 0x3FF71547, 0x60000000 =24b 1/ln2*/
|
||||
ivln2_l = 1.92596299112661746887e-08; /* 0x3E54AE0B, 0xF85DDF44 =1/ln2 tail*/
|
||||
|
||||
#ifdef __STDC__
|
||||
double attribute_hidden __ieee754_pow(double x, double y)
|
||||
#else
|
||||
double attribute_hidden __ieee754_pow(x, y)
|
||||
double x, y;
|
||||
#endif
|
||||
{
|
||||
double z,ax,z_h,z_l,p_h,p_l;
|
||||
double y1,t1,t2,r,s,t,u,v,w;
|
||||
|
|
@ -114,13 +100,17 @@ libm_hidden_proto(scalbn)
|
|||
u_int32_t lx,ly;
|
||||
|
||||
EXTRACT_WORDS(hx,lx,x);
|
||||
EXTRACT_WORDS(hy, ly, y);
|
||||
/* x==1: 1**y = 1 (even if y is NaN) */
|
||||
if (hx==0x3ff00000 && lx==0) {
|
||||
return x;
|
||||
}
|
||||
ix = hx&0x7fffffff;
|
||||
|
||||
EXTRACT_WORDS(hy,ly,y);
|
||||
iy = hy&0x7fffffff;
|
||||
|
||||
/* y==zero: x**0 = 1 */
|
||||
if ((iy | ly) == 0)
|
||||
return one;
|
||||
if((iy|ly)==0) return one;
|
||||
|
||||
/* +-NaN return x+y */
|
||||
if(ix > 0x7ff00000 || ((ix==0x7ff00000)&&(lx!=0)) ||
|
||||
|
|
@ -134,18 +124,15 @@ libm_hidden_proto(scalbn)
|
|||
*/
|
||||
yisint = 0;
|
||||
if(hx<0) {
|
||||
if (iy >= 0x43400000)
|
||||
yisint = 2; /* even integer y */
|
||||
if(iy>=0x43400000) yisint = 2; /* even integer y */
|
||||
else if(iy>=0x3ff00000) {
|
||||
k = (iy>>20)-0x3ff; /* exponent */
|
||||
if(k>20) {
|
||||
j = ly>>(52-k);
|
||||
if ((j << (52 - k)) == ly)
|
||||
yisint = 2 - (j & 1);
|
||||
if((j<<(52-k))==ly) yisint = 2-(j&1);
|
||||
} else if(ly==0) {
|
||||
j = iy>>(20-k);
|
||||
if ((j << (20 - k)) == iy)
|
||||
yisint = 2 - (j & 1);
|
||||
if((j<<(20-k))==iy) yisint = 2-(j&1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -154,20 +141,16 @@ libm_hidden_proto(scalbn)
|
|||
if(ly==0) {
|
||||
if (iy==0x7ff00000) { /* y is +-inf */
|
||||
if (((ix-0x3ff00000)|lx)==0)
|
||||
return y - y; /* inf**+-1 is NaN */
|
||||
else if (ix >= 0x3ff00000) /* (|x|>1)**+-inf = inf,0 */
|
||||
return one; /* +-1**+-inf is 1 (yes, weird rule) */
|
||||
if (ix >= 0x3ff00000) /* (|x|>1)**+-inf = inf,0 */
|
||||
return (hy>=0) ? y : zero;
|
||||
else /* (|x|<1)**-,+inf = inf,0 */
|
||||
/* (|x|<1)**-,+inf = inf,0 */
|
||||
return (hy<0) ? -y : zero;
|
||||
}
|
||||
if(iy==0x3ff00000) { /* y is +-1 */
|
||||
if (hy < 0)
|
||||
return one / x;
|
||||
else
|
||||
return x;
|
||||
if(hy<0) return one/x; else return x;
|
||||
}
|
||||
if (hy == 0x40000000)
|
||||
return x * x; /* y is 2 */
|
||||
if(hy==0x40000000) return x*x; /* y is 2 */
|
||||
if(hy==0x3fe00000) { /* y is 0.5 */
|
||||
if(hx>=0) /* x >= +0 */
|
||||
return __ieee754_sqrt(x);
|
||||
|
|
@ -179,8 +162,7 @@ libm_hidden_proto(scalbn)
|
|||
if(lx==0) {
|
||||
if(ix==0x7ff00000||ix==0||ix==0x3ff00000){
|
||||
z = ax; /*x is +-0,+-inf,+-1*/
|
||||
if (hy < 0)
|
||||
z = one / z; /* z = (1/|x|) */
|
||||
if(hy<0) z = one/z; /* z = (1/|x|) */
|
||||
if(hx<0) {
|
||||
if(((ix-0x3ff00000)|yisint)==0) {
|
||||
z = (z-z)/(z-z); /* (-1)**non-int is NaN */
|
||||
|
|
@ -192,22 +174,17 @@ libm_hidden_proto(scalbn)
|
|||
}
|
||||
|
||||
/* (x<0)**(non-int) is NaN */
|
||||
if (((((u_int32_t) hx >> 31) - 1) | yisint) == 0)
|
||||
return (x - x) / (x - x);
|
||||
if(((((u_int32_t)hx>>31)-1)|yisint)==0) return (x-x)/(x-x);
|
||||
|
||||
/* |y| is huge */
|
||||
if(iy>0x41e00000) { /* if |y| > 2**31 */
|
||||
if(iy>0x43f00000){ /* if |y| > 2**64, must o/uflow */
|
||||
if (ix <= 0x3fefffff)
|
||||
return (hy < 0) ? huge_val * huge_val : tiny * tiny;
|
||||
if (ix >= 0x3ff00000)
|
||||
return (hy > 0) ? huge_val * huge_val : tiny * tiny;
|
||||
if(ix<=0x3fefffff) return (hy<0)? huge*huge:tiny*tiny;
|
||||
if(ix>=0x3ff00000) return (hy>0)? huge*huge:tiny*tiny;
|
||||
}
|
||||
/* over/underflow if x is not close to one */
|
||||
if (ix < 0x3fefffff)
|
||||
return (hy < 0) ? huge_val * huge_val : tiny * tiny;
|
||||
if (ix > 0x3ff00000)
|
||||
return (hy > 0) ? huge_val * huge_val : tiny * tiny;
|
||||
if(ix<0x3fefffff) return (hy<0)? huge*huge:tiny*tiny;
|
||||
if(ix>0x3ff00000) return (hy>0)? huge*huge:tiny*tiny;
|
||||
/* now |1-x| is tiny <= 2**-20, suffice to compute
|
||||
log(x) by x-x^2/2+x^3/3-x^4/4 */
|
||||
t = x-1; /* t has 20 trailing zeros */
|
||||
|
|
@ -221,24 +198,15 @@ libm_hidden_proto(scalbn)
|
|||
double s2,s_h,s_l,t_h,t_l;
|
||||
n = 0;
|
||||
/* take care subnormal number */
|
||||
if (ix < 0x00100000) {
|
||||
ax *= two53;
|
||||
n -= 53;
|
||||
GET_HIGH_WORD(ix, ax);
|
||||
}
|
||||
if(ix<0x00100000)
|
||||
{ax *= two53; n -= 53; GET_HIGH_WORD(ix,ax); }
|
||||
n += ((ix)>>20)-0x3ff;
|
||||
j = ix&0x000fffff;
|
||||
/* determine interval */
|
||||
ix = j|0x3ff00000; /* normalize ix */
|
||||
if (j <= 0x3988E)
|
||||
k = 0; /* |x|<sqrt(3/2) */
|
||||
else if (j < 0xBB67A)
|
||||
k = 1; /* |x|<sqrt(3) */
|
||||
else {
|
||||
k = 0;
|
||||
n += 1;
|
||||
ix -= 0x00100000;
|
||||
}
|
||||
if(j<=0x3988E) k=0; /* |x|<sqrt(3/2) */
|
||||
else if(j<0xBB67A) k=1; /* |x|<sqrt(3) */
|
||||
else {k=0;n+=1;ix -= 0x00100000;}
|
||||
SET_HIGH_WORD(ax,ix);
|
||||
|
||||
/* compute s = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) */
|
||||
|
|
@ -249,16 +217,12 @@ libm_hidden_proto(scalbn)
|
|||
SET_LOW_WORD(s_h,0);
|
||||
/* t_h=ax+bp[k] High */
|
||||
t_h = zero;
|
||||
SET_HIGH_WORD(t_h,
|
||||
((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18));
|
||||
SET_HIGH_WORD(t_h,((ix>>1)|0x20000000)+0x00080000+(k<<18));
|
||||
t_l = ax - (t_h-bp[k]);
|
||||
s_l = v*((u-s_h*t_h)-s_h*t_l);
|
||||
/* compute log(ax) */
|
||||
s2 = s*s;
|
||||
r = s2 * s2 * (L1 +
|
||||
s2 * (L2 +
|
||||
s2 * (L3 +
|
||||
s2 * (L4 + s2 * (L5 + s2 * L6)))));
|
||||
r = s2*s2*(L1+s2*(L2+s2*(L3+s2*(L4+s2*(L5+s2*L6)))));
|
||||
r += s_l*(s_h+s);
|
||||
s2 = s_h*s_h;
|
||||
t_h = 3.0+s2+r;
|
||||
|
|
@ -293,17 +257,15 @@ libm_hidden_proto(scalbn)
|
|||
EXTRACT_WORDS(j,i,z);
|
||||
if (j>=0x40900000) { /* z >= 1024 */
|
||||
if(((j-0x40900000)|i)!=0) /* if z > 1024 */
|
||||
return s * huge_val * huge_val; /* overflow */
|
||||
return s*huge*huge; /* overflow */
|
||||
else {
|
||||
if (p_l + ovt > z - p_h)
|
||||
return s * huge_val * huge_val; /* overflow */
|
||||
if(p_l+ovt>z-p_h) return s*huge*huge; /* overflow */
|
||||
}
|
||||
} else if((j&0x7fffffff)>=0x4090cc00 ) { /* z <= -1075 */
|
||||
if(((j-0xc090cc00)|i)!=0) /* z < -1075 */
|
||||
return s*tiny*tiny; /* underflow */
|
||||
else {
|
||||
if (p_l <= z - p_h)
|
||||
return s * tiny * tiny; /* underflow */
|
||||
if(p_l<=z-p_h) return s*tiny*tiny; /* underflow */
|
||||
}
|
||||
}
|
||||
/*
|
||||
|
|
@ -318,8 +280,7 @@ libm_hidden_proto(scalbn)
|
|||
t = zero;
|
||||
SET_HIGH_WORD(t,n&~(0x000fffff>>k));
|
||||
n = ((n&0x000fffff)|0x00100000)>>(20-k);
|
||||
if (j < 0)
|
||||
n = -n;
|
||||
if(j<0) n = -n;
|
||||
p_h -= t;
|
||||
}
|
||||
t = p_l+p_h;
|
||||
|
|
@ -334,9 +295,44 @@ libm_hidden_proto(scalbn)
|
|||
z = one-(r-z);
|
||||
GET_HIGH_WORD(j,z);
|
||||
j += (n<<20);
|
||||
if ((j >> 20) <= 0)
|
||||
z = scalbn(z, n); /* subnormal output */
|
||||
else
|
||||
SET_HIGH_WORD(z, j);
|
||||
if((j>>20)<=0) z = scalbn(z,n); /* subnormal output */
|
||||
else SET_HIGH_WORD(z,j);
|
||||
return s*z;
|
||||
}
|
||||
|
||||
/*
|
||||
* wrapper pow(x,y) return x**y
|
||||
*/
|
||||
#ifndef _IEEE_LIBM
|
||||
double pow(double x, double y)
|
||||
{
|
||||
double z = __ieee754_pow(x, y);
|
||||
if (_LIB_VERSION == _IEEE_|| isnan(y))
|
||||
return z;
|
||||
if (isnan(x)) {
|
||||
if (y == 0.0)
|
||||
return __kernel_standard(x, y, 42); /* pow(NaN,0.0) */
|
||||
return z;
|
||||
}
|
||||
if (x == 0.0) {
|
||||
if (y == 0.0)
|
||||
return __kernel_standard(x, y, 20); /* pow(0.0,0.0) */
|
||||
if (isfinite(y) && y < 0.0)
|
||||
return __kernel_standard(x,y,23); /* pow(0.0,negative) */
|
||||
return z;
|
||||
}
|
||||
if (!isfinite(z)) {
|
||||
if (isfinite(x) && isfinite(y)) {
|
||||
if (isnan(z))
|
||||
return __kernel_standard(x, y, 24); /* pow neg**non-int */
|
||||
return __kernel_standard(x, y, 21); /* pow overflow */
|
||||
}
|
||||
}
|
||||
if (z == 0.0 && isfinite(x) && isfinite(y))
|
||||
return __kernel_standard(x, y, 22); /* pow underflow */
|
||||
return z;
|
||||
}
|
||||
#else
|
||||
strong_alias(__ieee754_pow, pow)
|
||||
#endif
|
||||
libm_hidden_def(pow)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
/* @(#)e_rem_pio2.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
|
|
@ -10,11 +9,6 @@
|
|||
* ====================================================
|
||||
*/
|
||||
|
||||
#if defined(LIBM_SCCS) && !defined(lint)
|
||||
static const char rcsid[] =
|
||||
"$NetBSD: e_rem_pio2.c,v 1.8 1995/05/10 20:46:02 jtc Exp $";
|
||||
#endif
|
||||
|
||||
/* __ieee754_rem_pio2(x,y)
|
||||
*
|
||||
* return the remainder of x rem pi/2 in y[0]+y[1]
|
||||
|
|
@ -24,18 +18,10 @@ static const char rcsid[] =
|
|||
#include "math_libm.h"
|
||||
#include "math_private.h"
|
||||
|
||||
#include "SDL_assert.h"
|
||||
|
||||
libm_hidden_proto(fabs)
|
||||
|
||||
/*
|
||||
* Table of constants for 2/pi, 396 Hex digits (476 decimal) of 2/pi
|
||||
*/
|
||||
#ifdef __STDC__
|
||||
static const int32_t two_over_pi[] = {
|
||||
#else
|
||||
static int32_t two_over_pi[] = {
|
||||
#endif
|
||||
0xA2F983, 0x6E4E44, 0x1529FC, 0x2757D1, 0xF534DD, 0xC0DB62,
|
||||
0x95993C, 0x439041, 0xFE5163, 0xABDEBB, 0xC561B7, 0x246E3A,
|
||||
0x424DD2, 0xE00649, 0x2EEA09, 0xD1921C, 0xFE1DEB, 0x1CB129,
|
||||
|
|
@ -49,11 +35,7 @@ libm_hidden_proto(fabs)
|
|||
0x4D7327, 0x310606, 0x1556CA, 0x73A8C9, 0x60E27B, 0xC08C6B,
|
||||
};
|
||||
|
||||
#ifdef __STDC__
|
||||
static const int32_t npio2_hw[] = {
|
||||
#else
|
||||
static int32_t npio2_hw[] = {
|
||||
#endif
|
||||
0x3FF921FB, 0x400921FB, 0x4012D97C, 0x401921FB, 0x401F6A7A, 0x4022D97C,
|
||||
0x4025FDBB, 0x402921FB, 0x402C463A, 0x402F6A7A, 0x4031475C, 0x4032D97C,
|
||||
0x40346B9C, 0x4035FDBB, 0x40378FDB, 0x403921FB, 0x403AB41B, 0x403C463A,
|
||||
|
|
@ -72,11 +54,7 @@ static int32_t npio2_hw[] = {
|
|||
* pio2_3t: pi/2 - (pio2_1+pio2_2+pio2_3)
|
||||
*/
|
||||
|
||||
#ifdef __STDC__
|
||||
static const double
|
||||
#else
|
||||
static double
|
||||
#endif
|
||||
zero = 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
|
||||
half = 5.00000000000000000000e-01, /* 0x3FE00000, 0x00000000 */
|
||||
two24 = 1.67772160000000000000e+07, /* 0x41700000, 0x00000000 */
|
||||
|
|
@ -88,14 +66,7 @@ static double
|
|||
pio2_3 = 2.02226624871116645580e-21, /* 0x3BA3198A, 0x2E000000 */
|
||||
pio2_3t = 8.47842766036889956997e-32; /* 0x397B839A, 0x252049C1 */
|
||||
|
||||
#ifdef __STDC__
|
||||
int32_t attribute_hidden
|
||||
__ieee754_rem_pio2(double x, double *y)
|
||||
#else
|
||||
int32_t attribute_hidden
|
||||
__ieee754_rem_pio2(x, y)
|
||||
double x, y[];
|
||||
#endif
|
||||
int32_t attribute_hidden __ieee754_rem_pio2(double x, double *y)
|
||||
{
|
||||
double z=0.0,w,t,r,fn;
|
||||
double tx[3];
|
||||
|
|
@ -104,11 +75,8 @@ __ieee754_rem_pio2(x, y)
|
|||
|
||||
GET_HIGH_WORD(hx,x); /* high word of x */
|
||||
ix = hx&0x7fffffff;
|
||||
if (ix <= 0x3fe921fb) { /* |x| ~<= pi/4 , no need for reduction */
|
||||
y[0] = x;
|
||||
y[1] = 0;
|
||||
return 0;
|
||||
}
|
||||
if(ix<=0x3fe921fb) /* |x| ~<= pi/4 , no need for reduction */
|
||||
{y[0] = x; y[1] = 0; return 0;}
|
||||
if(ix<0x4002d97c) { /* |x| < 3pi/4, special case with n=+-1 */
|
||||
if(hx>0) {
|
||||
z = x - pio2_1;
|
||||
|
|
@ -166,19 +134,14 @@ __ieee754_rem_pio2(x, y)
|
|||
}
|
||||
}
|
||||
y[1] = (r-y[0])-w;
|
||||
if (hx < 0) {
|
||||
y[0] = -y[0];
|
||||
y[1] = -y[1];
|
||||
return -n;
|
||||
} else
|
||||
return n;
|
||||
if(hx<0) {y[0] = -y[0]; y[1] = -y[1]; return -n;}
|
||||
else return n;
|
||||
}
|
||||
/*
|
||||
* all other (large) arguments
|
||||
*/
|
||||
if(ix>=0x7ff00000) { /* x is inf or NaN */
|
||||
y[0] = y[1] = x - x;
|
||||
return 0;
|
||||
y[0]=y[1]=x-x; return 0;
|
||||
}
|
||||
/* set z = scalbn(|x|,ilogb(x)-23) */
|
||||
GET_LOW_WORD(low,x);
|
||||
|
|
@ -191,18 +154,8 @@ __ieee754_rem_pio2(x, y)
|
|||
}
|
||||
tx[2] = z;
|
||||
nx = 3;
|
||||
|
||||
/* If this assertion ever fires, here's the static analysis that warned about it:
|
||||
http://buildbot.libsdl.org/sdl-static-analysis/sdl-macosx-static-analysis/sdl-macosx-static-analysis-1101/report-8c6ccb.html#EndPath */
|
||||
SDL_assert((tx[0] != zero) || (tx[1] != zero) || (tx[2] != zero));
|
||||
|
||||
while (nx && tx[nx - 1] == zero)
|
||||
nx--; /* skip zero term */
|
||||
while(tx[nx-1]==zero) nx--; /* skip zero term */
|
||||
n = __kernel_rem_pio2(tx,y,e0,nx,2,two_over_pi);
|
||||
if (hx < 0) {
|
||||
y[0] = -y[0];
|
||||
y[1] = -y[1];
|
||||
return -n;
|
||||
}
|
||||
if(hx<0) {y[0] = -y[0]; y[1] = -y[1]; return -n;}
|
||||
return n;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
/* @(#)e_sqrt.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
|
|
@ -10,11 +9,6 @@
|
|||
* ====================================================
|
||||
*/
|
||||
|
||||
#if defined(LIBM_SCCS) && !defined(lint)
|
||||
static const char rcsid[] =
|
||||
"$NetBSD: e_sqrt.c,v 1.8 1995/05/10 20:46:17 jtc Exp $";
|
||||
#endif
|
||||
|
||||
/* __ieee754_sqrt(x)
|
||||
* Return correctly rounded sqrt.
|
||||
* ------------------------------------------
|
||||
|
|
@ -88,20 +82,9 @@ static const char rcsid[] =
|
|||
#include "math_libm.h"
|
||||
#include "math_private.h"
|
||||
|
||||
#ifdef __STDC__
|
||||
static const double one = 1.0, tiny = 1.0e-300;
|
||||
#else
|
||||
static double one = 1.0, tiny = 1.0e-300;
|
||||
#endif
|
||||
|
||||
#ifdef __STDC__
|
||||
double attribute_hidden
|
||||
__ieee754_sqrt(double x)
|
||||
#else
|
||||
double attribute_hidden
|
||||
__ieee754_sqrt(x)
|
||||
double x;
|
||||
#endif
|
||||
double attribute_hidden __ieee754_sqrt(double x)
|
||||
{
|
||||
double z;
|
||||
int32_t sign = (int)0x80000000;
|
||||
|
|
@ -117,8 +100,7 @@ __ieee754_sqrt(x)
|
|||
}
|
||||
/* take care of zero */
|
||||
if(ix0<=0) {
|
||||
if (((ix0 & (~sign)) | ix1) == 0)
|
||||
return x; /* sqrt(+-0) = +-0 */
|
||||
if(((ix0&(~sign))|ix1)==0) return x;/* sqrt(+-0) = +-0 */
|
||||
else if(ix0<0)
|
||||
return (x-x)/(x-x); /* sqrt(-ve) = sNaN */
|
||||
}
|
||||
|
|
@ -127,11 +109,9 @@ __ieee754_sqrt(x)
|
|||
if(m==0) { /* subnormal x */
|
||||
while(ix0==0) {
|
||||
m -= 21;
|
||||
ix0 |= (ix1 >> 11);
|
||||
ix1 <<= 21;
|
||||
ix0 |= (ix1>>11); ix1 <<= 21;
|
||||
}
|
||||
for (i = 0; (ix0 & 0x00100000) == 0; i++)
|
||||
ix0 <<= 1;
|
||||
for(i=0;(ix0&0x00100000)==0;i++) ix0<<=1;
|
||||
m -= i-1;
|
||||
ix0 |= (ix1>>(32-i));
|
||||
ix1 <<= i;
|
||||
|
|
@ -168,11 +148,9 @@ __ieee754_sqrt(x)
|
|||
t = s0;
|
||||
if((t<ix0)||((t==ix0)&&(t1<=ix1))) {
|
||||
s1 = t1+r;
|
||||
if (((t1 & sign) == sign) && (s1 & sign) == 0)
|
||||
s0 += 1;
|
||||
if(((t1&sign)==sign)&&(s1&sign)==0) s0 += 1;
|
||||
ix0 -= t;
|
||||
if (ix1 < t1)
|
||||
ix0 -= 1;
|
||||
if (ix1 < t1) ix0 -= 1;
|
||||
ix1 -= t1;
|
||||
q1 += r;
|
||||
}
|
||||
|
|
@ -186,12 +164,9 @@ __ieee754_sqrt(x)
|
|||
z = one-tiny; /* trigger inexact flag */
|
||||
if (z>=one) {
|
||||
z = one+tiny;
|
||||
if (q1 == (u_int32_t) 0xffffffff) {
|
||||
q1 = 0;
|
||||
q += 1;
|
||||
} else if (z > one) {
|
||||
if (q1 == (u_int32_t) 0xfffffffe)
|
||||
q += 1;
|
||||
if (q1==(u_int32_t)0xffffffff) { q1=0; q += 1;}
|
||||
else if (z>one) {
|
||||
if (q1==(u_int32_t)0xfffffffe) q+=1;
|
||||
q1+=2;
|
||||
} else
|
||||
q1 += (q1&1);
|
||||
|
|
@ -199,13 +174,31 @@ __ieee754_sqrt(x)
|
|||
}
|
||||
ix0 = (q>>1)+0x3fe00000;
|
||||
ix1 = q1>>1;
|
||||
if ((q & 1) == 1)
|
||||
ix1 |= sign;
|
||||
if ((q&1)==1) ix1 |= sign;
|
||||
ix0 += (m <<20);
|
||||
INSERT_WORDS(z,ix0,ix1);
|
||||
return z;
|
||||
}
|
||||
|
||||
/*
|
||||
* wrapper sqrt(x)
|
||||
*/
|
||||
#ifndef _IEEE_LIBM
|
||||
double sqrt(double x)
|
||||
{
|
||||
double z = __ieee754_sqrt(x);
|
||||
if (_LIB_VERSION == _IEEE_ || isnan(x))
|
||||
return z;
|
||||
if (x < 0.0)
|
||||
return __kernel_standard(x, x, 26); /* sqrt(negative) */
|
||||
return z;
|
||||
}
|
||||
#else
|
||||
strong_alias(__ieee754_sqrt, sqrt)
|
||||
#endif
|
||||
libm_hidden_def(sqrt)
|
||||
|
||||
|
||||
/*
|
||||
Other methods (use floating-point arithmetic)
|
||||
-------------
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
/* @(#)k_cos.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
|
|
@ -10,11 +9,6 @@
|
|||
* ====================================================
|
||||
*/
|
||||
|
||||
#if defined(LIBM_SCCS) && !defined(lint)
|
||||
static const char rcsid[] =
|
||||
"$NetBSD: k_cos.c,v 1.8 1995/05/10 20:46:22 jtc Exp $";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* __kernel_cos( x, y )
|
||||
* kernel cos function on [-pi/4, pi/4], pi/4 ~ 0.785398164
|
||||
|
|
@ -53,11 +47,7 @@ static const char rcsid[] =
|
|||
#include "math_libm.h"
|
||||
#include "math_private.h"
|
||||
|
||||
#ifdef __STDC__
|
||||
static const double
|
||||
#else
|
||||
static double
|
||||
#endif
|
||||
one = 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
|
||||
C1 = 4.16666666666666019037e-02, /* 0x3FA55555, 0x5555554C */
|
||||
C2 = -1.38888888888741095749e-03, /* 0xBF56C16C, 0x16C15177 */
|
||||
|
|
@ -66,22 +56,14 @@ static double
|
|||
C5 = 2.08757232129817482790e-09, /* 0x3E21EE9E, 0xBDB4B1C4 */
|
||||
C6 = -1.13596475577881948265e-11; /* 0xBDA8FAE9, 0xBE8838D4 */
|
||||
|
||||
#ifdef __STDC__
|
||||
double attribute_hidden
|
||||
__kernel_cos(double x, double y)
|
||||
#else
|
||||
double attribute_hidden
|
||||
__kernel_cos(x, y)
|
||||
double x, y;
|
||||
#endif
|
||||
double attribute_hidden __kernel_cos(double x, double y)
|
||||
{
|
||||
double a,hz,z,r,qx;
|
||||
int32_t ix;
|
||||
GET_HIGH_WORD(ix,x);
|
||||
ix &= 0x7fffffff; /* ix = |x|'s high word*/
|
||||
if(ix<0x3e400000) { /* if x < 2**27 */
|
||||
if (((int) x) == 0)
|
||||
return one; /* generate inexact */
|
||||
if(((int)x)==0) return one; /* generate inexact */
|
||||
}
|
||||
z = x*x;
|
||||
r = z*(C1+z*(C2+z*(C3+z*(C4+z*(C5+z*C6)))));
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
/* @(#)k_rem_pio2.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
|
|
@ -10,11 +9,6 @@
|
|||
* ====================================================
|
||||
*/
|
||||
|
||||
#if defined(LIBM_SCCS) && !defined(lint)
|
||||
static const char rcsid[] =
|
||||
"$NetBSD: k_rem_pio2.c,v 1.7 1995/05/10 20:46:25 jtc Exp $";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* __kernel_rem_pio2(x,y,e0,nx,prec,ipio2)
|
||||
* double x[],y[]; int e0,nx,prec; int ipio2[];
|
||||
|
|
@ -134,21 +128,9 @@ static const char rcsid[] =
|
|||
#include "math_libm.h"
|
||||
#include "math_private.h"
|
||||
|
||||
#include "SDL_assert.h"
|
||||
|
||||
libm_hidden_proto(scalbn)
|
||||
libm_hidden_proto(floor)
|
||||
#ifdef __STDC__
|
||||
static const int init_jk[] = {2,3,4,6}; /* initial value for jk */
|
||||
#else
|
||||
static int init_jk[] = { 2, 3, 4, 6 };
|
||||
#endif
|
||||
|
||||
#ifdef __STDC__
|
||||
static const double PIo2[] = {
|
||||
#else
|
||||
static double PIo2[] = {
|
||||
#endif
|
||||
1.57079625129699707031e+00, /* 0x3FF921FB, 0x40000000 */
|
||||
7.54978941586159635335e-08, /* 0x3E74442D, 0x00000000 */
|
||||
5.39030252995776476554e-15, /* 0x3CF84698, 0x80000000 */
|
||||
|
|
@ -159,59 +141,33 @@ static double PIo2[] = {
|
|||
2.16741683877804819444e-51, /* 0x3569F31D, 0x00000000 */
|
||||
};
|
||||
|
||||
#ifdef __STDC__
|
||||
static const double
|
||||
#else
|
||||
static double
|
||||
#endif
|
||||
zero = 0.0, one = 1.0, two24 = 1.67772160000000000000e+07, /* 0x41700000, 0x00000000 */
|
||||
zero = 0.0,
|
||||
one = 1.0,
|
||||
two24 = 1.67772160000000000000e+07, /* 0x41700000, 0x00000000 */
|
||||
twon24 = 5.96046447753906250000e-08; /* 0x3E700000, 0x00000000 */
|
||||
|
||||
#ifdef __STDC__
|
||||
int attribute_hidden
|
||||
__kernel_rem_pio2(double *x, double *y, int e0, int nx, int prec,
|
||||
const int32_t * ipio2)
|
||||
#else
|
||||
int attribute_hidden
|
||||
__kernel_rem_pio2(x, y, e0, nx, prec, ipio2)
|
||||
double x[], y[];
|
||||
int e0, nx, prec;
|
||||
int32_t ipio2[];
|
||||
#endif
|
||||
int attribute_hidden __kernel_rem_pio2(double *x, double *y, int e0, int nx, int prec, const int32_t *ipio2)
|
||||
{
|
||||
int32_t jz,jx,jv,jp,jk,carry,n,iq[20],i,j,k,m,q0,ih;
|
||||
double z,fw,f[20],fq[20],q[20];
|
||||
|
||||
/* initialize jk*/
|
||||
SDL_assert((prec >= 0) && (prec < SDL_arraysize(init_jk)));
|
||||
jk = init_jk[prec];
|
||||
SDL_assert((jk >= 2) && (jk <= 6));
|
||||
jp = jk;
|
||||
|
||||
/* determine jx,jv,q0, note that 3>q0 */
|
||||
SDL_assert(nx > 0);
|
||||
jx = nx-1;
|
||||
jv = (e0 - 3) / 24;
|
||||
if (jv < 0)
|
||||
jv = 0;
|
||||
jv = (e0-3)/24; if(jv<0) jv=0;
|
||||
q0 = e0-24*(jv+1);
|
||||
|
||||
/* set up f[0] to f[jx+jk] where f[jx+jk] = ipio2[jv+jk] */
|
||||
j = jv - jx;
|
||||
m = jx + jk;
|
||||
for (i = 0; i <= m; i++, j++)
|
||||
f[i] = (j < 0) ? zero : (double) ipio2[j];
|
||||
j = jv-jx; m = jx+jk;
|
||||
for(i=0;i<=m;i++,j++) f[i] = (j<0)? zero : (double) ipio2[j];
|
||||
|
||||
/* compute q[0],q[1],...q[jk] */
|
||||
for (i=0;i<=jk;i++) {
|
||||
for (j = 0, fw = 0.0; j <= jx; j++) {
|
||||
const int32_t idx = jx + i - j;
|
||||
SDL_assert(idx >= 0);
|
||||
SDL_assert(idx < 20);
|
||||
SDL_assert(idx <= m);
|
||||
fw += x[j] * f[idx];
|
||||
}
|
||||
q[i] = fw;
|
||||
for(j=0,fw=0.0;j<=jx;j++) fw += x[j]*f[jx+i-j]; q[i] = fw;
|
||||
}
|
||||
|
||||
jz = jk;
|
||||
|
|
@ -230,57 +186,47 @@ __kernel_rem_pio2(x, y, e0, nx, prec, ipio2)
|
|||
z -= (double)n;
|
||||
ih = 0;
|
||||
if(q0>0) { /* need iq[jz-1] to determine n */
|
||||
i = (iq[jz - 1] >> (24 - q0));
|
||||
n += i;
|
||||
i = (iq[jz-1]>>(24-q0)); n += i;
|
||||
iq[jz-1] -= i<<(24-q0);
|
||||
ih = iq[jz-1]>>(23-q0);
|
||||
} else if (q0 == 0)
|
||||
ih = iq[jz - 1] >> 23;
|
||||
else if (z >= 0.5)
|
||||
ih = 2;
|
||||
}
|
||||
else if(q0==0) ih = iq[jz-1]>>23;
|
||||
else if(z>=0.5) ih=2;
|
||||
|
||||
if(ih>0) { /* q > 0.5 */
|
||||
n += 1;
|
||||
carry = 0;
|
||||
n += 1; carry = 0;
|
||||
for(i=0;i<jz ;i++) { /* compute 1-q */
|
||||
j = iq[i];
|
||||
if(carry==0) {
|
||||
if(j!=0) {
|
||||
carry = 1;
|
||||
iq[i] = 0x1000000 - j;
|
||||
carry = 1; iq[i] = 0x1000000- j;
|
||||
}
|
||||
} else
|
||||
iq[i] = 0xffffff - j;
|
||||
} else iq[i] = 0xffffff - j;
|
||||
}
|
||||
if(q0>0) { /* rare case: chance is 1 in 12 */
|
||||
switch(q0) {
|
||||
case 1:
|
||||
iq[jz - 1] &= 0x7fffff;
|
||||
break;
|
||||
iq[jz-1] &= 0x7fffff; break;
|
||||
case 2:
|
||||
iq[jz - 1] &= 0x3fffff;
|
||||
break;
|
||||
iq[jz-1] &= 0x3fffff; break;
|
||||
}
|
||||
}
|
||||
if(ih==2) {
|
||||
z = one - z;
|
||||
if (carry != 0)
|
||||
z -= scalbn(one, q0);
|
||||
if(carry!=0) z -= scalbn(one,q0);
|
||||
}
|
||||
}
|
||||
|
||||
/* check if recomputation is needed */
|
||||
if(z==zero) {
|
||||
j = 0;
|
||||
for (i = jz - 1; i >= jk; i--)
|
||||
j |= iq[i];
|
||||
for (i=jz-1;i>=jk;i--) j |= iq[i];
|
||||
if(j==0) { /* need recomputation */
|
||||
for(k=1;iq[jk-k]==0;k++); /* k = no. of terms needed */
|
||||
|
||||
for(i=jz+1;i<=jz+k;i++) { /* add q[jz+1] to q[jz+k] */
|
||||
f[jx+i] = (double) ipio2[jv+i];
|
||||
for (j = 0, fw = 0.0; j <= jx; j++)
|
||||
fw += x[j] * f[jx + i - j];
|
||||
for(j=0,fw=0.0;j<=jx;j++) fw += x[j]*f[jx+i-j];
|
||||
q[i] = fw;
|
||||
}
|
||||
jz += k;
|
||||
|
|
@ -290,35 +236,27 @@ __kernel_rem_pio2(x, y, e0, nx, prec, ipio2)
|
|||
|
||||
/* chop off zero terms */
|
||||
if(z==0.0) {
|
||||
jz -= 1;
|
||||
q0 -= 24;
|
||||
while (iq[jz] == 0) {
|
||||
jz--;
|
||||
q0 -= 24;
|
||||
}
|
||||
jz -= 1; q0 -= 24;
|
||||
while(iq[jz]==0) { jz--; q0-=24;}
|
||||
} else { /* break z into 24-bit if necessary */
|
||||
z = scalbn(z,-q0);
|
||||
if(z>=two24) {
|
||||
fw = (double)((int32_t)(twon24*z));
|
||||
iq[jz] = (int32_t)(z-two24*fw);
|
||||
jz += 1;
|
||||
q0 += 24;
|
||||
jz += 1; q0 += 24;
|
||||
iq[jz] = (int32_t) fw;
|
||||
} else
|
||||
iq[jz] = (int32_t) z;
|
||||
} else iq[jz] = (int32_t) z ;
|
||||
}
|
||||
|
||||
/* convert integer "bit" chunk to floating-point value */
|
||||
fw = scalbn(one,q0);
|
||||
for(i=jz;i>=0;i--) {
|
||||
q[i] = fw * (double) iq[i];
|
||||
fw *= twon24;
|
||||
q[i] = fw*(double)iq[i]; fw*=twon24;
|
||||
}
|
||||
|
||||
/* compute PIo2[0,...,jp]*q[jz,...,0] */
|
||||
for(i=jz;i>=0;i--) {
|
||||
for (fw = 0.0, k = 0; k <= jp && k <= jz - i; k++)
|
||||
fw += PIo2[k] * q[i + k];
|
||||
for(fw=0.0,k=0;k<=jp&&k<=jz-i;k++) fw += PIo2[k]*q[i+k];
|
||||
fq[jz-i] = fw;
|
||||
}
|
||||
|
||||
|
|
@ -326,19 +264,16 @@ __kernel_rem_pio2(x, y, e0, nx, prec, ipio2)
|
|||
switch(prec) {
|
||||
case 0:
|
||||
fw = 0.0;
|
||||
for (i = jz; i >= 0; i--)
|
||||
fw += fq[i];
|
||||
for (i=jz;i>=0;i--) fw += fq[i];
|
||||
y[0] = (ih==0)? fw: -fw;
|
||||
break;
|
||||
case 1:
|
||||
case 2:
|
||||
fw = 0.0;
|
||||
for (i = jz; i >= 0; i--)
|
||||
fw += fq[i];
|
||||
for (i=jz;i>=0;i--) fw += fq[i];
|
||||
y[0] = (ih==0)? fw: -fw;
|
||||
fw = fq[0]-fw;
|
||||
for (i = 1; i <= jz; i++)
|
||||
fw += fq[i];
|
||||
for (i=1;i<=jz;i++) fw += fq[i];
|
||||
y[1] = (ih==0)? fw: -fw;
|
||||
break;
|
||||
case 3: /* painful */
|
||||
|
|
@ -352,16 +287,11 @@ __kernel_rem_pio2(x, y, e0, nx, prec, ipio2)
|
|||
fq[i] += fq[i-1]-fw;
|
||||
fq[i-1] = fw;
|
||||
}
|
||||
for (fw = 0.0, i = jz; i >= 2; i--)
|
||||
fw += fq[i];
|
||||
for (fw=0.0,i=jz;i>=2;i--) fw += fq[i];
|
||||
if(ih==0) {
|
||||
y[0] = fq[0];
|
||||
y[1] = fq[1];
|
||||
y[2] = fw;
|
||||
y[0] = fq[0]; y[1] = fq[1]; y[2] = fw;
|
||||
} else {
|
||||
y[0] = -fq[0];
|
||||
y[1] = -fq[1];
|
||||
y[2] = -fw;
|
||||
y[0] = -fq[0]; y[1] = -fq[1]; y[2] = -fw;
|
||||
}
|
||||
}
|
||||
return n&7;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
/* @(#)k_sin.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
|
|
@ -10,11 +9,6 @@
|
|||
* ====================================================
|
||||
*/
|
||||
|
||||
#if defined(LIBM_SCCS) && !defined(lint)
|
||||
static const char rcsid[] =
|
||||
"$NetBSD: k_sin.c,v 1.8 1995/05/10 20:46:31 jtc Exp $";
|
||||
#endif
|
||||
|
||||
/* __kernel_sin( x, y, iy)
|
||||
* kernel sin function on [-pi/4, pi/4], pi/4 ~ 0.7854
|
||||
* Input x is assumed to be bounded by ~pi/4 in magnitude.
|
||||
|
|
@ -46,11 +40,7 @@ static const char rcsid[] =
|
|||
#include "math_libm.h"
|
||||
#include "math_private.h"
|
||||
|
||||
#ifdef __STDC__
|
||||
static const double
|
||||
#else
|
||||
static double
|
||||
#endif
|
||||
half = 5.00000000000000000000e-01, /* 0x3FE00000, 0x00000000 */
|
||||
S1 = -1.66666666666666324348e-01, /* 0xBFC55555, 0x55555549 */
|
||||
S2 = 8.33333333332248946124e-03, /* 0x3F811111, 0x1110F8A6 */
|
||||
|
|
@ -59,29 +49,17 @@ static double
|
|||
S5 = -2.50507602534068634195e-08, /* 0xBE5AE5E6, 0x8A2B9CEB */
|
||||
S6 = 1.58969099521155010221e-10; /* 0x3DE5D93A, 0x5ACFD57C */
|
||||
|
||||
#ifdef __STDC__
|
||||
double attribute_hidden
|
||||
__kernel_sin(double x, double y, int iy)
|
||||
#else
|
||||
double attribute_hidden
|
||||
__kernel_sin(x, y, iy)
|
||||
double x, y;
|
||||
int iy; /* iy=0 if y is zero */
|
||||
#endif
|
||||
double attribute_hidden __kernel_sin(double x, double y, int iy)
|
||||
{
|
||||
double z,r,v;
|
||||
int32_t ix;
|
||||
GET_HIGH_WORD(ix,x);
|
||||
ix &= 0x7fffffff; /* high word of x */
|
||||
if (ix < 0x3e400000) { /* |x| < 2**-27 */
|
||||
if ((int) x == 0)
|
||||
return x;
|
||||
} /* generate inexact */
|
||||
if(ix<0x3e400000) /* |x| < 2**-27 */
|
||||
{if((int)x==0) return x;} /* generate inexact */
|
||||
z = x*x;
|
||||
v = z*x;
|
||||
r = S2+z*(S3+z*(S4+z*(S5+z*S6)));
|
||||
if (iy == 0)
|
||||
return x + v * (S1 + z * r);
|
||||
else
|
||||
return x - ((z * (half * y - v * r) - y) - v * S1);
|
||||
if(iy==0) return x+v*(S1+z*r);
|
||||
else return x-((z*(half*y-v*r)-y)-v*S1);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -66,7 +66,7 @@ T[] = {
|
|||
2.59073051863633712884e-05, /* 0x3EFB2A70, 0x74BF7AD4 */
|
||||
};
|
||||
|
||||
double __kernel_tan(double x, double y, int iy)
|
||||
double attribute_hidden __kernel_tan(double x, double y, int iy)
|
||||
{
|
||||
double z,r,v,w,s;
|
||||
int32_t ix,hx;
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@ double SDL_uclibc_copysign(double x, double y);
|
|||
double SDL_uclibc_cos(double x);
|
||||
double SDL_uclibc_fabs(double x);
|
||||
double SDL_uclibc_floor(double x);
|
||||
double SDL_uclibc_fmod(double x, double y);
|
||||
double SDL_uclibc_log(double x);
|
||||
double SDL_uclibc_pow(double x, double y);
|
||||
double SDL_uclibc_scalbn(double x, int n);
|
||||
|
|
|
|||
|
|
@ -21,9 +21,11 @@
|
|||
#include "SDL_endian.h"
|
||||
/* #include <sys/types.h> */
|
||||
|
||||
#define _IEEE_LIBM
|
||||
#define attribute_hidden
|
||||
#define libm_hidden_proto(x)
|
||||
#define libm_hidden_def(x)
|
||||
#define strong_alias(x, y)
|
||||
|
||||
#ifndef __HAIKU__ /* already defined in a system header. */
|
||||
typedef unsigned int u_int32_t;
|
||||
|
|
@ -35,6 +37,7 @@ typedef unsigned int u_int32_t;
|
|||
#define cos SDL_uclibc_cos
|
||||
#define fabs SDL_uclibc_fabs
|
||||
#define floor SDL_uclibc_floor
|
||||
#define __ieee754_fmod SDL_uclibc_fmod
|
||||
#define __ieee754_log SDL_uclibc_log
|
||||
#define __ieee754_pow SDL_uclibc_pow
|
||||
#define scalbn SDL_uclibc_scalbn
|
||||
|
|
|
|||
|
|
@ -112,4 +112,3 @@ double atan(double x)
|
|||
}
|
||||
}
|
||||
libm_hidden_def(atan)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
/* @(#)s_copysign.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
|
|
@ -10,11 +9,6 @@
|
|||
* ====================================================
|
||||
*/
|
||||
|
||||
#if defined(LIBM_SCCS) && !defined(lint)
|
||||
static const char rcsid[] =
|
||||
"$NetBSD: s_copysign.c,v 1.8 1995/05/10 20:46:57 jtc Exp $";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* copysign(double x, double y)
|
||||
* copysign(x,y) returns a value with the magnitude of x and
|
||||
|
|
@ -24,13 +18,7 @@ static const char rcsid[] =
|
|||
#include "math_libm.h"
|
||||
#include "math_private.h"
|
||||
|
||||
libm_hidden_proto(copysign)
|
||||
#ifdef __STDC__
|
||||
double copysign(double x, double y)
|
||||
#else
|
||||
double copysign(x, y)
|
||||
double x, y;
|
||||
#endif
|
||||
{
|
||||
u_int32_t hx,hy;
|
||||
GET_HIGH_WORD(hx,x);
|
||||
|
|
@ -38,5 +26,4 @@ libm_hidden_proto(copysign)
|
|||
SET_HIGH_WORD(x,(hx&0x7fffffff)|(hy&0x80000000));
|
||||
return x;
|
||||
}
|
||||
|
||||
libm_hidden_def(copysign)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
/* @(#)s_cos.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
|
|
@ -10,11 +9,6 @@
|
|||
* ====================================================
|
||||
*/
|
||||
|
||||
#if defined(LIBM_SCCS) && !defined(lint)
|
||||
static const char rcsid[] =
|
||||
"$NetBSD: s_cos.c,v 1.7 1995/05/10 20:47:02 jtc Exp $";
|
||||
#endif
|
||||
|
||||
/* cos(x)
|
||||
* Return cosine function of x.
|
||||
*
|
||||
|
|
@ -49,13 +43,7 @@ static const char rcsid[] =
|
|||
#include "math_libm.h"
|
||||
#include "math_private.h"
|
||||
|
||||
libm_hidden_proto(cos)
|
||||
#ifdef __STDC__
|
||||
double cos(double x)
|
||||
#else
|
||||
double cos(x)
|
||||
double x;
|
||||
#endif
|
||||
{
|
||||
double y[2],z=0.0;
|
||||
int32_t n, ix;
|
||||
|
|
@ -65,27 +53,21 @@ libm_hidden_proto(cos)
|
|||
|
||||
/* |x| ~< pi/4 */
|
||||
ix &= 0x7fffffff;
|
||||
if (ix <= 0x3fe921fb)
|
||||
return __kernel_cos(x, z);
|
||||
if(ix <= 0x3fe921fb) return __kernel_cos(x,z);
|
||||
|
||||
/* cos(Inf or NaN) is NaN */
|
||||
else if (ix >= 0x7ff00000)
|
||||
return x - x;
|
||||
else if (ix>=0x7ff00000) return x-x;
|
||||
|
||||
/* argument reduction needed */
|
||||
else {
|
||||
n = __ieee754_rem_pio2(x,y);
|
||||
switch(n&3) {
|
||||
case 0:
|
||||
return __kernel_cos(y[0], y[1]);
|
||||
case 1:
|
||||
return -__kernel_sin(y[0], y[1], 1);
|
||||
case 2:
|
||||
return -__kernel_cos(y[0], y[1]);
|
||||
case 0: return __kernel_cos(y[0],y[1]);
|
||||
case 1: return -__kernel_sin(y[0],y[1],1);
|
||||
case 2: return -__kernel_cos(y[0],y[1]);
|
||||
default:
|
||||
return __kernel_sin(y[0],y[1],1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
libm_hidden_def(cos)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
/* @(#)s_fabs.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
|
|
@ -10,30 +9,21 @@
|
|||
* ====================================================
|
||||
*/
|
||||
|
||||
#if defined(LIBM_SCCS) && !defined(lint)
|
||||
static const char rcsid[] =
|
||||
"$NetBSD: s_fabs.c,v 1.7 1995/05/10 20:47:13 jtc Exp $";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* fabs(x) returns the absolute value of x.
|
||||
*/
|
||||
|
||||
/*#include <features.h>*/
|
||||
/* Prevent math.h from defining a colliding inline */
|
||||
#undef __USE_EXTERN_INLINES
|
||||
#include "math_libm.h"
|
||||
#include "math_private.h"
|
||||
|
||||
libm_hidden_proto(fabs)
|
||||
#ifdef __STDC__
|
||||
double fabs(double x)
|
||||
#else
|
||||
double fabs(x)
|
||||
double x;
|
||||
#endif
|
||||
{
|
||||
u_int32_t high;
|
||||
GET_HIGH_WORD(high,x);
|
||||
SET_HIGH_WORD(x,high&0x7fffffff);
|
||||
return x;
|
||||
}
|
||||
|
||||
libm_hidden_def(fabs)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
/* @(#)s_floor.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
|
|
@ -10,11 +9,6 @@
|
|||
* ====================================================
|
||||
*/
|
||||
|
||||
#if defined(LIBM_SCCS) && !defined(lint)
|
||||
static const char rcsid[] =
|
||||
"$NetBSD: s_floor.c,v 1.8 1995/05/10 20:47:20 jtc Exp $";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* floor(x)
|
||||
* Return x rounded toward -inf to integral value
|
||||
|
|
@ -24,22 +18,15 @@ static const char rcsid[] =
|
|||
* Inexact flag raised if x not equal to floor(x).
|
||||
*/
|
||||
|
||||
/*#include <features.h>*/
|
||||
/* Prevent math.h from defining a colliding inline */
|
||||
#undef __USE_EXTERN_INLINES
|
||||
#include "math_libm.h"
|
||||
#include "math_private.h"
|
||||
|
||||
#ifdef __STDC__
|
||||
static const double huge_val = 1.0e300;
|
||||
#else
|
||||
static double huge_val = 1.0e300;
|
||||
#endif
|
||||
static const double huge = 1.0e300;
|
||||
|
||||
libm_hidden_proto(floor)
|
||||
#ifdef __STDC__
|
||||
double floor(double x)
|
||||
#else
|
||||
double floor(x)
|
||||
double x;
|
||||
#endif
|
||||
{
|
||||
int32_t i0,i1,j0;
|
||||
u_int32_t i,j;
|
||||
|
|
@ -47,42 +34,31 @@ libm_hidden_proto(floor)
|
|||
j0 = ((i0>>20)&0x7ff)-0x3ff;
|
||||
if(j0<20) {
|
||||
if(j0<0) { /* raise inexact if x != 0 */
|
||||
if (huge_val + x > 0.0) { /* return 0*sign(x) if |x|<1 */
|
||||
if (i0 >= 0) {
|
||||
i0 = i1 = 0;
|
||||
} else if (((i0 & 0x7fffffff) | i1) != 0) {
|
||||
i0 = 0xbff00000;
|
||||
i1 = 0;
|
||||
}
|
||||
if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */
|
||||
if(i0>=0) {i0=i1=0;}
|
||||
else if(((i0&0x7fffffff)|i1)!=0)
|
||||
{ i0=0xbff00000;i1=0;}
|
||||
}
|
||||
} else {
|
||||
i = (0x000fffff)>>j0;
|
||||
if (((i0 & i) | i1) == 0)
|
||||
return x; /* x is integral */
|
||||
if (huge_val + x > 0.0) { /* raise inexact flag */
|
||||
if (i0 < 0)
|
||||
i0 += (0x00100000) >> j0;
|
||||
i0 &= (~i);
|
||||
i1 = 0;
|
||||
if(((i0&i)|i1)==0) return x; /* x is integral */
|
||||
if(huge+x>0.0) { /* raise inexact flag */
|
||||
if(i0<0) i0 += (0x00100000)>>j0;
|
||||
i0 &= (~i); i1=0;
|
||||
}
|
||||
}
|
||||
} else if (j0>51) {
|
||||
if (j0 == 0x400)
|
||||
return x + x; /* inf or NaN */
|
||||
else
|
||||
return x; /* x is integral */
|
||||
if(j0==0x400) return x+x; /* inf or NaN */
|
||||
else return x; /* x is integral */
|
||||
} else {
|
||||
i = ((u_int32_t)(0xffffffff))>>(j0-20);
|
||||
if ((i1 & i) == 0)
|
||||
return x; /* x is integral */
|
||||
if (huge_val + x > 0.0) { /* raise inexact flag */
|
||||
if((i1&i)==0) return x; /* x is integral */
|
||||
if(huge+x>0.0) { /* raise inexact flag */
|
||||
if(i0<0) {
|
||||
if (j0 == 20)
|
||||
i0 += 1;
|
||||
if(j0==20) i0+=1;
|
||||
else {
|
||||
j = i1+(1<<(52-j0));
|
||||
if (j < (u_int32_t) i1)
|
||||
i0 += 1; /* got a carry */
|
||||
if(j<i1) i0 +=1 ; /* got a carry */
|
||||
i1=j;
|
||||
}
|
||||
}
|
||||
|
|
@ -92,5 +68,4 @@ libm_hidden_proto(floor)
|
|||
INSERT_WORDS(x,i0,i1);
|
||||
return x;
|
||||
}
|
||||
|
||||
libm_hidden_def(floor)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
/* @(#)s_scalbn.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
|
|
@ -10,41 +9,27 @@
|
|||
* ====================================================
|
||||
*/
|
||||
|
||||
#if defined(LIBM_SCCS) && !defined(lint)
|
||||
static const char rcsid[] =
|
||||
"$NetBSD: s_scalbn.c,v 1.8 1995/05/10 20:48:08 jtc Exp $";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* scalbn (double x, int n)
|
||||
* scalbn(x,n) returns x* 2**n computed by exponent
|
||||
* scalbln(double x, long n)
|
||||
* scalbln(x,n) returns x * 2**n computed by exponent
|
||||
* manipulation rather than by actually performing an
|
||||
* exponentiation or a multiplication.
|
||||
*/
|
||||
|
||||
#include "math_libm.h"
|
||||
#include "math_private.h"
|
||||
#include <limits.h>
|
||||
|
||||
libm_hidden_proto(copysign)
|
||||
#ifdef __STDC__
|
||||
static const double
|
||||
#else
|
||||
static double
|
||||
#endif
|
||||
two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
|
||||
twom54 = 5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */
|
||||
huge_val = 1.0e+300, tiny = 1.0e-300;
|
||||
huge = 1.0e+300,
|
||||
tiny = 1.0e-300;
|
||||
|
||||
libm_hidden_proto(scalbn)
|
||||
#ifdef __STDC__
|
||||
double scalbn(double x, int n)
|
||||
#else
|
||||
double scalbn(x, n)
|
||||
double x;
|
||||
int n;
|
||||
#endif
|
||||
double scalbln(double x, long n)
|
||||
{
|
||||
int32_t k, hx, lx;
|
||||
|
||||
EXTRACT_WORDS(hx, lx, x);
|
||||
k = (hx & 0x7ff00000) >> 20; /* extract exponent */
|
||||
if (k == 0) { /* 0 or subnormal x */
|
||||
|
|
@ -53,27 +38,40 @@ libm_hidden_proto(scalbn)
|
|||
x *= two54;
|
||||
GET_HIGH_WORD(hx, x);
|
||||
k = ((hx & 0x7ff00000) >> 20) - 54;
|
||||
if (n < -50000)
|
||||
return tiny * x; /* underflow */
|
||||
}
|
||||
if (k == 0x7ff)
|
||||
return x + x; /* NaN or Inf */
|
||||
k = k + n;
|
||||
if (k > 0x7fe)
|
||||
return huge_val * copysign(huge_val, x); /* overflow */
|
||||
return huge * copysign(huge, x); /* overflow */
|
||||
if (n < -50000)
|
||||
return tiny * copysign(tiny, x); /* underflow */
|
||||
if (k > 0) { /* normal result */
|
||||
SET_HIGH_WORD(x, (hx & 0x800fffff) | (k << 20));
|
||||
return x;
|
||||
}
|
||||
if (k <= -54) {
|
||||
if (n > 50000) /* in case integer overflow in n+k */
|
||||
return huge_val * copysign(huge_val, x); /* overflow */
|
||||
else
|
||||
return huge * copysign(huge, x); /* overflow */
|
||||
return tiny * copysign(tiny, x); /* underflow */
|
||||
}
|
||||
k += 54; /* subnormal result */
|
||||
SET_HIGH_WORD(x, (hx & 0x800fffff) | (k << 20));
|
||||
return x * twom54;
|
||||
}
|
||||
libm_hidden_def(scalbln)
|
||||
|
||||
#if LONG_MAX == INT_MAX
|
||||
/* strong_alias(scalbln, scalbn) - "error: conflicting types for 'scalbn'"
|
||||
* because it tries to declare "typeof(scalbln) scalbn;"
|
||||
* which tries to give "long" parameter to scalbn.
|
||||
* Doing it by hand:
|
||||
*/
|
||||
__typeof(scalbn) scalbn __attribute__((alias("scalbln")));
|
||||
#else
|
||||
double scalbn(double x, int n)
|
||||
{
|
||||
return scalbln(x, n);
|
||||
}
|
||||
#endif
|
||||
libm_hidden_def(scalbn)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
/* @(#)s_sin.c 5.1 93/09/24 */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
|
|
@ -10,11 +9,6 @@
|
|||
* ====================================================
|
||||
*/
|
||||
|
||||
#if defined(LIBM_SCCS) && !defined(lint)
|
||||
static const char rcsid[] =
|
||||
"$NetBSD: s_sin.c,v 1.7 1995/05/10 20:48:15 jtc Exp $";
|
||||
#endif
|
||||
|
||||
/* sin(x)
|
||||
* Return sine function of x.
|
||||
*
|
||||
|
|
@ -49,13 +43,7 @@ static const char rcsid[] =
|
|||
#include "math_libm.h"
|
||||
#include "math_private.h"
|
||||
|
||||
libm_hidden_proto(sin)
|
||||
#ifdef __STDC__
|
||||
double sin(double x)
|
||||
#else
|
||||
double sin(x)
|
||||
double x;
|
||||
#endif
|
||||
{
|
||||
double y[2],z=0.0;
|
||||
int32_t n, ix;
|
||||
|
|
@ -65,27 +53,21 @@ libm_hidden_proto(sin)
|
|||
|
||||
/* |x| ~< pi/4 */
|
||||
ix &= 0x7fffffff;
|
||||
if (ix <= 0x3fe921fb)
|
||||
return __kernel_sin(x, z, 0);
|
||||
if(ix <= 0x3fe921fb) return __kernel_sin(x,z,0);
|
||||
|
||||
/* sin(Inf or NaN) is NaN */
|
||||
else if (ix >= 0x7ff00000)
|
||||
return x - x;
|
||||
else if (ix>=0x7ff00000) return x-x;
|
||||
|
||||
/* argument reduction needed */
|
||||
else {
|
||||
n = __ieee754_rem_pio2(x,y);
|
||||
switch(n&3) {
|
||||
case 0:
|
||||
return __kernel_sin(y[0], y[1], 1);
|
||||
case 1:
|
||||
return __kernel_cos(y[0], y[1]);
|
||||
case 2:
|
||||
return -__kernel_sin(y[0], y[1], 1);
|
||||
case 0: return __kernel_sin(y[0],y[1],1);
|
||||
case 1: return __kernel_cos(y[0],y[1]);
|
||||
case 2: return -__kernel_sin(y[0],y[1],1);
|
||||
default:
|
||||
return -__kernel_cos(y[0],y[1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
libm_hidden_def(sin)
|
||||
|
|
|
|||
Loading…
Reference in New Issue