static void
check_inf_nan (void)
{
/* only if nans and infs are available */
#if _GMP_IEEE_FLOATS
mpfr_t x;
double d;
long exp;
mpfr_init2 (x, 123);
mpfr_set_inf (x, 1);
d = mpfr_get_d_2exp (&exp, x, MPFR_RNDZ);
ASSERT_ALWAYS (d > 0);
ASSERT_ALWAYS (DOUBLE_ISINF (d));
mpfr_set_inf (x, -1);
d = mpfr_get_d_2exp (&exp, x, MPFR_RNDZ);
ASSERT_ALWAYS (d < 0);
ASSERT_ALWAYS (DOUBLE_ISINF (d));
mpfr_set_nan (x);
d = mpfr_get_d_2exp (&exp, x, MPFR_RNDZ);
ASSERT_ALWAYS (DOUBLE_ISNAN (d));
mpfr_clear (x);
#endif
}
static void
check_inf_nan (void)
{
#if !defined(MPFR_ERRDIVZERO)
mpfr_t x;
double d;
long exp;
mpfr_init2 (x, 123);
mpfr_set_inf (x, 1);
d = (double) mpfr_get_ld_2exp (&exp, x, MPFR_RNDZ);
MPFR_ASSERTN (d > 0);
MPFR_ASSERTN (DOUBLE_ISINF (d));
mpfr_set_inf (x, -1);
d = (double) mpfr_get_ld_2exp (&exp, x, MPFR_RNDZ);
MPFR_ASSERTN (d < 0);
MPFR_ASSERTN (DOUBLE_ISINF (d));
mpfr_set_nan (x);
d = (double) mpfr_get_ld_2exp (&exp, x, MPFR_RNDZ);
MPFR_ASSERTN (DOUBLE_ISNAN (d));
mpfr_clear (x);
#endif
}
static void
check_inf_nan (void)
{
/* only if nans and infs are available */
#if _GMP_IEEE_FLOATS && !defined(MPFR_ERRDIVZERO)
mpfr_t x;
double d;
mpfr_init2 (x, 123);
mpfr_set_inf (x, 1);
d = mpfr_get_d (x, MPFR_RNDZ);
ASSERT_ALWAYS (d > 0);
ASSERT_ALWAYS (DOUBLE_ISINF (d));
mpfr_set_inf (x, -1);
d = mpfr_get_d (x, MPFR_RNDZ);
ASSERT_ALWAYS (d < 0);
ASSERT_ALWAYS (DOUBLE_ISINF (d));
mpfr_set_nan (x);
d = mpfr_get_d (x, MPFR_RNDZ);
ASSERT_ALWAYS (DOUBLE_ISNAN (d));
mpfr_clear (x);
#endif
}
static double
pcc_scalbn(double x, int exp)
{
union ud x1, z1, z2;
x1.f = x;
if (DOUBLE_ISINF(x1) || DOUBLE_ISNAN(x1))
return x;
exp += 1023;
z1.dil = z2.dil = 0;
if (exp <= 0) {
z2.dih = (1023 - 110) << 20;
x *= z2.f;
exp += 110;
if (exp < 0) exp = 0;
} else if (exp > 2046) {
z2.dih = (1024 + 55) << 20;
x *= z2.f;
exp -= 55;
if (exp > 2046) exp = 2046;
}
z1.dih = exp << 20;
x *= z1.f;
return x;
}
static void
check_max (void)
{
double d, e;
mpfr_t u;
d = 1.0;
while (d < (DBL_MAX / 2.0))
d += d;
mpfr_init (u);
if (mpfr_set_d (u, d, MPFR_RNDN) == 0)
{
/* If setting is exact */
e = (mpfr_get_d1) (u);
if (e != d)
{
printf ("get_d(set_d)(1): %1.20e != %1.20e\n", d, e);
exit (1);
}
}
mpfr_set_str_binary (u, "-1E1024");
d = mpfr_get_d (u, MPFR_RNDZ);
MPFR_ASSERTN(d == -DBL_MAX);
d = mpfr_get_d (u, MPFR_RNDU);
MPFR_ASSERTN(d == -DBL_MAX);
#if _GMP_IEEE_FLOATS && !defined(MPFR_ERRDIVZERO)
d = mpfr_get_d (u, MPFR_RNDN);
MPFR_ASSERTN(DOUBLE_ISINF(d) && d < 0.0);
d = mpfr_get_d (u, MPFR_RNDD);
MPFR_ASSERTN(DOUBLE_ISINF(d) && d < 0.0);
#endif
mpfr_set_str_binary (u, "1E1024");
d = mpfr_get_d (u, MPFR_RNDZ);
MPFR_ASSERTN(d == DBL_MAX);
d = mpfr_get_d (u, MPFR_RNDD);
MPFR_ASSERTN(d == DBL_MAX);
#if _GMP_IEEE_FLOATS && !defined(MPFR_ERRDIVZERO)
d = mpfr_get_d (u, MPFR_RNDN);
MPFR_ASSERTN(DOUBLE_ISINF(d) && d > 0.0);
d = mpfr_get_d (u, MPFR_RNDU);
MPFR_ASSERTN(DOUBLE_ISINF(d) && d > 0.0);
#endif
mpfr_clear (u);
}
static void
test_generic (mpfr_prec_t p0, mpfr_prec_t p1, unsigned int nmax)
{
mpfr_prec_t prec, xprec, yprec;
mpfr_t x, y, z, t, w;
#if defined(TWO_ARGS_ALL)
mpfr_t u;
#endif
#if defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
double d;
#endif
#if defined(ULONG_ARG1) || defined(ULONG_ARG2)
unsigned long i;
#endif
mpfr_rnd_t rnd;
int inexact, compare, compare2;
unsigned int n;
unsigned long ctrt = 0, ctrn = 0;
int test_of = 1, test_uf = 1;
mpfr_exp_t old_emin, old_emax;
old_emin = mpfr_get_emin ();
old_emax = mpfr_get_emax ();
mpfr_inits2 (MPFR_PREC_MIN, x, y, z, t, w, (mpfr_ptr) 0);
#if defined(TWO_ARGS_ALL)
mpfr_init2 (u, MPFR_PREC_MIN);
#endif
/* generic test */
for (prec = p0; prec <= p1; prec++)
{
mpfr_set_prec (z, prec);
mpfr_set_prec (t, prec);
yprec = prec + 10;
mpfr_set_prec (y, yprec);
mpfr_set_prec (w, yprec);
/* Note: in precision p1, we test 4 special cases. */
for (n = 0; n < (prec == p1 ? nmax + 4 : nmax); n++)
{
int infinite_input = 0;
unsigned int flags;
mpfr_exp_t oemin, oemax;
xprec = prec;
if (randlimb () & 1)
{
xprec *= (double) randlimb () / MP_LIMB_T_MAX;
if (xprec < MPFR_PREC_MIN)
xprec = MPFR_PREC_MIN;
}
mpfr_set_prec (x, xprec);
#if defined(TWO_ARGS)
mpfr_set_prec (u, xprec);
#elif defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
mpfr_set_prec (u, IEEE_DBL_MANT_DIG);
#elif defined(ULONG_ARG1) || defined(ULONG_ARG2)
mpfr_set_prec (u, sizeof (unsigned long) * CHAR_BIT);
#endif
if (n > 3 || prec < p1)
{
#if defined(RAND_FUNCTION)
RAND_FUNCTION (x);
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
RAND_FUNCTION (u);
#endif
#else /* ! defined(RAND_FUNCTION) */
tests_default_random (x, TEST_RANDOM_POS,
TEST_RANDOM_EMIN, TEST_RANDOM_EMAX,
TEST_RANDOM_ALWAYS_SCALE);
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
tests_default_random (u, TEST_RANDOM_POS2,
TEST_RANDOM_EMIN, TEST_RANDOM_EMAX,
TEST_RANDOM_ALWAYS_SCALE);
#endif
#endif /* ! defined(RAND_FUNCTION) */
}
else
{
/* Special cases tested in precision p1 if n <= 3. They are
useful really in the extended exponent range. */
#if (defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)) && defined(MPFR_ERRDIVZERO)
goto next_n;
#endif
set_emin (MPFR_EMIN_MIN);
set_emax (MPFR_EMAX_MAX);
if (n <= 1)
{
mpfr_set_si (x, n == 0 ? 1 : -1, MPFR_RNDN);
mpfr_set_exp (x, mpfr_get_emin ());
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
mpfr_set_si (u, randlimb () % 2 == 0 ? 1 : -1, MPFR_RNDN);
mpfr_set_exp (u, mpfr_get_emin ());
#endif
}
else /* 2 <= n <= 3 */
{
if (getenv ("MPFR_CHECK_MAX") == NULL)
goto next_n;
mpfr_set_si (x, n == 0 ? 1 : -1, MPFR_RNDN);
mpfr_setmax (x, REDUCE_EMAX);
#if defined(TWO_ARGS) || defined(DOUBLE_ARG1) || defined(DOUBLE_ARG2)
mpfr_set_si (u, randlimb () % 2 == 0 ? 1 : -1, MPFR_RNDN);
mpfr_setmax (u, mpfr_get_emax ());
#endif
}
}
#if defined(ULONG_ARG1) || defined(ULONG_ARG2)
i = randlimb ();
inexact = mpfr_set_ui (u, i, MPFR_RNDN);
MPFR_ASSERTN (inexact == 0);
#endif
/* Exponent range for the test. */
oemin = mpfr_get_emin ();
oemax = mpfr_get_emax ();
rnd = RND_RAND ();
mpfr_clear_flags ();
#ifdef DEBUG_TGENERIC
TGENERIC_INFO (TEST_FUNCTION, MPFR_PREC (y));
#endif
#if defined(TWO_ARGS)
compare = TEST_FUNCTION (y, x, u, rnd);
#elif defined(DOUBLE_ARG1)
d = mpfr_get_d (u, rnd);
compare = TEST_FUNCTION (y, d, x, rnd);
/* d can be infinite due to overflow in mpfr_get_d */
infinite_input |= DOUBLE_ISINF (d);
#elif defined(DOUBLE_ARG2)
d = mpfr_get_d (u, rnd);
compare = TEST_FUNCTION (y, x, d, rnd);
/* d can be infinite due to overflow in mpfr_get_d */
infinite_input |= DOUBLE_ISINF (d);
#elif defined(ULONG_ARG1)
compare = TEST_FUNCTION (y, i, x, rnd);
#elif defined(ULONG_ARG2)
compare = TEST_FUNCTION (y, x, i, rnd);
#else
compare = TEST_FUNCTION (y, x, rnd);
#endif
flags = __gmpfr_flags;
if (mpfr_get_emin () != oemin ||
mpfr_get_emax () != oemax)
{
printf ("tgeneric: the exponent range has been modified"
" by the tested function!\n");
exit (1);
}
TGENERIC_CHECK ("bad inexact flag",
(compare != 0) ^ (mpfr_inexflag_p () == 0));
ctrt++;
/* Tests in a reduced exponent range. */
{
unsigned int oldflags = flags;
mpfr_exp_t e, emin, emax;
/* Determine the smallest exponent range containing the
exponents of the mpfr_t inputs (x, and u if TWO_ARGS)
and output (y). */
emin = MPFR_EMAX_MAX;
emax = MPFR_EMIN_MIN;
if (MPFR_IS_PURE_FP (x))
{
e = MPFR_GET_EXP (x);
if (e < emin)
emin = e;
if (e > emax)
emax = e;
}
#if defined(TWO_ARGS)
if (MPFR_IS_PURE_FP (u))
{
e = MPFR_GET_EXP (u);
if (e < emin)
emin = e;
if (e > emax)
emax = e;
}
#endif
if (MPFR_IS_PURE_FP (y))
{
e = MPFR_GET_EXP (y);
if (test_of && e - 1 >= emax)
{
unsigned int ex_flags;
mpfr_set_emax (e - 1);
mpfr_clear_flags ();
#if defined(TWO_ARGS)
inexact = TEST_FUNCTION (w, x, u, rnd);
#elif defined(DOUBLE_ARG1)
inexact = TEST_FUNCTION (w, d, x, rnd);
#elif defined(DOUBLE_ARG2)
inexact = TEST_FUNCTION (w, x, d, rnd);
#elif defined(ULONG_ARG1)
inexact = TEST_FUNCTION (w, i, x, rnd);
#elif defined(ULONG_ARG2)
inexact = TEST_FUNCTION (w, x, i, rnd);
#else
inexact = TEST_FUNCTION (w, x, rnd);
#endif
flags = __gmpfr_flags;
mpfr_set_emax (oemax);
ex_flags = MPFR_FLAGS_OVERFLOW | MPFR_FLAGS_INEXACT;
if (flags != ex_flags)
{
printf ("tgeneric: error for " MAKE_STR(TEST_FUNCTION)
", reduced exponent range [%"
MPFR_EXP_FSPEC "d,%" MPFR_EXP_FSPEC
"d] (overflow test) on:\n",
(mpfr_eexp_t) oemin, (mpfr_eexp_t) e - 1);
printf ("x = ");
mpfr_dump (x);
#if defined(TWO_ARGS_ALL)
printf ("u = ");
mpfr_dump (u);
#endif
printf ("yprec = %u, rnd_mode = %s\n",
(unsigned int) yprec,
mpfr_print_rnd_mode (rnd));
printf ("Expected flags =");
flags_out (ex_flags);
printf (" got flags =");
flags_out (flags);
printf ("inex = %d, w = ", inexact);
mpfr_dump (w);
exit (1);
}
test_of = 0; /* Overflow is tested only once. */
}
if (test_uf && e + 1 <= emin)
{
unsigned int ex_flags;
mpfr_set_emin (e + 1);
mpfr_clear_flags ();
#if defined(TWO_ARGS)
inexact = TEST_FUNCTION (w, x, u, rnd);
#elif defined(DOUBLE_ARG1)
inexact = TEST_FUNCTION (w, d, x, rnd);
#elif defined(DOUBLE_ARG2)
inexact = TEST_FUNCTION (w, x, d, rnd);
#elif defined(ULONG_ARG1)
inexact = TEST_FUNCTION (w, i, x, rnd);
#elif defined(ULONG_ARG2)
inexact = TEST_FUNCTION (w, x, i, rnd);
#else
inexact = TEST_FUNCTION (w, x, rnd);
#endif
flags = __gmpfr_flags;
mpfr_set_emin (oemin);
ex_flags = MPFR_FLAGS_UNDERFLOW | MPFR_FLAGS_INEXACT;
if (flags != ex_flags)
{
printf ("tgeneric: error for " MAKE_STR(TEST_FUNCTION)
", reduced exponent range [%"
MPFR_EXP_FSPEC "d,%" MPFR_EXP_FSPEC
"d] (underflow test) on:\n",
(mpfr_eexp_t) e + 1, (mpfr_eexp_t) oemax);
printf ("x = ");
mpfr_dump (x);
#if defined(TWO_ARGS_ALL)
printf ("u = ");
mpfr_dump (u);
#endif
printf ("yprec = %u, rnd_mode = %s\n",
(unsigned int) yprec,
mpfr_print_rnd_mode (rnd));
printf ("Expected flags =");
flags_out (ex_flags);
printf (" got flags =");
flags_out (flags);
printf ("inex = %d, w = ", inexact);
mpfr_dump (w);
exit (1);
}
test_uf = 0; /* Underflow is tested only once. */
}
if (e < emin)
emin = e;
if (e > emax)
emax = e;
}
if (emin > emax)
emin = emax; /* case where all values are singular */
/* Consistency test in a reduced exponent range. Doing it
for the first 10 samples and for prec == p1 (which has
some special cases) should be sufficient. */
if (ctrt <= 10 || prec == p1)
{
mpfr_set_emin (emin);
mpfr_set_emax (emax);
#ifdef DEBUG_TGENERIC
/* Useful information in case of assertion failure. */
printf ("tgeneric: reduced exponent range [%"
MPFR_EXP_FSPEC "d,%" MPFR_EXP_FSPEC "d]\n",
(mpfr_eexp_t) emin, (mpfr_eexp_t) emax);
#endif
mpfr_clear_flags ();
#if defined(TWO_ARGS)
inexact = TEST_FUNCTION (w, x, u, rnd);
#elif defined(DOUBLE_ARG1)
inexact = TEST_FUNCTION (w, d, x, rnd);
#elif defined(DOUBLE_ARG2)
inexact = TEST_FUNCTION (w, x, d, rnd);
#elif defined(ULONG_ARG1)
inexact = TEST_FUNCTION (w, i, x, rnd);
#elif defined(ULONG_ARG2)
inexact = TEST_FUNCTION (w, x, i, rnd);
#else
inexact = TEST_FUNCTION (w, x, rnd);
#endif
flags = __gmpfr_flags;
mpfr_set_emin (oemin);
mpfr_set_emax (oemax);
if (! (SAME_VAL (w, y) &&
SAME_SIGN (inexact, compare) &&
flags == oldflags))
{
printf ("tgeneric: error for " MAKE_STR(TEST_FUNCTION)
", reduced exponent range [%"
MPFR_EXP_FSPEC "d,%" MPFR_EXP_FSPEC "d] on:\n",
(mpfr_eexp_t) emin, (mpfr_eexp_t) emax);
printf ("x = ");
mpfr_dump (x);
#if defined(TWO_ARGS_ALL)
printf ("u = ");
mpfr_dump (u);
#endif
printf ("yprec = %u, rnd_mode = %s\n",
(unsigned int) yprec, mpfr_print_rnd_mode (rnd));
printf ("Expected:\n y = ");
mpfr_dump (y);
printf (" inex = %d, flags =", compare);
flags_out (oldflags);
printf ("Got:\n w = ");
mpfr_dump (w);
printf (" inex = %d, flags =", inexact);
flags_out (flags);
exit (1);
}
}
__gmpfr_flags = oldflags; /* restore the flags */
}
if (MPFR_IS_SINGULAR (y))
{
if (MPFR_IS_NAN (y) || mpfr_nanflag_p ())
TGENERIC_CHECK ("bad NaN flag",
MPFR_IS_NAN (y) && mpfr_nanflag_p ());
else if (MPFR_IS_INF (y))
{
TGENERIC_CHECK ("bad overflow flag",
(compare != 0) ^ (mpfr_overflow_p () == 0));
TGENERIC_CHECK ("bad divide-by-zero flag",
(compare == 0 && !infinite_input) ^
(mpfr_divby0_p () == 0));
}
else if (MPFR_IS_ZERO (y))
TGENERIC_CHECK ("bad underflow flag",
(compare != 0) ^ (mpfr_underflow_p () == 0));
}
else if (mpfr_divby0_p ())
{
TGENERIC_CHECK ("both overflow and divide-by-zero",
! mpfr_overflow_p ());
TGENERIC_CHECK ("both underflow and divide-by-zero",
! mpfr_underflow_p ());
TGENERIC_CHECK ("bad compare value (divide-by-zero)",
compare == 0);
}
else if (mpfr_overflow_p ())
{
TGENERIC_CHECK ("both underflow and overflow",
! mpfr_underflow_p ());
TGENERIC_CHECK ("bad compare value (overflow)", compare != 0);
mpfr_nexttoinf (y);
TGENERIC_CHECK ("should have been max MPFR number (overflow)",
MPFR_IS_INF (y));
}
else if (mpfr_underflow_p ())
{
TGENERIC_CHECK ("bad compare value (underflow)", compare != 0);
mpfr_nexttozero (y);
TGENERIC_CHECK ("should have been min MPFR number (underflow)",
MPFR_IS_ZERO (y));
}
else if (mpfr_can_round (y, yprec, rnd, rnd, prec))
{
ctrn++;
mpfr_set (t, y, rnd);
/* Risk of failures are known when some flags are already set
before the function call. Do not set the erange flag, as
it will remain set after the function call and no checks
are performed in such a case (see the mpfr_erangeflag_p
test below). */
if (randlimb () & 1)
__gmpfr_flags = MPFR_FLAGS_ALL ^ MPFR_FLAGS_ERANGE;
#ifdef DEBUG_TGENERIC
TGENERIC_INFO (TEST_FUNCTION, MPFR_PREC (z));
#endif
/* Let's increase the precision of the inputs in a random way.
In most cases, this doesn't make any difference, but for
the mpfr_fmod bug fixed in r6230, this triggers the bug. */
mpfr_prec_round (x, mpfr_get_prec (x) + (randlimb () & 15),
MPFR_RNDN);
#if defined(TWO_ARGS)
mpfr_prec_round (u, mpfr_get_prec (u) + (randlimb () & 15),
MPFR_RNDN);
inexact = TEST_FUNCTION (z, x, u, rnd);
#elif defined(DOUBLE_ARG1)
inexact = TEST_FUNCTION (z, d, x, rnd);
#elif defined(DOUBLE_ARG2)
inexact = TEST_FUNCTION (z, x, d, rnd);
#elif defined(ULONG_ARG1)
inexact = TEST_FUNCTION (z, i, x, rnd);
#elif defined(ULONG_ARG2)
inexact = TEST_FUNCTION (z, x, i, rnd);
#else
inexact = TEST_FUNCTION (z, x, rnd);
#endif
if (mpfr_erangeflag_p ())
goto next_n;
if (! mpfr_equal_p (t, z))
{
printf ("tgeneric: results differ for "
MAKE_STR(TEST_FUNCTION) " on\n x = ");
mpfr_dump (x);
#if defined(TWO_ARGS_ALL)
printf (" u = ");
mpfr_dump (u);
#endif
printf (" prec = %u, rnd_mode = %s\n",
(unsigned int) prec, mpfr_print_rnd_mode (rnd));
printf ("Got ");
mpfr_dump (z);
printf ("Expected ");
mpfr_dump (t);
printf ("Approx ");
mpfr_dump (y);
exit (1);
}
compare2 = mpfr_cmp (t, y);
/* if rounding to nearest, cannot know the sign of t - f(x)
because of composed rounding: y = o(f(x)) and t = o(y) */
if (compare * compare2 >= 0)
compare = compare + compare2;
else
compare = inexact; /* cannot determine sign(t-f(x)) */
if (! SAME_SIGN (inexact, compare))
{
printf ("Wrong inexact flag for rnd=%s: expected %d, got %d"
"\n", mpfr_print_rnd_mode (rnd), compare, inexact);
printf ("x = ");
mpfr_dump (x);
#if defined(TWO_ARGS_ALL)
printf ("u = ");
mpfr_dump (u);
#endif
printf ("y = ");
mpfr_dump (y);
printf ("t = ");
mpfr_dump (t);
exit (1);
}
}
else if (getenv ("MPFR_SUSPICIOUS_OVERFLOW") != NULL)
{
/* For developers only! */
MPFR_ASSERTN (MPFR_IS_PURE_FP (y));
mpfr_nexttoinf (y);
if (MPFR_IS_INF (y) && MPFR_IS_LIKE_RNDZ (rnd, MPFR_IS_NEG (y))
&& !mpfr_overflow_p () && TGENERIC_SO_TEST)
{
printf ("Possible bug! |y| is the maximum finite number "
"and has been obtained when\nrounding toward zero"
" (%s). Thus there is a very probable overflow,\n"
"but the overflow flag is not set!\n",
mpfr_print_rnd_mode (rnd));
printf ("x = ");
mpfr_dump (x);
#if defined(TWO_ARGS_ALL)
printf ("u = ");
mpfr_dump (u);
#endif
exit (1);
}
}
next_n:
/* In case the exponent range has been changed by
tests_default_random() or for special values... */
mpfr_set_emin (old_emin);
mpfr_set_emax (old_emax);
}
}
#ifndef TGENERIC_NOWARNING
if (3 * ctrn < 2 * ctrt)
printf ("Warning! Too few normal cases in generic tests (%lu / %lu)\n",
ctrn, ctrt);
#endif
mpfr_clears (x, y, z, t, w, (mpfr_ptr) 0);
#if defined(TWO_ARGS_ALL)
mpfr_clear (u);
#endif
}
double _Complex
__muldc3(double fa, double fb, double fc, double fd)
{
union ud ua, ub, uc, ud, ux, uy, uac, ubd, uad, ubc;
ua.f = fa;
ub.f = fb;
uc.f = fc;
ud.f = fd;
uac.f = ua.f * uc.f;
ubd.f = ub.f * ud.f;
uad.f = ua.f * ud.f;
ubc.f = ub.f * uc.f;
ux.f=uac.f-ubd.f;
uy.f=uad.f+ubc.f;
if (DOUBLE_ISNAN(ux) && DOUBLE_ISNAN(uy)) {
/* Recover infinities that computed as NaN+iNaN ... */
int recalc = 0;
if (DOUBLE_ISINF(ua) || DOUBLE_ISINF(ub) ) { // z is infinite
/* "Box" the infinity and change NaNs
in the other factor to 0 */
ua.f = pcc_copysign(DOUBLE_ISINF(ua) ? 1.0 : 0.0, ua.f);
ub.f = pcc_copysign(DOUBLE_ISINF(ub) ? 1.0 : 0.0, ub.f);
if (DOUBLE_ISNAN(uc)) uc.f = pcc_copysign(0.0, uc.f);
if (DOUBLE_ISNAN(ud)) ud.f = pcc_copysign(0.0, ud.f);
recalc = 1;
}
if (DOUBLE_ISINF(uc) || DOUBLE_ISINF(ud) ) { // w is infinite
/* "Box" the infinity and change NaNs
in the other factor to 0 */
uc.f = pcc_copysign(DOUBLE_ISINF(uc) ? 1.0 : 0.0, uc.f);
ud.f = pcc_copysign(DOUBLE_ISINF(ud) ? 1.0 : 0.0, ud.f);
if (DOUBLE_ISNAN(ua)) ua.f = pcc_copysign(0.0, ua.f);
if (DOUBLE_ISNAN(ub)) ub.f = pcc_copysign(0.0, ub.f);
recalc = 1;
}
if (!recalc && (DOUBLE_ISINF(uac) || DOUBLE_ISINF(ubd) ||
DOUBLE_ISINF(uad) || DOUBLE_ISINF(ubc))) {
/* Recover infinities from overflow by
changing NaNs to 0 ... */
if (DOUBLE_ISNAN(ua)) ua.f = pcc_copysign(0.0, ua.f);
if (DOUBLE_ISNAN(ub)) ub.f = pcc_copysign(0.0, ub.f);
if (DOUBLE_ISNAN(uc)) uc.f = pcc_copysign(0.0, uc.f);
if (DOUBLE_ISNAN(ud)) ud.f = pcc_copysign(0.0, ud.f);
recalc = 1;
}
if (recalc) {
ux.f = __builtin_inf() * ( ua.f * uc.f - ub.f * ud.f );
uy.f = __builtin_inf() * ( ua.f * ud.f + ub.f * uc.f );
}
}
return ux.f + 1.0iF * uy.f;
}
double _Complex
__divdc3(double ax, double bx, double cx, double dx)
{
double denom;
union ud ua, ub, uc, ud, ur, ulogbw, ux, uy;
int uci, udi, res, ilogbw = 0;
ua.f = ax;
ub.f = bx;
uc.f = cx;
ud.f = dx;
/* fabsf; clear sign */
uci = uc.dih & DOUBLE_MANTEXP;
udi = ud.dih & DOUBLE_MANTEXP;
/* fmaxf; ordinary integer compare */
if ((uci > udi) || (uci == udi && uc.dil > ud.dil)) {
ur.dih = uci;
ur.dil = uc.dil;
} else {
ur.dih = udi;
ur.dil = ud.dil;
}
/* logbf */
res = ur.dih >> 20;
if (ur.dih == 0 && ur.dil == 0)
ulogbw.f = (double)-1.0/ur.f;
else if (res == 2047)
ulogbw.f = ur.f * ur.f;
else if (res == 0)
ulogbw.f = -1022.0;
else
ulogbw.f = (res-1023);
/* isfinite */
if (DOUBLE_ISFIN(ulogbw)) {
ilogbw = (int)ulogbw.f;
uc.f = pcc_scalbn(uc.f, -ilogbw);
ud.f = pcc_scalbn(ud.f, -ilogbw);
}
denom = uc.f * uc.f + ud.f * ud.f;
ux.f = pcc_scalbn((ua.f * uc.f + ub.f * ud.f) / denom, -ilogbw);
uy.f = pcc_scalbn((ub.f * uc.f - ua.f * ud.f) / denom, -ilogbw);
if (DOUBLE_ISNAN(ux) && DOUBLE_ISNAN(uy)) {
if ((denom == 0.0) &&
(!DOUBLE_ISNAN(ua) || !DOUBLE_ISNAN(ub))) {
ux.f = pcc_copysign(__builtin_inff(), uc.f) * ua.f;
uy.f = pcc_copysign(__builtin_inff(), uc.f) * ub.f;
} else if ((DOUBLE_ISINF(ua) || DOUBLE_ISINF(ub)) &&
DOUBLE_ISFIN(uc) && DOUBLE_ISFIN(ud)) {
ua.f = pcc_copysign(DOUBLE_ISINF(ua) ? 1.0 : 0.0, ua.f);
ub.f = pcc_copysign(DOUBLE_ISINF(ub) ? 1.0 : 0.0, ub.f);
ux.f = __builtin_inf() * ( ua.f * uc.f + ub.f * ud.f );
uy.f = __builtin_inf() * ( ub.f * uc.f - ua.f * ud.f );
} else if (DOUBLE_ISINF(ulogbw) &&
DOUBLE_ISFIN(ua) && DOUBLE_ISFIN(ub)) {
uc.f = pcc_copysign(DOUBLE_ISINF(uc) ? 1.0 : 0.0, uc.f);
ud.f = pcc_copysign(DOUBLE_ISINF(ud) ? 1.0 : 0.0, ud.f);
ux.f = 0.0 * ( ua.f * uc.f + ub.f * ud.f );
uy.f = 0.0 * ( ub.f * uc.f - ua.f * ud.f );
}
}
return ux.f + 1.0iF * uy.f;
}