static void
special_overflow (void)
{
mpfr_t x, y;
mpfr_exp_t emin, emax;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
set_emin (-125);
set_emax (128);
mpfr_init2 (x, 24);
mpfr_init2 (y, 48);
mpfr_set_str_binary (x, "0.101100100000000000110100E0");
mpfr_asin (y, x, MPFR_RNDN);
if (mpfr_cmp_str (y, "0.110001001101001111110000010110001000111011001000E0",
2, MPFR_RNDN))
{
printf("Special Overflow error.\n");
mpfr_dump (y);
exit (1);
}
mpfr_clear (y);
mpfr_clear (x);
set_emin (emin);
set_emax (emax);
}
static void
check_overflow (void)
{
mpfr_t x, y, z1, z2;
mpfr_exp_t emin, emax;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
set_emin (-1021);
set_emax (1024);
mpfr_inits (x, y, z1, z2, (mpfr_ptr) 0);
mpfr_set_str1 (x, "8.00468257869324898448e+307");
mpfr_set_str1 (y, "7.44784712422708645156e+307");
mpfr_add1sp (z1, x, y, MPFR_RNDN);
mpfr_add1 (z2, x, y, MPFR_RNDN);
if (mpfr_cmp (z1, z2))
{
printf ("Overflow bug in add1sp.\n");
exit (1);
}
mpfr_clears (x, y, z1, z2, (mpfr_ptr) 0);
set_emin (emin);
set_emax (emax);
}
static void
special_overflow (void)
{
mpfr_t x, y;
int inex;
mpfr_exp_t emin, emax;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
set_emin (-125);
set_emax (128);
mpfr_init2 (x, 24);
mpfr_init2 (y, 24);
mpfr_set_str_binary (x, "0.101100100000000000110100E15");
inex = mpfr_exp2 (y, x, MPFR_RNDN);
if (!mpfr_inf_p (y) || inex <= 0)
{
printf ("Overflow error.\n");
mpfr_dump (y);
printf ("inex = %d\n", inex);
exit (1);
}
mpfr_clear (y);
mpfr_clear (x);
set_emin (emin);
set_emax (emax);
}
/* In particular, the following test makes sure that the rounding
* for %Ra and %Rb is not done on the MPFR number itself (as it
* would overflow). Note: it has been reported on comp.std.c that
* some C libraries behave differently on %a, but this is a bug.
*/
static void
check_emax_aux (mpfr_exp_t e)
{
mpfr_t x;
char *s1, s2[256];
int i;
mpfr_exp_t emax;
MPFR_ASSERTN (e <= LONG_MAX);
emax = mpfr_get_emax ();
set_emax (e);
mpfr_init2 (x, 16);
mpfr_set_inf (x, 1);
mpfr_nextbelow (x);
i = mpfr_asprintf (&s1, "%Ra %.2Ra", x, x);
MPFR_ASSERTN (i > 0);
mpfr_snprintf (s2, 256, "0x7.fff8p+%ld 0x8.00p+%ld", e-3, e-3);
if (strcmp (s1, s2) != 0)
{
printf ("Error in check_emax_aux for emax = ");
if (e > LONG_MAX)
printf ("(>LONG_MAX)\n");
else
printf ("%ld\n", (long) e);
printf ("Expected %s\n", s2);
printf ("Got %s\n", s1);
exit (1);
}
mpfr_free_str (s1);
i = mpfr_asprintf (&s1, "%Rb %.2Rb", x, x);
MPFR_ASSERTN (i > 0);
mpfr_snprintf (s2, 256, "1.111111111111111p+%ld 1.00p+%ld", e-1, e);
if (strcmp (s1, s2) != 0)
{
printf ("Error in check_emax_aux for emax = ");
if (e > LONG_MAX)
printf ("(>LONG_MAX)\n");
else
printf ("%ld\n", (long) e);
printf ("Expected %s\n", s2);
printf ("Got %s\n", s1);
exit (1);
}
mpfr_free_str (s1);
mpfr_clear (x);
set_emax (emax);
}
int
main (void)
{
mpfr_t x, y, z, u;
int inexact;
mpfr_exp_t emax;
tests_start_mpfr ();
/* check prototypes of mpfr_init_set_* */
inexact = mpfr_init_set_si (x, -1, MPFR_RNDN);
inexact = mpfr_init_set (y, x, MPFR_RNDN);
inexact = mpfr_init_set_ui (z, 1, MPFR_RNDN);
inexact = mpfr_init_set_d (u, 1.0, MPFR_RNDN);
emax = mpfr_get_emax ();
set_emax (0);
mpfr_set_prec (x, 3);
mpfr_set_str_binary (x, "0.111");
mpfr_set_prec (y, 2);
mpfr_set (y, x, MPFR_RNDU);
if (!(MPFR_IS_INF (y) && MPFR_SIGN (y) > 0))
{
printf ("Error for y=x=0.111 with px=3, py=2 and emax=0\nx=");
mpfr_dump (x);
printf ("y=");
mpfr_dump (y);
exit (1);
}
set_emax (emax);
mpfr_set_prec (y, 11);
mpfr_set_str_binary (y, "0.11111111100E-8");
mpfr_set_prec (x, 2);
mpfr_set (x, y, MPFR_RNDN);
mpfr_set_str_binary (y, "1.0E-8");
if (mpfr_cmp (x, y))
{
printf ("Error for y=0.11111111100E-8, prec=2, rnd=MPFR_RNDN\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (u);
check_ternary_value ();
check_special ();
check_neg_special ();
test_generic (2, 1000, 10);
tests_end_mpfr ();
return 0;
}
static void
special_overflow (void)
{
/* Check for overflow in 3 cases:
1. cosh(x) is representable, but not exp(x)
2. cosh(x) is not representable in the selected range of exp.
3. cosh(x) exp overflow even with the largest range of exp */
mpfr_t x, y;
mp_exp_t emin, emax;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
set_emin (-125);
set_emax (128);
mpfr_init2 (x, 24);
mpfr_init2 (y, 24);
mpfr_set_str_binary (x, "0.101100100000000000110100E7");
mpfr_cosh (y, x, GMP_RNDN);
if (mpfr_cmp_str (y, "0.101010001111001010001110E128", 2, GMP_RNDN))
{
printf("Special overflow error 1.\n");
mpfr_dump (y);
exit (1);
}
mpfr_set_str_binary (x, "0.101100100000000000110100E8");
mpfr_cosh (y, x, GMP_RNDN);
if (!mpfr_inf_p(y))
{
printf("Special overflow error 2.\n");
mpfr_dump (y);
exit (1);
}
set_emin (emin);
set_emax (emax);
mpfr_set_str_binary (x, "0.101100100000000000110100E1000000");
mpfr_cosh (y, x, GMP_RNDN);
if (!mpfr_inf_p(y))
{
printf("Special overflow error 3.\n");
mpfr_dump (y);
exit (1);
}
mpfr_clear (y);
mpfr_clear (x);
}
static void
check_overflow (void)
{
mpfr_t sum1, sum2, x, y;
mpfr_ptr t[2 * NOVFL];
mpfr_exp_t emin, emax;
int i, r;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
set_emin (MPFR_EMIN_MIN);
set_emax (MPFR_EMAX_MAX);
mpfr_inits2 (32, sum1, sum2, x, y, (mpfr_ptr) 0);
mpfr_setmax (x, mpfr_get_emax ());
mpfr_neg (y, x, MPFR_RNDN);
for (i = 0; i < 2 * NOVFL; i++)
t[i] = i < NOVFL ? x : y;
/* Two kinds of test:
* i = 1: overflow.
* i = 2: intermediate overflow (exact sum is 0).
*/
for (i = 1; i <= 2; i++)
RND_LOOP(r)
{
int inex1, inex2;
inex1 = mpfr_add (sum1, x, i == 1 ? x : y, (mpfr_rnd_t) r);
inex2 = mpfr_sum (sum2, t, i * NOVFL, (mpfr_rnd_t) r);
MPFR_ASSERTN (mpfr_check (sum1));
MPFR_ASSERTN (mpfr_check (sum2));
if (!(mpfr_equal_p (sum1, sum2) && SAME_SIGN (inex1, inex2)))
{
printf ("Error in check_overflow on %s, i = %d\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r), i);
printf ("Expected ");
mpfr_dump (sum1);
printf ("with inex = %d\n", inex1);
printf ("Got ");
mpfr_dump (sum2);
printf ("with inex = %d\n", inex2);
exit (1);
}
}
mpfr_clears (sum1, sum2, x, y, (mpfr_ptr) 0);
set_emin (emin);
set_emax (emax);
}
static void
check_large (void)
{
mpz_t z;
mpfr_t x, y;
mpfr_exp_t emax, emin;
mpz_init (z);
mpfr_init2 (x, 160);
mpfr_init2 (y, 160);
mpz_set_str (z, "77031627725494291259359895954016675357279104942148788042", 10);
mpfr_set_z (x, z, MPFR_RNDN);
mpfr_set_str_binary (y, "0.1100100100001111110110101010001000100001011010001100001000110100110001001100011001100010100010111000000011011100000111001101000100101001000000100100111000001001E186");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_z on large input\n");
exit (1);
}
/* check overflow */
emax = mpfr_get_emax ();
set_emax (2);
mpz_set_str (z, "7", 10);
mpfr_set_z (x, z, MPFR_RNDU);
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) > 0);
set_emax (3);
mpfr_set_prec (x, 2);
mpz_set_str (z, "7", 10);
mpfr_set_z (x, z, MPFR_RNDU);
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) > 0);
set_emax (emax);
/* check underflow */
emin = mpfr_get_emin ();
set_emin (3);
mpz_set_str (z, "1", 10);
mpfr_set_z (x, z, MPFR_RNDZ);
MPFR_ASSERTN(mpfr_cmp_ui (x, 0) == 0 && MPFR_IS_POS(x));
set_emin (2);
mpfr_set_z (x, z, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (x, 0) == 0 && MPFR_IS_POS(x));
set_emin (emin);
mpz_clear (z);
mpfr_clear (x);
mpfr_clear (y);
}
static void
check_emin_emax (void)
{
mpfr_exp_t old_emin, old_emax;
old_emin = mpfr_get_emin ();
old_emax = mpfr_get_emax ();
/* Check the functions not the macros ! */
if ((mpfr_set_emin)(MPFR_EMIN_MIN) != 0)
ERROR("set_emin failed!");
if ((mpfr_get_emin)() != MPFR_EMIN_MIN)
ERROR("get_emin FAILED!");
if ((mpfr_set_emin)(MPFR_EMIN_MIN-1) == 0)
ERROR("set_emin failed! (2)");
if ((mpfr_set_emax)(MPFR_EMAX_MAX) != 0)
ERROR("set_emax failed!");
if ((mpfr_get_emax)() != MPFR_EMAX_MAX)
ERROR("get_emax FAILED!");
if ((mpfr_set_emax)(MPFR_EMAX_MAX+1) == 0)
ERROR("set_emax failed! (2)");
if ((mpfr_get_emin_min) () != MPFR_EMIN_MIN)
ERROR ("get_emin_min");
if ((mpfr_get_emin_max) () != MPFR_EMIN_MAX)
ERROR ("get_emin_max");
if ((mpfr_get_emax_min) () != MPFR_EMAX_MIN)
ERROR ("get_emax_min");
if ((mpfr_get_emax_max) () != MPFR_EMAX_MAX)
ERROR ("get_emax_max");
set_emin (old_emin);
set_emax (old_emax);
}
static void
mpfr_set_double_range (void)
{
mpfr_set_default_prec (54);
if (mpfr_get_default_prec () != 54)
ERROR ("get_default_prec failed (1)");
mpfr_set_default_prec (53);
if ((mpfr_get_default_prec) () != 53)
ERROR ("get_default_prec failed (2)");
/* in double precision format, the unbiased exponent is between 0 and
2047, where 0 is used for subnormal numbers, and 2047 for special
numbers (infinities, NaN), and the bias is 1023, thus "normal" numbers
have an exponent between -1022 and 1023, corresponding to numbers
between 2^(-1022) and previous(2^(1024)).
(The smallest subnormal number is 0.(0^51)1*2^(-1022)= 2^(-1074).)
The smallest normal power of two is 1.0*2^(-1022).
The largest normal power of two is 2^1023.
(We have to add one for mpfr since mantissa are between 1/2 and 1.)
*/
set_emin (-1021);
set_emax (1024);
}
/* https://sympa.inria.fr/sympa/arc/mpfr/2011-05/msg00008.html
* Incorrect flags (in debug mode on a 32-bit machine, assertion failure).
*/
static void
reduced_expo_range (void)
{
mpfr_exp_t emin, emax;
mpfr_t x, y, ex_y;
int inex, ex_inex;
unsigned int flags, ex_flags;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
mpfr_inits2 (12, x, y, ex_y, (mpfr_ptr) 0);
mpfr_set_str (x, "0.1e-5", 2, MPFR_RNDN);
set_emin (-5);
set_emax (-5);
mpfr_clear_flags ();
inex = mpfr_atan (y, x, MPFR_RNDN);
flags = __gmpfr_flags;
set_emin (emin);
set_emax (emax);
mpfr_set_str (ex_y, "0.1e-5", 2, MPFR_RNDN);
ex_inex = 1;
ex_flags = MPFR_FLAGS_INEXACT;
if (SIGN (inex) != ex_inex || flags != ex_flags ||
! mpfr_equal_p (y, ex_y))
{
printf ("Error in reduced_expo_range\non x = ");
mpfr_dump (x);
printf ("Expected y = ");
mpfr_out_str (stdout, 2, 0, ex_y, MPFR_RNDN);
printf ("\n inex = %d, flags = %u\n", ex_inex, ex_flags);
printf ("Got y = ");
mpfr_out_str (stdout, 2, 0, y, MPFR_RNDN);
printf ("\n inex = %d, flags = %u\n", SIGN (inex), flags);
exit (1);
}
mpfr_clears (x, y, ex_y, (mpfr_ptr) 0);
}
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;
}
static void
check_reduced_exprange (void)
{
mpfr_t x;
char *s;
mpfr_exp_t emax, e;
emax = mpfr_get_emax ();
mpfr_init2 (x, 8);
mpfr_set_str (x, "0.11111111E0", 2, MPFR_RNDN);
set_emax (0);
s = mpfr_get_str (NULL, &e, 16, 0, x, MPFR_RNDN);
set_emax (emax);
if (strcmp (s, "ff0"))
{
printf ("Error for mpfr_get_str on 0.11111111E0 in base 16:\n"
"Got \"%s\" instead of \"ff0\".\n", s);
exit (1);
}
mpfr_free_str (s);
mpfr_clear (x);
}
static void
special_overflow (void)
{
mpfr_t x, y;
mpfr_exp_t emin, emax;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
mpfr_init2 (x, 24);
mpfr_init2 (y, 73);
/* Check special case: An overflow in const_pi could occurs! */
set_emin (-125);
set_emax (128);
mpfr_set_str_binary (x, "0.111101010110110011101101E6");
test_cos (y, x, MPFR_RNDZ);
set_emin (emin);
set_emax (emax);
mpfr_clear (x);
mpfr_clear (y);
}
static void
check_flags (void)
{
mpfr_t x;
mpfr_exp_t old_emin, old_emax;
old_emin = mpfr_get_emin ();
old_emax = mpfr_get_emax ();
mpfr_init (x);
/* Check the functions not the macros ! */
(mpfr_clear_flags)();
mpfr_set_double_range ();
mpfr_set_ui (x, 1, MPFR_RNDN);
(mpfr_clear_overflow)();
mpfr_mul_2exp (x, x, 1024, MPFR_RNDN);
if (!(mpfr_overflow_p)())
ERROR("ERROR: No overflow detected!\n");
(mpfr_clear_underflow)();
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_div_2exp (x, x, 1025, MPFR_RNDN);
if (!(mpfr_underflow_p)())
ERROR("ERROR: No underflow detected!\n");
(mpfr_clear_nanflag)();
MPFR_SET_NAN(x);
mpfr_add (x, x, x, MPFR_RNDN);
if (!(mpfr_nanflag_p)())
ERROR("ERROR: No NaN flag!\n");
(mpfr_clear_inexflag)();
mpfr_set_ui(x, 2, MPFR_RNDN);
mpfr_cos(x, x, MPFR_RNDN);
if (!(mpfr_inexflag_p)())
ERROR("ERROR: No inexact flag!\n");
(mpfr_clear_erangeflag) ();
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1024, MPFR_RNDN);
mpfr_get_ui (x, MPFR_RNDN);
if (!(mpfr_erangeflag_p)())
ERROR ("ERROR: No erange flag!\n");
mpfr_clear (x);
set_emin (old_emin);
set_emax (old_emax);
}
static void
alltst (void)
{
mpfr_exp_t emin, emax;
ext = 0;
test_small ();
test_large_small ();
check_overflow ();
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
set_emin (MPFR_EMIN_MIN);
set_emax (MPFR_EMAX_MAX);
if (mpfr_get_emin () != emin || mpfr_get_emax () != emax)
{
ext = 1;
test_small ();
test_large_small ();
check_overflow ();
set_emin (emin);
set_emax (emax);
}
}
static void
alltst (void)
{
mpfr_exp_t emin, emax;
ext = 0;
tst ();
underflow_up ();
overflow_inv ();
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
set_emin (MPFR_EMIN_MIN);
set_emax (MPFR_EMAX_MAX);
if (mpfr_get_emin () != emin || mpfr_get_emax () != emax)
{
ext = 1;
tst ();
underflow_up ();
overflow_inv ();
set_emin (emin);
set_emax (emax);
}
}
static void
check_underflow (void)
{
mpfr_t a;
mp_exp_t emin, emax;
int res;
mpfr_init (a);
/* Check underflow */
emin = mpfr_get_emin ();
set_emin (-20);
res = mpfr_set_str (a, "0.00000000001", 10, GMP_RNDZ);
if (!MPFR_IS_ZERO (a))
{
printf("ERROR for mpfr_set_str (a, \"0.00000000001\", 10, GMP_RNDN)\n"
" with emin=-20\n"
"res=%d\n", res);
mpfr_dump (a);
exit (1);
}
set_emin (emin);
/* check overflow */
emax = mpfr_get_emax ();
set_emax (1073741823); /* 2^30-1 */
mpfr_set_str (a, "2E1000000000", 10, GMP_RNDN);
if (!mpfr_inf_p (a) || mpfr_sgn (a) < 0)
{
printf("ERROR for mpfr_set_str (a, \"2E1000000000\", 10, GMP_RNDN);\n");
exit (1);
}
set_emax (emax);
mpfr_clear (a);
}
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
overflowed_sec0 (void)
{
mpfr_t x, y;
int emax, i, inex, rnd, err = 0;
mpfr_exp_t old_emax;
old_emax = mpfr_get_emax ();
mpfr_init2 (x, 8);
mpfr_init2 (y, 8);
for (emax = -1; emax <= 0; emax++)
{
mpfr_set_ui_2exp (y, 1, emax, MPFR_RNDN);
mpfr_nextbelow (y);
set_emax (emax); /* 1 is not representable. */
for (i = -1; i <= 1; i++)
RND_LOOP (rnd)
{
mpfr_set_si_2exp (x, i, -512 * ABS (i), MPFR_RNDN);
mpfr_clear_flags ();
inex = mpfr_sec (x, x, (mpfr_rnd_t) rnd);
if (! mpfr_overflow_p ())
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" The overflow flag is not set.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
if (rnd == MPFR_RNDZ || rnd == MPFR_RNDD)
{
if (inex >= 0)
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" The inexact value must be negative.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
if (! mpfr_equal_p (x, y))
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" Got ", i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpfr_print_binary (x);
printf (" instead of 0.11111111E%d.\n", emax);
err = 1;
}
}
else
{
if (inex <= 0)
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" The inexact value must be positive.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
if (! (mpfr_inf_p (x) && MPFR_SIGN (x) > 0))
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" Got ", i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpfr_print_binary (x);
printf (" instead of +Inf.\n");
err = 1;
}
}
}
set_emax (old_emax);
}
if (err)
exit (1);
mpfr_clear (x);
mpfr_clear (y);
}
static void
overflowed_fac0 (void)
{
mpfr_t x, y;
int inex, rnd, err = 0;
mp_exp_t old_emax;
old_emax = mpfr_get_emax ();
mpfr_init2 (x, 8);
mpfr_init2 (y, 8);
mpfr_set_ui (y, 1, GMP_RNDN);
mpfr_nextbelow (y);
set_emax (0); /* 1 is not representable. */
RND_LOOP (rnd)
{
mpfr_clear_flags ();
inex = mpfr_fac_ui (x, 0, rnd);
if (! mpfr_overflow_p ())
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" The overflow flag is not set.\n",
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (rnd == GMP_RNDZ || rnd == GMP_RNDD)
{
if (inex >= 0)
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" The inexact value must be negative.\n",
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (! mpfr_equal_p (x, y))
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" Got ", mpfr_print_rnd_mode (rnd));
mpfr_print_binary (x);
printf (" instead of 0.11111111E0.\n");
err = 1;
}
}
else
{
if (inex <= 0)
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" The inexact value must be positive.\n",
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (! (mpfr_inf_p (x) && MPFR_SIGN (x) > 0))
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" Got ", mpfr_print_rnd_mode (rnd));
mpfr_print_binary (x);
printf (" instead of +Inf.\n");
err = 1;
}
}
}
set_emax (old_emax);
if (err)
exit (1);
mpfr_clear (x);
mpfr_clear (y);
}
static void
special_overflow (void)
{
mpfr_t x, y;
mp_exp_t emin, emax;
int inex;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
set_emin (-125);
set_emax (128);
mpfr_init2 (x, 24);
mpfr_init2 (y, 24);
mpfr_set_str_binary (x, "0.101100100000000000110100E7");
mpfr_gamma (y, x, GMP_RNDN);
if (!mpfr_inf_p (y))
{
printf ("Overflow error.\n");
mpfr_dump (y);
exit (1);
}
/* problem mentioned by Kenneth Wilder, 18 Aug 2005 */
mpfr_set_prec (x, 29);
mpfr_set_prec (y, 29);
mpfr_set_str (x, "-200000000.5", 10, GMP_RNDN); /* exact */
mpfr_gamma (y, x, GMP_RNDN);
if (!(mpfr_zero_p (y) && MPFR_SIGN (y) < 0))
{
printf ("Error for gamma(-200000000.5)\n");
printf ("expected -0");
printf ("got ");
mpfr_dump (y);
exit (1);
}
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str (x, "-200000000.1", 10, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
if (!(mpfr_zero_p (y) && MPFR_SIGN (y) < 0))
{
printf ("Error for gamma(-200000000.1), prec=53\n");
printf ("expected -0");
printf ("got ");
mpfr_dump (y);
exit (1);
}
/* another problem mentioned by Kenneth Wilder, 29 Aug 2005 */
mpfr_set_prec (x, 333);
mpfr_set_prec (y, 14);
mpfr_set_str (x, "-2.0000000000000000000000005", 10, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_prec (x, 14);
mpfr_set_str_binary (x, "-11010011110001E66");
if (mpfr_cmp (x, y))
{
printf ("Error for gamma(-2.0000000000000000000000005)\n");
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
/* another tests from Kenneth Wilder, 31 Aug 2005 */
set_emax (200);
set_emin (-200);
mpfr_set_prec (x, 38);
mpfr_set_prec (y, 54);
mpfr_set_str_binary (x, "0.11101111011100111101001001010110101001E-166");
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_prec (x, 54);
mpfr_set_str_binary (x, "0.100010001101100001110110001010111111010000100101011E167");
if (mpfr_cmp (x, y))
{
printf ("Error for gamma (test 1)\n");
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
set_emax (1000);
set_emin (-2000);
mpfr_set_prec (x, 38);
mpfr_set_prec (y, 71);
mpfr_set_str_binary (x, "10101011011100001111111000010111110010E-1034");
/* 184083777010*2^(-1034) */
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_prec (x, 71);
mpfr_set_str_binary (x, "10111111001000011110010001000000000000110011110000000011101011111111100E926");
/* 1762885132679550982140*2^926 */
if (mpfr_cmp (x, y))
{
printf ("Error for gamma (test 2)\n");
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
mpfr_set_prec (x, 38);
mpfr_set_prec (y, 88);
mpfr_set_str_binary (x, "10111100111001010000100001100100100101E-104");
/* 202824096037*2^(-104) */
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_prec (x, 88);
mpfr_set_str_binary (x, "1010110101111000111010111100010110101010100110111000001011000111000011101100001101110010E-21");
/* 209715199999500283894743922*2^(-21) */
if (mpfr_cmp (x, y))
{
printf ("Error for gamma (test 3)\n");
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
mpfr_set_prec (x, 171);
mpfr_set_prec (y, 38);
mpfr_set_str (x, "-2993155353253689176481146537402947624254601559176535", 10,
GMP_RNDN);
mpfr_div_2exp (x, x, 170, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_prec (x, 38);
mpfr_set_str (x, "201948391737", 10, GMP_RNDN);
mpfr_mul_2exp (x, x, 92, GMP_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error for gamma (test 5)\n");
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
set_emin (-500000);
mpfr_set_prec (x, 337);
mpfr_set_prec (y, 38);
mpfr_set_str (x, "-30000.000000000000000000000000000000000000000000001", 10,
GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_prec (x, 38);
mpfr_set_str (x, "-3.623795987425E-121243", 10, GMP_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error for gamma (test 7)\n");
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
/* was producing infinite loop */
set_emin (emin);
mpfr_set_prec (x, 71);
mpfr_set_prec (y, 71);
mpfr_set_str (x, "-200000000.1", 10, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
if (!(mpfr_zero_p (y) && MPFR_SIGN (y) < 0))
{
printf ("Error for gamma (test 8)\n");
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
set_emax (1073741823);
mpfr_set_prec (x, 29);
mpfr_set_prec (y, 29);
mpfr_set_str (x, "423786866", 10, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error for gamma(423786866)\n");
exit (1);
}
/* check exact result */
mpfr_set_prec (x, 2);
mpfr_set_ui (x, 3, GMP_RNDN);
inex = mpfr_gamma (x, x, GMP_RNDN);
if (inex != 0 || mpfr_cmp_ui (x, 2) != 0)
{
printf ("Error for gamma(3)\n");
exit (1);
}
mpfr_set_emax (1024);
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str_binary (x, "101010110100110011111010000110001000111100000110101E-43");
mpfr_gamma (x, x, GMP_RNDU);
mpfr_set_str_binary (y, "110000011110001000111110110101011110000100001111111E971");
if (mpfr_cmp (x, y) != 0)
{
printf ("Error for gamma(4)\n");
printf ("expected "); mpfr_dump (y);
printf ("got "); mpfr_dump (x);
exit (1);
}
mpfr_clear (y);
mpfr_clear (x);
set_emin (emin);
set_emax (emax);
}
static void
special_overflow (void)
{
mpfr_t x, y;
int i;
mpfr_exp_t emin, emax;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
mpfr_clear_overflow ();
set_emin (-125);
set_emax (128);
mpfr_init2 (x, 24);
mpfr_init2 (y, 24);
mpfr_set_str_binary (x, "0.101100100000000000110100E7");
i = mpfr_tanh (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 1) || i != 1)
{
printf("Overflow error (1). i=%d\ny=", i);
mpfr_dump (y);
exit (1);
}
MPFR_ASSERTN (!mpfr_overflow_p ());
i = mpfr_tanh (y, x, MPFR_RNDZ);
if (mpfr_cmp_str (y, "0.111111111111111111111111E0", 2, MPFR_RNDN)
|| i != -1)
{
printf("Overflow error (2).i=%d\ny=", i);
mpfr_dump (y);
exit (1);
}
MPFR_ASSERTN (!mpfr_overflow_p ());
set_emin (emin);
set_emax (emax);
mpfr_set_str_binary (x, "0.1E1000000000");
i = mpfr_tanh (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 1) || i != 1)
{
printf("Overflow error (3). i=%d\ny=", i);
mpfr_dump (y);
exit (1);
}
MPFR_ASSERTN (!mpfr_overflow_p ());
mpfr_set_str_binary (x, "-0.1E1000000000");
i = mpfr_tanh (y, x, MPFR_RNDU);
if (mpfr_cmp_str (y, "-0.111111111111111111111111E0", 2, MPFR_RNDN)
|| i != 1)
{
printf("Overflow error (4). i=%d\ny=", i);
mpfr_dump (y);
exit (1);
}
mpfr_clear (y);
mpfr_clear (x);
}
int
main (int argc, char *argv[])
{
mpfr_t x;
long k, z, d, N;
unsigned long zl, dl;
int inex;
int r;
mpfr_exp_t emin, emax;
int flag;
tests_start_mpfr ();
mpfr_init2 (x, 100);
N = (argc==1) ? 100000 : atol (argv[1]);
for (k = 1; k <= N; k++)
{
z = (long) (randlimb () & LONG_MAX) + LONG_MIN / 2;
inex = mpfr_set_si (x, z, MPFR_RNDZ);
d = mpfr_get_si (x, MPFR_RNDZ);
if (d != z)
{
printf ("Error in mpfr_set_si: expected %ld got %ld\n", z, d);
exit (1);
}
if (inex)
{
printf ("Error in mpfr_set_si: inex value incorrect for %ld: %d\n",
z, inex);
exit (1);
}
}
for (k = 1; k <= N; k++)
{
zl = randlimb ();
inex = mpfr_set_ui (x, zl, MPFR_RNDZ);
dl = mpfr_get_ui (x, MPFR_RNDZ);
if (dl != zl)
{
printf ("Error in mpfr_set_ui: expected %lu got %lu\n", zl, dl);
exit (1);
}
if (inex)
{
printf ("Error in mpfr_set_ui: inex value incorrect for %lu: %d\n",
zl, inex);
exit (1);
}
}
mpfr_set_prec (x, 2);
if (mpfr_set_si (x, 5, MPFR_RNDZ) >= 0)
{
printf ("Wrong inexact flag for x=5, rnd=MPFR_RNDZ\n");
exit (1);
}
mpfr_set_prec (x, 2);
if (mpfr_set_si (x, -5, MPFR_RNDZ) <= 0)
{
printf ("Wrong inexact flag for x=-5, rnd=MPFR_RNDZ\n");
exit (1);
}
mpfr_set_prec (x, 3);
inex = mpfr_set_si (x, 77617, MPFR_RNDD); /* should be 65536 */
if (MPFR_MANT(x)[0] != ((mp_limb_t)1 << (mp_bits_per_limb-1))
|| inex >= 0)
{
printf ("Error in mpfr_set_si(x:3, 77617, MPFR_RNDD)\n");
mpfr_print_binary (x);
puts ("");
exit (1);
}
inex = mpfr_set_ui (x, 77617, MPFR_RNDD); /* should be 65536 */
if (MPFR_MANT(x)[0] != ((mp_limb_t)1 << (mp_bits_per_limb-1))
|| inex >= 0)
{
printf ("Error in mpfr_set_ui(x:3, 77617, MPFR_RNDD)\n");
mpfr_print_binary (x);
puts ("");
exit (1);
}
mpfr_set_prec (x, 2);
inex = mpfr_set_si (x, 33096, MPFR_RNDU);
if (mpfr_get_si (x, MPFR_RNDZ) != 49152 || inex <= 0)
{
printf ("Error in mpfr_set_si, exp. 49152, got %ld, inex %d\n",
mpfr_get_si (x, MPFR_RNDZ), inex);
exit (1);
}
inex = mpfr_set_ui (x, 33096, MPFR_RNDU);
if (mpfr_get_si (x, MPFR_RNDZ) != 49152)
{
printf ("Error in mpfr_set_ui, exp. 49152, got %ld, inex %d\n",
mpfr_get_si (x, MPFR_RNDZ), inex);
exit (1);
}
/* Also test the mpfr_set_ui function (instead of macro). */
inex = (mpfr_set_ui) (x, 33096, MPFR_RNDU);
if (mpfr_get_si (x, MPFR_RNDZ) != 49152)
{
printf ("Error in mpfr_set_ui function, exp. 49152, got %ld, inex %d\n",
mpfr_get_si (x, MPFR_RNDZ), inex);
exit (1);
}
for (r = 0 ; r < MPFR_RND_MAX ; r++)
{
mpfr_set_si (x, -1, (mpfr_rnd_t) r);
mpfr_set_ui (x, 0, (mpfr_rnd_t) r);
if (MPFR_IS_NEG (x) || mpfr_get_ui (x, (mpfr_rnd_t) r) != 0)
{
printf ("mpfr_set_ui (x, 0) gives -0 for %s\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r));
exit (1);
}
mpfr_set_si (x, -1, (mpfr_rnd_t) r);
mpfr_set_si (x, 0, (mpfr_rnd_t) r);
if (MPFR_IS_NEG (x) || mpfr_get_si (x, (mpfr_rnd_t) r) != 0)
{
printf ("mpfr_set_si (x, 0) gives -0 for %s\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r));
exit (1);
}
}
/* check potential bug in case mp_limb_t is unsigned */
emax = mpfr_get_emax ();
set_emax (0);
mpfr_set_si (x, -1, MPFR_RNDN);
if (mpfr_sgn (x) >= 0)
{
printf ("mpfr_set_si (x, -1) fails\n");
exit (1);
}
set_emax (emax);
emax = mpfr_get_emax ();
set_emax (5);
mpfr_set_prec (x, 2);
mpfr_set_si (x, -31, MPFR_RNDN);
if (mpfr_sgn (x) >= 0)
{
printf ("mpfr_set_si (x, -31) fails\n");
exit (1);
}
set_emax (emax);
/* test for get_ui */
mpfr_set_ui (x, 0, MPFR_RNDN);
MPFR_ASSERTN(mpfr_get_ui (x, MPFR_RNDN) == 0);
mpfr_set_ui (x, ULONG_MAX, MPFR_RNDU);
mpfr_nextabove (x);
mpfr_get_ui (x, MPFR_RNDU);
/* another test for get_ui */
mpfr_set_prec (x, 10);
mpfr_set_str_binary (x, "10.101");
dl = mpfr_get_ui (x, MPFR_RNDN);
MPFR_ASSERTN (dl == 3);
mpfr_set_str_binary (x, "-1.0");
mpfr_get_ui (x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.1");
dl = mpfr_get_ui (x, MPFR_RNDN);
MPFR_ASSERTN (dl == 0);
dl = mpfr_get_ui (x, MPFR_RNDZ);
MPFR_ASSERTN (dl == 0);
dl = mpfr_get_ui (x, MPFR_RNDD);
MPFR_ASSERTN (dl == 0);
dl = mpfr_get_ui (x, MPFR_RNDU);
MPFR_ASSERTN (dl == 1);
/* coverage tests */
mpfr_set_prec (x, 2);
mpfr_set_si (x, -7, MPFR_RNDD);
MPFR_ASSERTN(mpfr_cmp_si (x, -8) == 0);
mpfr_set_prec (x, 2);
mpfr_set_ui (x, 7, MPFR_RNDU);
MPFR_ASSERTN(mpfr_cmp_ui (x, 8) == 0);
emax = mpfr_get_emax ();
set_emax (3);
mpfr_set_ui (x, 7, MPFR_RNDU);
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) > 0);
set_emax (1);
MPFR_ASSERTN( mpfr_set_ui (x, 7, MPFR_RNDU) );
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) > 0);
set_emax (emax);
mpfr_set_ui_2exp (x, 17, -50, MPFR_RNDN);
MPFR_ASSERTN (mpfr_get_ui (x, MPFR_RNDD) == 0);
MPFR_ASSERTN (mpfr_get_si (x, MPFR_RNDD) == 0);
/* Test for ERANGE flag + correct behaviour if overflow */
mpfr_set_prec (x, 256);
mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
mpfr_clear_erangeflag ();
dl = mpfr_get_ui (x, MPFR_RNDN);
if (dl != ULONG_MAX || mpfr_erangeflag_p ())
{
printf ("ERROR for get_ui + ERANGE + ULONG_MAX (1)\n");
exit (1);
}
mpfr_add_ui (x, x, 1, MPFR_RNDN);
dl = mpfr_get_ui (x, MPFR_RNDN);
if (dl != ULONG_MAX || !mpfr_erangeflag_p ())
{
printf ("ERROR for get_ui + ERANGE + ULONG_MAX (2)\n");
exit (1);
}
mpfr_set_si (x, -1, MPFR_RNDN);
mpfr_clear_erangeflag ();
dl = mpfr_get_ui (x, MPFR_RNDN);
if (dl != 0 || !mpfr_erangeflag_p ())
{
printf ("ERROR for get_ui + ERANGE + -1 \n");
exit (1);
}
mpfr_set_si (x, LONG_MAX, MPFR_RNDN);
mpfr_clear_erangeflag ();
d = mpfr_get_si (x, MPFR_RNDN);
if (d != LONG_MAX || mpfr_erangeflag_p ())
{
printf ("ERROR for get_si + ERANGE + LONG_MAX (1): %ld\n", d);
exit (1);
}
mpfr_add_ui (x, x, 1, MPFR_RNDN);
d = mpfr_get_si (x, MPFR_RNDN);
if (d != LONG_MAX || !mpfr_erangeflag_p ())
{
printf ("ERROR for get_si + ERANGE + LONG_MAX (2)\n");
exit (1);
}
mpfr_set_si (x, LONG_MIN, MPFR_RNDN);
mpfr_clear_erangeflag ();
d = mpfr_get_si (x, MPFR_RNDN);
if (d != LONG_MIN || mpfr_erangeflag_p ())
{
printf ("ERROR for get_si + ERANGE + LONG_MIN (1)\n");
exit (1);
}
mpfr_sub_ui (x, x, 1, MPFR_RNDN);
d = mpfr_get_si (x, MPFR_RNDN);
if (d != LONG_MIN || !mpfr_erangeflag_p ())
{
printf ("ERROR for get_si + ERANGE + LONG_MIN (2)\n");
exit (1);
}
mpfr_set_nan (x);
mpfr_clear_erangeflag ();
d = mpfr_get_ui (x, MPFR_RNDN);
if (d != 0 || !mpfr_erangeflag_p ())
{
printf ("ERROR for get_ui + NaN\n");
exit (1);
}
mpfr_clear_erangeflag ();
d = mpfr_get_si (x, MPFR_RNDN);
if (d != 0 || !mpfr_erangeflag_p ())
{
printf ("ERROR for get_si + NaN\n");
exit (1);
}
emin = mpfr_get_emin ();
mpfr_set_prec (x, 2);
mpfr_set_emin (4);
mpfr_clear_flags ();
mpfr_set_ui (x, 7, MPFR_RNDU);
flag = mpfr_underflow_p ();
mpfr_set_emin (emin);
if (mpfr_cmp_ui (x, 8) != 0)
{
printf ("Error for mpfr_set_ui (x, 7, MPFR_RNDU), prec = 2, emin = 4\n");
exit (1);
}
if (flag)
{
printf ("mpfr_set_ui (x, 7, MPFR_RNDU) should not underflow "
"with prec = 2, emin = 4\n");
exit (1);
}
mpfr_set_emin (4);
mpfr_clear_flags ();
mpfr_set_si (x, -7, MPFR_RNDD);
flag = mpfr_underflow_p ();
mpfr_set_emin (emin);
if (mpfr_cmp_si (x, -8) != 0)
{
printf ("Error for mpfr_set_si (x, -7, MPFR_RNDD), prec = 2, emin = 4\n");
exit (1);
}
if (flag)
{
printf ("mpfr_set_si (x, -7, MPFR_RNDD) should not underflow "
"with prec = 2, emin = 4\n");
exit (1);
}
mpfr_clear (x);
test_2exp ();
test_macros ();
test_macros_keyword ();
tests_end_mpfr ();
return 0;
}
int
main (void)
{
mpfr_t x;
mpfr_exp_t emax;
tests_start_mpfr ();
mpfr_init (x);
mpfr_set_nan (x);
mpfr_prec_round (x, 2, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (x));
mpfr_set_inf (x, 1);
mpfr_prec_round (x, 2, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) > 0);
mpfr_set_inf (x, -1);
mpfr_prec_round (x, 2, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) < 0);
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_prec_round (x, 2, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (x, 0) == 0 && MPFR_IS_POS(x));
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_neg (x, x, MPFR_RNDN);
mpfr_prec_round (x, 2, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (x, 0) == 0 && MPFR_IS_NEG(x));
emax = mpfr_get_emax ();
set_emax (0);
mpfr_set_prec (x, 3);
mpfr_set_str_binary (x, "0.111");
mpfr_prec_round (x, 2, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) > 0);
set_emax (emax);
mpfr_set_prec (x, mp_bits_per_limb + 2);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_nextbelow (x);
mpfr_prec_round (x, mp_bits_per_limb + 1, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (x, 1) == 0);
mpfr_set_prec (x, 3);
mpfr_set_ui (x, 5, MPFR_RNDN);
mpfr_prec_round (x, 2, MPFR_RNDN);
if (mpfr_cmp_ui(x, 4))
{
printf ("Error in tround: got ");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
printf (" instead of 4\n");
exit (1);
}
/* check case when reallocation is needed */
mpfr_set_prec (x, 3);
mpfr_set_ui (x, 5, MPFR_RNDN); /* exact */
mpfr_prec_round (x, mp_bits_per_limb + 1, MPFR_RNDN);
if (mpfr_cmp_ui(x, 5))
{
printf ("Error in tround: got ");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
printf (" instead of 5\n");
exit (1);
}
mpfr_clear(x);
mpfr_init2 (x, 3);
mpfr_set_si (x, -5, MPFR_RNDN); /* exact */
mpfr_prec_round (x, mp_bits_per_limb + 1, MPFR_RNDN);
if (mpfr_cmp_si(x, -5))
{
printf ("Error in tround: got ");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
printf (" instead of -5\n");
exit (1);
}
/* check case when new precision needs less limbs */
mpfr_set_prec (x, mp_bits_per_limb + 1);
mpfr_set_ui (x, 5, MPFR_RNDN); /* exact */
mpfr_prec_round (x, 3, MPFR_RNDN); /* exact */
if (mpfr_cmp_ui(x, 5))
{
printf ("Error in tround: got ");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
printf (" instead of 5\n");
exit (1);
}
mpfr_clear(x);
tests_end_mpfr ();
return 0;
}
static void
check4 (const char *as, const char *bs, mpfr_rnd_t rnd_mode,
const char *res, int inex)
{
mpfr_t ta, tb, tc, tres;
mpfr_exp_t emin, emax;
int i;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
mpfr_inits2 (53, ta, tb, tc, tres, (mpfr_ptr) 0);
for (i = 0; i <= 2; i++)
{
unsigned int expflags, newflags;
int inex2;
mpfr_set_str1 (ta, as);
mpfr_set_str1 (tb, bs);
mpfr_set_str1 (tc, res);
if (i > 0)
{
mpfr_exp_t ea, eb, ec, e0;
set_emin (MPFR_EMIN_MIN);
set_emax (MPFR_EMAX_MAX);
ea = mpfr_get_exp (ta);
eb = mpfr_get_exp (tb);
ec = mpfr_get_exp (tc);
e0 = i == 1 ? __gmpfr_emin : __gmpfr_emax;
if ((i == 1 && ea < eb) || (i == 2 && ea > eb))
{
mpfr_set_exp (ta, e0);
mpfr_set_exp (tb, e0 + (eb - ea));
mpfr_set_exp (tc, e0 + (ec - ea));
}
else
{
mpfr_set_exp (ta, e0 + (ea - eb));
mpfr_set_exp (tb, e0);
mpfr_set_exp (tc, e0 + (ec - eb));
}
}
__gmpfr_flags = expflags =
(randlimb () & 1) ? MPFR_FLAGS_ALL ^ MPFR_FLAGS_ERANGE : 0;
inex2 = mpfr_agm (tres, ta, tb, rnd_mode);
newflags = __gmpfr_flags;
expflags |= MPFR_FLAGS_INEXACT;
if (SIGN (inex2) != inex || newflags != expflags ||
! mpfr_equal_p (tres, tc))
{
printf ("mpfr_agm failed in rnd_mode=%s for\n",
mpfr_print_rnd_mode (rnd_mode));
printf (" a = ");
mpfr_out_str (stdout, 10, 0, ta, MPFR_RNDN);
printf ("\n");
printf (" b = ");
mpfr_out_str (stdout, 10, 0, tb, MPFR_RNDN);
printf ("\n");
printf ("expected inex = %d, flags = %u,\n"
" ", inex, expflags);
mpfr_dump (tc);
printf ("got inex = %d, flags = %u,\n"
" ", inex2, newflags);
mpfr_dump (tres);
exit (1);
}
set_emin (emin);
set_emax (emax);
}
mpfr_clears (ta, tb, tc, tres, (mpfr_ptr) 0);
}
static void
check_special (void)
{
mpfr_t a, d, q;
mpfr_exp_t emax, emin;
int i;
mpfr_init2 (a, 100L);
mpfr_init2 (d, 100L);
mpfr_init2 (q, 100L);
/* 1/nan == nan */
mpfr_set_ui (a, 1L, MPFR_RNDN);
MPFR_SET_NAN (d);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_NAN);
/* nan/1 == nan */
MPFR_SET_NAN (a);
mpfr_set_ui (d, 1L, MPFR_RNDN);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_NAN);
/* +inf/1 == +inf */
MPFR_SET_INF (a);
MPFR_SET_POS (a);
mpfr_set_ui (d, 1L, MPFR_RNDN);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q));
MPFR_ASSERTN (mpfr_sgn (q) > 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* +inf/-1 == -inf */
MPFR_SET_INF (a);
MPFR_SET_POS (a);
mpfr_set_si (d, -1, MPFR_RNDN);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q));
MPFR_ASSERTN (mpfr_sgn (q) < 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* -inf/1 == -inf */
MPFR_SET_INF (a);
MPFR_SET_NEG (a);
mpfr_set_ui (d, 1L, MPFR_RNDN);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q));
MPFR_ASSERTN (mpfr_sgn (q) < 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* -inf/-1 == +inf */
MPFR_SET_INF (a);
MPFR_SET_NEG (a);
mpfr_set_si (d, -1, MPFR_RNDN);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q));
MPFR_ASSERTN (mpfr_sgn (q) > 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* 1/+inf == +0 */
mpfr_set_ui (a, 1L, MPFR_RNDN);
MPFR_SET_INF (d);
MPFR_SET_POS (d);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_number_p (q));
MPFR_ASSERTN (mpfr_sgn (q) == 0);
MPFR_ASSERTN (MPFR_IS_POS (q));
MPFR_ASSERTN (__gmpfr_flags == 0);
/* 1/-inf == -0 */
mpfr_set_ui (a, 1L, MPFR_RNDN);
MPFR_SET_INF (d);
MPFR_SET_NEG (d);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_number_p (q));
MPFR_ASSERTN (mpfr_sgn (q) == 0);
MPFR_ASSERTN (MPFR_IS_NEG (q));
MPFR_ASSERTN (__gmpfr_flags == 0);
/* -1/+inf == -0 */
mpfr_set_si (a, -1, MPFR_RNDN);
MPFR_SET_INF (d);
MPFR_SET_POS (d);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_number_p (q));
MPFR_ASSERTN (mpfr_sgn (q) == 0);
MPFR_ASSERTN (MPFR_IS_NEG (q));
MPFR_ASSERTN (__gmpfr_flags == 0);
/* -1/-inf == +0 */
mpfr_set_si (a, -1, MPFR_RNDN);
MPFR_SET_INF (d);
MPFR_SET_NEG (d);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_number_p (q));
MPFR_ASSERTN (mpfr_sgn (q) == 0);
MPFR_ASSERTN (MPFR_IS_POS (q));
MPFR_ASSERTN (__gmpfr_flags == 0);
/* 0/0 == nan */
mpfr_set_ui (a, 0L, MPFR_RNDN);
mpfr_set_ui (d, 0L, MPFR_RNDN);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_NAN);
/* +inf/+inf == nan */
MPFR_SET_INF (a);
MPFR_SET_POS (a);
MPFR_SET_INF (d);
MPFR_SET_POS (d);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_NAN);
/* 1/+0 = +inf */
mpfr_set_ui (a, 1, MPFR_RNDZ);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) > 0);
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_DIVBY0);
/* 1/-0 = -inf */
mpfr_set_ui (a, 1, MPFR_RNDZ);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_neg (d, d, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) < 0);
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_DIVBY0);
/* -1/+0 = -inf */
mpfr_set_si (a, -1, MPFR_RNDZ);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) < 0);
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_DIVBY0);
/* -1/-0 = +inf */
mpfr_set_si (a, -1, MPFR_RNDZ);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_neg (d, d, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) > 0);
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_DIVBY0);
/* +inf/+0 = +inf */
MPFR_SET_INF (a);
MPFR_SET_POS (a);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) > 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* +inf/-0 = -inf */
MPFR_SET_INF (a);
MPFR_SET_POS (a);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_neg (d, d, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) < 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* -inf/+0 = -inf */
MPFR_SET_INF (a);
MPFR_SET_NEG (a);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) < 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* -inf/-0 = +inf */
MPFR_SET_INF (a);
MPFR_SET_NEG (a);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_neg (d, d, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) > 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* check overflow */
emax = mpfr_get_emax ();
set_emax (1);
mpfr_set_ui (a, 1, MPFR_RNDZ);
mpfr_set_ui (d, 1, MPFR_RNDZ);
mpfr_div_2exp (d, d, 1, MPFR_RNDZ);
mpfr_clear_flags ();
test_div (q, a, d, MPFR_RNDU); /* 1 / 0.5 = 2 -> overflow */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) > 0);
MPFR_ASSERTN (__gmpfr_flags == (MPFR_FLAGS_OVERFLOW | MPFR_FLAGS_INEXACT));
set_emax (emax);
/* check underflow */
emin = mpfr_get_emin ();
set_emin (-1);
mpfr_set_ui (a, 1, MPFR_RNDZ);
mpfr_div_2exp (a, a, 2, MPFR_RNDZ);
mpfr_set_prec (d, mpfr_get_prec (q) + 8);
for (i = -1; i <= 1; i++)
{
int sign;
/* Test 2^(-2) / (+/- (2 + eps)), with eps < 0, eps = 0, eps > 0.
-> underflow.
With div.c r5513, this test fails for eps > 0 in MPFR_RNDN. */
mpfr_set_ui (d, 2, MPFR_RNDZ);
if (i < 0)
mpfr_nextbelow (d);
if (i > 0)
mpfr_nextabove (d);
for (sign = 0; sign <= 1; sign++)
{
mpfr_clear_flags ();
test_div (q, a, d, MPFR_RNDZ); /* result = 0 */
MPFR_ASSERTN (__gmpfr_flags ==
(MPFR_FLAGS_UNDERFLOW | MPFR_FLAGS_INEXACT));
MPFR_ASSERTN (sign ? MPFR_IS_NEG (q) : MPFR_IS_POS (q));
MPFR_ASSERTN (MPFR_IS_ZERO (q));
mpfr_clear_flags ();
test_div (q, a, d, MPFR_RNDN); /* result = 0 iff eps >= 0 */
MPFR_ASSERTN (__gmpfr_flags ==
(MPFR_FLAGS_UNDERFLOW | MPFR_FLAGS_INEXACT));
MPFR_ASSERTN (sign ? MPFR_IS_NEG (q) : MPFR_IS_POS (q));
if (i < 0)
mpfr_nexttozero (q);
MPFR_ASSERTN (MPFR_IS_ZERO (q));
mpfr_neg (d, d, MPFR_RNDN);
}
}
set_emin (emin);
mpfr_clear (a);
mpfr_clear (d);
mpfr_clear (q);
}
static void
special (void)
{
mpfr_t x, y;
int inex;
mp_exp_t emin, emax;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
/* Check special case: An overflow in const_pi could occurs! */
set_emin (-125);
set_emax (128);
mpfr_set_prec (y, 24*2);
mpfr_set_prec (x, 24);
mpfr_set_str_binary (x, "0.111110101010101011110101E0");
test_log (y, x, GMP_RNDN);
set_emin (emin);
set_emax (emax);
mpfr_set_prec (y, 53);
mpfr_set_prec (x, 53);
mpfr_set_ui (x, 3, GMP_RNDD);
test_log (y, x, GMP_RNDD);
if (mpfr_cmp_str1 (y, "1.09861228866810956"))
{
printf ("Error in mpfr_log(3) for GMP_RNDD\n");
exit (1);
}
/* check large precision */
mpfr_set_prec (x, 3322);
mpfr_set_prec (y, 3322);
mpfr_set_ui (x, 3, GMP_RNDN);
mpfr_sqrt (x, x, GMP_RNDN);
test_log (y, x, GMP_RNDN);
/* negative argument */
mpfr_set_si (x, -1, GMP_RNDN);
test_log (y, x, GMP_RNDN);
MPFR_ASSERTN(mpfr_nan_p (y));
/* infinite loop when */
set_emax (128);
mpfr_set_prec (x, 251);
mpfr_set_prec (y, 251);
mpfr_set_str_binary (x, "0.10010111000000000001101E8");
/* x = 4947981/32768, log(x) ~ 5.017282... */
test_log (y, x, GMP_RNDN);
set_emax (emax);
mpfr_set_ui (x, 0, GMP_RNDN);
inex = test_log (y, x, GMP_RNDN);
MPFR_ASSERTN (inex == 0);
MPFR_ASSERTN (mpfr_inf_p (y));
MPFR_ASSERTN (mpfr_sgn (y) < 0);
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_neg (x, x, GMP_RNDN);
inex = test_log (y, x, GMP_RNDN);
MPFR_ASSERTN (inex == 0);
MPFR_ASSERTN (mpfr_inf_p (y));
MPFR_ASSERTN (mpfr_sgn (y) < 0);
mpfr_clear (x);
mpfr_clear (y);
}
static void
check_special_exprange (void)
{
int inexact, ov;
unsigned int eflags, gflags;
mpfr_t xi, xf, x;
mpfr_exp_t emax;
emax = mpfr_get_emax ();
mpfr_init2 (xi, 7);
mpfr_init2 (xf, 7);
mpfr_init2 (x, 8);
mpfr_set_str (x, "0.11111111", 2, MPFR_RNDN);
for (ov = 0; ov <= 1; ov++)
{
const char *s = ov ? "@Inf@" : "1";
if (ov)
set_emax (0);
mpfr_clear_flags ();
inexact = mpfr_modf (xi, xf, x, MPFR_RNDN);
gflags = __gmpfr_flags;
set_emax (emax);
if (MPFR_NOTZERO (xi) || MPFR_IS_NEG (xi) ||
mpfr_cmp_str1 (xf, s) != 0)
{
printf ("Error in check_special_exprange (ov = %d):"
" expected 0 and %s, got\n", ov, s);
mpfr_out_str (stdout, 2, 0, xi, MPFR_RNDN);
printf (" and ");
mpfr_out_str (stdout, 2, 0, xf, MPFR_RNDN);
printf ("\n");
exit (1);
}
if (inexact != 4)
{
printf ("Bad inexact value in check_special_exprange (ov = %d):"
" expected 4, got %d\n", ov, inexact);
exit (1);
}
eflags = MPFR_FLAGS_INEXACT | (ov ? MPFR_FLAGS_OVERFLOW : 0);
if (gflags != eflags)
{
printf ("Bad flags in check_special_exprange (ov = %d):"
" expected %u, got %u\n", ov, eflags, gflags);
exit (1);
}
}
/* Test if an overflow occurs in mpfr_set for ope >= opq. */
mpfr_set_emax (MPFR_EMAX_MAX);
mpfr_set_inf (x, 1);
mpfr_nextbelow (x);
mpfr_clear_flags ();
inexact = mpfr_modf (xi, xf, x, MPFR_RNDN);
gflags = __gmpfr_flags;
if (mpfr_cmp_str1 (xi, "@Inf@") != 0 ||
MPFR_NOTZERO (xf) || MPFR_IS_NEG (xf))
{
printf ("Error in check_special_exprange:"
" expected 0 and @Inf@, got\n");
mpfr_out_str (stdout, 2, 0, xi, MPFR_RNDN);
printf (" and ");
mpfr_out_str (stdout, 2, 0, xf, MPFR_RNDN);
printf ("\n");
exit (1);
}
if (inexact != 1)
{
printf ("Bad inexact value in check_special_exprange:"
" expected 1, got %d\n", inexact);
exit (1);
}
eflags = MPFR_FLAGS_INEXACT | MPFR_FLAGS_OVERFLOW;
if (gflags != eflags)
{
printf ("Bad flags in check_special_exprange:"
" expected %u, got %u\n", eflags, gflags);
exit (1);
}
set_emax (emax);
/* Test if an underflow occurs in the general case. TODO */
mpfr_clears (xi, xf, x, (mpfr_ptr) 0);
}
static void
special_overflow (void)
{
mpfr_t x, y;
mpfr_exp_t emin, emax;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
set_emin (-125);
set_emax (128);
mpfr_init2 (x, 24);
mpfr_init2 (y, 48);
mpfr_set_str_binary (x, "0.101101010001001101111010E0");
mpfr_atan (y, x, MPFR_RNDN);
if (mpfr_cmp_str (y, "0.100111011001100111000010111101000111010101011110E0",
2, MPFR_RNDN))
{
printf("Special Overflow error.\n");
mpfr_dump (y);
exit (1);
}
/* intermediate Pi overflows while atan(+Inf) = Pi/2 is representable */
set_emax (1);
mpfr_set_inf (x, +1);
mpfr_clear_flags ();
mpfr_atan (y, x, MPFR_RNDN);
if (mpfr_cmp_str (y, "C90FDAA22169p-47", 16, MPFR_RNDN)
|| mpfr_overflow_p ())
{
printf("atan(+Inf) = Pi/2 should not overflow when emax = %ld\n",
(long int) mpfr_get_emax ());
mpfr_dump (y);
exit (1);
}
/* atan(+Inf) = Pi/2 underflows */
set_emax (128);
set_emin (3);
mpfr_clear_flags ();
mpfr_atan (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 0) || !mpfr_underflow_p ())
{
printf("atan(+Inf) = Pi/2 should underflow when emin = %ld\n",
(long int) mpfr_get_emin ());
mpfr_dump (y);
exit (1);
}
/* intermediate Pi overflows while atan(+1) = Pi/4 is representable */
set_emax (1);
set_emin (-128);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_clear_flags ();
mpfr_atan (y, x, MPFR_RNDN);
if (mpfr_cmp_str (y, "C90FDAA22169p-48", 16, MPFR_RNDN)
|| mpfr_overflow_p ())
{
printf("atan(+1) = Pi/4 should not overflow when emax = %ld\n",
(long int) mpfr_get_emax ());
mpfr_dump (y);
exit (1);
}
/* atan(+1) = Pi/4 underflows and is rounded up to 1 */
set_emax (128);
set_emin (1);
mpfr_set_prec (y, 2);
mpfr_clear_flags ();
mpfr_atan (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 1) || !mpfr_underflow_p ())
{
printf("atan(+1) = Pi/4 should underflow when emin = %+ld\n",
(long int) mpfr_get_emin ());
mpfr_dump (y);
exit (1);
}
/* atan(+1) = Pi/4 underflows and is rounded down to 0 */
mpfr_clear_flags ();
mpfr_atan (y, x, MPFR_RNDD);
if (mpfr_cmp_ui (y, 0) || !mpfr_underflow_p ())
{
printf("atan(+1) = Pi/4 should underflow when emin = %+ld\n",
(long int) mpfr_get_emin ());
mpfr_dump (y);
exit (1);
}
mpfr_clear (y);
mpfr_clear (x);
set_emin (emin);
set_emax (emax);
}
