double __ieee754_y1(double x) { double z, s,c,ss,cc,u,v,u1,u2,v1,v2,v3,z2,z4; int32_t hx,ix,lx; EXTRACT_WORDS(hx,lx,x); ix = 0x7fffffff&hx; /* if Y1(NaN) is NaN, Y1(-inf) is NaN, Y1(inf) is 0 */ if(__builtin_expect(ix>=0x7ff00000, 0)) return one/(x+x*x); if(__builtin_expect((ix|lx)==0, 0)) return -HUGE_VAL+x; /* -inf and overflow exception. */; if(__builtin_expect(hx<0, 0)) return zero/(zero*x); if(ix >= 0x40000000) { /* |x| >= 2.0 */ __sincos (x, &s, &c); ss = -s-c; cc = s-c; if(ix<0x7fe00000) { /* make sure x+x not overflow */ z = __cos(x+x); if ((s*c)>zero) cc = z/ss; else ss = z/cc; } /* y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x0)+q1(x)*cos(x0)) * where x0 = x-3pi/4 * Better formula: * cos(x0) = cos(x)cos(3pi/4)+sin(x)sin(3pi/4) * = 1/sqrt(2) * (sin(x) - cos(x)) * sin(x0) = sin(x)cos(3pi/4)-cos(x)sin(3pi/4) * = -1/sqrt(2) * (cos(x) + sin(x)) * To avoid cancellation, use * sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x)) * to compute the worse one. */ if(ix>0x48000000) z = (invsqrtpi*ss)/__ieee754_sqrt(x); else { u = pone(x); v = qone(x); z = invsqrtpi*(u*ss+v*cc)/__ieee754_sqrt(x); } return z; } if(__builtin_expect(ix<=0x3c900000, 0)) { /* x < 2**-54 */ return(-tpi/x); } z = x*x; #ifdef DO_NOT_USE_THIS u = U0[0]+z*(U0[1]+z*(U0[2]+z*(U0[3]+z*U0[4]))); v = one+z*(V0[0]+z*(V0[1]+z*(V0[2]+z*(V0[3]+z*V0[4])))); #else u1 = U0[0]+z*U0[1];z2=z*z; u2 = U0[2]+z*U0[3];z4=z2*z2; u = u1 + z2*u2 + z4*U0[4]; v1 = one+z*V0[0]; v2 = V0[1]+z*V0[2]; v3 = V0[3]+z*V0[4]; v = v1 + z2*v2 + z4*v3; #endif return(x*(u/v) + tpi*(__ieee754_j1(x)*__ieee754_log(x)-one/x)); }
double __ieee754_j0(double x) { double z, s,c,ss,cc,r,u,v,r1,r2,s1,s2,z2,z4; int32_t hx,ix; GET_HIGH_WORD(hx,x); ix = hx&0x7fffffff; if(ix>=0x7ff00000) return one/(x*x); x = fabs(x); if(ix >= 0x40000000) { /* |x| >= 2.0 */ __sincos (x, &s, &c); ss = s-c; cc = s+c; if(ix<0x7fe00000) { /* make sure x+x not overflow */ z = -__cos(x+x); if ((s*c)<zero) cc = z/ss; else ss = z/cc; } /* * j0(x) = 1/sqrt(pi) * (P(0,x)*cc - Q(0,x)*ss) / sqrt(x) * y0(x) = 1/sqrt(pi) * (P(0,x)*ss + Q(0,x)*cc) / sqrt(x) */ if(ix>0x48000000) z = (invsqrtpi*cc)/__ieee754_sqrt(x); else { u = pzero(x); v = qzero(x); z = invsqrtpi*(u*cc-v*ss)/__ieee754_sqrt(x); } return z; } if(ix<0x3f200000) { /* |x| < 2**-13 */ math_force_eval(huge+x); /* raise inexact if x != 0 */ if(ix<0x3e400000) return one; /* |x|<2**-27 */ else return one - 0.25*x*x; } z = x*x; #ifdef DO_NOT_USE_THIS r = z*(R02+z*(R03+z*(R04+z*R05))); s = one+z*(S01+z*(S02+z*(S03+z*S04))); #else r1 = z*R[2]; z2=z*z; r2 = R[3]+z*R[4]; z4=z2*z2; r = r1 + z2*r2 + z4*R[5]; s1 = one+z*S[1]; s2 = S[2]+z*S[3]; s = s1 + z2*s2 + z4*S[4]; #endif if(ix < 0x3FF00000) { /* |x| < 1.00 */ return one + z*(-0.25+(r/s)); } else { u = 0.5*x; return((one+u)*(one-u)+z*(r/s)); } }
double __ieee754_j1(double x) { double z, s,c,ss,cc,r,u,v,y,r1,r2,s1,s2,s3,z2,z4; int32_t hx,ix; GET_HIGH_WORD(hx,x); ix = hx&0x7fffffff; if(__builtin_expect(ix>=0x7ff00000, 0)) return one/x; y = fabs(x); if(ix >= 0x40000000) { /* |x| >= 2.0 */ __sincos (y, &s, &c); ss = -s-c; cc = s-c; if(ix<0x7fe00000) { /* make sure y+y not overflow */ z = __cos(y+y); if ((s*c)>zero) cc = z/ss; else ss = z/cc; } /* * j1(x) = 1/sqrt(pi) * (P(1,x)*cc - Q(1,x)*ss) / sqrt(x) * y1(x) = 1/sqrt(pi) * (P(1,x)*ss + Q(1,x)*cc) / sqrt(x) */ if(ix>0x48000000) z = (invsqrtpi*cc)/__ieee754_sqrt(y); else { u = pone(y); v = qone(y); z = invsqrtpi*(u*cc-v*ss)/__ieee754_sqrt(y); } if(hx<0) return -z; else return z; } if(__builtin_expect(ix<0x3e400000, 0)) { /* |x|<2**-27 */ if(huge+x>one) return 0.5*x;/* inexact if x!=0 necessary */ } z = x*x; #ifdef DO_NOT_USE_THIS r = z*(r00+z*(r01+z*(r02+z*r03))); s = one+z*(s01+z*(s02+z*(s03+z*(s04+z*s05)))); r *= x; #else r1 = z*R[0]; z2=z*z; r2 = R[1]+z*R[2]; z4=z2*z2; r = r1 + z2*r2 + z4*R[3]; r *= x; s1 = one+z*S[1]; s2 = S[2]+z*S[3]; s3 = S[4]+z*S[5]; s = s1 + z2*s2 + z4*s3; #endif return(x*0.5+r/s); }
__complex__ double __ctanh (__complex__ double x) { __complex__ double res; if (__builtin_expect (!isfinite (__real__ x) || !isfinite (__imag__ x), 0)) { if (__isinf_ns (__real__ x)) { __real__ res = __copysign (1.0, __real__ x); __imag__ res = __copysign (0.0, __imag__ x); } else if (__imag__ x == 0.0) { res = x; } else { __real__ res = __nan (""); __imag__ res = __nan (""); if (__isinf_ns (__imag__ x)) feraiseexcept (FE_INVALID); } } else { double sin2ix, cos2ix; double den; __sincos (2.0 * __imag__ x, &sin2ix, &cos2ix); den = (__ieee754_cosh (2.0 * __real__ x) + cos2ix); if (den == 0.0) { __complex__ double ez = __cexp (x); __complex__ double emz = __cexp (-x); res = (ez - emz) / (ez + emz); } else { __real__ res = __ieee754_sinh (2.0 * __real__ x) / den; __imag__ res = sin2ix / den; } } return res; }
__complex__ double __ctanh (__complex__ double x) { __complex__ double res; if (!isfinite (__real__ x) || !isfinite (__imag__ x)) { if (__isinf (__real__ x)) { __real__ res = __copysign (1.0, __real__ x); __imag__ res = __copysign (0.0, __imag__ x); } else if (__imag__ x == 0.0) { res = x; } else { __real__ res = __nan (""); __imag__ res = __nan (""); #ifdef FE_INVALID if (__isinf (__imag__ x)) feraiseexcept (FE_INVALID); #endif } } else { double sin2ix, cos2ix; double den; __sincos (2.0 * __imag__ x, &sin2ix, &cos2ix); den = (__ieee754_cosh (2.0 * __real__ x) + cos2ix); __real__ res = __ieee754_sinh (2.0 * __real__ x) / den; __imag__ res = sin2ix / den; } return res; }
__complex__ double __ccosh (__complex__ double x) { __complex__ double retval; int rcls = fpclassify (__real__ x); int icls = fpclassify (__imag__ x); if (__builtin_expect (rcls >= FP_ZERO, 1)) { /* Real part is finite. */ if (__builtin_expect (icls >= FP_ZERO, 1)) { /* Imaginary part is finite. */ const int t = (int) ((DBL_MAX_EXP - 1) * M_LN2); double sinix, cosix; if (__builtin_expect (icls != FP_SUBNORMAL, 1)) { __sincos (__imag__ x, &sinix, &cosix); } else { sinix = __imag__ x; cosix = 1.0; } if (fabs (__real__ x) > t) { double exp_t = __ieee754_exp (t); double rx = fabs (__real__ x); if (signbit (__real__ x)) sinix = -sinix; rx -= t; sinix *= exp_t / 2.0; cosix *= exp_t / 2.0; if (rx > t) { rx -= t; sinix *= exp_t; cosix *= exp_t; } if (rx > t) { /* Overflow (original real part of x > 3t). */ __real__ retval = DBL_MAX * cosix; __imag__ retval = DBL_MAX * sinix; } else { double exp_val = __ieee754_exp (rx); __real__ retval = exp_val * cosix; __imag__ retval = exp_val * sinix; } } else { __real__ retval = __ieee754_cosh (__real__ x) * cosix; __imag__ retval = __ieee754_sinh (__real__ x) * sinix; } if (fabs (__real__ retval) < DBL_MIN) { volatile double force_underflow = __real__ retval * __real__ retval; (void) force_underflow; } if (fabs (__imag__ retval) < DBL_MIN) { volatile double force_underflow = __imag__ retval * __imag__ retval; (void) force_underflow; } } else { __imag__ retval = __real__ x == 0.0 ? 0.0 : __nan (""); __real__ retval = __nan ("") + __nan (""); if (icls == FP_INFINITE) feraiseexcept (FE_INVALID); } } else if (rcls == FP_INFINITE) { /* Real part is infinite. */ if (__builtin_expect (icls > FP_ZERO, 1)) { /* Imaginary part is finite. */ double sinix, cosix; if (__builtin_expect (icls != FP_SUBNORMAL, 1)) { __sincos (__imag__ x, &sinix, &cosix); } else { sinix = __imag__ x; cosix = 1.0; } __real__ retval = __copysign (HUGE_VAL, cosix); __imag__ retval = (__copysign (HUGE_VAL, sinix) * __copysign (1.0, __real__ x)); } else if (icls == FP_ZERO) { /* Imaginary part is 0.0. */ __real__ retval = HUGE_VAL; __imag__ retval = __imag__ x * __copysign (1.0, __real__ x); } else { /* The addition raises the invalid exception. */ __real__ retval = HUGE_VAL; __imag__ retval = __nan ("") + __nan (""); if (icls == FP_INFINITE) feraiseexcept (FE_INVALID); } } else { __real__ retval = __nan (""); __imag__ retval = __imag__ x == 0.0 ? __imag__ x : __nan (""); } return retval; }
__complex__ double __ctanh (__complex__ double x) { __complex__ double res; if (__glibc_unlikely (!isfinite (__real__ x) || !isfinite (__imag__ x))) { if (isinf (__real__ x)) { __real__ res = __copysign (1.0, __real__ x); if (isfinite (__imag__ x) && fabs (__imag__ x) > 1.0) { double sinix, cosix; __sincos (__imag__ x, &sinix, &cosix); __imag__ res = __copysign (0.0, sinix * cosix); } else __imag__ res = __copysign (0.0, __imag__ x); } else if (__imag__ x == 0.0) { res = x; } else { __real__ res = __nan (""); __imag__ res = __nan (""); if (isinf (__imag__ x)) feraiseexcept (FE_INVALID); } } else { double sinix, cosix; double den; const int t = (int) ((DBL_MAX_EXP - 1) * M_LN2 / 2); /* tanh(x+iy) = (sinh(2x) + i*sin(2y))/(cosh(2x) + cos(2y)) = (sinh(x)*cosh(x) + i*sin(y)*cos(y))/(sinh(x)^2 + cos(y)^2). */ if (__glibc_likely (fabs (__imag__ x) > DBL_MIN)) { __sincos (__imag__ x, &sinix, &cosix); } else { sinix = __imag__ x; cosix = 1.0; } if (fabs (__real__ x) > t) { /* Avoid intermediate overflow when the imaginary part of the result may be subnormal. Ignoring negligible terms, the real part is +/- 1, the imaginary part is sin(y)*cos(y)/sinh(x)^2 = 4*sin(y)*cos(y)/exp(2x). */ double exp_2t = __ieee754_exp (2 * t); __real__ res = __copysign (1.0, __real__ x); __imag__ res = 4 * sinix * cosix; __real__ x = fabs (__real__ x); __real__ x -= t; __imag__ res /= exp_2t; if (__real__ x > t) { /* Underflow (original real part of x has absolute value > 2t). */ __imag__ res /= exp_2t; } else __imag__ res /= __ieee754_exp (2 * __real__ x); } else { double sinhrx, coshrx; if (fabs (__real__ x) > DBL_MIN) { sinhrx = __ieee754_sinh (__real__ x); coshrx = __ieee754_cosh (__real__ x); } else { sinhrx = __real__ x; coshrx = 1.0; } if (fabs (sinhrx) > fabs (cosix) * DBL_EPSILON) den = sinhrx * sinhrx + cosix * cosix; else den = cosix * cosix; __real__ res = sinhrx * coshrx / den; __imag__ res = sinix * cosix / den; } math_check_force_underflow_complex (res); } return res; }
Err mathlib_sincos(UInt16 refnum, double x, double *sinx, double *cosx) { #pragma unused(refnum) __sincos(x, sinx, cosx); return mlErrNone; }
double __ieee754_j1 (double x) { double z, s, c, ss, cc, r, u, v, y, r1, r2, s1, s2, s3, z2, z4; int32_t hx, ix; GET_HIGH_WORD (hx, x); ix = hx & 0x7fffffff; if (__glibc_unlikely (ix >= 0x7ff00000)) return one / x; y = fabs (x); if (ix >= 0x40000000) /* |x| >= 2.0 */ { __sincos (y, &s, &c); ss = -s - c; cc = s - c; if (ix < 0x7fe00000) /* make sure y+y not overflow */ { z = __cos (y + y); if ((s * c) > zero) cc = z / ss; else ss = z / cc; } /* * j1(x) = 1/sqrt(pi) * (P(1,x)*cc - Q(1,x)*ss) / sqrt(x) * y1(x) = 1/sqrt(pi) * (P(1,x)*ss + Q(1,x)*cc) / sqrt(x) */ if (ix > 0x48000000) z = (invsqrtpi * cc) / sqrt (y); else { u = pone (y); v = qone (y); z = invsqrtpi * (u * cc - v * ss) / sqrt (y); } if (hx < 0) return -z; else return z; } if (__glibc_unlikely (ix < 0x3e400000)) /* |x|<2**-27 */ { if (huge + x > one) /* inexact if x!=0 necessary */ { double ret = math_narrow_eval (0.5 * x); math_check_force_underflow (ret); if (ret == 0 && x != 0) __set_errno (ERANGE); return ret; } } z = x * x; r1 = z * R[0]; z2 = z * z; r2 = R[1] + z * R[2]; z4 = z2 * z2; r = r1 + z2 * r2 + z4 * R[3]; r *= x; s1 = one + z * S[1]; s2 = S[2] + z * S[3]; s3 = S[4] + z * S[5]; s = s1 + z2 * s2 + z4 * s3; return (x * 0.5 + r / s); }
double __ieee754_y1 (double x) { double z, s, c, ss, cc, u, v, u1, u2, v1, v2, v3, z2, z4; int32_t hx, ix, lx; EXTRACT_WORDS (hx, lx, x); ix = 0x7fffffff & hx; /* if Y1(NaN) is NaN, Y1(-inf) is NaN, Y1(inf) is 0 */ if (__glibc_unlikely (ix >= 0x7ff00000)) return one / (x + x * x); if (__glibc_unlikely ((ix | lx) == 0)) return -1 / zero; /* -inf and divide by zero exception. */ /* -inf and overflow exception. */; if (__glibc_unlikely (hx < 0)) return zero / (zero * x); if (ix >= 0x40000000) /* |x| >= 2.0 */ { __sincos (x, &s, &c); ss = -s - c; cc = s - c; if (ix < 0x7fe00000) /* make sure x+x not overflow */ { z = __cos (x + x); if ((s * c) > zero) cc = z / ss; else ss = z / cc; } /* y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x0)+q1(x)*cos(x0)) * where x0 = x-3pi/4 * Better formula: * cos(x0) = cos(x)cos(3pi/4)+sin(x)sin(3pi/4) * = 1/sqrt(2) * (sin(x) - cos(x)) * sin(x0) = sin(x)cos(3pi/4)-cos(x)sin(3pi/4) * = -1/sqrt(2) * (cos(x) + sin(x)) * To avoid cancellation, use * sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x)) * to compute the worse one. */ if (ix > 0x48000000) z = (invsqrtpi * ss) / sqrt (x); else { u = pone (x); v = qone (x); z = invsqrtpi * (u * ss + v * cc) / sqrt (x); } return z; } if (__glibc_unlikely (ix <= 0x3c900000)) /* x < 2**-54 */ { z = -tpi / x; if (isinf (z)) __set_errno (ERANGE); return z; } z = x * x; u1 = U0[0] + z * U0[1]; z2 = z * z; u2 = U0[2] + z * U0[3]; z4 = z2 * z2; u = u1 + z2 * u2 + z4 * U0[4]; v1 = one + z * V0[0]; v2 = V0[1] + z * V0[2]; v3 = V0[3] + z * V0[4]; v = v1 + z2 * v2 + z4 * v3; return (x * (u / v) + tpi * (__ieee754_j1 (x) * __ieee754_log (x) - one / x)); }
double __ieee754_y0(double x) { double z, s,c,ss,cc,u,v,z2,z4,z6,u1,u2,u3,v1,v2; int32_t hx,ix,lx; EXTRACT_WORDS(hx,lx,x); ix = 0x7fffffff&hx; /* Y0(NaN) is NaN, y0(-inf) is Nan, y0(inf) is 0, y0(0) is -inf. */ if(ix>=0x7ff00000) return one/(x+x*x); if((ix|lx)==0) return -HUGE_VAL+x; /* -inf and overflow exception. */ if(hx<0) return zero/(zero*x); if(ix >= 0x40000000) { /* |x| >= 2.0 */ /* y0(x) = sqrt(2/(pi*x))*(p0(x)*sin(x0)+q0(x)*cos(x0)) * where x0 = x-pi/4 * Better formula: * cos(x0) = cos(x)cos(pi/4)+sin(x)sin(pi/4) * = 1/sqrt(2) * (sin(x) + cos(x)) * sin(x0) = sin(x)cos(3pi/4)-cos(x)sin(3pi/4) * = 1/sqrt(2) * (sin(x) - cos(x)) * To avoid cancellation, use * sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x)) * to compute the worse one. */ __sincos (x, &s, &c); ss = s-c; cc = s+c; /* * j0(x) = 1/sqrt(pi) * (P(0,x)*cc - Q(0,x)*ss) / sqrt(x) * y0(x) = 1/sqrt(pi) * (P(0,x)*ss + Q(0,x)*cc) / sqrt(x) */ if(ix<0x7fe00000) { /* make sure x+x not overflow */ z = -__cos(x+x); if ((s*c)<zero) cc = z/ss; else ss = z/cc; } if(ix>0x48000000) z = (invsqrtpi*ss)/__ieee754_sqrt(x); else { u = pzero(x); v = qzero(x); z = invsqrtpi*(u*ss+v*cc)/__ieee754_sqrt(x); } return z; } if(ix<=0x3e400000) { /* x < 2**-27 */ return(U[0] + tpi*__ieee754_log(x)); } z = x*x; #ifdef DO_NOT_USE_THIS u = u00+z*(u01+z*(u02+z*(u03+z*(u04+z*(u05+z*u06))))); v = one+z*(v01+z*(v02+z*(v03+z*v04))); #else u1 = U[0]+z*U[1]; z2=z*z; u2 = U[2]+z*U[3]; z4=z2*z2; u3 = U[4]+z*U[5]; z6=z4*z2; u = u1 + z2*u2 + z4*u3 + z6*U[6]; v1 = one+z*V[0]; v2 = V[1]+z*V[2]; v = v1 + z2*v2 + z4*V[3]; #endif return(u/v + tpi*(__ieee754_j0(x)*__ieee754_log(x))); }
__complex__ double __csin (__complex__ double x) { __complex__ double retval; int negate = signbit (__real__ x); int rcls = fpclassify (__real__ x); int icls = fpclassify (__imag__ x); __real__ x = fabs (__real__ x); if (__glibc_likely (icls >= FP_ZERO)) { /* Imaginary part is finite. */ if (__glibc_likely (rcls >= FP_ZERO)) { /* Real part is finite. */ const int t = (int) ((DBL_MAX_EXP - 1) * M_LN2); double sinix, cosix; if (__glibc_likely (rcls != FP_SUBNORMAL)) { __sincos (__real__ x, &sinix, &cosix); } else { sinix = __real__ x; cosix = 1.0; } if (fabs (__imag__ x) > t) { double exp_t = __ieee754_exp (t); double ix = fabs (__imag__ x); if (signbit (__imag__ x)) cosix = -cosix; ix -= t; sinix *= exp_t / 2.0; cosix *= exp_t / 2.0; if (ix > t) { ix -= t; sinix *= exp_t; cosix *= exp_t; } if (ix > t) { /* Overflow (original imaginary part of x > 3t). */ __real__ retval = DBL_MAX * sinix; __imag__ retval = DBL_MAX * cosix; } else { double exp_val = __ieee754_exp (ix); __real__ retval = exp_val * sinix; __imag__ retval = exp_val * cosix; } } else { __real__ retval = __ieee754_cosh (__imag__ x) * sinix; __imag__ retval = __ieee754_sinh (__imag__ x) * cosix; } if (negate) __real__ retval = -__real__ retval; if (fabs (__real__ retval) < DBL_MIN) { volatile double force_underflow = __real__ retval * __real__ retval; (void) force_underflow; } if (fabs (__imag__ retval) < DBL_MIN) { volatile double force_underflow = __imag__ retval * __imag__ retval; (void) force_underflow; } } else { if (icls == FP_ZERO) { /* Imaginary part is 0.0. */ __real__ retval = __nan (""); __imag__ retval = __imag__ x; if (rcls == FP_INFINITE) feraiseexcept (FE_INVALID); } else { __real__ retval = __nan (""); __imag__ retval = __nan (""); feraiseexcept (FE_INVALID); } } } else if (icls == FP_INFINITE) { /* Imaginary part is infinite. */ if (rcls == FP_ZERO) { /* Real part is 0.0. */ __real__ retval = __copysign (0.0, negate ? -1.0 : 1.0); __imag__ retval = __imag__ x; } else if (rcls > FP_ZERO) { /* Real part is finite. */ double sinix, cosix; if (__glibc_likely (rcls != FP_SUBNORMAL)) { __sincos (__real__ x, &sinix, &cosix); } else { sinix = __real__ x; cosix = 1.0; } __real__ retval = __copysign (HUGE_VAL, sinix); __imag__ retval = __copysign (HUGE_VAL, cosix); if (negate) __real__ retval = -__real__ retval; if (signbit (__imag__ x)) __imag__ retval = -__imag__ retval; } else { /* The addition raises the invalid exception. */ __real__ retval = __nan (""); __imag__ retval = HUGE_VAL; if (rcls == FP_INFINITE) feraiseexcept (FE_INVALID); } } else { if (rcls == FP_ZERO) __real__ retval = __copysign (0.0, negate ? -1.0 : 1.0); else __real__ retval = __nan (""); __imag__ retval = __nan (""); } return retval; }
__complex__ double __cexp (__complex__ double x) { __complex__ double retval; int rcls = fpclassify (__real__ x); int icls = fpclassify (__imag__ x); if (__builtin_expect (rcls >= FP_ZERO, 1)) { /* Real part is finite. */ if (__builtin_expect (icls >= FP_ZERO, 1)) { /* Imaginary part is finite. */ double exp_val = __ieee754_exp (__real__ x); double sinix, cosix; __sincos (__imag__ x, &sinix, &cosix); if (isfinite (exp_val)) { __real__ retval = exp_val * cosix; __imag__ retval = exp_val * sinix; } else { __real__ retval = __copysign (exp_val, cosix); __imag__ retval = __copysign (exp_val, sinix); } } else { /* If the imaginary part is +-inf or NaN and the real part is not +-inf the result is NaN + iNaN. */ __real__ retval = __nan (""); __imag__ retval = __nan (""); feraiseexcept (FE_INVALID); } } else if (__builtin_expect (rcls == FP_INFINITE, 1)) { /* Real part is infinite. */ if (__builtin_expect (icls >= FP_ZERO, 1)) { /* Imaginary part is finite. */ double value = signbit (__real__ x) ? 0.0 : HUGE_VAL; if (icls == FP_ZERO) { /* Imaginary part is 0.0. */ __real__ retval = value; __imag__ retval = __imag__ x; } else { double sinix, cosix; __sincos (__imag__ x, &sinix, &cosix); __real__ retval = __copysign (value, cosix); __imag__ retval = __copysign (value, sinix); } } else if (signbit (__real__ x) == 0) { __real__ retval = HUGE_VAL; __imag__ retval = __nan (""); if (icls == FP_INFINITE) feraiseexcept (FE_INVALID); } else { __real__ retval = 0.0; __imag__ retval = __copysign (0.0, __imag__ x); } } else { /* If the real part is NaN the result is NaN + iNaN. */ __real__ retval = __nan (""); __imag__ retval = __nan (""); if (rcls != FP_NAN || icls != FP_NAN) feraiseexcept (FE_INVALID); } return retval; }
__complex__ double __csinh (__complex__ double x) { __complex__ double retval; int negate = signbit (__real__ x); int rcls = fpclassify (__real__ x); int icls = fpclassify (__imag__ x); __real__ x = fabs (__real__ x); if (rcls >= FP_ZERO) { /* Real part is finite. */ if (icls >= FP_ZERO) { /* Imaginary part is finite. */ double sinh_val = __ieee754_sinh (__real__ x); double cosh_val = __ieee754_cosh (__real__ x); double sinix, cosix; __sincos (__imag__ x, &sinix, &cosix); __real__ retval = sinh_val * cosix; __imag__ retval = cosh_val * sinix; if (negate) __real__ retval = -__real__ retval; } else { if (rcls == FP_ZERO) { /* Real part is 0.0. */ __real__ retval = __copysign (0.0, negate ? -1.0 : 1.0); __imag__ retval = __nan ("") + __nan (""); #ifdef FE_INVALID if (icls == FP_INFINITE) feraiseexcept (FE_INVALID); #endif } else { __real__ retval = __nan (""); __imag__ retval = __nan (""); #ifdef FE_INVALID feraiseexcept (FE_INVALID); #endif } } } else if (rcls == FP_INFINITE) { /* Real part is infinite. */ if (icls == FP_ZERO) { /* Imaginary part is 0.0. */ __real__ retval = negate ? -HUGE_VAL : HUGE_VAL; __imag__ retval = __imag__ x; } else if (icls > FP_ZERO) { /* Imaginary part is finite. */ double sinix, cosix; __sincos (__imag__ x, &sinix, &cosix); __real__ retval = __copysign (HUGE_VAL, cosix); __imag__ retval = __copysign (HUGE_VAL, sinix); if (negate) __real__ retval = -__real__ retval; } else { /* The addition raises the invalid exception. */ __real__ retval = HUGE_VAL; __imag__ retval = __nan ("") + __nan (""); #ifdef FE_INVALID if (icls == FP_INFINITE) feraiseexcept (FE_INVALID); #endif } } else { __real__ retval = __nan (""); __imag__ retval = __imag__ x == 0.0 ? __imag__ x : __nan (""); } return retval; }
__complex__ double __cexp (__complex__ double x) { __complex__ double retval; int rcls = fpclassify (__real__ x); int icls = fpclassify (__imag__ x); if (__builtin_expect (rcls >= FP_ZERO, 1)) { /* Real part is finite. */ if (__builtin_expect (icls >= FP_ZERO, 1)) { /* Imaginary part is finite. */ const int t = (int) ((DBL_MAX_EXP - 1) * M_LN2); double sinix, cosix; if (__builtin_expect (icls != FP_SUBNORMAL, 1)) { __sincos (__imag__ x, &sinix, &cosix); } else { sinix = __imag__ x; cosix = 1.0; } if (__real__ x > t) { double exp_t = __ieee754_exp (t); __real__ x -= t; sinix *= exp_t; cosix *= exp_t; if (__real__ x > t) { __real__ x -= t; sinix *= exp_t; cosix *= exp_t; } } if (__real__ x > t) { /* Overflow (original real part of x > 3t). */ __real__ retval = DBL_MAX * cosix; __imag__ retval = DBL_MAX * sinix; } else { double exp_val = __ieee754_exp (__real__ x); __real__ retval = exp_val * cosix; __imag__ retval = exp_val * sinix; } if (fabs (__real__ retval) < DBL_MIN) { volatile double force_underflow = __real__ retval * __real__ retval; (void) force_underflow; } if (fabs (__imag__ retval) < DBL_MIN) { volatile double force_underflow = __imag__ retval * __imag__ retval; (void) force_underflow; } } else { /* If the imaginary part is +-inf or NaN and the real part is not +-inf the result is NaN + iNaN. */ __real__ retval = __nan (""); __imag__ retval = __nan (""); feraiseexcept (FE_INVALID); } } else if (__builtin_expect (rcls == FP_INFINITE, 1)) { /* Real part is infinite. */ if (__builtin_expect (icls >= FP_ZERO, 1)) { /* Imaginary part is finite. */ double value = signbit (__real__ x) ? 0.0 : HUGE_VAL; if (icls == FP_ZERO) { /* Imaginary part is 0.0. */ __real__ retval = value; __imag__ retval = __imag__ x; } else { double sinix, cosix; if (__builtin_expect (icls != FP_SUBNORMAL, 1)) { __sincos (__imag__ x, &sinix, &cosix); } else { sinix = __imag__ x; cosix = 1.0; } __real__ retval = __copysign (value, cosix); __imag__ retval = __copysign (value, sinix); } } else if (signbit (__real__ x) == 0) { __real__ retval = HUGE_VAL; __imag__ retval = __nan (""); if (icls == FP_INFINITE) feraiseexcept (FE_INVALID); } else { __real__ retval = 0.0; __imag__ retval = __copysign (0.0, __imag__ x); } } else { /* If the real part is NaN the result is NaN + iNaN. */ __real__ retval = __nan (""); __imag__ retval = __nan (""); if (rcls != FP_NAN || icls != FP_NAN) feraiseexcept (FE_INVALID); } return retval; }