_Float128 __copysignl(_Float128 x, _Float128 y)
{
uint64_t hx,hy;
GET_LDOUBLE_MSW64(hx,x);
GET_LDOUBLE_MSW64(hy,y);
SET_LDOUBLE_MSW64(x,(hx&0x7fffffffffffffffULL)
|(hy&0x8000000000000000ULL));
return x;
}
long double __tanl(long double x)
{
long double y[2],z=0.0L;
int64_t n, ix;
/* High word of x. */
GET_LDOUBLE_MSW64(ix,x);
/* |x| ~< pi/4 */
ix &= 0x7fffffffffffffffLL;
if(ix <= 0x3ffe921fb54442d1LL) return __kernel_tanl(x,z,1);
/* tanl(Inf or NaN) is NaN */
else if (ix>=0x7fff000000000000LL) {
if (ix == 0x7fff000000000000LL) {
GET_LDOUBLE_LSW64(n,x);
if (n == 0)
__set_errno (EDOM);
}
return x-x; /* NaN */
}
/* argument reduction needed */
else {
n = __ieee754_rem_pio2l(x,y);
return __kernel_tanl(y[0],y[1],1-((n&1)<<1)); /* 1 -- n even
-1 -- n odd */
}
}
_Float128 __sinl(_Float128 x)
{
_Float128 y[2],z=0;
int64_t n, ix;
/* High word of x. */
GET_LDOUBLE_MSW64(ix,x);
/* |x| ~< pi/4 */
ix &= 0x7fffffffffffffffLL;
if(ix <= 0x3ffe921fb54442d1LL)
return __kernel_sinl(x,z,0);
/* sin(Inf or NaN) is NaN */
else if (ix>=0x7fff000000000000LL) {
if (ix == 0x7fff000000000000LL) {
GET_LDOUBLE_LSW64(n,x);
if (n == 0)
__set_errno (EDOM);
}
return x-x;
}
/* argument reduction needed */
else {
n = __ieee754_rem_pio2l(x,y);
switch(n&3) {
case 0: return __kernel_sinl(y[0],y[1],1);
case 1: return __kernel_cosl(y[0],y[1]);
case 2: return -__kernel_sinl(y[0],y[1],1);
default:
return -__kernel_cosl(y[0],y[1]);
}
}
}
_Float128 __fabsl(_Float128 x)
{
u_int64_t hx;
GET_LDOUBLE_MSW64(hx,x);
SET_LDOUBLE_MSW64(x,hx&0x7fffffffffffffffLL);
return x;
}
int __finitel(long double x)
{
int64_t hx;
GET_LDOUBLE_MSW64(hx,x);
return (int)((u_int64_t)((hx&0x7fffffffffffffffLL)
-0x7fff000000000000LL)>>63);
}
long double __fabsl(long double x)
{
u_int64_t hx;
GET_LDOUBLE_MSW64(hx,x);
SET_LDOUBLE_MSW64(x,hx&0x7fffffffffffffffLL);
return x;
}
void
__sincosl (_Float128 x, _Float128 *sinx, _Float128 *cosx)
{
int64_t ix;
/* High word of x. */
GET_LDOUBLE_MSW64 (ix, x);
/* |x| ~< pi/4 */
ix &= 0x7fffffffffffffffLL;
if (ix <= 0x3ffe921fb54442d1LL)
__kernel_sincosl (x, 0, sinx, cosx, 0);
else if (ix >= 0x7fff000000000000LL)
{
/* sin(Inf or NaN) is NaN */
*sinx = *cosx = x - x;
if (isinf (x))
__set_errno (EDOM);
}
else
{
/* Argument reduction needed. */
_Float128 y[2];
int n;
n = __ieee754_rem_pio2l (x, y);
switch (n & 3)
{
case 0:
__kernel_sincosl (y[0], y[1], sinx, cosx, 1);
break;
case 1:
__kernel_sincosl (y[0], y[1], cosx, sinx, 1);
*cosx = -*cosx;
break;
case 2:
__kernel_sincosl (y[0], y[1], sinx, cosx, 1);
*sinx = -*sinx;
*cosx = -*cosx;
break;
default:
__kernel_sincosl (y[0], y[1], cosx, sinx, 1);
*sinx = -*sinx;
break;
}
}
}
_Float128 __frexpl(_Float128 x, int *eptr)
{
uint64_t hx, lx, ix;
GET_LDOUBLE_WORDS64(hx,lx,x);
ix = 0x7fffffffffffffffULL&hx;
*eptr = 0;
if(ix>=0x7fff000000000000ULL||((ix|lx)==0)) return x + x;/* 0,inf,nan */
if (ix<0x0001000000000000ULL) { /* subnormal */
x *= two114;
GET_LDOUBLE_MSW64(hx,x);
ix = hx&0x7fffffffffffffffULL;
*eptr = -114;
}
*eptr += (ix>>48)-16382;
hx = (hx&0x8000ffffffffffffULL) | 0x3ffe000000000000ULL;
SET_LDOUBLE_MSW64(x,hx);
return x;
}
_Float128
__ieee754_remainderl(_Float128 x, _Float128 p)
{
int64_t hx,hp;
uint64_t sx,lx,lp;
_Float128 p_half;
GET_LDOUBLE_WORDS64(hx,lx,x);
GET_LDOUBLE_WORDS64(hp,lp,p);
sx = hx&0x8000000000000000ULL;
hp &= 0x7fffffffffffffffLL;
hx &= 0x7fffffffffffffffLL;
/* purge off exception values */
if((hp|lp)==0) return (x*p)/(x*p); /* p = 0 */
if((hx>=0x7fff000000000000LL)|| /* x not finite */
((hp>=0x7fff000000000000LL)&& /* p is NaN */
(((hp-0x7fff000000000000LL)|lp)!=0)))
return (x*p)/(x*p);
if (hp<=0x7ffdffffffffffffLL) x = __ieee754_fmodl(x,p+p); /* now x < 2p */
if (((hx-hp)|(lx-lp))==0) return zero*x;
x = fabsl(x);
p = fabsl(p);
if (hp<0x0002000000000000LL) {
if(x+x>p) {
x-=p;
if(x+x>=p) x -= p;
}
} else {
p_half = L(0.5)*p;
if(x>p_half) {
x-=p;
if(x>=p_half) x -= p;
}
}
GET_LDOUBLE_MSW64(hx,x);
SET_LDOUBLE_MSW64(x,hx^sx);
return x;
}
long double __asinhl(long double x)
{
long double t,w;
int64_t hx,ix;
GET_LDOUBLE_MSW64(hx,x);
ix = hx&0x7fffffffffffffffLL;
if(ix>=0x7ff0000000000000LL) return x+x; /* x is inf or NaN */
if(ix< 0x3e20000000000000LL) { /* |x|<2**-29 */
if(huge+x>one) return x; /* return x inexact except 0 */
}
if(ix>0x41b0000000000000LL) { /* |x| > 2**28 */
w = __ieee754_logl(fabs(x))+ln2;
} else if (ix>0x4000000000000000LL) { /* 2**28 > |x| > 2.0 */
t = fabs(x);
w = __ieee754_logl(2.0*t+one/(__ieee754_sqrtl(x*x+one)+t));
} else { /* 2.0 > |x| > 2**-29 */
t = x*x;
w =__log1pl(fabsl(x)+t/(one+__ieee754_sqrtl(one+t)));
}
if(hx>0) return w; else return -w;
}
long double
__ieee754_coshl (long double x)
{
long double t,w;
int64_t ix;
/* High word of |x|. */
GET_LDOUBLE_MSW64(ix,x);
ix &= 0x7fffffffffffffffLL;
/* x is INF or NaN */
if(ix>=0x7ff0000000000000LL) return x*x;
/* |x| in [0,0.5*ln2], return 1+expm1(|x|)^2/(2*exp(|x|)) */
if(ix<0x3fd62e42fefa39efLL) {
t = __expm1l(fabsl(x));
w = one+t;
if (ix<0x3c80000000000000LL) return w; /* cosh(tiny) = 1 */
return one+(t*t)/(w+w);
}
/* |x| in [0.5*ln2,22], return (exp(|x|)+1/exp(|x|)/2; */
if (ix < 0x4036000000000000LL) {
t = __ieee754_expl(fabsl(x));
return half*t+half/t;
}
/* |x| in [22, log(maxdouble)] return half*exp(|x|) */
if (ix < 0x40862e42fefa39efLL) return half*__ieee754_expl(fabsl(x));
/* |x| in [log(maxdouble), overflowthresold] */
if (ix < 0x408633ce8fb9f87dLL) {
w = __ieee754_expl(half*fabsl(x));
t = half*w;
return t*w;
}
/* |x| > overflowthresold, cosh(x) overflow */
return huge*huge;
}
long double
__ieee754_hypotl(long double x, long double y)
{
long double a,b,t1,t2,y1,y2,w;
int64_t j,k,ha,hb;
GET_LDOUBLE_MSW64(ha,x);
ha &= 0x7fffffffffffffffLL;
GET_LDOUBLE_MSW64(hb,y);
hb &= 0x7fffffffffffffffLL;
if(hb > ha) {a=y;b=x;j=ha; ha=hb;hb=j;} else {a=x;b=y;}
SET_LDOUBLE_MSW64(a,ha); /* a <- |a| */
SET_LDOUBLE_MSW64(b,hb); /* b <- |b| */
if((ha-hb)>0x78000000000000LL) {return a+b;} /* x/y > 2**120 */
k=0;
if(ha > 0x5f3f000000000000LL) { /* a>2**8000 */
if(ha >= 0x7fff000000000000LL) { /* Inf or NaN */
u_int64_t low;
w = a+b; /* for sNaN */
GET_LDOUBLE_LSW64(low,a);
if(((ha&0xffffffffffffLL)|low)==0) w = a;
GET_LDOUBLE_LSW64(low,b);
if(((hb^0x7fff000000000000LL)|low)==0) w = b;
return w;
}
/* scale a and b by 2**-9600 */
ha -= 0x2580000000000000LL;
hb -= 0x2580000000000000LL; k += 9600;
SET_LDOUBLE_MSW64(a,ha);
SET_LDOUBLE_MSW64(b,hb);
}
if(hb < 0x20bf000000000000LL) { /* b < 2**-8000 */
if(hb <= 0x0000ffffffffffffLL) { /* subnormal b or 0 */
u_int64_t low;
GET_LDOUBLE_LSW64(low,b);
if((hb|low)==0) return a;
t1=0;
SET_LDOUBLE_MSW64(t1,0x7ffd000000000000LL); /* t1=2^16382 */
b *= t1;
a *= t1;
k -= 16382;
GET_LDOUBLE_MSW64 (ha, a);
GET_LDOUBLE_MSW64 (hb, b);
if (hb > ha)
{
t1 = a;
a = b;
b = t1;
j = ha;
ha = hb;
hb = j;
}
} else { /* scale a and b by 2^9600 */
ha += 0x2580000000000000LL; /* a *= 2^9600 */
hb += 0x2580000000000000LL; /* b *= 2^9600 */
k -= 9600;
SET_LDOUBLE_MSW64(a,ha);
SET_LDOUBLE_MSW64(b,hb);
}
}
/* medium size a and b */
w = a-b;
if (w>b) {
t1 = 0;
SET_LDOUBLE_MSW64(t1,ha);
t2 = a-t1;
w = __ieee754_sqrtl(t1*t1-(b*(-b)-t2*(a+t1)));
} else {
a = a+a;
y1 = 0;
SET_LDOUBLE_MSW64(y1,hb);
y2 = b - y1;
t1 = 0;
SET_LDOUBLE_MSW64(t1,ha+0x0001000000000000LL);
t2 = a - t1;
w = __ieee754_sqrtl(t1*y1-(w*(-w)-(t1*y2+t2*b)));
}
if(k!=0) {
u_int64_t high;
t1 = 1.0L;
GET_LDOUBLE_MSW64(high,t1);
SET_LDOUBLE_MSW64(t1,high+(k<<48));
return t1*w;
} else return w;
}
