__complex__ float
__kernel_casinhf (__complex__ float x, int adj)
{
__complex__ float res;
float rx, ix;
__complex__ float y;
/* Avoid cancellation by reducing to the first quadrant. */
rx = fabsf (__real__ x);
ix = fabsf (__imag__ x);
if (rx >= 1.0f / FLT_EPSILON || ix >= 1.0f / FLT_EPSILON)
{
/* For large x in the first quadrant, x + csqrt (1 + x * x)
is sufficiently close to 2 * x to make no significant
difference to the result; avoid possible overflow from
the squaring and addition. */
__real__ y = rx;
__imag__ y = ix;
if (adj)
{
float t = __real__ y;
__real__ y = __copysignf (__imag__ y, __imag__ x);
__imag__ y = t;
}
res = __clogf (y);
__real__ res += (float) M_LN2;
}
else
{
__real__ y = (rx - ix) * (rx + ix) + 1.0;
__imag__ y = 2.0 * rx * ix;
y = __csqrtf (y);
__real__ y += rx;
__imag__ y += ix;
if (adj)
{
float t = __real__ y;
__real__ y = __copysignf (__imag__ y, __imag__ x);
__imag__ y = t;
}
res = __clogf (y);
}
/* Give results the correct sign for the original argument. */
__real__ res = __copysignf (__real__ res, __real__ x);
__imag__ res = __copysignf (__imag__ res, (adj ? 1.0f : __imag__ x));
return res;
}
__complex__ float
__casinhf (__complex__ float x)
{
__complex__ float res;
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
if (rcls <= FP_INFINITE || icls <= FP_INFINITE)
{
if (icls == FP_INFINITE)
{
__real__ res = __copysignf (HUGE_VALF, __real__ x);
if (rcls == FP_NAN)
__imag__ res = __nanf ("");
else
__imag__ res = __copysignf (rcls >= FP_ZERO ? M_PI_2 : M_PI_4,
__imag__ x);
}
else if (rcls <= FP_INFINITE)
{
__real__ res = __real__ x;
if ((rcls == FP_INFINITE && icls >= FP_ZERO)
|| (rcls == FP_NAN && icls == FP_ZERO))
__imag__ res = __copysignf (0.0, __imag__ x);
else
__imag__ res = __nanf ("");
}
else
{
__real__ res = __nanf ("");
__imag__ res = __nanf ("");
}
}
else if (rcls == FP_ZERO && icls == FP_ZERO)
{
res = x;
}
else
{
__complex__ float y;
__real__ y = (__real__ x - __imag__ x) * (__real__ x + __imag__ x) + 1.0;
__imag__ y = 2.0 * __real__ x * __imag__ x;
y = __csqrtf (y);
__real__ y += __real__ x;
__imag__ y += __imag__ x;
res = __clogf (y);
}
return res;
}
__complex__ float
__catanhf (__complex__ float x)
{
__complex__ float res;
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
if (__builtin_expect (rcls <= FP_INFINITE || icls <= FP_INFINITE, 0))
{
if (icls == FP_INFINITE)
{
__real__ res = __copysignf (0.0, __real__ x);
__imag__ res = __copysignf (M_PI_2, __imag__ x);
}
else if (rcls == FP_INFINITE || rcls == FP_ZERO)
{
__real__ res = __copysignf (0.0, __real__ x);
if (icls >= FP_ZERO)
__imag__ res = __copysignf (M_PI_2, __imag__ x);
else
__imag__ res = __nanf ("");
}
else
{
__real__ res = __nanf ("");
__imag__ res = __nanf ("");
}
}
else if (__builtin_expect (rcls == FP_ZERO && icls == FP_ZERO, 0))
{
res = x;
}
else
{
float i2 = __imag__ x * __imag__ x;
float num = 1.0 + __real__ x;
num = i2 + num * num;
float den = 1.0 - __real__ x;
den = i2 + den * den;
__real__ res = 0.25 * (__ieee754_logf (num) - __ieee754_logf (den));
den = 1 - __real__ x * __real__ x - i2;
__imag__ res = 0.5 * __ieee754_atan2f (2.0 * __imag__ x, den);
}
return res;
}
float
__asinhf(float x)
{
float w;
int32_t hx,ix;
GET_FLOAT_WORD(hx,x);
ix = hx&0x7fffffff;
if(__builtin_expect(ix< 0x38000000, 0)) { /* |x|<2**-14 */
math_check_force_underflow (x);
if(huge+x>one) return x; /* return x inexact except 0 */
}
if(__builtin_expect(ix>0x47000000, 0)) { /* |x| > 2**14 */
if(ix>=0x7f800000) return x+x; /* x is inf or NaN */
w = __ieee754_logf(fabsf(x))+ln2;
} else {
float xa = fabsf(x);
if (ix>0x40000000) { /* 2**14 > |x| > 2.0 */
w = __ieee754_logf(2.0f*xa+one/(__ieee754_sqrtf(xa*xa+one)+xa));
} else { /* 2.0 > |x| > 2**-14 */
float t = xa*xa;
w =__log1pf(xa+t/(one+__ieee754_sqrtf(one+t)));
}
}
return __copysignf(w, x);
}
float
__ieee754_atanhf (float x)
{
float xa = fabsf (x);
float t;
if (isless (xa, 0.5f))
{
if (__builtin_expect (xa < 0x1.0p-28f, 0))
{
math_force_eval (huge + x);
return x;
}
t = xa + xa;
t = 0.5f * __log1pf (t + t * xa / (1.0f - xa));
}
else if (__builtin_expect (isless (xa, 1.0f), 1))
t = 0.5f * __log1pf ((xa + xa) / (1.0f - xa));
else
{
if (isgreater (xa, 1.0f))
return (x - x) / (x - x);
return x / 0.0f;
}
return __copysignf (t, x);
}
float
__ieee754_atanhf (float x)
{
float xa = fabsf (x);
float t;
if (isless (xa, 0.5f))
{
if (__glibc_unlikely (xa < 0x1.0p-28f))
{
math_force_eval (huge + x);
if (fabsf (x) < FLT_MIN)
{
float force_underflow = x * x;
math_force_eval (force_underflow);
}
return x;
}
t = xa + xa;
t = 0.5f * __log1pf (t + t * xa / (1.0f - xa));
}
else if (__glibc_likely (isless (xa, 1.0f)))
t = 0.5f * __log1pf ((xa + xa) / (1.0f - xa));
else
{
if (isgreater (xa, 1.0f))
return (x - x) / (x - x);
return x / 0.0f;
}
return __copysignf (t, x);
}
__complex__ float
__clog10f (__complex__ float x)
{
__complex__ float result;
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
if (rcls == FP_ZERO && icls == FP_ZERO)
{
/* Real and imaginary part are 0.0. */
__imag__ result = signbit (__real__ x) ? M_PI : 0.0;
__imag__ result = __copysignf (__imag__ result, __imag__ x);
/* Yes, the following line raises an exception. */
__real__ result = -1.0 / fabsf (__real__ x);
}
else if (rcls != FP_NAN && icls != FP_NAN)
{
/* Neither real nor imaginary part is NaN. */
__real__ result = __ieee754_log10f (__ieee754_hypotf (__real__ x,
__imag__ x));
__imag__ result = M_LOG10E * __ieee754_atan2f (__imag__ x, __real__ x);
}
else
{
__imag__ result = __nanf ("");
if (rcls == FP_INFINITE || icls == FP_INFINITE)
/* Real or imaginary part is infinite. */
__real__ result = HUGE_VALF;
else
__real__ result = __nanf ("");
}
return result;
}
__complex__ float
__ctanf (__complex__ float x)
{
__complex__ float res;
if (!isfinite (__real__ x) || !isfinite (__imag__ x))
{
if (__isinff (__imag__ x))
{
__real__ res = __copysignf (0.0, __real__ x);
__imag__ res = __copysignf (1.0, __imag__ x);
}
else if (__real__ x == 0.0)
{
res = x;
}
else
{
__real__ res = __nanf ("");
__imag__ res = __nanf ("");
#ifdef FE_INVALID
if (__isinff (__real__ x))
feraiseexcept (FE_INVALID);
#endif
}
}
else
{
float sin2rx, cos2rx;
float den;
__sincosf (2.0 * __real__ x, &sin2rx, &cos2rx);
den = cos2rx + __ieee754_coshf (2.0 * __imag__ x);
__real__ res = sin2rx / den;
__imag__ res = __ieee754_sinhf (2.0 * __imag__ x) / den;
}
return res;
}
__complex__ float
__clog10f (__complex__ float x)
{
__complex__ float result;
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
if (__builtin_expect (rcls == FP_ZERO && icls == FP_ZERO, 0))
{
/* Real and imaginary part are 0.0. */
__imag__ result = signbit (__real__ x) ? M_PI : 0.0;
__imag__ result = __copysignf (__imag__ result, __imag__ x);
/* Yes, the following line raises an exception. */
__real__ result = -1.0 / fabsf (__real__ x);
}
else if (__builtin_expect (rcls != FP_NAN && icls != FP_NAN, 1))
{
/* Neither real nor imaginary part is NaN. */
float d;
int scale = 0;
if (fabsf (__real__ x) > FLT_MAX / 2.0f
|| fabsf (__imag__ x) > FLT_MAX / 2.0f)
{
scale = -1;
__real__ x = __scalbnf (__real__ x, scale);
__imag__ x = __scalbnf (__imag__ x, scale);
}
else if (fabsf (__real__ x) < FLT_MIN
&& fabsf (__imag__ x) < FLT_MIN)
{
scale = FLT_MANT_DIG;
__real__ x = __scalbnf (__real__ x, scale);
__imag__ x = __scalbnf (__imag__ x, scale);
}
d = __ieee754_hypotf (__real__ x, __imag__ x);
__real__ result = __ieee754_log10f (d) - scale * M_LOG10_2f;
__imag__ result = M_LOG10E * __ieee754_atan2f (__imag__ x, __real__ x);
}
else
{
__imag__ result = __nanf ("");
if (rcls == FP_INFINITE || icls == FP_INFINITE)
/* Real or imaginary part is infinite. */
__real__ result = HUGE_VALF;
else
__real__ result = __nanf ("");
}
return result;
}
__complex__ float
__cprojf (__complex__ float x)
{
if (__isinf_nsf (__real__ x) || __isinf_nsf (__imag__ x))
{
__complex__ float res;
__real__ res = INFINITY;
__imag__ res = __copysignf (0.0, __imag__ x);
return res;
}
return x;
}
__complex__ float
__cprojf (__complex__ float x)
{
if (isnan (__real__ x) && isnan (__imag__ x))
return x;
else if (!isfinite (__real__ x) || !isfinite (__imag__ x))
{
__complex__ float res;
__real__ res = INFINITY;
__imag__ res = __copysignf (0.0, __imag__ x);
return res;
}
return x;
}
__complex__ float
__casinf (__complex__ float x)
{
__complex__ float res;
if (isnan (__real__ x) || isnan (__imag__ x))
{
if (__real__ x == 0.0)
{
res = x;
}
else if (isinf (__real__ x) || isinf (__imag__ x))
{
__real__ res = __nanf ("");
__imag__ res = __copysignf (HUGE_VALF, __imag__ x);
}
else
{
__real__ res = __nanf ("");
__imag__ res = __nanf ("");
}
}
else
{
__complex__ float y;
__real__ y = -__imag__ x;
__imag__ y = __real__ x;
y = __casinhf (y);
__real__ res = __imag__ y;
__imag__ res = -__real__ y;
}
return res;
}
__complex__ float
__cacoshf (__complex__ float x)
{
__complex__ float res;
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
if (rcls <= FP_INFINITE || icls <= FP_INFINITE)
{
if (icls == FP_INFINITE)
{
__real__ res = HUGE_VALF;
if (rcls == FP_NAN)
__imag__ res = __nanf ("");
else
__imag__ res = __copysignf ((rcls == FP_INFINITE
? (__real__ x < 0.0
? M_PI - M_PI_4 : M_PI_4)
: M_PI_2), __imag__ x);
}
else if (rcls == FP_INFINITE)
{
__real__ res = HUGE_VALF;
if (icls >= FP_ZERO)
__imag__ res = __copysignf (signbit (__real__ x) ? M_PI : 0.0,
__imag__ x);
else
__imag__ res = __nanf ("");
}
else
{
__real__ res = __nanf ("");
__imag__ res = __nanf ("");
}
}
else if (rcls == FP_ZERO && icls == FP_ZERO)
{
__real__ res = 0.0;
__imag__ res = __copysignf (M_PI_2, __imag__ x);
}
else
{
#if 1
__complex__ float y;
__real__ y = (__real__ x - __imag__ x) * (__real__ x + __imag__ x) - 1.0;
__imag__ y = 2.0 * __real__ x * __imag__ x;
y = __csqrtf (y);
if (__real__ x < 0.0)
y = -y;
__real__ y += __real__ x;
__imag__ y += __imag__ x;
res = __clogf (y);
#else
float re2 = __real__ x * __real__ x;
float im2 = __imag__ x * __imag__ x;
float sq = re2 - im2 - 1.0;
float ro = __ieee754_sqrtf (sq * sq + 4 * re2 * im2);
float a = __ieee754_sqrtf ((sq + ro) / 2.0);
float b = __ieee754_sqrtf ((-sq + ro) / 2.0);
__real__ res = 0.5 * __ieee754_logf (re2 + __real__ x * 2 * a
+ im2 + __imag__ x * 2 * b
+ ro);
__imag__ res = __ieee754_atan2f (__imag__ x + b, __real__ x + a);
#endif
/* We have to use the positive branch. */
if (__real__ res < 0.0)
res = -res;
}
return res;
}
__complex__ float
__csinhf (__complex__ float x)
{
__complex__ float retval;
int negate = signbit (__real__ x);
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
__real__ x = fabsf (__real__ x);
if (rcls >= FP_ZERO)
{
/* Real part is finite. */
if (icls >= FP_ZERO)
{
/* Imaginary part is finite. */
float sinh_val = __ieee754_sinhf (__real__ x);
float cosh_val = __ieee754_coshf (__real__ x);
float sinix, cosix;
__sincosf (__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 = __copysignf (0.0, negate ? -1.0 : 1.0);
__imag__ retval = __nanf ("") + __nanf ("");
#ifdef FE_INVALID
if (icls == FP_INFINITE)
feraiseexcept (FE_INVALID);
#endif
}
else
{
__real__ retval = __nanf ("");
__imag__ retval = __nanf ("");
#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_VALF : HUGE_VALF;
__imag__ retval = __imag__ x;
}
else if (icls > FP_ZERO)
{
/* Imaginary part is finite. */
float sinix, cosix;
__sincosf (__imag__ x, &sinix, &cosix);
__real__ retval = __copysignf (HUGE_VALF, cosix);
__imag__ retval = __copysignf (HUGE_VALF, sinix);
if (negate)
__real__ retval = -__real__ retval;
}
else
{
/* The addition raises the invalid exception. */
__real__ retval = HUGE_VALF;
__imag__ retval = __nanf ("") + __nanf ("");
#ifdef FE_INVALID
if (icls == FP_INFINITE)
feraiseexcept (FE_INVALID);
#endif
}
}
else
{
__real__ retval = __nanf ("");
__imag__ retval = __imag__ x == 0.0 ? __imag__ x : __nanf ("");
}
return retval;
}
__complex__ float
__csinhf (__complex__ float x)
{
__complex__ float retval;
int negate = signbit (__real__ x);
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
__real__ x = fabsf (__real__ 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) ((FLT_MAX_EXP - 1) * M_LN2);
float sinix, cosix;
if (__builtin_expect (icls != FP_SUBNORMAL, 1))
{
__sincosf (__imag__ x, &sinix, &cosix);
}
else
{
sinix = __imag__ x;
cosix = 1.0f;
}
if (fabsf (__real__ x) > t)
{
float exp_t = __ieee754_expf (t);
float rx = fabsf (__real__ x);
if (signbit (__real__ x))
cosix = -cosix;
rx -= t;
sinix *= exp_t / 2.0f;
cosix *= exp_t / 2.0f;
if (rx > t)
{
rx -= t;
sinix *= exp_t;
cosix *= exp_t;
}
if (rx > t)
{
/* Overflow (original real part of x > 3t). */
__real__ retval = FLT_MAX * cosix;
__imag__ retval = FLT_MAX * sinix;
}
else
{
float exp_val = __ieee754_expf (rx);
__real__ retval = exp_val * cosix;
__imag__ retval = exp_val * sinix;
}
}
else
{
__real__ retval = __ieee754_sinhf (__real__ x) * cosix;
__imag__ retval = __ieee754_coshf (__real__ x) * sinix;
}
if (negate)
__real__ retval = -__real__ retval;
if (fabsf (__real__ retval) < FLT_MIN)
{
volatile float force_underflow
= __real__ retval * __real__ retval;
(void) force_underflow;
}
if (fabsf (__imag__ retval) < FLT_MIN)
{
volatile float force_underflow
= __imag__ retval * __imag__ retval;
(void) force_underflow;
}
}
else
{
if (rcls == FP_ZERO)
{
/* Real part is 0.0. */
__real__ retval = __copysignf (0.0, negate ? -1.0 : 1.0);
__imag__ retval = __nanf ("") + __nanf ("");
if (icls == FP_INFINITE)
feraiseexcept (FE_INVALID);
}
else
{
__real__ retval = __nanf ("");
__imag__ retval = __nanf ("");
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. */
float sinix, cosix;
if (__builtin_expect (icls != FP_SUBNORMAL, 1))
{
__sincosf (__imag__ x, &sinix, &cosix);
}
else
{
sinix = __imag__ x;
cosix = 1.0f;
}
__real__ retval = __copysignf (HUGE_VALF, cosix);
__imag__ retval = __copysignf (HUGE_VALF, sinix);
if (negate)
__real__ retval = -__real__ retval;
}
else if (icls == FP_ZERO)
{
/* Imaginary part is 0.0. */
__real__ retval = negate ? -HUGE_VALF : HUGE_VALF;
__imag__ retval = __imag__ x;
}
else
{
/* The addition raises the invalid exception. */
__real__ retval = HUGE_VALF;
__imag__ retval = __nanf ("") + __nanf ("");
#ifdef FE_INVALID
if (icls == FP_INFINITE)
feraiseexcept (FE_INVALID);
#endif
}
}
else
{
__real__ retval = __nanf ("");
__imag__ retval = __imag__ x == 0.0 ? __imag__ x : __nanf ("");
}
return retval;
}
__complex__ float
__clog10f (__complex__ float x)
{
__complex__ float result;
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
if (__glibc_unlikely (rcls == FP_ZERO && icls == FP_ZERO))
{
/* Real and imaginary part are 0.0. */
__imag__ result = signbit (__real__ x) ? M_PI_LOG10Ef : 0.0;
__imag__ result = __copysignf (__imag__ result, __imag__ x);
/* Yes, the following line raises an exception. */
__real__ result = -1.0 / fabsf (__real__ x);
}
else if (__glibc_likely (rcls != FP_NAN && icls != FP_NAN))
{
/* Neither real nor imaginary part is NaN. */
float absx = fabsf (__real__ x), absy = fabsf (__imag__ x);
int scale = 0;
if (absx < absy)
{
float t = absx;
absx = absy;
absy = t;
}
if (absx > FLT_MAX / 2.0f)
{
scale = -1;
absx = __scalbnf (absx, scale);
absy = (absy >= FLT_MIN * 2.0f ? __scalbnf (absy, scale) : 0.0f);
}
else if (absx < FLT_MIN && absy < FLT_MIN)
{
scale = FLT_MANT_DIG;
absx = __scalbnf (absx, scale);
absy = __scalbnf (absy, scale);
}
if (absx == 1.0f && scale == 0)
{
float absy2 = absy * absy;
if (absy2 <= FLT_MIN * 2.0f * (float) M_LN10)
{
float force_underflow = absy2 * absy2;
__real__ result = absy2 * ((float) M_LOG10E / 2.0f);
math_force_eval (force_underflow);
}
else
__real__ result = __log1pf (absy2) * ((float) M_LOG10E / 2.0f);
}
else if (absx > 1.0f && absx < 2.0f && absy < 1.0f && scale == 0)
{
float d2m1 = (absx - 1.0f) * (absx + 1.0f);
if (absy >= FLT_EPSILON)
d2m1 += absy * absy;
__real__ result = __log1pf (d2m1) * ((float) M_LOG10E / 2.0f);
}
else if (absx < 1.0f
&& absx >= 0.75f
&& absy < FLT_EPSILON / 2.0f
&& scale == 0)
{
float d2m1 = (absx - 1.0f) * (absx + 1.0f);
__real__ result = __log1pf (d2m1) * ((float) M_LOG10E / 2.0f);
}
else if (absx < 1.0f && (absx >= 0.75f || absy >= 0.5f) && scale == 0)
{
float d2m1 = __x2y2m1f (absx, absy);
__real__ result = __log1pf (d2m1) * ((float) M_LOG10E / 2.0f);
}
else
{
float d = __ieee754_hypotf (absx, absy);
__real__ result = __ieee754_log10f (d) - scale * M_LOG10_2f;
}
__imag__ result = M_LOG10E * __ieee754_atan2f (__imag__ x, __real__ x);
}
else
{
__imag__ result = __nanf ("");
if (rcls == FP_INFINITE || icls == FP_INFINITE)
/* Real or imaginary part is infinite. */
__real__ result = HUGE_VALF;
else
__real__ result = __nanf ("");
}
return result;
}
__complex__ float
__ctanf (__complex__ float x)
{
__complex__ float res;
if (__glibc_unlikely (!isfinite (__real__ x) || !isfinite (__imag__ x)))
{
if (isinf (__imag__ x))
{
if (isfinite (__real__ x) && fabsf (__real__ x) > 1.0f)
{
float sinrx, cosrx;
__sincosf (__real__ x, &sinrx, &cosrx);
__real__ res = __copysignf (0.0f, sinrx * cosrx);
}
else
__real__ res = __copysignf (0.0, __real__ x);
__imag__ res = __copysignf (1.0, __imag__ x);
}
else if (__real__ x == 0.0)
{
res = x;
}
else
{
__real__ res = __nanf ("");
__imag__ res = __nanf ("");
if (isinf (__real__ x))
feraiseexcept (FE_INVALID);
}
}
else
{
float sinrx, cosrx;
float den;
const int t = (int) ((FLT_MAX_EXP - 1) * M_LN2 / 2);
/* tan(x+iy) = (sin(2x) + i*sinh(2y))/(cos(2x) + cosh(2y))
= (sin(x)*cos(x) + i*sinh(y)*cosh(y)/(cos(x)^2 + sinh(y)^2). */
if (__glibc_likely (fabsf (__real__ x) > FLT_MIN))
{
__sincosf (__real__ x, &sinrx, &cosrx);
}
else
{
sinrx = __real__ x;
cosrx = 1.0f;
}
if (fabsf (__imag__ x) > t)
{
/* Avoid intermediate overflow when the real part of the
result may be subnormal. Ignoring negligible terms, the
imaginary part is +/- 1, the real part is
sin(x)*cos(x)/sinh(y)^2 = 4*sin(x)*cos(x)/exp(2y). */
float exp_2t = __ieee754_expf (2 * t);
__imag__ res = __copysignf (1.0, __imag__ x);
__real__ res = 4 * sinrx * cosrx;
__imag__ x = fabsf (__imag__ x);
__imag__ x -= t;
__real__ res /= exp_2t;
if (__imag__ x > t)
{
/* Underflow (original imaginary part of x has absolute
value > 2t). */
__real__ res /= exp_2t;
}
else
__real__ res /= __ieee754_expf (2 * __imag__ x);
}
else
{
float sinhix, coshix;
if (fabsf (__imag__ x) > FLT_MIN)
{
sinhix = __ieee754_sinhf (__imag__ x);
coshix = __ieee754_coshf (__imag__ x);
}
else
{
sinhix = __imag__ x;
coshix = 1.0f;
}
if (fabsf (sinhix) > fabsf (cosrx) * FLT_EPSILON)
den = cosrx * cosrx + sinhix * sinhix;
else
den = cosrx * cosrx;
__real__ res = sinrx * cosrx / den;
__imag__ res = sinhix * coshix / den;
}
math_check_force_underflow_complex (res);
}
return res;
}
__complex__ float
__catanf (__complex__ float x)
{
__complex__ float res;
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
if (__glibc_unlikely (rcls <= FP_INFINITE || icls <= FP_INFINITE))
{
if (rcls == FP_INFINITE)
{
__real__ res = __copysignf (M_PI_2, __real__ x);
__imag__ res = __copysignf (0.0, __imag__ x);
}
else if (icls == FP_INFINITE)
{
if (rcls >= FP_ZERO)
__real__ res = __copysignf (M_PI_2, __real__ x);
else
__real__ res = __nanf ("");
__imag__ res = __copysignf (0.0, __imag__ x);
}
else if (icls == FP_ZERO || icls == FP_INFINITE)
{
__real__ res = __nanf ("");
__imag__ res = __copysignf (0.0, __imag__ x);
}
else
{
__real__ res = __nanf ("");
__imag__ res = __nanf ("");
}
}
else if (__glibc_unlikely (rcls == FP_ZERO && icls == FP_ZERO))
{
res = x;
}
else
{
if (fabsf (__real__ x) >= 16.0f / FLT_EPSILON
|| fabsf (__imag__ x) >= 16.0f / FLT_EPSILON)
{
__real__ res = __copysignf ((float) M_PI_2, __real__ x);
if (fabsf (__real__ x) <= 1.0f)
__imag__ res = 1.0f / __imag__ x;
else if (fabsf (__imag__ x) <= 1.0f)
__imag__ res = __imag__ x / __real__ x / __real__ x;
else
{
float h = __ieee754_hypotf (__real__ x / 2.0f,
__imag__ x / 2.0f);
__imag__ res = __imag__ x / h / h / 4.0f;
}
}
else
{
float den, absx, absy;
absx = fabsf (__real__ x);
absy = fabsf (__imag__ x);
if (absx < absy)
{
float t = absx;
absx = absy;
absy = t;
}
if (absy < FLT_EPSILON / 2.0f)
{
den = (1.0f - absx) * (1.0f + absx);
if (den == -0.0f)
den = 0.0f;
}
else if (absx >= 1.0f)
den = (1.0f - absx) * (1.0f + absx) - absy * absy;
else if (absx >= 0.75f || absy >= 0.5f)
den = -__x2y2m1f (absx, absy);
else
den = (1.0f - absx) * (1.0f + absx) - absy * absy;
__real__ res = 0.5f * __ieee754_atan2f (2.0f * __real__ x, den);
if (fabsf (__imag__ x) == 1.0f
&& fabsf (__real__ x) < FLT_EPSILON * FLT_EPSILON)
__imag__ res = (__copysignf (0.5f, __imag__ x)
* ((float) M_LN2
- __ieee754_logf (fabsf (__real__ x))));
else
{
float r2 = 0.0f, num, f;
if (fabsf (__real__ x) >= FLT_EPSILON * FLT_EPSILON)
r2 = __real__ x * __real__ x;
num = __imag__ x + 1.0f;
num = r2 + num * num;
den = __imag__ x - 1.0f;
den = r2 + den * den;
f = num / den;
if (f < 0.5f)
__imag__ res = 0.25f * __ieee754_logf (f);
else
{
num = 4.0f * __imag__ x;
__imag__ res = 0.25f * __log1pf (num / den);
}
}
}
if (fabsf (__real__ res) < FLT_MIN)
{
volatile float force_underflow = __real__ res * __real__ res;
(void) force_underflow;
}
if (fabsf (__imag__ res) < FLT_MIN)
{
volatile float force_underflow = __imag__ res * __imag__ res;
(void) force_underflow;
}
}
return res;
}
__complex__ float
__cexpf (__complex__ float x)
{
__complex__ float retval;
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
if (__glibc_likely (rcls >= FP_ZERO))
{
/* Real part is finite. */
if (__glibc_likely (icls >= FP_ZERO))
{
/* Imaginary part is finite. */
const int t = (int) ((FLT_MAX_EXP - 1) * M_LN2);
float sinix, cosix;
if (__glibc_likely (icls != FP_SUBNORMAL))
{
__sincosf (__imag__ x, &sinix, &cosix);
}
else
{
sinix = __imag__ x;
cosix = 1.0f;
}
if (__real__ x > t)
{
float exp_t = __ieee754_expf (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 = FLT_MAX * cosix;
__imag__ retval = FLT_MAX * sinix;
}
else
{
float exp_val = __ieee754_expf (__real__ x);
__real__ retval = exp_val * cosix;
__imag__ retval = exp_val * sinix;
}
if (fabsf (__real__ retval) < FLT_MIN)
{
volatile float force_underflow
= __real__ retval * __real__ retval;
(void) force_underflow;
}
if (fabsf (__imag__ retval) < FLT_MIN)
{
volatile float 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 = __nanf ("");
__imag__ retval = __nanf ("");
feraiseexcept (FE_INVALID);
}
}
else if (__glibc_likely (rcls == FP_INFINITE))
{
/* Real part is infinite. */
if (__glibc_likely (icls >= FP_ZERO))
{
/* Imaginary part is finite. */
float value = signbit (__real__ x) ? 0.0 : HUGE_VALF;
if (icls == FP_ZERO)
{
/* Imaginary part is 0.0. */
__real__ retval = value;
__imag__ retval = __imag__ x;
}
else
{
float sinix, cosix;
if (__glibc_likely (icls != FP_SUBNORMAL))
{
__sincosf (__imag__ x, &sinix, &cosix);
}
else
{
sinix = __imag__ x;
cosix = 1.0f;
}
__real__ retval = __copysignf (value, cosix);
__imag__ retval = __copysignf (value, sinix);
}
}
else if (signbit (__real__ x) == 0)
{
__real__ retval = HUGE_VALF;
__imag__ retval = __nanf ("");
if (icls == FP_INFINITE)
feraiseexcept (FE_INVALID);
}
else
{
__real__ retval = 0.0;
__imag__ retval = __copysignf (0.0, __imag__ x);
}
}
else
{
/* If the real part is NaN the result is NaN + iNaN unless the
imaginary part is zero. */
__real__ retval = __nanf ("");
if (icls == FP_ZERO)
__imag__ retval = __imag__ x;
else
{
__imag__ retval = __nanf ("");
if (rcls != FP_NAN || icls != FP_NAN)
feraiseexcept (FE_INVALID);
}
}
return retval;
}
__complex__ float
__ccoshf (__complex__ float x)
{
__complex__ float retval;
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
if (__glibc_likely (rcls >= FP_ZERO))
{
/* Real part is finite. */
if (__glibc_likely (icls >= FP_ZERO))
{
/* Imaginary part is finite. */
const int t = (int) ((FLT_MAX_EXP - 1) * M_LN2);
float sinix, cosix;
if (__glibc_likely (fabsf (__imag__ x) > FLT_MIN))
{
__sincosf (__imag__ x, &sinix, &cosix);
}
else
{
sinix = __imag__ x;
cosix = 1.0f;
}
if (fabsf (__real__ x) > t)
{
float exp_t = __ieee754_expf (t);
float rx = fabsf (__real__ x);
if (signbit (__real__ x))
sinix = -sinix;
rx -= t;
sinix *= exp_t / 2.0f;
cosix *= exp_t / 2.0f;
if (rx > t)
{
rx -= t;
sinix *= exp_t;
cosix *= exp_t;
}
if (rx > t)
{
/* Overflow (original real part of x > 3t). */
__real__ retval = FLT_MAX * cosix;
__imag__ retval = FLT_MAX * sinix;
}
else
{
float exp_val = __ieee754_expf (rx);
__real__ retval = exp_val * cosix;
__imag__ retval = exp_val * sinix;
}
}
else
{
__real__ retval = __ieee754_coshf (__real__ x) * cosix;
__imag__ retval = __ieee754_sinhf (__real__ x) * sinix;
}
math_check_force_underflow_complex (retval);
}
else
{
__imag__ retval = __real__ x == 0.0 ? 0.0 : __nanf ("");
__real__ retval = __nanf ("");
if (icls == FP_INFINITE)
feraiseexcept (FE_INVALID);
}
}
else if (rcls == FP_INFINITE)
{
/* Real part is infinite. */
if (__glibc_likely (icls > FP_ZERO))
{
/* Imaginary part is finite. */
float sinix, cosix;
if (__glibc_likely (fabsf (__imag__ x) > FLT_MIN))
{
__sincosf (__imag__ x, &sinix, &cosix);
}
else
{
sinix = __imag__ x;
cosix = 1.0f;
}
__real__ retval = __copysignf (HUGE_VALF, cosix);
__imag__ retval = (__copysignf (HUGE_VALF, sinix)
* __copysignf (1.0, __real__ x));
}
else if (icls == FP_ZERO)
{
/* Imaginary part is 0.0. */
__real__ retval = HUGE_VALF;
__imag__ retval = __imag__ x * __copysignf (1.0, __real__ x);
}
else
{
/* The addition raises the invalid exception. */
__real__ retval = HUGE_VALF;
__imag__ retval = __nanf ("") + __nanf ("");
if (icls == FP_INFINITE)
feraiseexcept (FE_INVALID);
}
}
else
{
__real__ retval = __nanf ("");
__imag__ retval = __imag__ x == 0.0 ? __imag__ x : __nanf ("");
}
return retval;
}
__complex__ float
__csqrtf (__complex__ float x)
{
__complex__ float res;
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
if (__builtin_expect (rcls <= FP_INFINITE || icls <= FP_INFINITE, 0))
{
if (icls == FP_INFINITE)
{
__real__ res = HUGE_VALF;
__imag__ res = __imag__ x;
}
else if (rcls == FP_INFINITE)
{
if (__real__ x < 0.0)
{
__real__ res = icls == FP_NAN ? __nanf ("") : 0;
__imag__ res = __copysignf (HUGE_VALF, __imag__ x);
}
else
{
__real__ res = __real__ x;
__imag__ res = (icls == FP_NAN
? __nanf ("") : __copysignf (0.0, __imag__ x));
}
}
else
{
__real__ res = __nanf ("");
__imag__ res = __nanf ("");
}
}
else
{
if (__builtin_expect (icls == FP_ZERO, 0))
{
if (__real__ x < 0.0)
{
__real__ res = 0.0;
__imag__ res = __copysignf (__ieee754_sqrtf (-__real__ x),
__imag__ x);
}
else
{
__real__ res = fabsf (__ieee754_sqrtf (__real__ x));
__imag__ res = __copysignf (0.0, __imag__ x);
}
}
else if (__builtin_expect (rcls == FP_ZERO, 0))
{
float r;
if (fabsf (__imag__ x) >= 2.0f * FLT_MIN)
r = __ieee754_sqrtf (0.5f * fabsf (__imag__ x));
else
r = 0.5f * __ieee754_sqrtf (2.0f * fabsf (__imag__ x));
__real__ res = r;
__imag__ res = __copysignf (r, __imag__ x);
}
else
{
float d, r, s;
int scale = 0;
if (fabsf (__real__ x) > FLT_MAX / 4.0f)
{
scale = 1;
__real__ x = __scalbnf (__real__ x, -2 * scale);
__imag__ x = __scalbnf (__imag__ x, -2 * scale);
}
else if (fabsf (__imag__ x) > FLT_MAX / 4.0f)
{
scale = 1;
if (fabsf (__real__ x) >= 4.0f * FLT_MIN)
__real__ x = __scalbnf (__real__ x, -2 * scale);
else
__real__ x = 0.0f;
__imag__ x = __scalbnf (__imag__ x, -2 * scale);
}
else if (fabsf (__real__ x) < FLT_MIN
&& fabsf (__imag__ x) < FLT_MIN)
{
scale = -(FLT_MANT_DIG / 2);
__real__ x = __scalbnf (__real__ x, -2 * scale);
__imag__ x = __scalbnf (__imag__ x, -2 * scale);
}
d = __ieee754_hypotf (__real__ x, __imag__ x);
/* Use the identity 2 Re res Im res = Im x
to avoid cancellation error in d +/- Re x. */
if (__real__ x > 0)
{
r = __ieee754_sqrtf (0.5f * (d + __real__ x));
s = 0.5f * (__imag__ x / r);
}
else
{
s = __ieee754_sqrtf (0.5f * (d - __real__ x));
r = fabsf (0.5f * (__imag__ x / s));
}
if (scale)
{
r = __scalbnf (r, scale);
s = __scalbnf (s, scale);
}
__real__ res = r;
__imag__ res = __copysignf (s, __imag__ x);
}
}
return res;
}
__complex__ float
__ctanhf (__complex__ float x)
{
__complex__ float res;
if (__builtin_expect (!isfinite (__real__ x) || !isfinite (__imag__ x), 0))
{
if (__isinf_nsf (__real__ x))
{
__real__ res = __copysignf (1.0, __real__ x);
__imag__ res = __copysignf (0.0, __imag__ x);
}
else if (__imag__ x == 0.0)
{
res = x;
}
else
{
__real__ res = __nanf ("");
__imag__ res = __nanf ("");
if (__isinf_nsf (__imag__ x))
feraiseexcept (FE_INVALID);
}
}
else
{
float sinix, cosix;
float den;
const int t = (int) ((FLT_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 (__builtin_expect (fpclassify(__imag__ x) != FP_SUBNORMAL, 1))
{
__sincosf (__imag__ x, &sinix, &cosix);
}
else
{
sinix = __imag__ x;
cosix = 1.0f;
}
if (fabsf (__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). */
float exp_2t = __ieee754_expf (2 * t);
__real__ res = __copysignf (1.0, __real__ x);
__imag__ res = 4 * sinix * cosix;
__real__ x = fabsf (__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_expf (2 * __real__ x);
}
else
{
float sinhrx, coshrx;
if (fabsf (__real__ x) > FLT_MIN)
{
sinhrx = __ieee754_sinhf (__real__ x);
coshrx = __ieee754_coshf (__real__ x);
}
else
{
sinhrx = __real__ x;
coshrx = 1.0f;
}
if (fabsf (sinhrx) > fabsf (cosix) * FLT_EPSILON)
den = sinhrx * sinhrx + cosix * cosix;
else
den = cosix * cosix;
__real__ res = sinhrx * coshrx / den;
__imag__ res = sinix * cosix / den;
}
}
return res;
}
__complex__ float
__clogf (__complex__ float x)
{
__complex__ float result;
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
if (__builtin_expect (rcls == FP_ZERO && icls == FP_ZERO, 0))
{
/* Real and imaginary part are 0.0. */
__imag__ result = signbit (__real__ x) ? M_PI : 0.0;
__imag__ result = __copysignf (__imag__ result, __imag__ x);
/* Yes, the following line raises an exception. */
__real__ result = -1.0 / fabsf (__real__ x);
}
else if (__builtin_expect (rcls != FP_NAN && icls != FP_NAN, 1))
{
/* Neither real nor imaginary part is NaN. */
float absx = fabsf (__real__ x), absy = fabsf (__imag__ x);
int scale = 0;
if (absx < absy)
{
float t = absx;
absx = absy;
absy = t;
}
if (absx > FLT_MAX / 2.0f)
{
scale = -1;
absx = __scalbnf (absx, scale);
absy = (absy >= FLT_MIN * 2.0f ? __scalbnf (absy, scale) : 0.0f);
}
else if (absx < FLT_MIN && absy < FLT_MIN)
{
scale = FLT_MANT_DIG;
absx = __scalbnf (absx, scale);
absy = __scalbnf (absy, scale);
}
if (absx == 1.0f && scale == 0)
{
float absy2 = absy * absy;
if (absy2 <= FLT_MIN * 2.0f)
{
#if __FLT_EVAL_METHOD__ == 0
__real__ result = absy2 / 2.0f - absy2 * absy2 / 4.0f;
#else
volatile float force_underflow = absy2 * absy2 / 4.0f;
__real__ result = absy2 / 2.0f - force_underflow;
#endif
}
else
__real__ result = __log1pf (absy2) / 2.0f;
}
else if (absx > 1.0f && absx < 2.0f && absy < 1.0f && scale == 0)
{
float d2m1 = (absx - 1.0f) * (absx + 1.0f);
if (absy >= FLT_EPSILON)
d2m1 += absy * absy;
__real__ result = __log1pf (d2m1) / 2.0f;
}
else if (absx < 1.0f
&& absx >= 0.75f
&& absy < FLT_EPSILON / 2.0f
&& scale == 0)
{
float d2m1 = (absx - 1.0f) * (absx + 1.0f);
__real__ result = __log1pf (d2m1) / 2.0f;
}
else if (absx < 1.0f && (absx >= 0.75f || absy >= 0.5f) && scale == 0)
{
float d2m1 = __x2y2m1f (absx, absy);
__real__ result = __log1pf (d2m1) / 2.0f;
}
else
{
float d = __ieee754_hypotf (absx, absy);
__real__ result = __ieee754_logf (d) - scale * (float) M_LN2;
}
__imag__ result = __ieee754_atan2f (__imag__ x, __real__ x);
}
else
{
__imag__ result = __nanf ("");
if (rcls == FP_INFINITE || icls == FP_INFINITE)
/* Real or imaginary part is infinite. */
__real__ result = HUGE_VALF;
else
__real__ result = __nanf ("");
}
return result;
}
__complex__ float
__kernel_casinhf (__complex__ float x, int adj)
{
__complex__ float res;
float rx, ix;
__complex__ float y;
/* Avoid cancellation by reducing to the first quadrant. */
rx = fabsf (__real__ x);
ix = fabsf (__imag__ x);
if (rx >= 1.0f / FLT_EPSILON || ix >= 1.0f / FLT_EPSILON)
{
/* For large x in the first quadrant, x + csqrt (1 + x * x)
is sufficiently close to 2 * x to make no significant
difference to the result; avoid possible overflow from
the squaring and addition. */
__real__ y = rx;
__imag__ y = ix;
if (adj)
{
float t = __real__ y;
__real__ y = __copysignf (__imag__ y, __imag__ x);
__imag__ y = t;
}
res = __clogf (y);
__real__ res += (float) M_LN2;
}
else if (rx >= 0.5f && ix < FLT_EPSILON / 8.0f)
{
float s = __ieee754_hypotf (1.0f, rx);
__real__ res = __ieee754_logf (rx + s);
if (adj)
__imag__ res = __ieee754_atan2f (s, __imag__ x);
else
__imag__ res = __ieee754_atan2f (ix, s);
}
else if (rx < FLT_EPSILON / 8.0f && ix >= 1.5f)
{
float s = __ieee754_sqrtf ((ix + 1.0f) * (ix - 1.0f));
__real__ res = __ieee754_logf (ix + s);
if (adj)
__imag__ res = __ieee754_atan2f (rx, __copysignf (s, __imag__ x));
else
__imag__ res = __ieee754_atan2f (s, rx);
}
else if (ix > 1.0f && ix < 1.5f && rx < 0.5f)
{
if (rx < FLT_EPSILON * FLT_EPSILON)
{
float ix2m1 = (ix + 1.0f) * (ix - 1.0f);
float s = __ieee754_sqrtf (ix2m1);
__real__ res = __log1pf (2.0f * (ix2m1 + ix * s)) / 2.0f;
if (adj)
__imag__ res = __ieee754_atan2f (rx, __copysignf (s, __imag__ x));
else
__imag__ res = __ieee754_atan2f (s, rx);
}
else
{
float ix2m1 = (ix + 1.0f) * (ix - 1.0f);
float rx2 = rx * rx;
float f = rx2 * (2.0f + rx2 + 2.0f * ix * ix);
float d = __ieee754_sqrtf (ix2m1 * ix2m1 + f);
float dp = d + ix2m1;
float dm = f / dp;
float r1 = __ieee754_sqrtf ((dm + rx2) / 2.0f);
float r2 = rx * ix / r1;
__real__ res
= __log1pf (rx2 + dp + 2.0f * (rx * r1 + ix * r2)) / 2.0f;
if (adj)
__imag__ res = __ieee754_atan2f (rx + r1, __copysignf (ix + r2,
__imag__ x));
else
__imag__ res = __ieee754_atan2f (ix + r2, rx + r1);
}
}
else if (ix == 1.0f && rx < 0.5f)
{
if (rx < FLT_EPSILON / 8.0f)
{
__real__ res = __log1pf (2.0f * (rx + __ieee754_sqrtf (rx))) / 2.0f;
if (adj)
__imag__ res = __ieee754_atan2f (__ieee754_sqrtf (rx),
__copysignf (1.0f, __imag__ x));
else
__imag__ res = __ieee754_atan2f (1.0f, __ieee754_sqrtf (rx));
}
else
{
float d = rx * __ieee754_sqrtf (4.0f + rx * rx);
float s1 = __ieee754_sqrtf ((d + rx * rx) / 2.0f);
float s2 = __ieee754_sqrtf ((d - rx * rx) / 2.0f);
__real__ res = __log1pf (rx * rx + d + 2.0f * (rx * s1 + s2)) / 2.0f;
if (adj)
__imag__ res = __ieee754_atan2f (rx + s1,
__copysignf (1.0f + s2,
__imag__ x));
else
__imag__ res = __ieee754_atan2f (1.0f + s2, rx + s1);
}
}
else if (ix < 1.0f && rx < 0.5f)
{
if (ix >= FLT_EPSILON)
{
if (rx < FLT_EPSILON * FLT_EPSILON)
{
float onemix2 = (1.0f + ix) * (1.0f - ix);
float s = __ieee754_sqrtf (onemix2);
__real__ res = __log1pf (2.0f * rx / s) / 2.0f;
if (adj)
__imag__ res = __ieee754_atan2f (s, __imag__ x);
else
__imag__ res = __ieee754_atan2f (ix, s);
}
else
{
float onemix2 = (1.0f + ix) * (1.0f - ix);
float rx2 = rx * rx;
float f = rx2 * (2.0f + rx2 + 2.0f * ix * ix);
float d = __ieee754_sqrtf (onemix2 * onemix2 + f);
float dp = d + onemix2;
float dm = f / dp;
float r1 = __ieee754_sqrtf ((dp + rx2) / 2.0f);
float r2 = rx * ix / r1;
__real__ res
= __log1pf (rx2 + dm + 2.0f * (rx * r1 + ix * r2)) / 2.0f;
if (adj)
__imag__ res = __ieee754_atan2f (rx + r1,
__copysignf (ix + r2,
__imag__ x));
else
__imag__ res = __ieee754_atan2f (ix + r2, rx + r1);
}
}
else
{
float s = __ieee754_hypotf (1.0f, rx);
__real__ res = __log1pf (2.0f * rx * (rx + s)) / 2.0f;
if (adj)
__imag__ res = __ieee754_atan2f (s, __imag__ x);
else
__imag__ res = __ieee754_atan2f (ix, s);
}
if (__real__ res < FLT_MIN)
{
volatile float force_underflow = __real__ res * __real__ res;
(void) force_underflow;
}
}
else
{
__real__ y = (rx - ix) * (rx + ix) + 1.0f;
__imag__ y = 2.0f * rx * ix;
y = __csqrtf (y);
__real__ y += rx;
__imag__ y += ix;
if (adj)
{
float t = __real__ y;
__real__ y = __copysignf (__imag__ y, __imag__ x);
__imag__ y = t;
}
res = __clogf (y);
}
/* Give results the correct sign for the original argument. */
__real__ res = __copysignf (__real__ res, __real__ x);
__imag__ res = __copysignf (__imag__ res, (adj ? 1.0f : __imag__ x));
return res;
}
float
__ieee754_gammaf_r (float x, int *signgamp)
{
int32_t hx;
float ret;
GET_FLOAT_WORD (hx, x);
if (__glibc_unlikely ((hx & 0x7fffffff) == 0))
{
/* Return value for x == 0 is Inf with divide by zero exception. */
*signgamp = 0;
return 1.0 / x;
}
if (__builtin_expect (hx < 0, 0)
&& (u_int32_t) hx < 0xff800000 && __rintf (x) == x)
{
/* Return value for integer x < 0 is NaN with invalid exception. */
*signgamp = 0;
return (x - x) / (x - x);
}
if (__glibc_unlikely (hx == 0xff800000))
{
/* x == -Inf. According to ISO this is NaN. */
*signgamp = 0;
return x - x;
}
if (__glibc_unlikely ((hx & 0x7f800000) == 0x7f800000))
{
/* Positive infinity (return positive infinity) or NaN (return
NaN). */
*signgamp = 0;
return x + x;
}
if (x >= 36.0f)
{
/* Overflow. */
*signgamp = 0;
ret = math_narrow_eval (FLT_MAX * FLT_MAX);
return ret;
}
else
{
SET_RESTORE_ROUNDF (FE_TONEAREST);
if (x > 0.0f)
{
*signgamp = 0;
int exp2_adj;
float tret = gammaf_positive (x, &exp2_adj);
ret = __scalbnf (tret, exp2_adj);
}
else if (x >= -FLT_EPSILON / 4.0f)
{
*signgamp = 0;
ret = 1.0f / x;
}
else
{
float tx = __truncf (x);
*signgamp = (tx == 2.0f * __truncf (tx / 2.0f)) ? -1 : 1;
if (x <= -42.0f)
/* Underflow. */
ret = FLT_MIN * FLT_MIN;
else
{
float frac = tx - x;
if (frac > 0.5f)
frac = 1.0f - frac;
float sinpix = (frac <= 0.25f
? __sinf ((float) M_PI * frac)
: __cosf ((float) M_PI * (0.5f - frac)));
int exp2_adj;
float tret = (float) M_PI / (-x * sinpix
* gammaf_positive (-x, &exp2_adj));
ret = __scalbnf (tret, -exp2_adj);
math_check_force_underflow_nonneg (ret);
}
}
ret = math_narrow_eval (ret);
}
if (isinf (ret) && x != 0)
{
if (*signgamp < 0)
{
ret = math_narrow_eval (-__copysignf (FLT_MAX, ret) * FLT_MAX);
ret = -ret;
}
else
ret = math_narrow_eval (__copysignf (FLT_MAX, ret) * FLT_MAX);
return ret;
}
else if (ret == 0)
{
if (*signgamp < 0)
{
ret = math_narrow_eval (-__copysignf (FLT_MIN, ret) * FLT_MIN);
ret = -ret;
}
else
ret = math_narrow_eval (__copysignf (FLT_MIN, ret) * FLT_MIN);
return ret;
}
else
return ret;
}
__complex__ float
__csqrtf (__complex__ float x)
{
__complex__ float res;
int rcls = fpclassify (__real__ x);
int icls = fpclassify (__imag__ x);
if (rcls <= FP_INFINITE || icls <= FP_INFINITE)
{
if (icls == FP_INFINITE)
{
__real__ res = HUGE_VALF;
__imag__ res = __imag__ x;
}
else if (rcls == FP_INFINITE)
{
if (__real__ x < 0.0)
{
__real__ res = icls == FP_NAN ? __nanf ("") : 0;
__imag__ res = __copysignf (HUGE_VALF, __imag__ x);
}
else
{
__real__ res = __real__ x;
__imag__ res = (icls == FP_NAN
? __nanf ("") : __copysignf (0.0, __imag__ x));
}
}
else
{
__real__ res = __nanf ("");
__imag__ res = __nanf ("");
}
}
else
{
if (icls == FP_ZERO)
{
if (__real__ x < 0.0)
{
__real__ res = 0.0;
__imag__ res = __copysignf (__ieee754_sqrtf (-__real__ x),
__imag__ x);
}
else
{
__real__ res = fabsf (__ieee754_sqrtf (__real__ x));
__imag__ res = __copysignf (0.0, __imag__ x);
}
}
else if (rcls == FP_ZERO)
{
float r = __ieee754_sqrtf (0.5 * fabsf (__imag__ x));
__real__ res = __copysignf (r, __imag__ x);
__imag__ res = r;
}
else
{
float d, r, s;
d = __ieee754_hypotf (__real__ x, __imag__ x);
/* Use the identity 2 Re res Im res = Im x
to avoid cancellation error in d +/- Re x. */
if (__real__ x > 0)
{
r = __ieee754_sqrtf (0.5f * d + 0.5f * __real__ x);
s = (0.5f * __imag__ x) / r;
}
else
{
s = __ieee754_sqrtf (0.5f * d - 0.5f * __real__ x);
r = fabsf ((0.5f * __imag__ x) / s);
}
__real__ res = r;
__imag__ res = __copysignf (s, __imag__ x);
}
}
return res;
}