/* bug found in nightly tests */
static void
test20071214 (void)
{
mpfr_t a, b;
int inex;
mpfr_init2 (a, 4);
mpfr_init2 (b, 4);
mpfr_set_ui_2exp (a, 3, -4, MPFR_RNDN);
inex = mpfr_sin_cos (a, b, a, MPFR_RNDD);
MPFR_ASSERTN(mpfr_cmp_ui_2exp (a, 11, -6) == 0);
MPFR_ASSERTN(mpfr_cmp_ui_2exp (b, 15, -4) == 0);
MPFR_ASSERTN(inex == 10);
mpfr_set_ui_2exp (a, 3, -4, MPFR_RNDN);
inex = mpfr_sin_cos (a, b, a, MPFR_RNDU);
MPFR_ASSERTN(mpfr_cmp_ui_2exp (a, 3, -4) == 0);
MPFR_ASSERTN(mpfr_cmp_ui (b, 1) == 0);
MPFR_ASSERTN(inex == 5);
mpfr_set_ui_2exp (a, 3, -4, MPFR_RNDN);
inex = mpfr_sin_cos (a, b, a, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui_2exp (a, 3, -4) == 0);
MPFR_ASSERTN(mpfr_cmp_ui (b, 1) == 0);
MPFR_ASSERTN(inex == 5);
mpfr_clear (a);
mpfr_clear (b);
}
/* bug found by Kevin P. Rauch on 22 Oct 2007 */
static void
check3 (void)
{
mpfr_t x, y, z;
int tern;
mpfr_exp_t emin;
emin = mpfr_get_emin ();
mpfr_init2 (x, 32);
mpfr_init2 (y, 32);
mpfr_init2 (z, 32);
mpfr_set_ui (x, 0xBFFFFFFFU, MPFR_RNDN); /* 3221225471/2^32 */
mpfr_set_ui (y, 0x80000001U, MPFR_RNDN); /* 2147483649/2^32 */
mpfr_set_exp (x, 0);
mpfr_set_exp (y, 0);
mpfr_set_emin (-1);
/* the exact product is 6917529028714823679/2^64, which is rounded to
3/8 = 0.375, which is smaller, thus tern < 0 */
tern = mpfr_mul (z, x, y, MPFR_RNDN);
MPFR_ASSERTN (tern < 0 && mpfr_cmp_ui_2exp (z, 3, -3) == 0);
tern = mpfr_subnormalize (z, tern, MPFR_RNDN);
/* since emin = -1, and EXP(z)=-1, z should be rounded to precision
EXP(z)-emin+1 = 1, i.e., z should be a multiple of the smallest possible
positive representable value with emin=-1, which is 1/4. The two
possible values are 1/4 and 2/4, which are at equal distance of z.
But since tern < 0, we should choose the largest value, i.e., 2/4. */
MPFR_ASSERTN (tern > 0 && mpfr_cmp_ui_2exp (z, 1, -1) == 0);
/* here is another test for the alternate case, where z was rounded up
first, thus we have to round down */
mpfr_set_str_binary (x, "0.11111111111010110101011011011011");
mpfr_set_str_binary (y, "0.01100000000001111100000000001110");
tern = mpfr_mul (z, x, y, MPFR_RNDN);
MPFR_ASSERTN (tern > 0 && mpfr_cmp_ui_2exp (z, 3, -3) == 0);
tern = mpfr_subnormalize (z, tern, MPFR_RNDN);
MPFR_ASSERTN (tern < 0 && mpfr_cmp_ui_2exp (z, 1, -2) == 0);
/* finally the case where z was exact, which we simulate here */
mpfr_set_ui_2exp (z, 3, -3, MPFR_RNDN);
tern = mpfr_subnormalize (z, 0, MPFR_RNDN);
MPFR_ASSERTN (tern > 0 && mpfr_cmp_ui_2exp (z, 1, -1) == 0);
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
MPFR_ASSERTN (mpfr_get_emin () == -1);
set_emin (emin);
}
static void
special (void)
{
mpfr_t x;
int i;
mpfr_init (x);
mpfr_set_nan (x);
mpfr_sinh (x, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (x));
mpfr_set_inf (x, 1);
mpfr_sinh (x, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) > 0);
mpfr_set_inf (x, -1);
mpfr_sinh (x, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) < 0);
mpfr_set_prec (x, 10);
mpfr_set_str_binary (x, "-0.1001011001");
mpfr_sinh (x, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_si_2exp (x, -159, -8) == 0);
/* corner case */
mpfr_set_prec (x, 2);
mpfr_set_str_binary (x, "1E-6");
mpfr_sinh (x, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui_2exp (x, 1, -6) == 0);
mpfr_clear_flags ();
mpfr_set_str_binary (x, "1E1000000000");
i = mpfr_sinh (x, x, MPFR_RNDN);
MPFR_ASSERTN (MPFR_IS_INF (x) && MPFR_SIGN (x) > 0);
MPFR_ASSERTN (mpfr_overflow_p ());
MPFR_ASSERTN (i == 1);
mpfr_clear_flags ();
mpfr_set_str_binary (x, "-1E1000000000");
i = mpfr_sinh (x, x, MPFR_RNDN);
MPFR_ASSERTN (MPFR_IS_INF (x) && MPFR_SIGN (x) < 0);
MPFR_ASSERTN (mpfr_overflow_p () && !mpfr_underflow_p ());
MPFR_ASSERTN (i == -1);
mpfr_clear_flags ();
mpfr_set_str_binary (x, "-1E1000000000");
i = mpfr_sinh (x, x, MPFR_RNDD);
MPFR_ASSERTN (MPFR_IS_INF (x) && MPFR_SIGN (x) < 0);
MPFR_ASSERTN (mpfr_overflow_p () && !mpfr_underflow_p ());
MPFR_ASSERTN (i == -1);
mpfr_clear_flags ();
mpfr_set_str_binary (x, "-1E1000000000");
i = mpfr_sinh (x, x, MPFR_RNDU);
MPFR_ASSERTN (!MPFR_IS_INF (x) && MPFR_SIGN (x) < 0);
MPFR_ASSERTN (mpfr_overflow_p () && !mpfr_underflow_p ());
MPFR_ASSERTN (i == 1);
mpfr_clear (x);
}
static void
test_reuse (void)
{
mpc_t z;
mpfr_t y;
int inex;
mpfr_init2 (y, 2);
mpc_init2 (z, 2);
mpc_set_si_si (z, 0, -1, MPC_RNDNN);
mpfr_neg (mpc_realref (z), mpc_realref (z), MPFR_RNDN);
mpc_div_2ui (z, z, 4, MPC_RNDNN);
mpfr_set_ui (y, 512, MPFR_RNDN);
inex = mpc_pow_fr (z, z, y, MPC_RNDNN);
if (MPC_INEX_RE(inex) != 0 || MPC_INEX_IM(inex) != 0 ||
mpfr_cmp_ui_2exp (mpc_realref(z), 1, -2048) != 0 ||
mpfr_cmp_ui (mpc_imagref(z), 0) != 0 || mpfr_signbit (mpc_imagref(z)) == 0)
{
printf ("Error in test_reuse, wrong ternary value or output\n");
printf ("inex=(%d %d)\n", MPC_INEX_RE(inex), MPC_INEX_IM(inex));
printf ("z="); mpc_out_str (stdout, 2, 0, z, MPC_RNDNN); printf ("\n");
exit (1);
}
mpfr_clear (y);
mpc_clear (z);
}
/* Bug found by Jakub Jelinek
* http://bugzilla.redhat.com/643657
* https://gforge.inria.fr/tracker/index.php?func=detail&aid=11301
* The consequence can be either an assertion failure (i = 2 in the
* testcase below, in debug mode) or an incorrectly rounded value.
*/
static void
bug20101017 (void)
{
mpfr_t a, b, c;
int inex;
int i;
mpfr_init2 (a, GMP_NUMB_BITS * 2);
mpfr_init2 (b, GMP_NUMB_BITS);
mpfr_init2 (c, GMP_NUMB_BITS);
/* a = 2^(2N) + k.2^(2N-1) + 2^N and b = 1
with N = GMP_NUMB_BITS and k = 0 or 1.
c = a - b should round to the same value as a. */
for (i = 2; i <= 3; i++)
{
mpfr_set_ui_2exp (a, i, GMP_NUMB_BITS - 1, MPFR_RNDN);
mpfr_add_ui (a, a, 1, MPFR_RNDN);
mpfr_mul_2ui (a, a, GMP_NUMB_BITS, MPFR_RNDN);
mpfr_set_ui (b, 1, MPFR_RNDN);
inex = mpfr_sub (c, a, b, MPFR_RNDN);
mpfr_set (b, a, MPFR_RNDN);
if (! mpfr_equal_p (c, b))
{
printf ("Error in bug20101017 for i = %d.\n", i);
printf ("Expected ");
mpfr_out_str (stdout, 16, 0, b, MPFR_RNDN);
putchar ('\n');
printf ("Got ");
mpfr_out_str (stdout, 16, 0, c, MPFR_RNDN);
putchar ('\n');
exit (1);
}
if (inex >= 0)
{
printf ("Error in bug20101017 for i = %d: bad inex value.\n", i);
printf ("Expected negative, got %d.\n", inex);
exit (1);
}
}
mpfr_set_prec (a, 64);
mpfr_set_prec (b, 129);
mpfr_set_prec (c, 2);
mpfr_set_str_binary (b, "0.100000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001E65");
mpfr_set_str_binary (c, "0.10E1");
inex = mpfr_sub (a, b, c, MPFR_RNDN);
if (mpfr_cmp_ui_2exp (a, 1, 64) != 0 || inex >= 0)
{
printf ("Error in mpfr_sub for b-c for b=2^64+1+2^(-64), c=1\n");
printf ("Expected result 2^64 with inex < 0\n");
printf ("Got ");
mpfr_print_binary (a);
printf (" with inex=%d\n", inex);
exit (1);
}
mpfr_clears (a, b, c, (mpfr_ptr) 0);
}
/* check case when c overlaps with a */
static void
check_case_2 (void)
{
mpfr_t a, b, c, d;
mpfr_init2 (a, 300);
mpfr_init2 (b, 800);
mpfr_init2 (c, 500);
mpfr_init2 (d, 800);
mpfr_set_str_binary(a, "1E110"); /* a = 2^110 */
mpfr_set_str_binary(b, "1E900"); /* b = 2^900 */
mpfr_set_str_binary(c, "1E500"); /* c = 2^500 */
test_add (c, c, a, MPFR_RNDZ); /* c = 2^500 + 2^110 */
mpfr_sub (d, b, c, MPFR_RNDZ); /* d = 2^900 - 2^500 - 2^110 */
test_add (b, b, c, MPFR_RNDZ); /* b = 2^900 + 2^500 + 2^110 */
test_add (a, b, d, MPFR_RNDZ); /* a = 2^901 */
if (mpfr_cmp_ui_2exp (a, 1, 901))
{
printf ("b + d fails for b=2^900+2^500+2^110, d=2^900-2^500-2^110\n");
printf ("expected 1.0e901, got ");
mpfr_out_str (stdout, 2, 0, a, MPFR_RNDN);
printf ("\n");
exit (1);
}
mpfr_clear (a);
mpfr_clear (b);
mpfr_clear (c);
mpfr_clear (d);
}
/* check case when c overlaps with a */
void
check_case_2 (void)
{
mpfr_t a, b, c, d;
mpfr_init2 (a, 300);
mpfr_init2 (b, 800);
mpfr_init2 (c, 500);
mpfr_init2 (d, 800);
mpfr_set_str_raw(a, "1E110"); /* a = 2^110 */
mpfr_set_str_raw(b, "1E900"); /* b = 2^900 */
mpfr_set_str_raw(c, "1E500"); /* c = 2^500 */
mpfr_add(c, c, a, GMP_RNDZ); /* c = 2^500 + 2^110 */
mpfr_sub(d, b, c, GMP_RNDZ); /* d = 2^900 - 2^500 - 2^110 */
mpfr_add(b, b, c, GMP_RNDZ); /* b = 2^900 + 2^500 + 2^110 */
mpfr_add(a, b, d, GMP_RNDZ); /* a = 2^901 */
if (mpfr_cmp_ui_2exp (a, 1, 901))
{
fprintf (stderr, "b + d fails for b=2^900+2^500+2^110, d=2^900-2^500-2^110\n");
fprintf (stderr, "expected 1.0e901, got ");
mpfr_out_str (stderr, 2, 0, a, GMP_RNDN);
fprintf (stderr, "\n");
exit (1);
}
mpfr_clear (a);
mpfr_clear (b);
mpfr_clear (c);
mpfr_clear (d);
}
static void
bug20091013 (void)
{
mpfr_t x, y;
int inex;
mpfr_init2 (x, 17);
mpfr_init2 (y, 2);
mpfr_set_str_binary (x, "0.10000000000000000E-16");
inex = mpfr_li2 (y, x, MPFR_RNDN);
if (mpfr_cmp_ui_2exp (y, 1, -17) != 0)
{
printf ("Error in bug20091013()\n");
printf ("expected 2^(-17)\n");
printf ("got ");
mpfr_dump (y);
exit (1);
}
if (inex >= 0)
{
printf ("Error in bug20091013()\n");
printf ("expected negative ternary value, got %d\n", inex);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
int
main (int argc, char *argv[])
{
mpfr_t x;
int ret;
mpfr_exp_t emin, emax;
tests_start_mpfr ();
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
mpfr_init (x);
mpfr_set_ui (x, 1, MPFR_RNDN);
ret = mpfr_set_exp (x, 2);
MPFR_ASSERTN(ret == 0 && mpfr_cmp_ui (x, 2) == 0);
set_emin (-1);
ret = mpfr_set_exp (x, -1);
MPFR_ASSERTN(ret == 0 && mpfr_cmp_ui_2exp (x, 1, -2) == 0);
set_emax (1);
ret = mpfr_set_exp (x, 1);
MPFR_ASSERTN(ret == 0 && mpfr_cmp_ui (x, 1) == 0);
ret = mpfr_set_exp (x, -2);
MPFR_ASSERTN(ret != 0 && mpfr_cmp_ui (x, 1) == 0);
ret = mpfr_set_exp (x, 2);
MPFR_ASSERTN(ret != 0 && mpfr_cmp_ui (x, 1) == 0);
mpfr_clear (x);
set_emin (emin);
set_emax (emax);
tests_end_mpfr ();
return 0;
}
int
main (int argc, char *argv[])
{
mpfr_t x, y, z;
unsigned long k, n;
volatile double d;
double dd;
tests_start_mpfr ();
mpfr_test_init ();
#ifndef MPFR_DOUBLE_SPEC
printf ("Warning! The MPFR_DOUBLE_SPEC macro is not defined. This means\n"
"that you do not have a conforming C implementation and problems\n"
"may occur with conversions between MPFR numbers and standard\n"
"floating-point types. Please contact the MPFR team.\n");
#elif MPFR_DOUBLE_SPEC == 0
/*
printf ("The type 'double' of your C implementation does not seem to\n"
"correspond to the IEEE-754 double precision. Though code has\n"
"been written to support such implementations, tests have been\n"
"done only on IEEE-754 double-precision implementations and\n"
"conversions between MPFR numbers and standard floating-point\n"
"types may be inaccurate. You may wish to contact the MPFR team\n"
"for further testing.\n");
*/
printf ("The type 'double' of your C implementation does not seem to\n"
"correspond to the IEEE-754 double precision. Such particular\n"
"implementations are not supported yet, and conversions between\n"
"MPFR numbers and standard floating-point types may be very\n"
"inaccurate.\n");
printf ("FLT_RADIX = %ld\n", (long) FLT_RADIX);
printf ("DBL_MANT_DIG = %ld\n", (long) DBL_MANT_DIG);
printf ("DBL_MIN_EXP = %ld\n", (long) DBL_MIN_EXP);
printf ("DBL_MAX_EXP = %ld\n", (long) DBL_MAX_EXP);
#endif
mpfr_init (x);
mpfr_set_nan (x);
d = mpfr_get_d (x, MPFR_RNDN);
if (! DOUBLE_ISNAN (d))
{
printf ("ERROR for NAN (1)\n");
#ifdef MPFR_NANISNAN
printf ("The reason is that NAN == NAN. Please look at the configure "
"output\nand Section \"In case of problem\" of the INSTALL "
"file.\n");
#endif
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_set_d (x, d, MPFR_RNDN);
if (! mpfr_nan_p (x))
{
printf ("ERROR for NAN (2)\n");
#ifdef MPFR_NANISNAN
printf ("The reason is that NAN == NAN. Please look at the configure "
"output\nand Section \"In case of problem\" of the INSTALL "
"file.\n");
#endif
exit (1);
}
d = 0.0;
mpfr_set_d (x, d, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (x, 0) == 0 && MPFR_IS_POS(x));
d = -d;
mpfr_set_d (x, d, MPFR_RNDN);
if (mpfr_cmp_ui (x, 0) != 0 || MPFR_IS_POS(x))
{
printf ("Error in mpfr_set_d on -0\n");
exit (1);
}
mpfr_set_inf (x, 1);
d = mpfr_get_d (x, MPFR_RNDN);
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_set_d (x, d, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) > 0);
mpfr_set_inf (x, -1);
d = mpfr_get_d (x, MPFR_RNDN);
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_set_d (x, d, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) < 0);
mpfr_set_prec (x, 2);
/* checks that denormalized are not flushed to zero */
d = DBL_MIN; /* 2^(-1022) */
for (n=0; n<52; n++, d /= 2.0)
if (d != 0.0) /* should be 2^(-1022-n) */
{
mpfr_set_d (x, d, MPFR_RNDN);
if (mpfr_cmp_ui_2exp (x, 1, -1022-n))
{
printf ("Wrong result for d=2^(%ld), ", -1022-n);
printf ("got ");
mpfr_out_str (stdout, 10, 10, x, MPFR_RNDN);
printf ("\n");
mpfr_print_binary (x);
puts ("");
exit (1);
}
}
/* checks that rounds to nearest sets the last
bit to zero in case of equal distance */
mpfr_set_d (x, 5.0, MPFR_RNDN);
if (mpfr_cmp_ui (x, 4))
{
printf ("Error in tset_d: expected 4.0, got ");
mpfr_print_binary (x); putchar('\n');
exit (1);
}
mpfr_set_d (x, -5.0, MPFR_RNDN);
if (mpfr_cmp_si (x, -4))
{
printf ("Error in tset_d: expected -4.0, got ");
mpfr_print_binary (x); putchar('\n');
exit (1);
}
mpfr_set_d (x, 9.84891017624509146344e-01, MPFR_RNDU);
if (mpfr_cmp_ui (x, 1))
{
printf ("Error in tset_d: expected 1.0, got ");
mpfr_print_binary (x); putchar('\n');
exit (1);
}
mpfr_init2 (z, 32);
mpfr_set_d (z, 1.0, (mpfr_rnd_t) 0);
if (mpfr_cmp_ui (z, 1))
{
mpfr_print_binary (z); puts ("");
printf ("Error: 1.0 != 1.0\n");
exit (1);
}
mpfr_set_prec (x, 53);
mpfr_init2 (y, 53);
mpfr_set_d (x, d=-1.08007920352320089721e+150, (mpfr_rnd_t) 0);
if (mpfr_get_d1 (x) != d)
{
mpfr_print_binary (x); puts ("");
printf ("Error: get_d o set_d <> identity for d = %1.20e %1.20e\n",
d, mpfr_get_d1 (x));
exit (1);
}
mpfr_set_d (x, 8.06294740693074521573e-310, (mpfr_rnd_t) 0);
d = -6.72658901114033715233e-165;
mpfr_set_d (x, d, (mpfr_rnd_t) 0);
if (d != mpfr_get_d1 (x))
{
mpfr_print_binary (x);
puts ("");
printf ("Error: get_d o set_d <> identity for d = %1.20e %1.20e\n",
d, mpfr_get_d1 (x));
exit (1);
}
n = (argc==1) ? 500000 : atoi(argv[1]);
for (k = 1; k <= n; k++)
{
do
{
d = DBL_RAND ();
}
#ifdef HAVE_DENORMS
while (0);
#else
while (ABS(d) < DBL_MIN);
#endif
mpfr_set_d (x, d, (mpfr_rnd_t) 0);
dd = mpfr_get_d1 (x);
if (d != dd && !(Isnan(d) && Isnan(dd)))
{
printf ("Mismatch on : %1.18g != %1.18g\n", d, mpfr_get_d1 (x));
mpfr_print_binary (x);
puts ("");
exit (1);
}
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
tests_end_mpfr ();
return 0;
}
int
main (int argc, char *argv[])
{
mpfr_t x, y;
mpfr_exp_t emin, emax;
tests_start_mpfr ();
special_overflow ();
emax_m_eps ();
exp_range ();
mpfr_init (x);
mpfr_init (y);
mpfr_set_ui (x, 4, MPFR_RNDN);
mpfr_exp2 (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 16) != 0)
{
printf ("Error for 2^4, MPFR_RNDN\n");
exit (1);
}
mpfr_exp2 (y, x, MPFR_RNDD);
if (mpfr_cmp_ui (y, 16) != 0)
{
printf ("Error for 2^4, MPFR_RNDD\n");
exit (1);
}
mpfr_exp2 (y, x, MPFR_RNDU);
if (mpfr_cmp_ui (y, 16) != 0)
{
printf ("Error for 2^4, MPFR_RNDU\n");
exit (1);
}
mpfr_set_si (x, -4, MPFR_RNDN);
mpfr_exp2 (y, x, MPFR_RNDN);
if (mpfr_cmp_ui_2exp (y, 1, -4) != 0)
{
printf ("Error for 2^(-4), MPFR_RNDN\n");
exit (1);
}
mpfr_exp2 (y, x, MPFR_RNDD);
if (mpfr_cmp_ui_2exp (y, 1, -4) != 0)
{
printf ("Error for 2^(-4), MPFR_RNDD\n");
exit (1);
}
mpfr_exp2 (y, x, MPFR_RNDU);
if (mpfr_cmp_ui_2exp (y, 1, -4) != 0)
{
printf ("Error for 2^(-4), MPFR_RNDU\n");
exit (1);
}
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str (x, /*-1683977482443233.0 / 2199023255552.0*/
"-7.6578429909351734750089235603809357e2", 10, MPFR_RNDN);
mpfr_exp2 (y, x, MPFR_RNDN);
if (mpfr_cmp_str1 (y, "2.991959870867646566478e-231"))
{
printf ("Error for x=-1683977482443233/2^41\n");
exit (1);
}
mpfr_set_prec (x, 10);
mpfr_set_prec (y, 10);
/* save emin */
emin = mpfr_get_emin ();
set_emin (-10);
mpfr_set_si (x, -12, MPFR_RNDN);
mpfr_exp2 (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 0) || mpfr_sgn (y) < 0)
{
printf ("Error for x=emin-2, RNDN\n");
printf ("Expected +0\n");
printf ("Got "); mpfr_print_binary (y); puts ("");
exit (1);
}
/* restore emin */
set_emin (emin);
/* save emax */
emax = mpfr_get_emax ();
set_emax (10);
mpfr_set_ui (x, 11, MPFR_RNDN);
mpfr_exp2 (y, x, MPFR_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error for x=emax+1, RNDN\n");
exit (1);
}
/* restore emax */
set_emax (emax);
MPFR_SET_INF(x);
MPFR_SET_POS(x);
mpfr_exp2 (y, x, MPFR_RNDN);
if(!MPFR_IS_INF(y))
{
printf ("evaluation of function in INF does not return INF\n");
exit (1);
}
MPFR_CHANGE_SIGN(x);
mpfr_exp2 (y, x, MPFR_RNDN);
if(!MPFR_IS_ZERO(y))
{
printf ("evaluation of function in -INF does not return 0\n");
exit (1);
}
MPFR_SET_NAN(x);
mpfr_exp2 (y, x, MPFR_RNDN);
if(!MPFR_IS_NAN(y))
{
printf ("evaluation of function in NaN does not return NaN\n");
exit (1);
}
if ((mpfr_uexp_t) 8 << 31 != 0 ||
mpfr_get_emax () <= (mpfr_uexp_t) 100000 * 100000)
{
/* emax <= 10000000000 */
mpfr_set_prec (x, 40);
mpfr_set_prec (y, 40);
mpfr_set_str (x, "10000000000.5", 10, MPFR_RNDN);
mpfr_clear_flags ();
mpfr_exp2 (y, x, MPFR_RNDN);
if (!(MPFR_IS_INF (y) && MPFR_IS_POS (y) && mpfr_overflow_p ()))
{
printf ("exp2(10000000000.5) should overflow.\n");
exit (1);
}
}
mpfr_set_prec (x, 2);
mpfr_set_prec (y, 2);
mpfr_set_str_binary (x, "-1.0E-26");
mpfr_exp2 (y, x, MPFR_RNDD);
mpfr_set_str_binary (x, "1.1E-1");
if (mpfr_cmp (x, y))
{
printf ("Error for exp(-2^(-26)) for prec=2\n");
exit (1);
}
test_generic (2, 100, 100);
mpfr_clear (x);
mpfr_clear (y);
overflowed_exp2_0 ();
data_check ("data/exp2", mpfr_exp2, "mpfr_exp2");
tests_end_mpfr ();
return 0;
}
static void
special (void)
{
mpfr_t x, y, z;
int inexact;
mpfr_prec_t p;
mpfr_init (x);
mpfr_init (y);
mpfr_init (z);
mpfr_set_prec (x, 64);
mpfr_set_str_binary (x, "1010000010100011011001010101010010001100001101011101110001011001E-1");
mpfr_set_prec (y, 32);
test_sqrt (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 2405743844UL))
{
printf ("Error for n^2+n+1/2 with n=2405743843\n");
exit (1);
}
mpfr_set_prec (x, 65);
mpfr_set_str_binary (x, "10100000101000110110010101010100100011000011010111011100010110001E-2");
mpfr_set_prec (y, 32);
test_sqrt (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 2405743844UL))
{
printf ("Error for n^2+n+1/4 with n=2405743843\n");
mpfr_dump (y);
exit (1);
}
mpfr_set_prec (x, 66);
mpfr_set_str_binary (x, "101000001010001101100101010101001000110000110101110111000101100011E-3");
mpfr_set_prec (y, 32);
test_sqrt (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 2405743844UL))
{
printf ("Error for n^2+n+1/4+1/8 with n=2405743843\n");
mpfr_dump (y);
exit (1);
}
mpfr_set_prec (x, 66);
mpfr_set_str_binary (x, "101000001010001101100101010101001000110000110101110111000101100001E-3");
mpfr_set_prec (y, 32);
test_sqrt (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 2405743843UL))
{
printf ("Error for n^2+n+1/8 with n=2405743843\n");
mpfr_dump (y);
exit (1);
}
mpfr_set_prec (x, 27);
mpfr_set_str_binary (x, "0.110100111010101000010001011");
if ((inexact = test_sqrt (x, x, MPFR_RNDZ)) >= 0)
{
printf ("Wrong inexact flag: expected -1, got %d\n", inexact);
exit (1);
}
mpfr_set_prec (x, 2);
for (p=2; p<1000; p++)
{
mpfr_set_prec (z, p);
mpfr_set_ui (z, 1, MPFR_RNDN);
mpfr_nexttoinf (z);
test_sqrt (x, z, MPFR_RNDU);
if (mpfr_cmp_ui_2exp(x, 3, -1))
{
printf ("Error: sqrt(1+ulp(1), up) should give 1.5 (prec=%u)\n",
(unsigned int) p);
printf ("got "); mpfr_print_binary (x); puts ("");
exit (1);
}
}
/* check inexact flag */
mpfr_set_prec (x, 5);
mpfr_set_str_binary (x, "1.1001E-2");
if ((inexact = test_sqrt (x, x, MPFR_RNDN)))
{
printf ("Wrong inexact flag: expected 0, got %d\n", inexact);
exit (1);
}
mpfr_set_prec (x, 2);
mpfr_set_prec (z, 2);
/* checks the sign is correctly set */
mpfr_set_si (x, 1, MPFR_RNDN);
mpfr_set_si (z, -1, MPFR_RNDN);
test_sqrt (z, x, MPFR_RNDN);
if (mpfr_cmp_ui (z, 0) < 0)
{
printf ("Error: square root of 1 gives ");
mpfr_print_binary(z);
putchar('\n');
exit (1);
}
mpfr_set_prec (x, 192);
mpfr_set_prec (z, 160);
mpfr_set_str_binary (z, "0.1011010100000100100100100110011001011100100100000011000111011001011101101101110000110100001000100001100001011000E1");
mpfr_set_prec (x, 160);
test_sqrt(x, z, MPFR_RNDN);
test_sqrt(z, x, MPFR_RNDN);
mpfr_set_prec (x, 53);
mpfr_set_str (x, "8093416094703476.0", 10, MPFR_RNDN);
mpfr_div_2exp (x, x, 1075, MPFR_RNDN);
test_sqrt (x, x, MPFR_RNDN);
mpfr_set_str (z, "1e55596835b5ef@-141", 16, MPFR_RNDN);
if (mpfr_cmp (x, z))
{
printf ("Error: square root of 8093416094703476*2^(-1075)\n");
printf ("expected "); mpfr_dump (z);
printf ("got "); mpfr_dump (x);
exit (1);
}
mpfr_set_prec (x, 33);
mpfr_set_str_binary (x, "0.111011011011110001100111111001000e-10");
mpfr_set_prec (z, 157);
inexact = test_sqrt (z, x, MPFR_RNDN);
mpfr_set_prec (x, 157);
mpfr_set_str_binary (x, "0.11110110101100101111001011100011100011100001101010111011010000100111011000111110100001001011110011111100101110010110010110011001011011010110010000011001101E-5");
if (mpfr_cmp (x, z))
{
printf ("Error: square root (1)\n");
exit (1);
}
if (inexact <= 0)
{
printf ("Error: wrong inexact flag (1)\n");
exit (1);
}
/* case prec(result) << prec(input) */
mpfr_set_prec (z, 2);
for (p = 2; p < 1000; p++)
{
mpfr_set_prec (x, p);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_nextabove (x);
/* 1.0 < x <= 1.5 thus 1 < sqrt(x) <= 1.23 */
inexact = test_sqrt (z, x, MPFR_RNDN);
MPFR_ASSERTN(inexact < 0 && mpfr_cmp_ui (z, 1) == 0);
inexact = test_sqrt (z, x, MPFR_RNDZ);
MPFR_ASSERTN(inexact < 0 && mpfr_cmp_ui (z, 1) == 0);
inexact = test_sqrt (z, x, MPFR_RNDU);
MPFR_ASSERTN(inexact > 0 && mpfr_cmp_ui_2exp (z, 3, -1) == 0);
inexact = test_sqrt (z, x, MPFR_RNDD);
MPFR_ASSERTN(inexact < 0 && mpfr_cmp_ui (z, 1) == 0);
inexact = test_sqrt (z, x, MPFR_RNDA);
MPFR_ASSERTN(inexact > 0 && mpfr_cmp_ui_2exp (z, 3, -1) == 0);
}
/* corner case rw = 0 in rounding to nearest */
mpfr_set_prec (z, GMP_NUMB_BITS - 1);
mpfr_set_prec (y, GMP_NUMB_BITS - 1);
mpfr_set_ui (y, 1, MPFR_RNDN);
mpfr_mul_2exp (y, y, GMP_NUMB_BITS - 1, MPFR_RNDN);
mpfr_nextabove (y);
for (p = 2 * GMP_NUMB_BITS - 1; p <= 1000; p++)
{
mpfr_set_prec (x, p);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_set_exp (x, GMP_NUMB_BITS);
mpfr_add_ui (x, x, 1, MPFR_RNDN);
/* now x = 2^(GMP_NUMB_BITS - 1) + 1 (GMP_NUMB_BITS bits) */
MPFR_ASSERTN (mpfr_mul (x, x, x, MPFR_RNDN) == 0); /* exact */
inexact = test_sqrt (z, x, MPFR_RNDN);
/* even rule: z should be 2^(GMP_NUMB_BITS - 1) */
MPFR_ASSERTN (inexact < 0);
MPFR_ASSERTN (mpfr_cmp_ui_2exp (z, 1, GMP_NUMB_BITS - 1) == 0);
mpfr_nextbelow (x);
/* now x is just below [2^(GMP_NUMB_BITS - 1) + 1]^2 */
inexact = test_sqrt (z, x, MPFR_RNDN);
MPFR_ASSERTN(inexact < 0 &&
mpfr_cmp_ui_2exp (z, 1, GMP_NUMB_BITS - 1) == 0);
mpfr_nextabove (x);
mpfr_nextabove (x);
/* now x is just above [2^(GMP_NUMB_BITS - 1) + 1]^2 */
inexact = test_sqrt (z, x, MPFR_RNDN);
if (mpfr_cmp (z, y))
{
printf ("Error for sqrt(x) in rounding to nearest\n");
printf ("x="); mpfr_dump (x);
printf ("Expected "); mpfr_dump (y);
printf ("Got "); mpfr_dump (z);
exit (1);
}
if (inexact <= 0)
{
printf ("Wrong inexact flag in corner case for p = %lu\n", (unsigned long) p);
exit (1);
}
}
mpfr_set_prec (x, 1000);
mpfr_set_ui (x, 9, MPFR_RNDN);
mpfr_set_prec (y, 10);
inexact = test_sqrt (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 3) || inexact != 0)
{
printf ("Error in sqrt(9:1000) for prec=10\n");
exit (1);
}
mpfr_set_prec (y, GMP_NUMB_BITS);
mpfr_nextabove (x);
inexact = test_sqrt (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 3) || inexact >= 0)
{
printf ("Error in sqrt(9:1000) for prec=%d\n", (int) GMP_NUMB_BITS);
exit (1);
}
mpfr_set_prec (x, 2 * GMP_NUMB_BITS);
mpfr_set_prec (y, GMP_NUMB_BITS);
mpfr_set_ui (y, 1, MPFR_RNDN);
mpfr_nextabove (y);
mpfr_set (x, y, MPFR_RNDN);
inexact = test_sqrt (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 1) || inexact >= 0)
{
printf ("Error in sqrt(1) for prec=%d\n", (int) GMP_NUMB_BITS);
mpfr_dump (y);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
}
int
main (int argc, char *argv[])
{
mpfr_t x, c, s, c2, s2;
tests_start_mpfr ();
check_regression ();
check_nans ();
/* worst case from PhD thesis of Vincent Lefe`vre: x=8980155785351021/2^54 */
check53 ("4.984987858808754279e-1", "4.781075595393330379e-1", MPFR_RNDN);
check53 ("4.984987858808754279e-1", "4.781075595393329824e-1", MPFR_RNDD);
check53 ("4.984987858808754279e-1", "4.781075595393329824e-1", MPFR_RNDZ);
check53 ("4.984987858808754279e-1", "4.781075595393330379e-1", MPFR_RNDU);
check53 ("1.00031274099908640274", "8.416399183372403892e-1", MPFR_RNDN);
check53 ("1.00229256850978698523", "8.427074524447979442e-1", MPFR_RNDZ);
check53 ("1.00288304857059840103", "8.430252033025980029e-1", MPFR_RNDZ);
check53 ("1.00591265847407274059", "8.446508805292128885e-1", MPFR_RNDN);
/* Other worst cases showing a bug introduced on 2005-01-29 in rev 3248 */
check53b ("1.0111001111010111010111111000010011010001110001111011e-21",
"1.0111001111010111010111111000010011010001101001110001e-21",
MPFR_RNDU);
check53b ("1.1011101111111010000001010111000010000111100100101101",
"1.1111100100101100001111100000110011110011010001010101e-1",
MPFR_RNDU);
mpfr_init2 (x, 2);
mpfr_set_str (x, "0.5", 10, MPFR_RNDN);
test_sin (x, x, MPFR_RNDD);
if (mpfr_cmp_ui_2exp (x, 3, -3)) /* x != 0.375 = 3/8 */
{
printf ("mpfr_sin(0.5, MPFR_RNDD) failed with precision=2\n");
exit (1);
}
/* bug found by Kevin Ryde */
mpfr_const_pi (x, MPFR_RNDN);
mpfr_mul_ui (x, x, 3L, MPFR_RNDN);
mpfr_div_ui (x, x, 2L, MPFR_RNDN);
test_sin (x, x, MPFR_RNDN);
if (mpfr_cmp_ui (x, 0) >= 0)
{
printf ("Error: wrong sign for sin(3*Pi/2)\n");
exit (1);
}
/* Can fail on an assert */
mpfr_set_prec (x, 53);
mpfr_set_str (x, "77291789194529019661184401408", 10, MPFR_RNDN);
mpfr_init2 (c, 4); mpfr_init2 (s, 42);
mpfr_init2 (c2, 4); mpfr_init2 (s2, 42);
test_sin (s, x, MPFR_RNDN);
mpfr_cos (c, x, MPFR_RNDN);
mpfr_sin_cos (s2, c2, x, MPFR_RNDN);
if (mpfr_cmp (c2, c))
{
printf("cos differs for x=77291789194529019661184401408");
exit (1);
}
if (mpfr_cmp (s2, s))
{
printf("sin differs for x=77291789194529019661184401408");
exit (1);
}
mpfr_set_str_binary (x, "1.1001001000011111101101010100010001000010110100010011");
test_sin (x, x, MPFR_RNDZ);
if (mpfr_cmp_str (x, "1.1111111111111111111111111111111111111111111111111111e-1", 2, MPFR_RNDN))
{
printf ("Error for x= 1.1001001000011111101101010100010001000010110100010011\nGot ");
mpfr_dump (x);
exit (1);
}
mpfr_set_prec (s, 9);
mpfr_set_prec (x, 190);
mpfr_const_pi (x, MPFR_RNDN);
mpfr_sin (s, x, MPFR_RNDZ);
if (mpfr_cmp_str (s, "0.100000101e-196", 2, MPFR_RNDN))
{
printf ("Error for x ~= pi\n");
mpfr_dump (s);
exit (1);
}
mpfr_clear (s2);
mpfr_clear (c2);
mpfr_clear (s);
mpfr_clear (c);
mpfr_clear (x);
test_generic (2, 100, 15);
test_generic (MPFR_SINCOS_THRESHOLD-1, MPFR_SINCOS_THRESHOLD+1, 2);
test_sign ();
check_tiny ();
data_check ("data/sin", mpfr_sin, "mpfr_sin");
bad_cases (mpfr_sin, mpfr_asin, "mpfr_sin", 256, -40, 0, 4, 128, 800, 50);
tests_end_mpfr ();
return 0;
}
int
main (void)
{
mpfr_t x, u;
mpf_t y, z;
mpfr_exp_t emax;
unsigned long k, pr;
int r, inexact;
tests_start_mpfr ();
mpf_init (y);
mpf_init (z);
mpf_set_d (y, 0.0);
/* check prototype of mpfr_init_set_f */
mpfr_init_set_f (x, y, MPFR_RNDN);
mpfr_set_prec (x, 100);
mpfr_set_f (x, y, MPFR_RNDN);
mpf_urandomb (y, RANDS, 10 * GMP_NUMB_BITS);
mpfr_set_f (x, y, RND_RAND ());
/* bug found by Jean-Pierre Merlet */
mpfr_set_prec (x, 256);
mpf_set_prec (y, 256);
mpfr_init2 (u, 256);
mpfr_set_str (u,
"7.f10872b020c49ba5e353f7ced916872b020c49ba5e353f7ced916872b020c498@2",
16, MPFR_RNDN);
mpf_set_str (y, "2033033E-3", 10); /* avoid 2033.033 which is
locale-sensitive */
mpfr_set_f (x, y, MPFR_RNDN);
if (mpfr_cmp (x, u))
{
printf ("mpfr_set_f failed for y=2033033E-3\n");
exit (1);
}
mpf_set_str (y, "-2033033E-3", 10); /* avoid -2033.033 which is
locale-sensitive */
mpfr_set_f (x, y, MPFR_RNDN);
mpfr_neg (u, u, MPFR_RNDN);
if (mpfr_cmp (x, u))
{
printf ("mpfr_set_f failed for y=-2033033E-3\n");
exit (1);
}
mpf_set_prec (y, 300);
mpf_set_str (y, "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", -2);
mpf_mul_2exp (y, y, 600);
mpfr_set_prec (x, 300);
mpfr_set_f (x, y, MPFR_RNDN);
if (mpfr_check (x) == 0)
{
printf ("Error in mpfr_set_f: corrupted result\n");
mpfr_dump (x);
exit (1);
}
MPFR_ASSERTN(mpfr_cmp_ui_2exp (x, 1, 901) == 0);
/* random values */
for (k = 1; k <= 1000; k++)
{
pr = 2 + (randlimb () & 255);
mpf_set_prec (z, pr);
mpf_urandomb (z, RANDS, z->_mp_prec);
mpfr_set_prec (u, ((pr / GMP_NUMB_BITS + 1) * GMP_NUMB_BITS));
mpfr_set_f (u, z, MPFR_RNDN);
if (mpfr_cmp_f (u , z) != 0)
{
printf ("Error in mpfr_set_f:\n");
printf ("mpf (precision=%lu)=", pr);
mpf_out_str (stdout, 16, 0, z);
printf ("\nmpfr(precision=%lu)=",
((pr / GMP_NUMB_BITS + 1) * GMP_NUMB_BITS));
mpfr_out_str (stdout, 16, 0, u, MPFR_RNDN);
putchar ('\n');
exit (1);
}
mpfr_set_prec (x, pr);
mpfr_set_f (x, z, MPFR_RNDN);
mpfr_sub (u, u, x, MPFR_RNDN);
mpfr_abs (u, u, MPFR_RNDN);
if (mpfr_cmp_ui_2exp (u, 1, -pr - 1) > 0)
{
printf ("Error in mpfr_set_f: precision=%lu\n", pr);
printf ("mpf =");
mpf_out_str (stdout, 16, 0, z);
printf ("\nmpfr=");
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
}
/* Check for +0 */
mpfr_set_prec (x, 53);
mpf_set_prec (y, 53);
mpf_set_ui (y, 0);
for (r = 0 ; r < MPFR_RND_MAX ; r++)
{
int i;
for (i = -1; i <= 1; i++)
{
if (i)
mpfr_set_si (x, i, MPFR_RNDN);
inexact = mpfr_set_f (x, y, (mpfr_rnd_t) r);
if (!MPFR_IS_ZERO(x) || !MPFR_IS_POS(x) || inexact)
{
printf ("mpfr_set_f(x,0) failed for %s, i = %d\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r), i);
exit (1);
}
}
}
/* coverage test */
mpf_set_prec (y, 2);
mpfr_set_prec (x, 3 * mp_bits_per_limb);
mpf_set_ui (y, 1);
for (r = 0; r < mp_bits_per_limb; r++)
{
mpfr_urandomb (x, RANDS); /* to fill low limbs with random data */
inexact = mpfr_set_f (x, y, MPFR_RNDN);
MPFR_ASSERTN(inexact == 0 && mpfr_cmp_ui_2exp (x, 1, r) == 0);
mpf_mul_2exp (y, y, 1);
}
mpf_set_ui (y, 1);
mpf_mul_2exp (y, y, ULONG_MAX);
mpfr_set_f (x, y, MPFR_RNDN);
mpfr_set_ui (u, 1, MPFR_RNDN);
mpfr_mul_2ui (u, u, ULONG_MAX, MPFR_RNDN);
if (!mpfr_equal_p (x, u))
{
printf ("Error: mpfr_set_f (x, y, MPFR_RNDN) for y = 2^ULONG_MAX\n");
exit (1);
}
emax = mpfr_get_emax ();
/* For mpf_mul_2exp, emax must fit in an unsigned long! */
if (emax >= 0 && emax <= ULONG_MAX)
{
mpf_set_ui (y, 1);
mpf_mul_2exp (y, y, emax);
mpfr_set_f (x, y, MPFR_RNDN);
mpfr_set_ui_2exp (u, 1, emax, MPFR_RNDN);
if (!mpfr_equal_p (x, u))
{
printf ("Error: mpfr_set_f (x, y, MPFR_RNDN) for y = 2^emax\n");
exit (1);
}
}
/* For mpf_mul_2exp, emax - 1 must fit in an unsigned long! */
if (emax >= 1 && emax - 1 <= ULONG_MAX)
{
mpf_set_ui (y, 1);
mpf_mul_2exp (y, y, emax - 1);
mpfr_set_f (x, y, MPFR_RNDN);
mpfr_set_ui_2exp (u, 1, emax - 1, MPFR_RNDN);
if (!mpfr_equal_p (x, u))
{
printf ("Error: mpfr_set_f (x, y, MPFR_RNDN) for y = 2^(emax-1)\n");
exit (1);
}
}
mpfr_clear (x);
mpfr_clear (u);
mpf_clear (y);
mpf_clear (z);
tests_end_mpfr ();
return 0;
}
static void
test_nonspecial (void)
{
mpfr_t x, y;
int inex;
mpfr_init2 (x, 10);
mpfr_init2 (y, 10);
/* case where the computation on n+1 bits ends with a '0' */
mpfr_set_ui (x, 2, MPFR_RNDN);
inex = mpfr_round_nearest_away (mpfr_sin, y, x);
if (inex >= 0)
{
printf ("Wrong ternary value for sin(2)\n");
exit (1);
}
if (mpfr_cmp_ui_2exp (y, 931, -10) != 0)
{
printf ("Wrong output for sin(2)\n");
exit (1);
}
/* case where the computation on n+1 bits ends with a '1' and is exact */
mpfr_set_ui (x, 37, MPFR_RNDN);
inex = mpfr_round_nearest_away (mpfr_sqr, y, x);
if (inex <= 0)
{
printf ("Wrong ternary value for sqr(37)\n");
exit (1);
}
if (mpfr_cmp_ui (y, 1370) != 0)
{
printf ("Wrong output for sqr(37)\n");
exit (1);
}
/* case where the computation on n+1 bits ends with a '1' but is inexact */
mpfr_set_ui (x, 91, MPFR_RNDN);
inex = mpfr_round_nearest_away (mpfr_sqr, y, x);
if (inex <= 0)
{
printf ("Wrong ternary value for sqr(91)\n");
exit (1);
}
if (mpfr_cmp_ui (y, 8288) != 0)
{
printf ("Wrong output for sqr(91)\n");
exit (1);
}
mpfr_set_ui (x, 131, MPFR_RNDN);
inex = mpfr_round_nearest_away (mpfr_sqr, y, x);
if (inex >= 0)
{
printf ("Wrong ternary value for sqr(131)\n");
exit (1);
}
if (mpfr_cmp_ui (y, 17152) != 0)
{
printf ("Wrong output for sqr(131)\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
static void
test1 (void)
{
mpfr_t x, y;
mpfr_init2 (x, 32);
mpfr_init2 (y, 42);
mpfr_set_str_binary (x, "1.1111111101000111011010010010100e-1");
mpfr_zeta (y, x, MPFR_RNDN); /* shouldn't crash */
mpfr_set_prec (x, 40);
mpfr_set_prec (y, 50);
mpfr_set_str_binary (x, "1.001101001101000010011010110100110000101e-1");
mpfr_zeta (y, x, MPFR_RNDU);
mpfr_set_prec (x, 50);
mpfr_set_str_binary (x, "-0.11111100011100111111101111100011110111001111111111E1");
if (mpfr_cmp (x, y))
{
printf ("Error for input on 40 bits, output on 50 bits\n");
printf ("Expected "); mpfr_print_binary (x); puts ("");
printf ("Got "); mpfr_print_binary (y); puts ("");
mpfr_set_str_binary (x, "1.001101001101000010011010110100110000101e-1");
mpfr_zeta (y, x, MPFR_RNDU);
mpfr_print_binary (x); puts ("");
mpfr_print_binary (y); puts ("");
exit (1);
}
mpfr_set_prec (x, 2);
mpfr_set_prec (y, 55);
mpfr_set_str_binary (x, "0.11e3");
mpfr_zeta (y, x, MPFR_RNDN);
mpfr_set_prec (x, 55);
mpfr_set_str_binary (x, "0.1000001000111000010011000010011000000100100100100010010E1");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_zeta (1)\n");
printf ("Expected "); mpfr_print_binary (x); puts ("");
printf ("Got "); mpfr_print_binary (y); puts ("");
exit (1);
}
mpfr_set_prec (x, 3);
mpfr_set_prec (y, 47);
mpfr_set_str_binary (x, "0.111e4");
mpfr_zeta (y, x, MPFR_RNDN);
mpfr_set_prec (x, 47);
mpfr_set_str_binary (x, "1.0000000000000100000000111001001010111100101011");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_zeta (2)\n");
exit (1);
}
/* coverage test */
mpfr_set_prec (x, 7);
mpfr_set_str_binary (x, "1.000001");
mpfr_set_prec (y, 2);
mpfr_zeta (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 64) == 0);
/* another coverage test */
mpfr_set_prec (x, 24);
mpfr_set_ui (x, 2, MPFR_RNDN);
mpfr_set_prec (y, 2);
mpfr_zeta (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui_2exp (y, 3, -1) == 0);
mpfr_set_nan (x);
mpfr_zeta (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (y));
mpfr_set_inf (x, 1);
mpfr_zeta (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 1) == 0);
mpfr_set_inf (x, -1);
mpfr_zeta (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (y));
mpfr_clear (x);
mpfr_clear (y);
}
int
main (int argc, char *argv[])
{
mpfr_t x, y;
int inex;
tests_start_mpfr ();
mpfr_init (x);
mpfr_init (y);
/* special values */
mpfr_set_nan (x);
mpfr_j0 (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (y));
mpfr_set_inf (x, 1); /* +Inf */
mpfr_j0 (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS (y));
mpfr_set_inf (x, -1); /* -Inf */
mpfr_j0 (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS (y));
mpfr_set_ui (x, 0, MPFR_RNDN); /* +0 */
mpfr_j0 (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 1) == 0); /* j0(+0)=1 */
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_neg (x, x, MPFR_RNDN); /* -0 */
mpfr_j0 (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 1) == 0); /* j0(-0)=1 */
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_j0 (y, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.1100001111100011111111101101111010111101110001111");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_j0 for x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_si (x, -1, MPFR_RNDN);
mpfr_j0 (y, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.1100001111100011111111101101111010111101110001111");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_j0 for x=-1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
/* Bug reported on 2007-07-03 by Sisyphus (assertion failed in r4619) */
mpfr_set_si (x, 70000, MPFR_RNDN);
mpfr_j0 (y, x, MPFR_RNDN);
/* Bug reported by Kevin Rauch on 27 Oct 2007 */
mpfr_set_prec (x, 7);
mpfr_set_prec (y, 7);
mpfr_set_si (x, -100, MPFR_RNDN);
mpfr_j0 (y, x, MPFR_RNDN);
MPFR_ASSERTN (! mpfr_nan_p (y) && mpfr_cmp_ui_2exp (y, 41, -11) == 0);
/* Case for which s = 0 in mpfr_jn */
mpfr_set_prec (x, 44);
mpfr_set_prec (y, 44);
mpfr_set_si (x, 2, MPFR_RNDN);
mpfr_clear_flags ();
inex = mpfr_j0 (y, x, MPFR_RNDN);
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_INEXACT);
mpfr_set_str (x, "0x.e5439fd9267p-2", 0, MPFR_RNDN);
if (! mpfr_equal_p (y, x))
{
printf ("Error on 2:\n");
printf ("Expected ");
mpfr_dump (x);
printf ("Got ");
mpfr_dump (y);
exit (1);
}
if (inex >= 0)
{
printf ("Bad ternary value on 2: expected negative, got %d\n", inex);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
test_generic (2, 100, 10);
data_check ("data/j0", mpfr_j0, "mpfr_j0");
tests_end_mpfr ();
return 0;
}
/* Put in z the value of x^y, rounded according to 'rnd'.
Return the inexact flag in [0, 10]. */
int
mpc_pow (mpc_ptr z, mpc_srcptr x, mpc_srcptr y, mpc_rnd_t rnd)
{
int ret = -2, loop, x_real, y_real, z_real = 0, z_imag = 0;
mpc_t t, u;
mp_prec_t p, q, pr, pi, maxprec;
long Q;
x_real = mpfr_zero_p (MPC_IM(x));
y_real = mpfr_zero_p (MPC_IM(y));
if (y_real && mpfr_zero_p (MPC_RE(y))) /* case y zero */
{
if (x_real && mpfr_zero_p (MPC_RE(x))) /* 0^0 = NaN +i*NaN */
{
mpfr_set_nan (MPC_RE(z));
mpfr_set_nan (MPC_IM(z));
return 0;
}
else /* x^0 = 1 +/- i*0 even for x=NaN see algorithms.tex for the
sign of zero */
{
mpfr_t n;
int inex, cx1;
int sign_zi;
/* cx1 < 0 if |x| < 1
cx1 = 0 if |x| = 1
cx1 > 0 if |x| > 1
*/
mpfr_init (n);
inex = mpc_norm (n, x, GMP_RNDN);
cx1 = mpfr_cmp_ui (n, 1);
if (cx1 == 0 && inex != 0)
cx1 = -inex;
sign_zi = (cx1 < 0 && mpfr_signbit (MPC_IM (y)) == 0)
|| (cx1 == 0
&& mpfr_signbit (MPC_IM (x)) != mpfr_signbit (MPC_RE (y)))
|| (cx1 > 0 && mpfr_signbit (MPC_IM (y)));
/* warning: mpc_set_ui_ui does not set Im(z) to -0 if Im(rnd)=RNDD */
ret = mpc_set_ui_ui (z, 1, 0, rnd);
if (MPC_RND_IM (rnd) == GMP_RNDD || sign_zi)
mpc_conj (z, z, MPC_RNDNN);
mpfr_clear (n);
return ret;
}
}
if (mpfr_nan_p (MPC_RE(x)) || mpfr_nan_p (MPC_IM(x)) ||
mpfr_nan_p (MPC_RE(y)) || mpfr_nan_p (MPC_IM(y)) ||
mpfr_inf_p (MPC_RE(x)) || mpfr_inf_p (MPC_IM(x)) ||
mpfr_inf_p (MPC_RE(y)) || mpfr_inf_p (MPC_IM(y)))
{
/* special values: exp(y*log(x)) */
mpc_init2 (u, 2);
mpc_log (u, x, MPC_RNDNN);
mpc_mul (u, u, y, MPC_RNDNN);
ret = mpc_exp (z, u, rnd);
mpc_clear (u);
goto end;
}
if (x_real) /* case x real */
{
if (mpfr_zero_p (MPC_RE(x))) /* x is zero */
{
/* special values: exp(y*log(x)) */
mpc_init2 (u, 2);
mpc_log (u, x, MPC_RNDNN);
mpc_mul (u, u, y, MPC_RNDNN);
ret = mpc_exp (z, u, rnd);
mpc_clear (u);
goto end;
}
/* Special case 1^y = 1 */
if (mpfr_cmp_ui (MPC_RE(x), 1) == 0)
{
int s1, s2;
s1 = mpfr_signbit (MPC_RE (y));
s2 = mpfr_signbit (MPC_IM (x));
ret = mpc_set_ui (z, +1, rnd);
/* the sign of the zero imaginary part is known in some cases (see
algorithm.tex). In such cases we have
(x +s*0i)^(y+/-0i) = x^y + s*sign(y)*0i
where s = +/-1. We extend here this rule to fix the sign of the
zero part.
Note that the sign must also be set explicitly when rnd=RNDD
because mpfr_set_ui(z_i, 0, rnd) always sets z_i to +0.
*/
if (MPC_RND_IM (rnd) == GMP_RNDD || s1 != s2)
mpc_conj (z, z, MPC_RNDNN);
goto end;
}
/* x^y is real when:
(a) x is real and y is integer
(b) x is real non-negative and y is real */
if (y_real && (mpfr_integer_p (MPC_RE(y)) ||
mpfr_cmp_ui (MPC_RE(x), 0) >= 0))
{
int s1, s2;
s1 = mpfr_signbit (MPC_RE (y));
s2 = mpfr_signbit (MPC_IM (x));
ret = mpfr_pow (MPC_RE(z), MPC_RE(x), MPC_RE(y), MPC_RND_RE(rnd));
ret = MPC_INEX(ret, mpfr_set_ui (MPC_IM(z), 0, MPC_RND_IM(rnd)));
/* the sign of the zero imaginary part is known in some cases
(see algorithm.tex). In such cases we have (x +s*0i)^(y+/-0i)
= x^y + s*sign(y)*0i where s = +/-1.
We extend here this rule to fix the sign of the zero part.
Note that the sign must also be set explicitly when rnd=RNDD
because mpfr_set_ui(z_i, 0, rnd) always sets z_i to +0.
*/
if (MPC_RND_IM(rnd) == GMP_RNDD || s1 != s2)
mpfr_neg (MPC_IM(z), MPC_IM(z), MPC_RND_IM(rnd));
goto end;
}
/* (-1)^(n+I*t) is real for n integer and t real */
if (mpfr_cmp_si (MPC_RE(x), -1) == 0 && mpfr_integer_p (MPC_RE(y)))
z_real = 1;
/* for x real, x^y is imaginary when:
(a) x is negative and y is half-an-integer
(b) x = -1 and Re(y) is half-an-integer
*/
if (mpfr_cmp_ui (MPC_RE(x), 0) < 0 && is_odd (MPC_RE(y), 1) &&
(y_real || mpfr_cmp_si (MPC_RE(x), -1) == 0))
z_imag = 1;
}
else /* x non real */
/* I^(t*I) and (-I)^(t*I) are real for t real,
I^(n+t*I) and (-I)^(n+t*I) are real for n even and t real, and
I^(n+t*I) and (-I)^(n+t*I) are imaginary for n odd and t real
(s*I)^n is real for n even and imaginary for n odd */
if ((mpc_cmp_si_si (x, 0, 1) == 0 || mpc_cmp_si_si (x, 0, -1) == 0 ||
(mpfr_cmp_ui (MPC_RE(x), 0) == 0 && y_real)) &&
mpfr_integer_p (MPC_RE(y)))
{ /* x is I or -I, and Re(y) is an integer */
if (is_odd (MPC_RE(y), 0))
z_imag = 1; /* Re(y) odd: z is imaginary */
else
z_real = 1; /* Re(y) even: z is real */
}
else /* (t+/-t*I)^(2n) is imaginary for n odd and real for n even */
if (mpfr_cmpabs (MPC_RE(x), MPC_IM(x)) == 0 && y_real &&
mpfr_integer_p (MPC_RE(y)) && is_odd (MPC_RE(y), 0) == 0)
{
if (is_odd (MPC_RE(y), -1)) /* y/2 is odd */
z_imag = 1;
else
z_real = 1;
}
/* first bound |Re(y log(x))|, |Im(y log(x)| < 2^q */
mpc_init2 (t, 64);
mpc_log (t, x, MPC_RNDNN);
mpc_mul (t, t, y, MPC_RNDNN);
/* the default maximum exponent for MPFR is emax=2^30-1, thus if
t > log(2^emax) = emax*log(2), then exp(t) will overflow */
if (mpfr_cmp_ui_2exp (MPC_RE(t), 372130558, 1) > 0)
goto overflow;
/* the default minimum exponent for MPFR is emin=-2^30+1, thus the
smallest representable value is 2^(emin-1), and if
t < log(2^(emin-1)) = (emin-1)*log(2), then exp(t) will underflow */
if (mpfr_cmp_si_2exp (MPC_RE(t), -372130558, 1) < 0)
goto underflow;
q = mpfr_get_exp (MPC_RE(t)) > 0 ? mpfr_get_exp (MPC_RE(t)) : 0;
if (mpfr_get_exp (MPC_IM(t)) > (mp_exp_t) q)
q = mpfr_get_exp (MPC_IM(t));
pr = mpfr_get_prec (MPC_RE(z));
pi = mpfr_get_prec (MPC_IM(z));
p = (pr > pi) ? pr : pi;
p += 11; /* experimentally, seems to give less than 10% of failures in
Ziv's strategy */
mpc_init2 (u, p);
pr += MPC_RND_RE(rnd) == GMP_RNDN;
pi += MPC_RND_IM(rnd) == GMP_RNDN;
maxprec = MPFR_PREC(MPC_RE(z));
if (MPFR_PREC(MPC_IM(z)) > maxprec)
maxprec = MPFR_PREC(MPC_IM(z));
for (loop = 0;; loop++)
{
mp_exp_t dr, di;
if (p + q > 64) /* otherwise we reuse the initial approximation
t of y*log(x), avoiding two computations */
{
mpc_set_prec (t, p + q);
mpc_log (t, x, MPC_RNDNN);
mpc_mul (t, t, y, MPC_RNDNN);
}
mpc_exp (u, t, MPC_RNDNN);
/* Since the error bound is global, we have to take into account the
exponent difference between the real and imaginary parts. We assume
either the real or the imaginary part of u is not zero.
*/
dr = mpfr_zero_p (MPC_RE(u)) ? mpfr_get_exp (MPC_IM(u))
: mpfr_get_exp (MPC_RE(u));
di = mpfr_zero_p (MPC_IM(u)) ? dr : mpfr_get_exp (MPC_IM(u));
if (dr > di)
{
di = dr - di;
dr = 0;
}
else
{
dr = di - dr;
di = 0;
}
/* the term -3 takes into account the factor 4 in the complex error
(see algorithms.tex) plus one due to the exponent difference: if
z = a + I*b, where the relative error on z is at most 2^(-p), and
EXP(a) = EXP(b) + k, the relative error on b is at most 2^(k-p) */
if ((z_imag || mpfr_can_round (MPC_RE(u), p - 3 - dr, GMP_RNDN, GMP_RNDZ, pr)) &&
(z_real || mpfr_can_round (MPC_IM(u), p - 3 - di, GMP_RNDN, GMP_RNDZ, pi)))
break;
/* if Re(u) is not known to be zero, assume it is a normal number, i.e.,
neither zero, Inf or NaN, otherwise we might enter an infinite loop */
MPC_ASSERT (z_imag || mpfr_number_p (MPC_RE(u)));
/* idem for Im(u) */
MPC_ASSERT (z_real || mpfr_number_p (MPC_IM(u)));
if (ret == -2) /* we did not yet call mpc_pow_exact, or it aborted
because intermediate computations had > maxprec bits */
{
/* check exact cases (see algorithms.tex) */
if (y_real)
{
maxprec *= 2;
ret = mpc_pow_exact (z, x, MPC_RE(y), rnd, maxprec);
if (ret != -1 && ret != -2)
goto exact;
}
p += dr + di + 64;
}
else
p += p / 2;
mpc_set_prec (t, p + q);
mpc_set_prec (u, p);
}
if (z_real)
{
/* When the result is real (see algorithm.tex for details),
Im(x^y) =
+ sign(imag(y))*0i, if |x| > 1
+ sign(imag(x))*sign(real(y))*0i, if |x| = 1
- sign(imag(y))*0i, if |x| < 1
*/
mpfr_t n;
int inex, cx1;
int sign_zi;
/* cx1 < 0 if |x| < 1
cx1 = 0 if |x| = 1
cx1 > 0 if |x| > 1
*/
mpfr_init (n);
inex = mpc_norm (n, x, GMP_RNDN);
cx1 = mpfr_cmp_ui (n, 1);
if (cx1 == 0 && inex != 0)
cx1 = -inex;
sign_zi = (cx1 < 0 && mpfr_signbit (MPC_IM (y)) == 0)
|| (cx1 == 0
&& mpfr_signbit (MPC_IM (x)) != mpfr_signbit (MPC_RE (y)))
|| (cx1 > 0 && mpfr_signbit (MPC_IM (y)));
ret = mpfr_set (MPC_RE(z), MPC_RE(u), MPC_RND_RE(rnd));
/* warning: mpfr_set_ui does not set Im(z) to -0 if Im(rnd) = RNDD */
ret = MPC_INEX (ret, mpfr_set_ui (MPC_IM (z), 0, MPC_RND_IM (rnd)));
if (MPC_RND_IM (rnd) == GMP_RNDD || sign_zi)
mpc_conj (z, z, MPC_RNDNN);
mpfr_clear (n);
}
else if (z_imag)
{
ret = mpfr_set (MPC_IM(z), MPC_IM(u), MPC_RND_IM(rnd));
ret = MPC_INEX(mpfr_set_ui (MPC_RE(z), 0, MPC_RND_RE(rnd)), ret);
}
else
ret = mpc_set (z, u, rnd);
exact:
mpc_clear (t);
mpc_clear (u);
end:
return ret;
underflow:
/* If we have an underflow, we know that |z| is too small to be
represented, but depending on arg(z), we should return +/-0 +/- I*0.
We assume t is the approximation of y*log(x), thus we want
exp(t) = exp(Re(t))+exp(I*Im(t)).
FIXME: this part of code is not 100% rigorous, since we don't consider
rounding errors.
*/
mpc_init2 (u, 64);
mpfr_const_pi (MPC_RE(u), GMP_RNDN);
mpfr_div_2exp (MPC_RE(u), MPC_RE(u), 1, GMP_RNDN); /* Pi/2 */
mpfr_remquo (MPC_RE(u), &Q, MPC_IM(t), MPC_RE(u), GMP_RNDN);
if (mpfr_sgn (MPC_RE(u)) < 0)
Q--; /* corresponds to positive remainder */
mpfr_set_ui (MPC_RE(z), 0, GMP_RNDN);
mpfr_set_ui (MPC_IM(z), 0, GMP_RNDN);
switch (Q & 3)
{
case 0: /* first quadrant: round to (+0 +0) */
ret = MPC_INEX(-1, -1);
break;
case 1: /* second quadrant: round to (-0 +0) */
mpfr_neg (MPC_RE(z), MPC_RE(z), GMP_RNDN);
ret = MPC_INEX(1, -1);
break;
case 2: /* third quadrant: round to (-0 -0) */
mpfr_neg (MPC_RE(z), MPC_RE(z), GMP_RNDN);
mpfr_neg (MPC_IM(z), MPC_IM(z), GMP_RNDN);
ret = MPC_INEX(1, 1);
break;
case 3: /* fourth quadrant: round to (+0 -0) */
mpfr_neg (MPC_IM(z), MPC_IM(z), GMP_RNDN);
ret = MPC_INEX(-1, 1);
break;
}
goto clear_t_and_u;
overflow:
/* If we have an overflow, we know that |z| is too large to be
represented, but depending on arg(z), we should return +/-Inf +/- I*Inf.
We assume t is the approximation of y*log(x), thus we want
exp(t) = exp(Re(t))+exp(I*Im(t)).
FIXME: this part of code is not 100% rigorous, since we don't consider
rounding errors.
*/
mpc_init2 (u, 64);
mpfr_const_pi (MPC_RE(u), GMP_RNDN);
mpfr_div_2exp (MPC_RE(u), MPC_RE(u), 1, GMP_RNDN); /* Pi/2 */
/* the quotient is rounded to the nearest integer in mpfr_remquo */
mpfr_remquo (MPC_RE(u), &Q, MPC_IM(t), MPC_RE(u), GMP_RNDN);
if (mpfr_sgn (MPC_RE(u)) < 0)
Q--; /* corresponds to positive remainder */
switch (Q & 3)
{
case 0: /* first quadrant */
mpfr_set_inf (MPC_RE(z), 1);
mpfr_set_inf (MPC_IM(z), 1);
ret = MPC_INEX(1, 1);
break;
case 1: /* second quadrant */
mpfr_set_inf (MPC_RE(z), -1);
mpfr_set_inf (MPC_IM(z), 1);
ret = MPC_INEX(-1, 1);
break;
case 2: /* third quadrant */
mpfr_set_inf (MPC_RE(z), -1);
mpfr_set_inf (MPC_IM(z), -1);
ret = MPC_INEX(-1, -1);
break;
case 3: /* fourth quadrant */
mpfr_set_inf (MPC_RE(z), 1);
mpfr_set_inf (MPC_IM(z), -1);
ret = MPC_INEX(1, -1);
break;
}
clear_t_and_u:
mpc_clear (t);
mpc_clear (u);
return ret;
}
int
main (int argc, char *argv[])
{
mpfr_t x;
unsigned int i;
unsigned int prec[10] = {14, 15, 19, 22, 23, 24, 25, 40, 41, 52};
unsigned int prec2[10] = {4, 5, 6, 19, 70, 95, 100, 106, 107, 108};
tests_start_mpfr ();
check_nans ();
mpfr_init (x);
mpfr_set_prec (x, 2);
mpfr_set_str (x, "0.5", 10, MPFR_RNDN);
mpfr_tan (x, x, MPFR_RNDD);
if (mpfr_cmp_ui_2exp(x, 1, -1))
{
printf ("mpfr_tan(0.5, MPFR_RNDD) failed\n"
"expected 0.5, got");
mpfr_print_binary(x);
putchar('\n');
exit (1);
}
/* check that tan(3*Pi/4) ~ -1 */
for (i=0; i<10; i++)
{
mpfr_set_prec (x, prec[i]);
mpfr_const_pi (x, MPFR_RNDN);
mpfr_mul_ui (x, x, 3, MPFR_RNDN);
mpfr_div_ui (x, x, 4, MPFR_RNDN);
mpfr_tan (x, x, MPFR_RNDN);
if (mpfr_cmp_si (x, -1))
{
printf ("tan(3*Pi/4) fails for prec=%u\n", prec[i]);
exit (1);
}
}
/* check that tan(7*Pi/4) ~ -1 */
for (i=0; i<10; i++)
{
mpfr_set_prec (x, prec2[i]);
mpfr_const_pi (x, MPFR_RNDN);
mpfr_mul_ui (x, x, 7, MPFR_RNDN);
mpfr_div_ui (x, x, 4, MPFR_RNDN);
mpfr_tan (x, x, MPFR_RNDN);
if (mpfr_cmp_si (x, -1))
{
printf ("tan(3*Pi/4) fails for prec=%u\n", prec2[i]);
exit (1);
}
}
mpfr_clear (x);
test_generic (2, 100, 10);
data_check ("data/tan", mpfr_tan, "mpfr_tan");
bad_cases (mpfr_tan, mpfr_atan, "mpfr_tan", 256, -256, 255, 4, 128, 800, 40);
tests_end_mpfr ();
return 0;
}
static void
special (void)
{
mpfr_t x, y;
mpq_t q;
mpz_t z;
int res = 0;
mpfr_init (x);
mpfr_init (y);
mpq_init (q);
mpz_init (z);
/* cancellation in mpfr_add_q */
mpfr_set_prec (x, 60);
mpfr_set_prec (y, 20);
mpz_set_str (mpq_numref (q), "-187207494", 10);
mpz_set_str (mpq_denref (q), "5721", 10);
mpfr_set_str_binary (x, "11111111101001011011100101100011011110010011100010000100001E-44");
mpfr_add_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("cancelation in add_q", mpfr_cmp_ui_2exp (y, 256783, -64) == 0);
mpfr_set_prec (x, 19);
mpfr_set_str_binary (x, "0.1011110101110011100E0");
mpz_set_str (mpq_numref (q), "187207494", 10);
mpz_set_str (mpq_denref (q), "5721", 10);
mpfr_set_prec (y, 29);
mpfr_add_q (y, x, q, MPFR_RNDD);
mpfr_set_prec (x, 29);
mpfr_set_str_binary (x, "11111111101001110011010001001E-14");
CHECK_FOR ("cancelation in add_q", mpfr_cmp (x,y) == 0);
/* Inf */
mpfr_set_inf (x, 1);
mpz_set_str (mpq_numref (q), "395877315", 10);
mpz_set_str (mpq_denref (q), "3508975966", 10);
mpfr_set_prec (y, 118);
mpfr_add_q (y, x, q, MPFR_RNDU);
CHECK_FOR ("inf", mpfr_inf_p (y) && mpfr_sgn (y) > 0);
mpfr_sub_q (y, x, q, MPFR_RNDU);
CHECK_FOR ("inf", mpfr_inf_p (y) && mpfr_sgn (y) > 0);
/* Nan */
MPFR_SET_NAN (x);
mpfr_add_q (y, x, q, MPFR_RNDU);
CHECK_FOR ("nan", mpfr_nan_p (y));
mpfr_sub_q (y, x, q, MPFR_RNDU);
CHECK_FOR ("nan", mpfr_nan_p (y));
/* Exact value */
mpfr_set_prec (x, 60);
mpfr_set_prec (y, 60);
mpfr_set_str1 (x, "0.5");
mpz_set_str (mpq_numref (q), "3", 10);
mpz_set_str (mpq_denref (q), "2", 10);
res = mpfr_add_q (y, x, q, MPFR_RNDU);
CHECK_FOR ("0.5+3/2", mpfr_cmp_ui(y, 2)==0 && res==0);
res = mpfr_sub_q (y, x, q, MPFR_RNDU);
CHECK_FOR ("0.5-3/2", mpfr_cmp_si(y, -1)==0 && res==0);
/* Inf Rationnal */
mpq_set_ui (q, 1, 0);
mpfr_set_str1 (x, "0.5");
res = mpfr_add_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("0.5+1/0", mpfr_inf_p (y) && MPFR_IS_POS (y) && res == 0);
res = mpfr_sub_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("0.5-1/0", mpfr_inf_p (y) && MPFR_IS_NEG (y) && res == 0);
mpq_set_si (q, -1, 0);
res = mpfr_add_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("0.5+ -1/0", mpfr_inf_p (y) && MPFR_IS_NEG (y) && res == 0);
res = mpfr_sub_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("0.5- -1/0", mpfr_inf_p (y) && MPFR_IS_POS (y) && res == 0);
res = mpfr_div_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("0.5 / (-1/0)", mpfr_zero_p (y) && MPFR_IS_NEG (y) && res == 0);
mpq_set_ui (q, 1, 0);
mpfr_set_inf (x, 1);
res = mpfr_add_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("+Inf + +Inf", mpfr_inf_p (y) && MPFR_IS_POS (y) && res == 0);
res = mpfr_sub_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("+Inf - +Inf", MPFR_IS_NAN (y) && res == 0);
mpfr_set_inf (x, -1);
res = mpfr_add_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("-Inf + +Inf", MPFR_IS_NAN (y) && res == 0);
res = mpfr_sub_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("-Inf - +Inf", mpfr_inf_p (y) && MPFR_IS_NEG (y) && res == 0);
mpq_set_si (q, -1, 0);
mpfr_set_inf (x, 1);
res = mpfr_add_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("+Inf + -Inf", MPFR_IS_NAN (y) && res == 0);
res = mpfr_sub_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("+Inf - -Inf", mpfr_inf_p (y) && MPFR_IS_POS (y) && res == 0);
mpfr_set_inf (x, -1);
res = mpfr_add_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("-Inf + -Inf", mpfr_inf_p (y) && MPFR_IS_NEG (y) && res == 0);
res = mpfr_sub_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("-Inf - -Inf", MPFR_IS_NAN (y) && res == 0);
/* 0 */
mpq_set_ui (q, 0, 1);
mpfr_set_ui (x, 42, MPFR_RNDN);
res = mpfr_add_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("42+0/1", mpfr_cmp_ui (y, 42) == 0 && res == 0);
res = mpfr_sub_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("42-0/1", mpfr_cmp_ui (y, 42) == 0 && res == 0);
res = mpfr_mul_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("42*0/1", mpfr_zero_p (y) && MPFR_IS_POS (y) && res == 0);
mpfr_clear_flags ();
res = mpfr_div_q (y, x, q, MPFR_RNDN);
CHECK_FOR ("42/(0/1)", mpfr_inf_p (y) && MPFR_IS_POS (y) && res == 0
&& mpfr_divby0_p ());
mpz_set_ui (z, 0);
mpfr_clear_flags ();
res = mpfr_div_z (y, x, z, MPFR_RNDN);
CHECK_FORZ ("42/0", mpfr_inf_p (y) && MPFR_IS_POS (y) && res == 0
&& mpfr_divby0_p ());
mpz_clear (z);
mpq_clear (q);
mpfr_clear (x);
mpfr_clear (y);
}
int
mpfr_cmp_ui (mpfr_srcptr b, unsigned long int i)
{
return mpfr_cmp_ui_2exp (b, i, 0);
}
static void
special ()
{
mpfr_t x, y, z, t;
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
mpfr_init2 (z, 53);
mpfr_init2 (t, 2);
mpfr_set_ui (x, 2, GMP_RNDN);
mpfr_pow_si (x, x, -2, GMP_RNDN);
if (mpfr_cmp_ui_2exp (x, 1, -2))
{
printf ("Error in pow_si(x,x,-2) for x=2\n");
exit (1);
}
mpfr_set_ui (x, 2, GMP_RNDN);
mpfr_set_si (y, -2, GMP_RNDN);
test_pow (x, x, y, GMP_RNDN);
if (mpfr_cmp_ui_2exp (x, 1, -2))
{
printf ("Error in pow(x,x,y) for x=2, y=-2\n");
exit (1);
}
mpfr_set_prec (x, 2);
mpfr_set_str_binary (x, "1.0e-1");
mpfr_set_prec (y, 53);
mpfr_set_str_binary (y, "0.11010110011100101010110011001010100111000001000101110E-1");
mpfr_set_prec (z, 2);
test_pow (z, x, y, GMP_RNDZ);
mpfr_set_str_binary (x, "1.0e-1");
if (mpfr_cmp (x, z))
{
printf ("Error in mpfr_pow (1)\n");
exit (1);
}
mpfr_set_prec (x, 64);
mpfr_set_prec (y, 64);
mpfr_set_prec (z, 64);
mpfr_set_prec (t, 64);
mpfr_set_str_binary (x, "0.111011000111100000111010000101010100110011010000011");
mpfr_set_str_binary (y, "0.111110010100110000011101100011010111000010000100101");
mpfr_set_str_binary (t, "0.1110110011110110001000110100100001001111010011111000010000011001");
test_pow (z, x, y, GMP_RNDN);
if (mpfr_cmp (z, t))
{
printf ("Error in mpfr_pow for prec=64, rnd=GMP_RNDN\n");
exit (1);
}
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_prec (z, 53);
mpfr_set_str (x, "5.68824667828621954868e-01", 10, GMP_RNDN);
mpfr_set_str (y, "9.03327850535952658895e-01", 10, GMP_RNDN);
test_pow (z, x, y, GMP_RNDZ);
if (mpfr_cmp_str1 (z, "0.60071044650456473235"))
{
printf ("Error in mpfr_pow for prec=53, rnd=GMP_RNDZ\n");
exit (1);
}
mpfr_set_prec (t, 2);
mpfr_set_prec (x, 30);
mpfr_set_prec (y, 30);
mpfr_set_prec (z, 30);
mpfr_set_str (x, "1.00000000001010111110001111011e1", 2, GMP_RNDN);
mpfr_set_str (t, "-0.5", 10, GMP_RNDN);
test_pow (z, x, t, GMP_RNDN);
mpfr_set_str (y, "1.01101001111010101110000101111e-1", 2, GMP_RNDN);
if (mpfr_cmp (z, y))
{
printf ("Error in mpfr_pow for prec=30, rnd=GMP_RNDN\n");
exit (1);
}
mpfr_set_prec (x, 21);
mpfr_set_prec (y, 21);
mpfr_set_prec (z, 21);
mpfr_set_str (x, "1.11111100100001100101", 2, GMP_RNDN);
test_pow (z, x, t, GMP_RNDZ);
mpfr_set_str (y, "1.01101011010001100000e-1", 2, GMP_RNDN);
if (mpfr_cmp (z, y))
{
printf ("Error in mpfr_pow for prec=21, rnd=GMP_RNDZ\n");
printf ("Expected ");
mpfr_out_str (stdout, 2, 0, y, GMP_RNDN);
printf ("\nGot ");
mpfr_out_str (stdout, 2, 0, z, GMP_RNDN);
printf ("\n");
exit (1);
}
/* From http://www.terra.es/personal9/ismaeljc/hall.htm */
mpfr_set_prec (x, 113);
mpfr_set_prec (y, 2);
mpfr_set_prec (z, 169);
mpfr_set_str1 (x, "6078673043126084065007902175846955");
mpfr_set_ui_2exp (y, 3, -1, GMP_RNDN);
test_pow (z, x, y, GMP_RNDZ);
if (mpfr_cmp_str1 (z, "473928882491000966028828671876527456070714790264144"))
{
printf ("Error in mpfr_pow for 6078673043126084065007902175846955");
printf ("^(3/2), GMP_RNDZ\nExpected ");
printf ("4.73928882491000966028828671876527456070714790264144e50");
printf ("\nGot ");
mpfr_out_str (stdout, 10, 0, z, GMP_RNDN);
printf ("\n");
exit (1);
}
test_pow (z, x, y, GMP_RNDU);
if (mpfr_cmp_str1 (z, "473928882491000966028828671876527456070714790264145"))
{
printf ("Error in mpfr_pow for 6078673043126084065007902175846955");
printf ("^(3/2), GMP_RNDU\nExpected ");
printf ("4.73928882491000966028828671876527456070714790264145e50");
printf ("\nGot ");
mpfr_out_str (stdout, 10, 0, z, GMP_RNDN);
printf ("\n");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_set_prec (y, 2);
mpfr_set_str_binary (y, "1E10");
test_pow (z, x, y, GMP_RNDN);
MPFR_ASSERTN(mpfr_inf_p (z) && MPFR_IS_POS(z));
mpfr_set_inf (x, -1);
test_pow (z, x, y, GMP_RNDN);
MPFR_ASSERTN(mpfr_inf_p (z) && MPFR_IS_POS(z));
mpfr_set_prec (y, 10);
mpfr_set_str_binary (y, "1.000000001E9");
test_pow (z, x, y, GMP_RNDN);
MPFR_ASSERTN(mpfr_inf_p (z) && MPFR_IS_NEG(z));
mpfr_set_str_binary (y, "1.000000001E8");
test_pow (z, x, y, GMP_RNDN);
MPFR_ASSERTN(mpfr_inf_p (z) && MPFR_IS_POS(z));
mpfr_set_inf (x, -1);
mpfr_set_prec (y, 2 * mp_bits_per_limb);
mpfr_set_ui (y, 1, GMP_RNDN);
mpfr_mul_2exp (y, y, mp_bits_per_limb - 1, GMP_RNDN);
/* y = 2^(mp_bits_per_limb - 1) */
test_pow (z, x, y, GMP_RNDN);
MPFR_ASSERTN(mpfr_inf_p (z) && MPFR_IS_POS(z));
mpfr_nextabove (y);
test_pow (z, x, y, GMP_RNDN);
/* y = 2^(mp_bits_per_limb - 1) + epsilon */
MPFR_ASSERTN(mpfr_inf_p (z) && MPFR_IS_POS(z));
mpfr_nextbelow (y);
mpfr_div_2exp (y, y, 1, GMP_RNDN);
mpfr_nextabove (y);
test_pow (z, x, y, GMP_RNDN);
/* y = 2^(mp_bits_per_limb - 2) + epsilon */
MPFR_ASSERTN(mpfr_inf_p (z) && MPFR_IS_POS(z));
mpfr_set_si (x, -1, GMP_RNDN);
mpfr_set_prec (y, 2);
mpfr_set_str_binary (y, "1E10");
test_pow (z, x, y, GMP_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (z, 1) == 0);
/* Check (-0)^(17.0001) */
mpfr_set_prec (x, 6);
mpfr_set_prec (y, 640);
MPFR_SET_ZERO (x);
MPFR_SET_NEG (x);
mpfr_set_ui (y, 17, GMP_RNDN);
mpfr_nextabove (y);
test_pow (z, x, y, GMP_RNDN);
MPFR_ASSERTN (MPFR_IS_ZERO (z) && MPFR_IS_POS (z));
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (t);
}
/* hard test of rounding */
static void
check_rounding (void)
{
mpfr_t a, b, c, res;
mpfr_prec_t p;
long k, l;
int i;
#define MAXKL (2 * GMP_NUMB_BITS)
for (p = MPFR_PREC_MIN; p <= GMP_NUMB_BITS; p++)
{
mpfr_init2 (a, p);
mpfr_init2 (res, p);
mpfr_init2 (b, p + 1 + MAXKL);
mpfr_init2 (c, MPFR_PREC_MIN);
/* b = 2^p + 1 + 2^(-k), c = 2^(-l) */
for (k = 0; k <= MAXKL; k++)
for (l = 0; l <= MAXKL; l++)
{
mpfr_set_ui_2exp (b, 1, p, MPFR_RNDN);
mpfr_add_ui (b, b, 1, MPFR_RNDN);
mpfr_mul_2ui (b, b, k, MPFR_RNDN);
mpfr_add_ui (b, b, 1, MPFR_RNDN);
mpfr_div_2ui (b, b, k, MPFR_RNDN);
mpfr_set_ui_2exp (c, 1, -l, MPFR_RNDN);
i = mpfr_sub (a, b, c, MPFR_RNDN);
/* b - c = 2^p + 1 + 2^(-k) - 2^(-l), should be rounded to
2^p for l <= k, and 2^p+2 for l < k */
if (l <= k)
{
if (mpfr_cmp_ui_2exp (a, 1, p) != 0)
{
printf ("Wrong result in check_rounding\n");
printf ("p=%lu k=%ld l=%ld\n", p, k, l);
printf ("b="); mpfr_print_binary (b); puts ("");
printf ("c="); mpfr_print_binary (c); puts ("");
printf ("Expected 2^%lu\n", p);
printf ("Got "); mpfr_print_binary (a); puts ("");
exit (1);
}
if (i >= 0)
{
printf ("Wrong ternary value in check_rounding\n");
printf ("p=%lu k=%ld l=%ld\n", p, k, l);
printf ("b="); mpfr_print_binary (b); puts ("");
printf ("c="); mpfr_print_binary (c); puts ("");
printf ("a="); mpfr_print_binary (a); puts ("");
printf ("Expected < 0, got %d\n", i);
exit (1);
}
}
else /* l < k */
{
mpfr_set_ui_2exp (res, 1, p, MPFR_RNDN);
mpfr_add_ui (res, res, 2, MPFR_RNDN);
if (mpfr_cmp (a, res) != 0)
{
printf ("Wrong result in check_rounding\n");
printf ("b="); mpfr_print_binary (b); puts ("");
printf ("c="); mpfr_print_binary (c); puts ("");
printf ("Expected "); mpfr_print_binary (res); puts ("");
printf ("Got "); mpfr_print_binary (a); puts ("");
exit (1);
}
if (i <= 0)
{
printf ("Wrong ternary value in check_rounding\n");
printf ("b="); mpfr_print_binary (b); puts ("");
printf ("c="); mpfr_print_binary (c); puts ("");
printf ("Expected > 0, got %d\n", i);
exit (1);
}
}
}
mpfr_clear (a);
mpfr_clear (res);
mpfr_clear (b);
mpfr_clear (c);
}
}
int
mpfr_log2 (mpfr_ptr r, mpfr_srcptr a, mpfr_rnd_t rnd_mode)
{
int inexact;
MPFR_SAVE_EXPO_DECL (expo);
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (a)))
{
/* If a is NaN, the result is NaN */
if (MPFR_IS_NAN (a))
{
MPFR_SET_NAN (r);
MPFR_RET_NAN;
}
/* check for infinity before zero */
else if (MPFR_IS_INF (a))
{
if (MPFR_IS_NEG (a))
/* log(-Inf) = NaN */
{
MPFR_SET_NAN (r);
MPFR_RET_NAN;
}
else /* log(+Inf) = +Inf */
{
MPFR_SET_INF (r);
MPFR_SET_POS (r);
MPFR_RET (0);
}
}
else /* a is zero */
{
MPFR_ASSERTD (MPFR_IS_ZERO (a));
MPFR_SET_INF (r);
MPFR_SET_NEG (r);
MPFR_RET (0); /* log2(0) is an exact -infinity */
}
}
/* If a is negative, the result is NaN */
if (MPFR_UNLIKELY (MPFR_IS_NEG (a)))
{
MPFR_SET_NAN (r);
MPFR_RET_NAN;
}
/* If a is 1, the result is 0 */
if (MPFR_UNLIKELY (mpfr_cmp_ui (a, 1) == 0))
{
MPFR_SET_ZERO (r);
MPFR_SET_POS (r);
MPFR_RET (0); /* only "normal" case where the result is exact */
}
/* If a is 2^N, log2(a) is exact*/
if (MPFR_UNLIKELY (mpfr_cmp_ui_2exp (a, 1, MPFR_GET_EXP (a) - 1) == 0))
return mpfr_set_si(r, MPFR_GET_EXP (a) - 1, rnd_mode);
MPFR_SAVE_EXPO_MARK (expo);
/* General case */
{
/* Declaration of the intermediary variable */
mpfr_t t, tt;
/* Declaration of the size variable */
mpfr_prec_t Ny = MPFR_PREC(r); /* target precision */
mpfr_prec_t Nt; /* working precision */
mpfr_exp_t err; /* error */
MPFR_ZIV_DECL (loop);
/* compute the precision of intermediary variable */
/* the optimal number of bits : see algorithms.tex */
Nt = Ny + 3 + MPFR_INT_CEIL_LOG2 (Ny);
/* initialise of intermediary variable */
mpfr_init2 (t, Nt);
mpfr_init2 (tt, Nt);
/* First computation of log2 */
MPFR_ZIV_INIT (loop, Nt);
for (;;)
{
/* compute log2 */
mpfr_const_log2(t,MPFR_RNDD); /* log(2) */
mpfr_log(tt,a,MPFR_RNDN); /* log(a) */
mpfr_div(t,tt,t,MPFR_RNDN); /* log(a)/log(2) */
/* estimation of the error */
err = Nt-3;
if (MPFR_LIKELY (MPFR_CAN_ROUND (t, err, Ny, rnd_mode)))
break;
/* actualisation of the precision */
MPFR_ZIV_NEXT (loop, Nt);
mpfr_set_prec (t, Nt);
mpfr_set_prec (tt, Nt);
}
MPFR_ZIV_FREE (loop);
inexact = mpfr_set (r, t, rnd_mode);
mpfr_clear (t);
mpfr_clear (tt);
}
MPFR_SAVE_EXPO_FREE (expo);
return mpfr_check_range (r, inexact, rnd_mode);
}
int
main (int argc, char *argv[])
{
mpfr_t x, y;
unsigned long int n;
tests_start_mpfr ();
mpfr_init (x);
mpfr_init (y);
n = randlimb ();
MPFR_SET_INF(x);
mpfr_ui_pow (y, n, x, MPFR_RNDN);
if(!MPFR_IS_INF(y))
{
printf ("evaluation of function in INF does not return INF\n");
exit (1);
}
MPFR_CHANGE_SIGN(x);
mpfr_ui_pow (y, n, x, MPFR_RNDN);
if(!MPFR_IS_ZERO(y))
{
printf ("evaluation of function in -INF does not return 0");
exit (1);
}
MPFR_SET_NAN(x);
mpfr_ui_pow (y, n, x, MPFR_RNDN);
if(!MPFR_IS_NAN(y))
{
printf ("evaluation of function in NAN does not return NAN");
exit (1);
}
test1 ();
{
mpfr_t z, t;
mpfr_prec_t prec;
mpfr_rnd_t rnd;
unsigned int n;
mpfr_prec_t p0=2, p1=100;
unsigned int N=20;
mpfr_init2 (z, 38);
mpfr_init2 (t, 6);
/* check exact power */
mpfr_set_str_binary (t, "0.110000E5");
mpfr_ui_pow (z, 3, t, MPFR_RNDN);
mpfr_set_prec (x, 2);
mpfr_set_prec (y, 2);
mpfr_set_str (x, "-0.5", 10, MPFR_RNDZ);
mpfr_ui_pow (y, 4, x, MPFR_RNDD);
if (mpfr_cmp_ui_2exp(y, 1, -1))
{
fprintf (stderr, "Error for 4^(-0.5), prec=2, MPFR_RNDD\n");
fprintf (stderr, "expected 0.5, got ");
mpfr_out_str (stderr, 2, 0, y, MPFR_RNDN);
fprintf (stderr, "\n");
exit (1);
}
/* problem found by Kevin on spe175.testdrive.compaq.com
(03 Sep 2003), ia64 under HP-UX */
mpfr_set_prec (x, 2);
mpfr_set_prec (y, 2);
mpfr_set_str (x, "0.5", 10, MPFR_RNDN);
mpfr_ui_pow (y, 398441521, x, MPFR_RNDN);
if (mpfr_cmp_ui_2exp(y, 1, 14))
{
fprintf (stderr, "Error for 398441521^(0.5), prec=2, MPFR_RNDN\n");
fprintf (stderr, "expected 1.0e14, got ");
mpfr_out_str (stderr, 2, 0, y, MPFR_RNDN);
fprintf (stderr, "\n");
exit (1);
}
mpfr_clear (z);
mpfr_clear (t);
mpfr_set_prec (x, 2);
mpfr_set_str (x, "0.5", 10, MPFR_RNDN);
check1 (x, 2, 398441521, MPFR_RNDN); /* 398441521 = 19961^2 */
/* generic test */
for (prec = p0; prec <= p1; prec++)
{
mpfr_set_prec (x, prec);
for (n=0; n<N; n++)
{
int nt;
nt = randlimb () & INT_MAX;
mpfr_urandomb (x, RANDS);
rnd = RND_RAND ();
check1 (x, prec, nt, rnd);
}
}
}
mpfr_clear (x);
mpfr_clear (y);
tests_end_mpfr ();
return 0;
}
static void
check64 (void)
{
mpfr_t x, t, u;
mpfr_init (x);
mpfr_init (t);
mpfr_init (u);
mpfr_set_prec (x, 29);
mpfr_set_str_binary (x, "1.1101001000101111011010010110e-3");
mpfr_set_prec (t, 58);
mpfr_set_str_binary (t, "0.11100010011111001001100110010111110110011000000100101E-1");
mpfr_set_prec (u, 29);
test_add (u, x, t, MPFR_RNDD);
mpfr_set_str_binary (t, "1.0101011100001000011100111110e-1");
if (mpfr_cmp (u, t))
{
printf ("mpfr_add(u, x, t) failed for prec(x)=29, prec(t)=58\n");
printf ("expected ");
mpfr_out_str (stdout, 2, 29, t, MPFR_RNDN);
puts ("");
printf ("got ");
mpfr_out_str (stdout, 2, 29, u, MPFR_RNDN);
puts ("");
exit(1);
}
mpfr_set_prec (x, 4);
mpfr_set_str_binary (x, "-1.0E-2");
mpfr_set_prec (t, 2);
mpfr_set_str_binary (t, "-1.1e-2");
mpfr_set_prec (u, 2);
test_add (u, x, t, MPFR_RNDN);
if (MPFR_MANT(u)[0] << 2)
{
printf ("result not normalized for prec=2\n");
mpfr_print_binary (u);
puts ("");
exit (1);
}
mpfr_set_str_binary (t, "-1.0e-1");
if (mpfr_cmp (u, t))
{
printf ("mpfr_add(u, x, t) failed for prec(x)=4, prec(t)=2\n");
printf ("expected -1.0e-1\n");
printf ("got ");
mpfr_out_str (stdout, 2, 4, u, MPFR_RNDN);
puts ("");
exit (1);
}
mpfr_set_prec (x, 8);
mpfr_set_str_binary (x, "-0.10011010"); /* -77/128 */
mpfr_set_prec (t, 4);
mpfr_set_str_binary (t, "-1.110e-5"); /* -7/128 */
mpfr_set_prec (u, 4);
test_add (u, x, t, MPFR_RNDN); /* should give -5/8 */
mpfr_set_str_binary (t, "-1.010e-1");
if (mpfr_cmp (u, t)) {
printf ("mpfr_add(u, x, t) failed for prec(x)=8, prec(t)=4\n");
printf ("expected -1.010e-1\n");
printf ("got ");
mpfr_out_str (stdout, 2, 4, u, MPFR_RNDN);
puts ("");
exit (1);
}
mpfr_set_prec (x, 112);
mpfr_set_prec (t, 98);
mpfr_set_prec (u, 54);
mpfr_set_str_binary (x, "-0.11111100100000000011000011100000101101010001000111E-401");
mpfr_set_str_binary (t, "0.10110000100100000101101100011111111011101000111000101E-464");
test_add (u, x, t, MPFR_RNDN);
if (mpfr_cmp (u, x))
{
printf ("mpfr_add(u, x, t) failed for prec(x)=112, prec(t)=98\n");
exit (1);
}
mpfr_set_prec (x, 92);
mpfr_set_prec (t, 86);
mpfr_set_prec (u, 53);
mpfr_set_str (x, "-5.03525136761487735093e-74", 10, MPFR_RNDN);
mpfr_set_str (t, "8.51539046314262304109e-91", 10, MPFR_RNDN);
test_add (u, x, t, MPFR_RNDN);
if (mpfr_cmp_str1 (u, "-5.0352513676148773509283672e-74") )
{
printf ("mpfr_add(u, x, t) failed for prec(x)=92, prec(t)=86\n");
exit (1);
}
mpfr_set_prec(x, 53);
mpfr_set_prec(t, 76);
mpfr_set_prec(u, 76);
mpfr_set_str_binary(x, "-0.10010010001001011011110000000000001010011011011110001E-32");
mpfr_set_str_binary(t, "-0.1011000101110010000101111111011111010001110011110111100110101011110010011111");
mpfr_sub(u, x, t, MPFR_RNDU);
mpfr_set_str_binary(t, "0.1011000101110010000101111111011100111111101010011011110110101011101000000100");
if (mpfr_cmp(u,t))
{
printf ("expect ");
mpfr_print_binary(t);
puts ("");
printf ("mpfr_add failed for precisions 53-76\n");
exit (1);
}
mpfr_set_prec(x, 53);
mpfr_set_prec(t, 108);
mpfr_set_prec(u, 108);
mpfr_set_str_binary(x, "-0.10010010001001011011110000000000001010011011011110001E-32");
mpfr_set_str_binary(t, "-0.101100010111001000010111111101111101000111001111011110011010101111001001111000111011001110011000000000111111");
mpfr_sub(u, x, t, MPFR_RNDU);
mpfr_set_str_binary(t, "0.101100010111001000010111111101110011111110101001101111011010101110100000001011000010101110011000000000111111");
if (mpfr_cmp(u,t))
{
printf ("expect ");
mpfr_print_binary(t);
puts ("");
printf ("mpfr_add failed for precisions 53-108\n");
exit (1);
}
mpfr_set_prec(x, 97);
mpfr_set_prec(t, 97);
mpfr_set_prec(u, 97);
mpfr_set_str_binary(x, "0.1111101100001000000001011000110111101000001011111000100001000101010100011111110010000000000000000E-39");
mpfr_set_ui(t, 1, MPFR_RNDN);
test_add (u, x, t, MPFR_RNDN);
mpfr_set_str_binary(x, "0.1000000000000000000000000000000000000000111110110000100000000101100011011110100000101111100010001E1");
if (mpfr_cmp(u,x))
{
printf ("mpfr_add failed for precision 97\n");
exit (1);
}
mpfr_set_prec(x, 128);
mpfr_set_prec(t, 128);
mpfr_set_prec(u, 128);
mpfr_set_str_binary(x, "0.10101011111001001010111011001000101100111101000000111111111011010100001100011101010001010111111101111010100110111111100101100010E-4");
mpfr_set(t, x, MPFR_RNDN);
mpfr_sub(u, x, t, MPFR_RNDN);
mpfr_set_prec(x, 96);
mpfr_set_prec(t, 96);
mpfr_set_prec(u, 96);
mpfr_set_str_binary(x, "0.111000000001110100111100110101101001001010010011010011100111100011010100011001010011011011000010E-4");
mpfr_set(t, x, MPFR_RNDN);
mpfr_sub(u, x, t, MPFR_RNDN);
mpfr_set_prec(x, 85);
mpfr_set_prec(t, 85);
mpfr_set_prec(u, 85);
mpfr_set_str_binary(x, "0.1111101110100110110110100010101011101001100010100011110110110010010011101100101111100E-4");
mpfr_set_str_binary(t, "0.1111101110100110110110100010101001001000011000111000011101100101110100001110101010110E-4");
mpfr_sub(u, x, t, MPFR_RNDU);
mpfr_sub(x, x, t, MPFR_RNDU);
if (mpfr_cmp(x, u) != 0)
{
printf ("Error in mpfr_sub: u=x-t and x=x-t give different results\n");
exit (1);
}
if ((MPFR_MANT(u)[(MPFR_PREC(u)-1)/mp_bits_per_limb] &
((mp_limb_t)1<<(mp_bits_per_limb-1)))==0)
{
printf ("Error in mpfr_sub: result is not msb-normalized (1)\n");
exit (1);
}
mpfr_set_prec(x, 65);
mpfr_set_prec(t, 65);
mpfr_set_prec(u, 65);
mpfr_set_str_binary(x, "0.10011010101000110101010000000011001001001110001011101011111011101E623");
mpfr_set_str_binary(t, "0.10011010101000110101010000000011001001001110001011101011111011100E623");
mpfr_sub(u, x, t, MPFR_RNDU);
if (mpfr_cmp_ui_2exp(u, 1, 558))
{ /* 2^558 */
printf ("Error (1) in mpfr_sub\n");
exit (1);
}
mpfr_set_prec(x, 64);
mpfr_set_prec(t, 64);
mpfr_set_prec(u, 64);
mpfr_set_str_binary(x, "0.1000011110101111011110111111000011101011101111101101101100000100E-220");
mpfr_set_str_binary(t, "0.1000011110101111011110111111000011101011101111101101010011111101E-220");
test_add (u, x, t, MPFR_RNDU);
if ((MPFR_MANT(u)[0] & 1) != 1)
{
printf ("error in mpfr_add with rnd_mode=MPFR_RNDU\n");
printf ("b= ");
mpfr_print_binary(x);
puts ("");
printf ("c= ");
mpfr_print_binary(t);
puts ("");
printf ("b+c=");
mpfr_print_binary(u);
puts ("");
exit (1);
}
/* bug found by Norbert Mueller, 14 Sep 2000 */
mpfr_set_prec(x, 56);
mpfr_set_prec(t, 83);
mpfr_set_prec(u, 10);
mpfr_set_str_binary(x, "0.10001001011011001111101100110100000101111010010111010111E-7");
mpfr_set_str_binary(t, "0.10001001011011001111101100110100000101111010010111010111000000000111110110110000100E-7");
mpfr_sub(u, x, t, MPFR_RNDU);
/* array bound write found by Norbert Mueller, 26 Sep 2000 */
mpfr_set_prec(x, 109);
mpfr_set_prec(t, 153);
mpfr_set_prec(u, 95);
mpfr_set_str_binary(x,"0.1001010000101011101100111000110001111111111111111111111111111111111111111111111111111111111111100000000000000E33");
mpfr_set_str_binary(t,"-0.100101000010101110110011100011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011100101101000000100100001100110111E33");
test_add (u, x, t, MPFR_RNDN);
/* array bound writes found by Norbert Mueller, 27 Sep 2000 */
mpfr_set_prec(x, 106);
mpfr_set_prec(t, 53);
mpfr_set_prec(u, 23);
mpfr_set_str_binary(x, "-0.1000011110101111111001010001000100001011000000000000000000000000000000000000000000000000000000000000000000E-59");
mpfr_set_str_binary(t, "-0.10000111101011111110010100010001101100011100110100000E-59");
mpfr_sub(u, x, t, MPFR_RNDN);
mpfr_set_prec(x, 177);
mpfr_set_prec(t, 217);
mpfr_set_prec(u, 160);
mpfr_set_str_binary(x, "-0.111010001011010000111001001010010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E35");
mpfr_set_str_binary(t, "0.1110100010110100001110010010100100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000111011010011100001111001E35");
test_add (u, x, t, MPFR_RNDN);
mpfr_set_prec(x, 214);
mpfr_set_prec(t, 278);
mpfr_set_prec(u, 207);
mpfr_set_str_binary(x, "0.1000100110100110101101101101000000010000100111000001001110001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E66");
mpfr_set_str_binary(t, "-0.10001001101001101011011011010000000100001001110000010011100010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111011111001001100011E66");
test_add (u, x, t, MPFR_RNDN);
mpfr_set_prec(x, 32);
mpfr_set_prec(t, 247);
mpfr_set_prec(u, 223);
mpfr_set_str_binary(x, "0.10000000000000000000000000000000E1");
mpfr_set_str_binary(t, "0.1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000110001110100000100011110000101110110011101110100110110111111011010111100100000000000000000000000000E0");
mpfr_sub(u, x, t, MPFR_RNDN);
if ((MPFR_MANT(u)[(MPFR_PREC(u)-1)/mp_bits_per_limb] &
((mp_limb_t)1<<(mp_bits_per_limb-1)))==0)
{
printf ("Error in mpfr_sub: result is not msb-normalized (2)\n");
exit (1);
}
/* bug found by Nathalie Revol, 21 March 2001 */
mpfr_set_prec (x, 65);
mpfr_set_prec (t, 65);
mpfr_set_prec (u, 65);
mpfr_set_str_binary (x, "0.11100100101101001100111011111111110001101001000011101001001010010E-35");
mpfr_set_str_binary (t, "0.10000000000000000000000000000000000001110010010110100110011110000E1");
mpfr_sub (u, t, x, MPFR_RNDU);
if ((MPFR_MANT(u)[(MPFR_PREC(u)-1)/mp_bits_per_limb] &
((mp_limb_t)1<<(mp_bits_per_limb-1)))==0)
{
printf ("Error in mpfr_sub: result is not msb-normalized (3)\n");
exit (1);
}
/* bug found by Fabrice Rouillier, 27 Mar 2001 */
mpfr_set_prec (x, 107);
mpfr_set_prec (t, 107);
mpfr_set_prec (u, 107);
mpfr_set_str_binary (x, "0.10111001001111010010001000000010111111011011011101000001001000101000000000000000000000000000000000000000000E315");
mpfr_set_str_binary (t, "0.10000000000000000000000000000000000101110100100101110110000001100101011111001000011101111100100100111011000E350");
mpfr_sub (u, x, t, MPFR_RNDU);
if ((MPFR_MANT(u)[(MPFR_PREC(u)-1)/mp_bits_per_limb] &
((mp_limb_t)1<<(mp_bits_per_limb-1)))==0)
{
printf ("Error in mpfr_sub: result is not msb-normalized (4)\n");
exit (1);
}
/* checks that NaN flag is correctly reset */
mpfr_set_ui (t, 1, MPFR_RNDN);
mpfr_set_ui (u, 1, MPFR_RNDN);
mpfr_set_nan (x);
test_add (x, t, u, MPFR_RNDN);
if (mpfr_cmp_ui (x, 2))
{
printf ("Error in mpfr_add: 1+1 gives ");
mpfr_out_str(stdout, 10, 0, x, MPFR_RNDN);
exit (1);
}
mpfr_clear(x);
mpfr_clear(t);
mpfr_clear(u);
}
int
main (int argc, char *argv[])
{
mpfr_t x, y, r;
long q[1];
if (argc == 3) /* usage: tremquo x y (rnd=MPFR_RNDN implicit) */
{
mpfr_init2 (x, GMP_NUMB_BITS);
mpfr_init2 (y, GMP_NUMB_BITS);
mpfr_init2 (r, GMP_NUMB_BITS);
mpfr_set_str (x, argv[1], 10, MPFR_RNDN);
mpfr_set_str (y, argv[2], 10, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
printf ("r=");
mpfr_out_str (stdout, 10, 0, r, MPFR_RNDN);
printf (" q=%ld\n", q[0]);
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (r);
return 0;
}
tests_start_mpfr ();
bug20090227 ();
mpfr_init (x);
mpfr_init (y);
mpfr_init (r);
/* special values */
mpfr_set_nan (x);
mpfr_set_ui (y, 1, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (r));
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_set_nan (y);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (r));
mpfr_set_inf (x, 1); /* +Inf */
mpfr_set_ui (y, 1, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_nan_p (r));
mpfr_set_inf (x, 1); /* +Inf */
mpfr_set_ui (y, 0, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_nan_p (r));
mpfr_set_inf (x, 1); /* +Inf */
mpfr_set_inf (y, 1);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_nan_p (r));
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_set_inf (y, 1);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui (r, 0) == 0 && MPFR_IS_POS (r));
MPFR_ASSERTN (q[0] == (long) 0);
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_neg (x, x, MPFR_RNDN); /* -0 */
mpfr_set_inf (y, 1);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui (r, 0) == 0 && MPFR_IS_NEG (r));
MPFR_ASSERTN (q[0] == (long) 0);
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_set_inf (y, 1);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp (r, x) == 0);
MPFR_ASSERTN (q[0] == (long) 0);
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_set_ui (y, 0, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_nan_p (r));
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_set_ui (y, 17, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui (r, 0) == 0 && MPFR_IS_POS (r));
MPFR_ASSERTN (q[0] == (long) 0);
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_neg (x, x, MPFR_RNDN);
mpfr_set_ui (y, 17, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui (r, 0) == 0 && MPFR_IS_NEG (r));
MPFR_ASSERTN (q[0] == (long) 0);
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
/* check four possible sign combinations */
mpfr_set_ui (x, 42, MPFR_RNDN);
mpfr_set_ui (y, 17, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui (r, 8) == 0);
MPFR_ASSERTN (q[0] == (long) 2);
mpfr_set_si (x, -42, MPFR_RNDN);
mpfr_set_ui (y, 17, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_si (r, -8) == 0);
MPFR_ASSERTN (q[0] == (long) -2);
mpfr_set_si (x, -42, MPFR_RNDN);
mpfr_set_si (y, -17, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_si (r, -8) == 0);
MPFR_ASSERTN (q[0] == (long) 2);
mpfr_set_ui (x, 42, MPFR_RNDN);
mpfr_set_si (y, -17, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui (r, 8) == 0);
MPFR_ASSERTN (q[0] == (long) -2);
mpfr_set_prec (x, 100);
mpfr_set_prec (y, 50);
mpfr_set_ui (x, 42, MPFR_RNDN);
mpfr_nextabove (x); /* 42 + 2^(-94) */
mpfr_set_ui (y, 21, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui_2exp (r, 1, -94) == 0);
MPFR_ASSERTN (q[0] == (long) 2);
mpfr_set_prec (x, 50);
mpfr_set_prec (y, 100);
mpfr_set_ui (x, 42, MPFR_RNDN);
mpfr_nextabove (x); /* 42 + 2^(-44) */
mpfr_set_ui (y, 21, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui_2exp (r, 1, -44) == 0);
MPFR_ASSERTN (q[0] == (long) 2);
mpfr_set_prec (x, 100);
mpfr_set_prec (y, 50);
mpfr_set_ui (x, 42, MPFR_RNDN);
mpfr_set_ui (y, 21, MPFR_RNDN);
mpfr_nextabove (y); /* 21 + 2^(-45) */
mpfr_remquo (r, q, x, y, MPFR_RNDN);
/* r should be 42 - 2*(21 + 2^(-45)) = -2^(-44) */
MPFR_ASSERTN (mpfr_cmp_si_2exp (r, -1, -44) == 0);
MPFR_ASSERTN (q[0] == (long) 2);
mpfr_set_prec (x, 50);
mpfr_set_prec (y, 100);
mpfr_set_ui (x, 42, MPFR_RNDN);
mpfr_set_ui (y, 21, MPFR_RNDN);
mpfr_nextabove (y); /* 21 + 2^(-95) */
mpfr_remquo (r, q, x, y, MPFR_RNDN);
/* r should be 42 - 2*(21 + 2^(-95)) = -2^(-94) */
MPFR_ASSERTN (mpfr_cmp_si_2exp (r, -1, -94) == 0);
MPFR_ASSERTN (q[0] == (long) 2);
/* exercise large quotient */
mpfr_set_ui_2exp (x, 1, 65, MPFR_RNDN);
mpfr_set_ui (y, 1, MPFR_RNDN);
/* quotient is 2^65 */
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_si (r, 0) == 0);
MPFR_ASSERTN (q[0] % 1073741824L == 0L);
/* another large quotient */
mpfr_set_prec (x, 65);
mpfr_set_prec (y, 65);
mpfr_const_pi (x, MPFR_RNDN);
mpfr_mul_2exp (x, x, 63, MPFR_RNDN);
mpfr_const_log2 (y, MPFR_RNDN);
mpfr_set_prec (r, 10);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
/* q should be 41803643793084085130, r should be 605/2048 */
MPFR_ASSERTN (mpfr_cmp_ui_2exp (r, 605, -11) == 0);
MPFR_ASSERTN ((q[0] > 0) && ((q[0] % 1073741824L) == 733836170L));
/* check cases where quotient is 1.5 +/- eps */
mpfr_set_prec (x, 65);
mpfr_set_prec (y, 65);
mpfr_set_prec (r, 63);
mpfr_set_ui (x, 3, MPFR_RNDN);
mpfr_set_ui (y, 2, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
/* x/y = 1.5, quotient should be 2 (even rule), remainder should be -1 */
MPFR_ASSERTN (mpfr_cmp_si (r, -1) == 0);
MPFR_ASSERTN (q[0] == 2L);
mpfr_set_ui (x, 3, MPFR_RNDN);
mpfr_nextabove (x); /* 3 + 2^(-63) */
mpfr_set_ui (y, 2, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
/* x/y = 1.5 + 2^(-64), quo should be 2, r should be -1 + 2^(-63) */
MPFR_ASSERTN (mpfr_add_ui (r, r, 1, MPFR_RNDN) == 0);
MPFR_ASSERTN (mpfr_cmp_ui_2exp (r, 1, -63) == 0);
MPFR_ASSERTN (q[0] == 2L);
mpfr_set_ui (x, 3, MPFR_RNDN);
mpfr_set_ui (y, 2, MPFR_RNDN);
mpfr_nextabove (y); /* 2 + 2^(-63) */
mpfr_remquo (r, q, x, y, MPFR_RNDN);
/* x/y = 1.5 - eps, quo should be 1, r should be 1 - 2^(-63) */
MPFR_ASSERTN (mpfr_sub_ui (r, r, 1, MPFR_RNDN) == 0);
MPFR_ASSERTN (mpfr_cmp_si_2exp (r, -1, -63) == 0);
MPFR_ASSERTN (q[0] == 1L);
/* bug founds by Kaveh Ghazi, 3 May 2007 */
mpfr_set_ui (x, 2, MPFR_RNDN);
mpfr_set_ui (y, 3, MPFR_RNDN);
mpfr_remainder (r, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_si (r, -1) == 0);
mpfr_set_si (x, -1, MPFR_RNDN);
mpfr_set_ui (y, 1, MPFR_RNDN);
mpfr_remainder (r, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_si (r, 0) == 0 && MPFR_SIGN (r) < 0);
/* check argument reuse */
mpfr_set_si (x, -1, MPFR_RNDN);
mpfr_set_ui (y, 1, MPFR_RNDN);
mpfr_remainder (x, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_si (x, 0) == 0 && MPFR_SIGN (x) < 0);
mpfr_set_ui_2exp (x, 1, mpfr_get_emax () - 1, MPFR_RNDN);
mpfr_set_ui_2exp (y, 1, mpfr_get_emin (), MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_zero_p (r) && MPFR_SIGN (r) > 0);
MPFR_ASSERTN (q[0] == 0);
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (r);
tests_end_mpfr ();
return 0;
}
static void
check_special (void)
{
mpfr_t x, y, z;
mpfr_exp_t emin, emax;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
mpfr_init (x);
mpfr_init (y);
mpfr_init (z);
/* check exp(NaN) = NaN */
mpfr_set_nan (x);
test_exp (y, x, MPFR_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error for exp(NaN)\n");
exit (1);
}
/* check exp(+inf) = +inf */
mpfr_set_inf (x, 1);
test_exp (y, x, MPFR_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error for exp(+inf)\n");
exit (1);
}
/* check exp(-inf) = +0 */
mpfr_set_inf (x, -1);
test_exp (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 0) || mpfr_sgn (y) < 0)
{
printf ("Error for exp(-inf)\n");
exit (1);
}
/* Check overflow. Corner case of mpfr_exp_2 */
mpfr_set_prec (x, 64);
mpfr_set_emax (MPFR_EMAX_DEFAULT);
mpfr_set_emin (MPFR_EMIN_DEFAULT);
mpfr_set_str (x,
"0.1011000101110010000101111111010100001100000001110001100111001101E30",
2, MPFR_RNDN);
mpfr_exp (x, x, MPFR_RNDD);
if (mpfr_cmp_str (x,
".1111111111111111111111111111111111111111111111111111111111111111E1073741823",
2, MPFR_RNDN) != 0)
{
printf ("Wrong overflow detection in mpfr_exp\n");
mpfr_dump (x);
exit (1);
}
/* Check underflow. Corner case of mpfr_exp_2 */
mpfr_set_str (x,
"-0.1011000101110010000101111111011111010001110011110111100110101100E30",
2, MPFR_RNDN);
mpfr_exp (x, x, MPFR_RNDN);
if (mpfr_cmp_str (x, "0.1E-1073741823", 2, MPFR_RNDN) != 0)
{
printf ("Wrong underflow (1) detection in mpfr_exp\n");
mpfr_dump (x);
exit (1);
}
mpfr_set_str (x,
"-0.1011001101110010000101111111011111010001110011110111100110111101E30",
2, MPFR_RNDN);
mpfr_exp (x, x, MPFR_RNDN);
if (mpfr_cmp_ui (x, 0) != 0)
{
printf ("Wrong underflow (2) detection in mpfr_exp\n");
mpfr_dump (x);
exit (1);
}
/* Check overflow. Corner case of mpfr_exp_3 */
if (MPFR_PREC_MAX >= MPFR_EXP_THRESHOLD + 10 && MPFR_PREC_MAX >= 64)
{
/* this ensures that for small MPFR_EXP_THRESHOLD, the following
mpfr_set_str conversion is exact */
mpfr_set_prec (x, (MPFR_EXP_THRESHOLD + 10 > 64)
? MPFR_EXP_THRESHOLD + 10 : 64);
mpfr_set_str (x,
"0.1011000101110010000101111111010100001100000001110001100111001101E30",
2, MPFR_RNDN);
mpfr_clear_overflow ();
mpfr_exp (x, x, MPFR_RNDD);
if (!mpfr_overflow_p ())
{
printf ("Wrong overflow detection in mpfr_exp_3\n");
mpfr_dump (x);
exit (1);
}
/* Check underflow. Corner case of mpfr_exp_3 */
mpfr_set_str (x,
"-0.1011000101110010000101111111011111010001110011110111100110101100E30",
2, MPFR_RNDN);
mpfr_clear_underflow ();
mpfr_exp (x, x, MPFR_RNDN);
if (!mpfr_underflow_p ())
{
printf ("Wrong underflow detection in mpfr_exp_3\n");
mpfr_dump (x);
exit (1);
}
mpfr_set_prec (x, 53);
}
/* check overflow */
set_emax (10);
mpfr_set_ui (x, 7, MPFR_RNDN);
test_exp (y, x, MPFR_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error for exp(7) for emax=10\n");
exit (1);
}
set_emax (emax);
/* check underflow */
set_emin (-10);
mpfr_set_si (x, -9, MPFR_RNDN);
test_exp (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 0) || mpfr_sgn (y) < 0)
{
printf ("Error for exp(-9) for emin=-10\n");
printf ("Expected +0\n");
printf ("Got ");
mpfr_print_binary (y);
puts ("");
exit (1);
}
set_emin (emin);
/* check case EXP(x) < -precy */
mpfr_set_prec (y, 2);
mpfr_set_str_binary (x, "-0.1E-3");
test_exp (y, x, MPFR_RNDD);
if (mpfr_cmp_ui_2exp (y, 3, -2))
{
printf ("Error for exp(-1/16), prec=2, RNDD\n");
printf ("expected 0.11, got ");
mpfr_dump (y);
exit (1);
}
test_exp (y, x, MPFR_RNDZ);
if (mpfr_cmp_ui_2exp (y, 3, -2))
{
printf ("Error for exp(-1/16), prec=2, RNDZ\n");
printf ("expected 0.11, got ");
mpfr_dump (y);
exit (1);
}
mpfr_set_str_binary (x, "0.1E-3");
test_exp (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 1))
{
printf ("Error for exp(1/16), prec=2, RNDN\n");
exit (1);
}
test_exp (y, x, MPFR_RNDU);
if (mpfr_cmp_ui_2exp (y, 3, -1))
{
printf ("Error for exp(1/16), prec=2, RNDU\n");
exit (1);
}
/* bug reported by Franky Backeljauw, 28 Mar 2003 */
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str_binary (x, "1.1101011000111101011110000111010010101001101001110111e28");
test_exp (y, x, MPFR_RNDN);
mpfr_set_prec (x, 153);
mpfr_set_prec (z, 153);
mpfr_set_str_binary (x, "1.1101011000111101011110000111010010101001101001110111e28");
test_exp (z, x, MPFR_RNDN);
mpfr_prec_round (z, 53, MPFR_RNDN);
if (mpfr_cmp (y, z))
{
printf ("Error in mpfr_exp for large argument\n");
exit (1);
}
/* corner cases in mpfr_exp_3 */
mpfr_set_prec (x, 2);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_set_prec (y, 2);
mpfr_exp_3 (y, x, MPFR_RNDN);
/* Check some little things about overflow detection */
set_emin (-125);
set_emax (128);
mpfr_set_prec (x, 107);
mpfr_set_prec (y, 107);
mpfr_set_str_binary (x, "0.11110000000000000000000000000000000000000000000"
"0000000000000000000000000000000000000000000000000000"
"00000000E4");
test_exp (y, x, MPFR_RNDN);
if (mpfr_cmp_str (y, "0.11000111100001100110010101111101011010010101010000"
"1101110111100010111001011111111000110111001011001101010"
"01E22", 2, MPFR_RNDN))
{
printf ("Special overflow error (1)\n");
mpfr_dump (y);
exit (1);
}
set_emin (emin);
set_emax (emax);
/* Check for overflow producing a segfault with HUGE exponent */
mpfr_set_ui (x, 3, MPFR_RNDN);
mpfr_mul_2ui (x, x, 32, MPFR_RNDN);
test_exp (y, x, MPFR_RNDN); /* Can't test return value: May overflow or not*/
/* Bug due to wrong approximation of (x)/log2 */
mpfr_set_prec (x, 163);
mpfr_set_str (x, "-4.28ac8fceeadcda06bb56359017b1c81b85b392e7", 16,
MPFR_RNDN);
mpfr_exp (x, x, MPFR_RNDN);
if (mpfr_cmp_str (x, "3.fffffffffffffffffffffffffffffffffffffffe8@-2",
16, MPFR_RNDN))
{
printf ("Error for x= -4.28ac8fceeadcda06bb56359017b1c81b85b392e7");
printf ("expected 3.fffffffffffffffffffffffffffffffffffffffe8@-2");
printf ("Got ");
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN);
putchar ('\n');
}
/* bug found by Guillaume Melquiond, 13 Sep 2005 */
mpfr_set_prec (x, 53);
mpfr_set_str_binary (x, "-1E-400");
mpfr_exp (x, x, MPFR_RNDZ);
if (mpfr_cmp_ui (x, 1) == 0)
{
printf ("Error for exp(-2^(-400))\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
}
int
main (int argc, char *argv[])
{
mpfr_t x;
int p;
mpfr_rnd_t rnd;
tests_start_mpfr ();
p = (argc>1) ? atoi(argv[1]) : 53;
rnd = (argc>2) ? (mpfr_rnd_t) atoi(argv[2]) : MPFR_RNDZ;
mpfr_init (x);
check (2, 1000);
/* check precision of 2 bits */
mpfr_set_prec (x, 2);
mpfr_const_log2 (x, MPFR_RNDN);
if (mpfr_cmp_ui_2exp(x, 3, -2)) /* 3*2^-2 */
{
printf ("mpfr_const_log2 failed for prec=2, rnd=MPFR_RNDN\n"
"expected 0.75, got ");
mpfr_out_str(stdout, 10, 0, x, MPFR_RNDN);
putchar('\n');
exit (1);
}
if (argc>=2)
{
mpfr_set_prec (x, p);
mpfr_const_log2 (x, rnd);
printf ("log(2)=");
mpfr_out_str (stdout, 10, 0, x, rnd);
puts ("");
}
mpfr_set_prec (x, 53);
mpfr_const_log2 (x, MPFR_RNDZ);
if (mpfr_cmp_str1 (x, "6.9314718055994530941e-1") )
{
printf ("mpfr_const_log2 failed for prec=53\n");
exit (1);
}
mpfr_set_prec (x, 32);
mpfr_const_log2 (x, MPFR_RNDN);
if (mpfr_cmp_str1 (x, "0.69314718060195446"))
{
printf ("mpfr_const_log2 failed for prec=32\n");
exit (1);
}
mpfr_clear(x);
check_large();
check_cache ();
test_generic (2, 200, 1);
tests_end_mpfr ();
return 0;
}
static void
check_special ()
{
mpfr_t x, y, z;
mp_exp_t emin, emax;
mpfr_init (x);
mpfr_init (y);
mpfr_init (z);
/* check exp(NaN) = NaN */
mpfr_set_nan (x);
mpfr_exp (y, x, GMP_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error for exp(NaN)\n");
exit (1);
}
/* check exp(+inf) = +inf */
mpfr_set_inf (x, 1);
mpfr_exp (y, x, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error for exp(+inf)\n");
exit (1);
}
/* check exp(-inf) = +0 */
mpfr_set_inf (x, -1);
mpfr_exp (y, x, GMP_RNDN);
if (mpfr_cmp_ui (y, 0) || mpfr_sgn (y) < 0)
{
printf ("Error for exp(-inf)\n");
exit (1);
}
/* check overflow */
emax = mpfr_get_emax ();
set_emax (10);
mpfr_set_ui (x, 7, GMP_RNDN);
mpfr_exp (y, x, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error for exp(7) for emax=10\n");
exit (1);
}
set_emax (emax);
/* check underflow */
emin = mpfr_get_emin ();
set_emin (-10);
mpfr_set_si (x, -9, GMP_RNDN);
mpfr_exp (y, x, GMP_RNDN);
if (mpfr_cmp_ui (y, 0) || mpfr_sgn (y) < 0)
{
printf ("Error for exp(-9) for emin=-10\n");
printf ("Expected +0\n");
printf ("Got "); mpfr_print_binary (y); puts ("");
exit (1);
}
set_emin (emin);
/* check case EXP(x) < -precy */
mpfr_set_prec (y, 2);
mpfr_set_str_binary (x, "-0.1E-3");
mpfr_exp (y, x, GMP_RNDD);
if (mpfr_cmp_ui_2exp (y, 3, -2))
{
printf ("Error for exp(-1/16), prec=2, RNDD\n");
exit (1);
}
mpfr_exp (y, x, GMP_RNDZ);
if (mpfr_cmp_ui (y, 1))
{
printf ("Error for exp(-1/16), prec=2, RNDZ\n");
exit (1);
}
mpfr_set_str_binary (x, "0.1E-3");
mpfr_exp (y, x, GMP_RNDN);
if (mpfr_cmp_ui (y, 1))
{
printf ("Error for exp(1/16), prec=2, RNDN\n");
exit (1);
}
mpfr_exp (y, x, GMP_RNDU);
if (mpfr_cmp_ui_2exp (y, 3, -1))
{
printf ("Error for exp(1/16), prec=2, RNDU\n");
exit (1);
}
/* bug reported by Franky Backeljauw, 28 Mar 2003 */
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str_binary (x, "1.1101011000111101011110000111010010101001101001110111e28");
mpfr_exp (y, x, GMP_RNDN);
mpfr_set_prec (x, 153);
mpfr_set_prec (z, 153);
mpfr_set_str_binary (x, "1.1101011000111101011110000111010010101001101001110111e28");
mpfr_exp (z, x, GMP_RNDN);
mpfr_prec_round (z, 53, GMP_RNDN);
if (mpfr_cmp (y, z))
{
printf ("Error in mpfr_exp for large argument\n");
exit (1);
}
/* corner cases in mpfr_exp_3 */
mpfr_set_prec (x, 2);
mpfr_set_ui (x, 1, GMP_RNDN);
mpfr_set_prec (y, 2);
mpfr_exp_3 (y, x, GMP_RNDN);
/* Check some little things about overflow detection */
set_emin (-125);
set_emax (128);
mpfr_set_prec (x, 107);
mpfr_set_prec (y, 107);
mpfr_set_str_binary (x, "0.11110000000000000000000000000000000000000000000"
"0000000000000000000000000000000000000000000000000000"
"00000000E4");
mpfr_exp (y, x, GMP_RNDN);
if (mpfr_cmp_str (y, "0.11000111100001100110010101111101011010010101010000"
"1101110111100010111001011111111000110111001011001101010"
"01E22", 2, GMP_RNDN))
{
printf ("Special overflow error (1)\n");
mpfr_dump (y);
exit (1);
}
set_emin (MPFR_EMIN_MIN);
set_emax (MPFR_EMAX_MAX);
/* Check for overflow producing a segfault with HUGE exponent */
mpfr_set_ui (x, 3, GMP_RNDN);
mpfr_mul_2ui (x, x, 32, GMP_RNDN);
mpfr_exp (y, x, GMP_RNDN); /* Can't test return value: May overflow or not*/
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
}
