summaryrefslogtreecommitdiffstats
path: root/lib/msun/src/catrig.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/msun/src/catrig.c')
-rw-r--r--lib/msun/src/catrig.c64
1 files changed, 32 insertions, 32 deletions
diff --git a/lib/msun/src/catrig.c b/lib/msun/src/catrig.c
index 200977c..c0f5f55 100644
--- a/lib/msun/src/catrig.c
+++ b/lib/msun/src/catrig.c
@@ -286,19 +286,19 @@ casinh(double complex z)
if (isnan(x) || isnan(y)) {
/* casinh(+-Inf + I*NaN) = +-Inf + I*NaN */
if (isinf(x))
- return (cpack(x, y + y));
+ return (CMPLX(x, y + y));
/* casinh(NaN + I*+-Inf) = opt(+-)Inf + I*NaN */
if (isinf(y))
- return (cpack(y, x + x));
+ return (CMPLX(y, x + x));
/* casinh(NaN + I*0) = NaN + I*0 */
if (y == 0)
- return (cpack(x + x, y));
+ return (CMPLX(x + x, y));
/*
* All other cases involving NaN return NaN + I*NaN.
* C99 leaves it optional whether to raise invalid if one of
* the arguments is not NaN, so we opt not to raise it.
*/
- return (cpack(x + 0.0L + (y + 0), x + 0.0L + (y + 0)));
+ return (CMPLX(x + 0.0L + (y + 0), x + 0.0L + (y + 0)));
}
if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
@@ -307,7 +307,7 @@ casinh(double complex z)
w = clog_for_large_values(z) + m_ln2;
else
w = clog_for_large_values(-z) + m_ln2;
- return (cpack(copysign(creal(w), x), copysign(cimag(w), y)));
+ return (CMPLX(copysign(creal(w), x), copysign(cimag(w), y)));
}
/* Avoid spuriously raising inexact for z = 0. */
@@ -325,7 +325,7 @@ casinh(double complex z)
ry = asin(B);
else
ry = atan2(new_y, sqrt_A2my2);
- return (cpack(copysign(rx, x), copysign(ry, y)));
+ return (CMPLX(copysign(rx, x), copysign(ry, y)));
}
/*
@@ -335,9 +335,9 @@ casinh(double complex z)
double complex
casin(double complex z)
{
- double complex w = casinh(cpack(cimag(z), creal(z)));
+ double complex w = casinh(CMPLX(cimag(z), creal(z)));
- return (cpack(cimag(w), creal(w)));
+ return (CMPLX(cimag(w), creal(w)));
}
/*
@@ -370,19 +370,19 @@ cacos(double complex z)
if (isnan(x) || isnan(y)) {
/* cacos(+-Inf + I*NaN) = NaN + I*opt(-)Inf */
if (isinf(x))
- return (cpack(y + y, -INFINITY));
+ return (CMPLX(y + y, -INFINITY));
/* cacos(NaN + I*+-Inf) = NaN + I*-+Inf */
if (isinf(y))
- return (cpack(x + x, -y));
+ return (CMPLX(x + x, -y));
/* cacos(0 + I*NaN) = PI/2 + I*NaN with inexact */
if (x == 0)
- return (cpack(pio2_hi + pio2_lo, y + y));
+ return (CMPLX(pio2_hi + pio2_lo, y + y));
/*
* All other cases involving NaN return NaN + I*NaN.
* C99 leaves it optional whether to raise invalid if one of
* the arguments is not NaN, so we opt not to raise it.
*/
- return (cpack(x + 0.0L + (y + 0), x + 0.0L + (y + 0)));
+ return (CMPLX(x + 0.0L + (y + 0), x + 0.0L + (y + 0)));
}
if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
@@ -392,18 +392,18 @@ cacos(double complex z)
ry = creal(w) + m_ln2;
if (sy == 0)
ry = -ry;
- return (cpack(rx, ry));
+ return (CMPLX(rx, ry));
}
/* Avoid spuriously raising inexact for z = 1. */
if (x == 1 && y == 0)
- return (cpack(0, -y));
+ return (CMPLX(0, -y));
/* All remaining cases are inexact. */
raise_inexact();
if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
- return (cpack(pio2_hi - (x - pio2_lo), -y));
+ return (CMPLX(pio2_hi - (x - pio2_lo), -y));
do_hard_work(ay, ax, &ry, &B_is_usable, &B, &sqrt_A2mx2, &new_x);
if (B_is_usable) {
@@ -419,7 +419,7 @@ cacos(double complex z)
}
if (sy == 0)
ry = -ry;
- return (cpack(rx, ry));
+ return (CMPLX(rx, ry));
}
/*
@@ -437,15 +437,15 @@ cacosh(double complex z)
ry = cimag(w);
/* cacosh(NaN + I*NaN) = NaN + I*NaN */
if (isnan(rx) && isnan(ry))
- return (cpack(ry, rx));
+ return (CMPLX(ry, rx));
/* cacosh(NaN + I*+-Inf) = +Inf + I*NaN */
/* cacosh(+-Inf + I*NaN) = +Inf + I*NaN */
if (isnan(rx))
- return (cpack(fabs(ry), rx));
+ return (CMPLX(fabs(ry), rx));
/* cacosh(0 + I*NaN) = NaN + I*NaN */
if (isnan(ry))
- return (cpack(ry, ry));
- return (cpack(fabs(ry), copysign(rx, cimag(z))));
+ return (CMPLX(ry, ry));
+ return (CMPLX(fabs(ry), copysign(rx, cimag(z))));
}
/*
@@ -475,16 +475,16 @@ clog_for_large_values(double complex z)
* this method is still poor since it is uneccessarily slow.
*/
if (ax > DBL_MAX / 2)
- return (cpack(log(hypot(x / m_e, y / m_e)) + 1, atan2(y, x)));
+ return (CMPLX(log(hypot(x / m_e, y / m_e)) + 1, atan2(y, x)));
/*
* Avoid overflow when x or y is large. Avoid underflow when x or
* y is small.
*/
if (ax > QUARTER_SQRT_MAX || ay < SQRT_MIN)
- return (cpack(log(hypot(x, y)), atan2(y, x)));
+ return (CMPLX(log(hypot(x, y)), atan2(y, x)));
- return (cpack(log(ax * ax + ay * ay) / 2, atan2(y, x)));
+ return (CMPLX(log(ax * ax + ay * ay) / 2, atan2(y, x)));
}
/*
@@ -575,30 +575,30 @@ catanh(double complex z)
/* This helps handle many cases. */
if (y == 0 && ax <= 1)
- return (cpack(atanh(x), y));
+ return (CMPLX(atanh(x), y));
/* To ensure the same accuracy as atan(), and to filter out z = 0. */
if (x == 0)
- return (cpack(x, atan(y)));
+ return (CMPLX(x, atan(y)));
if (isnan(x) || isnan(y)) {
/* catanh(+-Inf + I*NaN) = +-0 + I*NaN */
if (isinf(x))
- return (cpack(copysign(0, x), y + y));
+ return (CMPLX(copysign(0, x), y + y));
/* catanh(NaN + I*+-Inf) = sign(NaN)0 + I*+-PI/2 */
if (isinf(y))
- return (cpack(copysign(0, x),
+ return (CMPLX(copysign(0, x),
copysign(pio2_hi + pio2_lo, y)));
/*
* All other cases involving NaN return NaN + I*NaN.
* C99 leaves it optional whether to raise invalid if one of
* the arguments is not NaN, so we opt not to raise it.
*/
- return (cpack(x + 0.0L + (y + 0), x + 0.0L + (y + 0)));
+ return (CMPLX(x + 0.0L + (y + 0), x + 0.0L + (y + 0)));
}
if (ax > RECIP_EPSILON || ay > RECIP_EPSILON)
- return (cpack(real_part_reciprocal(x, y),
+ return (CMPLX(real_part_reciprocal(x, y),
copysign(pio2_hi + pio2_lo, y)));
if (ax < SQRT_3_EPSILON / 2 && ay < SQRT_3_EPSILON / 2) {
@@ -623,7 +623,7 @@ catanh(double complex z)
else
ry = atan2(2 * ay, (1 - ax) * (1 + ax) - ay * ay) / 2;
- return (cpack(copysign(rx, x), copysign(ry, y)));
+ return (CMPLX(copysign(rx, x), copysign(ry, y)));
}
/*
@@ -633,7 +633,7 @@ catanh(double complex z)
double complex
catan(double complex z)
{
- double complex w = catanh(cpack(cimag(z), creal(z)));
+ double complex w = catanh(CMPLX(cimag(z), creal(z)));
- return (cpack(cimag(w), creal(w)));
+ return (CMPLX(cimag(w), creal(w)));
}
OpenPOWER on IntegriCloud