static void
special_erf (void)
{
mpfr_t x, y;
int inex;
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
/* erf(NaN) = NaN */
mpfr_set_nan (x);
mpfr_erf (y, x, MPFR_RNDN);
if (!mpfr_nan_p (y))
{
printf ("mpfr_erf failed for x=NaN\n");
exit (1);
}
/* erf(+Inf) = 1 */
mpfr_set_inf (x, 1);
mpfr_erf (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 1))
{
printf ("mpfr_erf failed for x=+Inf\n");
printf ("expected 1.0, got ");
mpfr_out_str (stdout, 2, 0, y, MPFR_RNDN);
printf ("\n");
exit (1);
}
/* erf(-Inf) = -1 */
mpfr_set_inf (x, -1);
mpfr_erf (y, x, MPFR_RNDN);
if (mpfr_cmp_si (y, -1))
{
printf ("mpfr_erf failed for x=-Inf\n");
exit (1);
}
/* erf(+0) = +0 */
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_erf (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 0) || mpfr_sgn (y) < 0)
{
printf ("mpfr_erf failed for x=+0\n");
exit (1);
}
/* erf(-0) = -0 */
mpfr_neg (x, x, MPFR_RNDN);
mpfr_erf (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 0) || mpfr_sgn (y) > 0)
{
printf ("mpfr_erf failed for x=-0\n");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_erf (x, x, MPFR_RNDN);
mpfr_set_str_binary (y, "0.11010111101110110011110100111010000010000100010001011");
if (mpfr_cmp (x, y))
{
printf ("mpfr_erf failed for x=1.0, rnd=MPFR_RNDN\n");
printf ("expected ");
mpfr_out_str (stdout, 2, 0, y, MPFR_RNDN);
printf ("\n");
printf ("got ");
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN);
printf ("\n");
exit (1);
}
mpfr_set_str (x, "6.6", 10, MPFR_RNDN);
mpfr_erf (x, x, MPFR_RNDN);
if (mpfr_cmp_ui (x, 1))
{
printf ("mpfr_erf failed for x=6.6, rnd=MPFR_RNDN\n");
printf ("expected 1\n");
printf ("got ");
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN);
printf ("\n");
exit (1);
}
mpfr_set_str (x, "-6.6", 10, MPFR_RNDN);
mpfr_erf (x, x, MPFR_RNDN);
if (mpfr_cmp_si (x, -1))
{
printf ("mpfr_erf failed for x=-6.6, rnd=MPFR_RNDN\n");
printf ("expected -1\n");
printf ("got ");
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN);
printf ("\n");
exit (1);
}
mpfr_set_str (x, "6.6", 10, MPFR_RNDN);
mpfr_erf (x, x, MPFR_RNDZ);
mpfr_set_str_binary (y, "0.11111111111111111111111111111111111111111111111111111");
if (mpfr_cmp (x, y))
{
printf ("mpfr_erf failed for x=6.6, rnd=MPFR_RNDZ\n");
printf ("expected ");
mpfr_out_str (stdout, 2, 0, y, MPFR_RNDN);
printf ("\n");
printf ("got ");
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN);
printf ("\n");
exit (1);
}
mpfr_set_str (x, "4.5", 10, MPFR_RNDN);
mpfr_erf (x, x, MPFR_RNDN);
mpfr_set_str_binary (y, "0.1111111111111111111111111111111100100111110100011");
if (mpfr_cmp (x, y))
{
printf ("mpfr_erf failed for x=4.5, rnd=MPFR_RNDN\n");
printf ("expected ");
mpfr_out_str (stdout, 2, 0, y, MPFR_RNDN);
printf ("\n");
printf ("got ");
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN);
printf ("\n");
exit (1);
}
mpfr_set_prec (x, 120);
mpfr_set_prec (y, 120);
mpfr_set_str_binary (x, "0.110100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011E3");
mpfr_erf (x, x, MPFR_RNDN);
mpfr_set_str_binary (y, "0.11111111111111111111111111111111111111111111111111111111111111111100111111000100111011111011010000110101111100011001101");
if (mpfr_cmp (x, y))
{
printf ("mpfr_erf failed for x=6.6, rnd=MPFR_RNDN\n");
printf ("expected ");
mpfr_out_str (stdout, 2, 0, y, MPFR_RNDN);
printf ("\n");
printf ("got ");
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN);
printf ("\n");
exit (1);
}
mpfr_set_prec (x, 8);
mpfr_set_prec (y, 8);
mpfr_set_ui (x, 50, MPFR_RNDN);
inex = mpfr_erf (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, 1))
{
printf ("mpfr_erf failed for x=50, rnd=MPFR_RNDN\n");
printf ("expected 1, got ");
mpfr_out_str (stdout, 2, 0, y, MPFR_RNDN);
printf ("\n");
exit (1);
}
if (inex <= 0)
{
printf ("mpfr_erf failed for x=50, rnd=MPFR_RNDN: wrong ternary value\n"
"expected positive, got %d\n", inex);
exit (1);
}
inex = mpfr_erf (x, x, MPFR_RNDZ);
mpfr_nextbelow (y);
if (mpfr_cmp (x, y))
{
printf ("mpfr_erf failed for x=50, rnd=MPFR_RNDZ\n");
printf ("expected ");
mpfr_out_str (stdout, 2, 0, y, MPFR_RNDN);
printf ("\n");
printf ("got ");
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN);
printf ("\n");
exit (1);
}
if (inex >= 0)
{
printf ("mpfr_erf failed for x=50, rnd=MPFR_RNDN: wrong ternary value\n"
"expected negative, got %d\n", inex);
exit (1);
}
mpfr_set_prec (x, 32);
mpfr_set_prec (y, 32);
mpfr_set_str_binary (x, "0.1010100100111011001111100101E-1");
mpfr_set_str_binary (y, "0.10111000001110011010110001101011E-1");
mpfr_erf (x, x, MPFR_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error: erf for prec=32 (1)\n");
exit (1);
}
mpfr_set_str_binary (x, "-0.10110011011010111110010001100001");
mpfr_set_str_binary (y, "-0.1010110110101011100010111000111");
mpfr_erf (x, x, MPFR_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error: erf for prec=32 (2)\n");
mpfr_print_binary (x); printf ("\n");
exit (1);
}
mpfr_set_str_binary (x, "100.10001110011110100000110000111");
mpfr_set_str_binary (y, "0.11111111111111111111111111111111");
mpfr_erf (x, x, MPFR_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error: erf for prec=32 (3)\n");
exit (1);
}
mpfr_set_str_binary (x, "100.10001110011110100000110000111");
mpfr_erf (x, x, MPFR_RNDZ);
if (mpfr_cmp (x, y))
{
printf ("Error: erf for prec=32 (4)\n");
exit (1);
}
mpfr_set_str_binary (x, "100.10001110011110100000110000111");
mpfr_erf (x, x, MPFR_RNDU);
if (mpfr_cmp_ui (x, 1))
{
printf ("Error: erf for prec=32 (5)\n");
exit (1);
}
mpfr_set_str_binary (x, "100.10001110011110100000110001000");
mpfr_erf (x, x, MPFR_RNDN);
if (mpfr_cmp_ui (x, 1))
{
printf ("Error: erf for prec=32 (6)\n");
exit (1);
}
mpfr_set_str_binary (x, "100.10001110011110100000110001000");
mpfr_set_str_binary (y, "0.11111111111111111111111111111111");
mpfr_erf (x, x, MPFR_RNDZ);
if (mpfr_cmp (x, y))
{
printf ("Error: erf for prec=32 (7)\n");
exit (1);
}
mpfr_set_str_binary (x, "100.10001110011110100000110001000");
mpfr_erf (x, x, MPFR_RNDU);
if (mpfr_cmp_ui (x, 1))
{
printf ("Error: erf for prec=32 (8)\n");
exit (1);
}
mpfr_set_ui (x, 5, MPFR_RNDN);
mpfr_erf (x, x, MPFR_RNDN);
if (mpfr_cmp_ui (x, 1))
{
printf ("Error: erf for prec=32 (9)\n");
exit (1);
}
mpfr_set_ui (x, 5, MPFR_RNDN);
mpfr_erf (x, x, MPFR_RNDU);
if (mpfr_cmp_ui (x, 1))
{
printf ("Error: erf for prec=32 (10)\n");
exit (1);
}
mpfr_set_ui (x, 5, MPFR_RNDN);
mpfr_erf (x, x, MPFR_RNDZ);
mpfr_set_str_binary (y, "0.11111111111111111111111111111111");
if (mpfr_cmp (x, y))
{
printf ("Error: erf for prec=32 (11)\n");
exit (1);
}
mpfr_set_ui (x, 5, MPFR_RNDN);
mpfr_erf (x, x, MPFR_RNDD);
mpfr_set_str_binary (y, "0.11111111111111111111111111111111");
if (mpfr_cmp (x, y))
{
printf ("Error: erf for prec=32 (12)\n");
exit (1);
}
mpfr_set_prec (x, 43);
mpfr_set_prec (y, 64);
mpfr_set_str_binary (x, "-0.1101110110101111100101011101110101101001001e3");
mpfr_erf (y, x, MPFR_RNDU);
mpfr_set_prec (x, 64);
mpfr_set_str_binary (x, "-0.1111111111111111111111111111111111111111111111111111111111111111");
if (mpfr_cmp (x, y))
{
printf ("Error: erf for prec=43,64 (13)\n");
exit (1);
}
/* worst cases */
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str_binary (x, "1.0000000000000000000000000000000000000110000000101101");
mpfr_erf (y, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.110101111011101100111101001110100000101011000011001");
if (mpfr_cmp (x, y))
{
printf ("Error: erf for worst case (1)\n");
exit (1);
}
mpfr_set_str_binary (x, "1.0000000000000000000000000000011000111010101101011010");
mpfr_erf (y, x, MPFR_RNDU);
mpfr_set_str_binary (x, "0.11010111101110110011110100111100100111100011111000110");
if (mpfr_cmp (x, y))
{
printf ("Error: erf for worst case (2a)\n");
exit (1);
}
mpfr_set_str_binary (x, "1.0000000000000000000000000000011000111010101101011010");
mpfr_erf (y, x, MPFR_RNDD);
mpfr_set_str_binary (x, "0.11010111101110110011110100111100100111100011111000101");
if (mpfr_cmp (x, y))
{
printf ("Error: erf for worst case (2b)\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
/* Usage: tzeta - generic tests
tzeta s prec rnd_mode - compute zeta(s) with precision 'prec'
and rounding mode 'mode' */
int
main (int argc, char *argv[])
{
mpfr_t s, y, z;
mpfr_prec_t prec;
mpfr_rnd_t rnd_mode;
int inex;
tests_start_mpfr ();
if (argc != 1 && argc != 4)
{
printf ("Usage: tzeta\n"
" or tzeta s prec rnd_mode\n");
exit (1);
}
if (argc == 4)
{
prec = atoi(argv[2]);
mpfr_init2 (s, prec);
mpfr_init2 (z, prec);
mpfr_set_str (s, argv[1], 10, MPFR_RNDN);
rnd_mode = (mpfr_rnd_t) atoi(argv[3]);
mpfr_zeta (z, s, rnd_mode);
mpfr_out_str (stdout, 10, 0, z, MPFR_RNDN);
printf ("\n");
mpfr_clear (s);
mpfr_clear (z);
return 0;
}
test1();
mpfr_init2 (s, MPFR_PREC_MIN);
mpfr_init2 (y, MPFR_PREC_MIN);
mpfr_init2 (z, MPFR_PREC_MIN);
/* the following seems to loop */
mpfr_set_prec (s, 6);
mpfr_set_prec (z, 6);
mpfr_set_str_binary (s, "1.10010e4");
mpfr_zeta (z, s, MPFR_RNDZ);
mpfr_set_prec (s, 53);
mpfr_set_prec (y, 53);
mpfr_set_prec (z, 53);
mpfr_set_ui (s, 1, MPFR_RNDN);
mpfr_zeta (z, s, MPFR_RNDN);
if (!mpfr_inf_p (z) || MPFR_SIGN (z) < 0)
{
printf ("Error in mpfr_zeta for s = 1 (should be +inf)\n");
exit (1);
}
mpfr_set_str_binary (s, "0.1100011101110111111111111010000110010111001011001011");
mpfr_set_str_binary (y, "-0.11111101111011001001001111111000101010000100000100100E2");
mpfr_zeta (z, s, MPFR_RNDN);
if (mpfr_cmp (z, y) != 0)
{
printf ("Error in mpfr_zeta (1,RNDN)\n");
exit (1);
}
mpfr_zeta (z, s, MPFR_RNDZ);
if (mpfr_cmp (z, y) != 0)
{
printf ("Error in mpfr_zeta (1,RNDZ)\n");
exit (1);
}
mpfr_zeta (z, s, MPFR_RNDU);
if (mpfr_cmp (z, y) != 0)
{
printf ("Error in mpfr_zeta (1,RNDU)\n");
exit (1);
}
mpfr_zeta (z, s, MPFR_RNDD);
mpfr_nexttoinf (y);
if (mpfr_cmp (z, y) != 0)
{
printf ("Error in mpfr_zeta (1,RNDD)\n");
exit (1);
}
mpfr_set_str_binary (s, "0.10001011010011100110010001100100001011000010011001011");
mpfr_set_str_binary (y, "-0.11010011010010101101110111011010011101111101111010110E1");
mpfr_zeta (z, s, MPFR_RNDN);
if (mpfr_cmp (z, y) != 0)
{
printf ("Error in mpfr_zeta (2,RNDN)\n");
exit (1);
}
mpfr_zeta (z, s, MPFR_RNDZ);
if (mpfr_cmp (z, y) != 0)
{
printf ("Error in mpfr_zeta (2,RNDZ)\n");
exit (1);
}
mpfr_zeta (z, s, MPFR_RNDU);
if (mpfr_cmp (z, y) != 0)
{
printf ("Error in mpfr_zeta (2,RNDU)\n");
exit (1);
}
mpfr_zeta (z, s, MPFR_RNDD);
mpfr_nexttoinf (y);
if (mpfr_cmp (z, y) != 0)
{
printf ("Error in mpfr_zeta (2,RNDD)\n");
exit (1);
}
mpfr_set_str_binary (s, "0.1100111110100001111110111000110101111001011101000101");
mpfr_set_str_binary (y, "-0.10010111010110000111011111001101100001111011000001010E3");
mpfr_zeta (z, s, MPFR_RNDN);
if (mpfr_cmp (z, y) != 0)
{
printf ("Error in mpfr_zeta (3,RNDN)\n");
exit (1);
}
mpfr_zeta (z, s, MPFR_RNDD);
if (mpfr_cmp (z, y) != 0)
{
printf ("Error in mpfr_zeta (3,RNDD)\n");
exit (1);
}
mpfr_nexttozero (y);
mpfr_zeta (z, s, MPFR_RNDZ);
if (mpfr_cmp (z, y) != 0)
{
printf ("Error in mpfr_zeta (3,RNDZ)\n");
exit (1);
}
mpfr_zeta (z, s, MPFR_RNDU);
if (mpfr_cmp (z, y) != 0)
{
printf ("Error in mpfr_zeta (3,RNDU)\n");
exit (1);
}
mpfr_set_str (s, "-400000001", 10, MPFR_RNDZ);
mpfr_zeta (z, s, MPFR_RNDN);
if (!(mpfr_inf_p (z) && MPFR_SIGN(z) < 0))
{
printf ("Error in mpfr_zeta (-400000001)\n");
exit (1);
}
mpfr_set_str (s, "-400000003", 10, MPFR_RNDZ);
mpfr_zeta (z, s, MPFR_RNDN);
if (!(mpfr_inf_p (z) && MPFR_SIGN(z) > 0))
{
printf ("Error in mpfr_zeta (-400000003)\n");
exit (1);
}
mpfr_set_prec (s, 34);
mpfr_set_prec (z, 34);
mpfr_set_str_binary (s, "-1.111111100001011110000010001010000e-35");
mpfr_zeta (z, s, MPFR_RNDD);
mpfr_set_str_binary (s, "-1.111111111111111111111111111111111e-2");
if (mpfr_cmp (s, z))
{
printf ("Error in mpfr_zeta, prec=34, MPFR_RNDD\n");
mpfr_dump (z);
exit (1);
}
/* bug found by nightly tests on June 7, 2007 */
mpfr_set_prec (s, 23);
mpfr_set_prec (z, 25);
mpfr_set_str_binary (s, "-1.0110110110001000000000e-27");
mpfr_zeta (z, s, MPFR_RNDN);
mpfr_set_prec (s, 25);
mpfr_set_str_binary (s, "-1.111111111111111111111111e-2");
if (mpfr_cmp (s, z))
{
printf ("Error in mpfr_zeta, prec=25, MPFR_RNDN\n");
printf ("expected ");
mpfr_dump (s);
printf ("got ");
mpfr_dump (z);
exit (1);
}
/* bug reported by Kevin Rauch on 26 Oct 2007 */
mpfr_set_prec (s, 128);
mpfr_set_prec (z, 128);
mpfr_set_str_binary (s, "-0.1000000000000000000000000000000000000000000000000000000000000001E64");
inex = mpfr_zeta (z, s, MPFR_RNDN);
MPFR_ASSERTN (mpfr_inf_p (z) && MPFR_SIGN (z) < 0 && inex < 0);
inex = mpfr_zeta (z, s, MPFR_RNDU);
mpfr_set_inf (s, -1);
mpfr_nextabove (s);
MPFR_ASSERTN (mpfr_equal_p (z, s) && inex > 0);
mpfr_clear (s);
mpfr_clear (y);
mpfr_clear (z);
test_generic (2, 70, 5);
test2 ();
tests_end_mpfr ();
return 0;
}
int
main (int argc, char *argv[])
{
mpfr_t x, y;
unsigned int n;
int inex;
tests_start_mpfr ();
test_generic (2, 100, 20);
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
/* check NaN */
mpfr_set_nan (x);
inex = test_log10 (y, x, MPFR_RNDN);
MPFR_ASSERTN (mpfr_nan_p (y) && inex == 0);
/* check Inf */
mpfr_set_inf (x, -1);
inex = test_log10 (y, x, MPFR_RNDN);
MPFR_ASSERTN (mpfr_nan_p (y) && inex == 0);
mpfr_set_inf (x, 1);
inex = test_log10 (y, x, MPFR_RNDN);
MPFR_ASSERTN (mpfr_inf_p (y) && mpfr_sgn (y) > 0 && inex == 0);
mpfr_set_ui (x, 0, MPFR_RNDN);
inex = test_log10 (x, x, MPFR_RNDN);
MPFR_ASSERTN (mpfr_inf_p (x) && mpfr_sgn (x) < 0 && inex == 0);
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_neg (x, x, MPFR_RNDN);
inex = test_log10 (x, x, MPFR_RNDN);
MPFR_ASSERTN (mpfr_inf_p (x) && mpfr_sgn (x) < 0 && inex == 0);
/* check negative argument */
mpfr_set_si (x, -1, MPFR_RNDN);
inex = test_log10 (y, x, MPFR_RNDN);
MPFR_ASSERTN (mpfr_nan_p (y) && inex == 0);
/* check log10(1) = 0 */
mpfr_set_ui (x, 1, MPFR_RNDN);
inex = test_log10 (y, x, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS (y) && inex == 0);
/* check log10(10^n)=n */
mpfr_set_ui (x, 1, MPFR_RNDN);
for (n = 1; n <= 15; n++)
{
mpfr_mul_ui (x, x, 10, MPFR_RNDN); /* x = 10^n */
inex = test_log10 (y, x, MPFR_RNDN);
if (mpfr_cmp_ui (y, n))
{
printf ("log10(10^n) <> n for n=%u\n", n);
exit (1);
}
MPFR_ASSERTN (inex == 0);
}
mpfr_clear (x);
mpfr_clear (y);
data_check ("data/log10", mpfr_log10, "mpfr_log10");
tests_end_mpfr ();
return 0;
}
int
main (int argc, char *argv[])
{
mpfr_t x;
mpfr_prec_t ret;
unsigned long i;
tests_start_mpfr ();
mpfr_init2 (x, 53);
/* Check special values */
mpfr_set_nan (x);
ret = mpfr_min_prec (x);
MPFR_ASSERTN (ret == 0);
mpfr_set_inf (x, 1);
ret = mpfr_min_prec (x);
MPFR_ASSERTN (ret == 0);
mpfr_set_inf (x, -1);
ret = mpfr_min_prec (x);
MPFR_ASSERTN (ret == 0);
mpfr_set_ui (x, 0, MPFR_RNDN);
ret = mpfr_min_prec (x);
MPFR_ASSERTN (ret == 0);
/* Some constants */
mpfr_set_ui (x, 1, MPFR_RNDN);
ret = mpfr_min_prec (x);
MPFR_ASSERTN (ret == 1);
mpfr_set_ui (x, 17, MPFR_RNDN);
ret = mpfr_min_prec (x);
MPFR_ASSERTN (ret == 5);
mpfr_set_ui (x, 42, MPFR_RNDN);
ret = mpfr_min_prec (x);
MPFR_ASSERTN (ret == 5);
mpfr_set_prec (x, 256);
for (i = 0; i <= 255; i++)
{
mpfr_set_ui_2exp (x, 1, i, MPFR_RNDN);
mpfr_add_ui (x, x, 1, MPFR_RNDN);
ret = mpfr_min_prec (x);
if (ret != i + 1)
{
printf ("Error for x = 2^%lu + 1\n", i);
printf ("Expected %lu, got %lu\n", i + 1, (unsigned long) ret);
exit (1);
}
}
for (i = MPFR_PREC_MIN; i <= 255; i++)
{
mpfr_set_prec (x, i);
mpfr_set_ui_2exp (x, 1, i, MPFR_RNDN);
mpfr_sub_ui (x, x, 1, MPFR_RNDN);
ret = mpfr_min_prec (x);
if (ret != i)
{
printf ("Error for x = 2^%lu - 1\n", i);
printf ("Expected %lu, got %lu\n", i, (unsigned long) ret);
exit (1);
}
}
mpfr_clear (x);
tests_end_mpfr ();
return 0;
}
int
main (void)
{
mpfr_t xx, yy;
int c;
tests_start_mpfr ();
mpfr_init2 (xx, 2);
mpfr_init2 (yy, 2);
mpfr_clear_erangeflag ();
MPFR_SET_NAN (xx);
MPFR_SET_NAN (yy);
if (mpfr_cmpabs (xx, yy) != 0)
ERROR ("mpfr_cmpabs (NAN,NAN) returns non-zero\n");
if (!mpfr_erangeflag_p ())
ERROR ("mpfr_cmpabs (NAN,NAN) doesn't set erange flag\n");
mpfr_set_str_binary (xx, "0.10E0");
mpfr_set_str_binary (yy, "-0.10E0");
if (mpfr_cmpabs (xx, yy) != 0)
ERROR ("mpfr_cmpabs (xx, yy) returns non-zero for prec=2\n");
mpfr_set_prec (xx, 65);
mpfr_set_prec (yy, 65);
mpfr_set_str_binary (xx, "-0.10011010101000110101010000000011001001001110001011101011111011101E623");
mpfr_set_str_binary (yy, "0.10011010101000110101010000000011001001001110001011101011111011100E623");
if (mpfr_cmpabs (xx, yy) <= 0)
ERROR ("Error (1) in mpfr_cmpabs\n");
mpfr_set_str_binary (xx, "-0.10100010001110110111000010001000010011111101000100011101000011100");
mpfr_set_str_binary (yy, "-0.10100010001110110111000010001000010011111101000100011101000011011");
if (mpfr_cmpabs (xx, yy) <= 0)
ERROR ("Error (2) in mpfr_cmpabs\n");
mpfr_set_prec (xx, 160);
mpfr_set_prec (yy, 160);
mpfr_set_str_binary (xx, "0.1E1");
mpfr_set_str_binary (yy, "-0.1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000110001110100");
if (mpfr_cmpabs (xx, yy) <= 0)
ERROR ("Error (3) in mpfr_cmpabs\n");
mpfr_set_prec(xx, 53);
mpfr_set_prec(yy, 200);
mpfr_set_ui (xx, 1, (mpfr_rnd_t) 0);
mpfr_set_ui (yy, 1, (mpfr_rnd_t) 0);
if (mpfr_cmpabs(xx, yy) != 0)
ERROR ("Error in mpfr_cmpabs: 1.0 != 1.0\n");
mpfr_set_prec (yy, 31);
mpfr_set_str (xx, "-1.0000000002", 10, (mpfr_rnd_t) 0);
mpfr_set_ui (yy, 1, (mpfr_rnd_t) 0);
if (!(mpfr_cmpabs(xx,yy)>0))
ERROR ("Error in mpfr_cmpabs: not 1.0000000002 > 1.0\n");
mpfr_set_prec(yy, 53);
mpfr_set_ui(xx, 0, MPFR_RNDN);
mpfr_set_str (yy, "-0.1", 10, MPFR_RNDN);
if (mpfr_cmpabs(xx, yy) >= 0)
ERROR ("Error in mpfr_cmpabs(0.0, 0.1)\n");
mpfr_set_inf (xx, -1);
mpfr_set_str (yy, "23489745.0329", 10, MPFR_RNDN);
if (mpfr_cmpabs(xx, yy) <= 0)
ERROR ("Error in mpfr_cmp(-Inf, 23489745.0329)\n");
mpfr_set_inf (xx, 1);
mpfr_set_inf (yy, -1);
if (mpfr_cmpabs(xx, yy) != 0)
ERROR ("Error in mpfr_cmpabs(Inf, -Inf)\n");
mpfr_set_inf (yy, -1);
mpfr_set_str (xx, "2346.09234", 10, MPFR_RNDN);
if (mpfr_cmpabs (xx, yy) >= 0)
ERROR ("Error in mpfr_cmpabs(-Inf, 2346.09234)\n");
mpfr_set_prec (xx, 2);
mpfr_set_prec (yy, 128);
mpfr_set_str_binary (xx, "0.1E10");
mpfr_set_str_binary (yy,
"0.100000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000001E10");
if (mpfr_cmpabs (xx, yy) >= 0)
ERROR ("Error in mpfr_cmpabs(10.235, 2346.09234)\n");
mpfr_swap (xx, yy);
if (mpfr_cmpabs(xx, yy) <= 0)
ERROR ("Error in mpfr_cmpabs(2346.09234, 10.235)\n");
mpfr_swap (xx, yy);
/* Check for NAN */
mpfr_set_nan (xx);
mpfr_clear_erangeflag ();
c = (mpfr_cmp) (xx, yy);
if (c != 0 || !mpfr_erangeflag_p () )
{
printf ("NAN error (1)\n");
exit (1);
}
mpfr_clear_erangeflag ();
c = (mpfr_cmp) (yy, xx);
if (c != 0 || !mpfr_erangeflag_p () )
{
printf ("NAN error (2)\n");
exit (1);
}
mpfr_clear_erangeflag ();
c = (mpfr_cmp) (xx, xx);
if (c != 0 || !mpfr_erangeflag_p () )
{
printf ("NAN error (3)\n");
exit (1);
}
mpfr_clear (xx);
mpfr_clear (yy);
tests_end_mpfr ();
return 0;
}
/* bugs found by Alain Delplanque */
static void
check_large (void)
{
mpfr_t x;
char *s, s1[7];
const char xm[] = { '1', '1', '9', '1', '3', '2', '9', '3', '7', '3',
'5', '8', '4', '4', '5', '4', '9', '0', '2', '9',
'6', '3', '4', '4', '6', '9', '9', '1', '9', '5',
'5', '7', '2', '0', '1', '7', '5', '2', '8', '6',
'1', '2', '5', '2', '5', '2', '7', '4', '0', '2',
'7', '9', '1', '1', '7', '4', '5', '6', '7', '5',
'9', '3', '1', '4', '2', '5', '5', '6', '6', '6',
'1', '6', '4', '3', '8', '1', '2', '8', '7', '6',
'2', '9', '2', '0', '8', '8', '9', '4', '3', '9',
'6', '2', '8', '4', '1', '1', '8', '1', '0', '6',
'2', '3', '7', '6', '3', '8', '1', '5', '1', '7',
'3', '4', '6', '1', '2', '4', '0', '1', '3', '0',
'8', '4', '1', '3', '9', '3', '2', '0', '1', '6',
'3', '6', '7', '1', '5', '1', '7', '5', '0', '1',
'9', '8', '4', '0', '8', '2', '7', '9', '1', '3',
'2', '2', '8', '3', '4', '1', '6', '2', '3', '9',
'6', '2', '0', '7', '3', '5', '5', '5', '3', '4',
'2', '1', '7', '0', '9', '7', '6', '2', '1', '0',
'3', '3', '5', '4', '7', '6', '0', '9', '7', '6',
'9', '3', '5', '1', '7', '8', '6', '8', '8', '2',
'8', '1', '4', '3', '7', '4', '3', '3', '2', '4',
'1', '5', '4', '7', '8', '1', '1', '4', '2', '1',
'2', '4', '2', '7', '6', '5', '9', '5', '4', '5',
'2', '6', '7', '3', '0', '3', '4', '0', '6', '9',
'1', '8', '9', '9', '9', '8', '0', '5', '7', '0',
'9', '3', '8', '7', '6', '2', '4', '6', '1', '6',
'7', '2', '0', '3', '5', '9', '3', '5', '8', '8',
'9', '7', '7', '9', '2', '7', '0', '8', '1', '6',
'8', '7', '4', '8', '5', '3', '0', '8', '4', '3',
'5', '6', '5', '1', '6', '6', '0', '9', '7', '9',
'8', '9', '2', '7', '2', '6', '8', '5', '9', '4',
'5', '8', '1', '3', '7', '2', '9', '3', '8', '3',
'7', '9', '1', '7', '9', '9', '7', '7', '2', '8',
'4', '6', '5', '5', '7', '3', '3', '8', '3', '6',
'6', '9', '7', '1', '4', '3', '3', '7', '1', '4',
'9', '4', '1', '2', '4', '9', '5', '1', '4', '7',
'2', '6', '4', '4', '8', '0', '6', '2', '6', '0',
'6', '9', '8', '1', '1', '7', '9', '9', '3', '9',
'3', '8', '4', '7', '3', '1', '9', '0', '2', '3',
'5', '3', '5', '4', '2', '1', '1', '7', '6', '7',
'4', '3', '2', '2', '0', '6', '5', '9', '9', '3',
'2', '6', '7', '1', '2', '0', '0', '3', '7', '3',
'8', '7', '4', '3', '3', '3', '3', '3', '2', '3',
'8', '2', '8', '6', '3', '1', '5', '5', '2', '2',
'5', '9', '3', '3', '7', '0', '6', '2', '8', '1',
'0', '3', '6', '7', '6', '9', '6', '5', '9', '0',
'6', '6', '6', '3', '6', '9', '9', '3', '8', '7',
'6', '5', '4', '5', '3', '5', '9', '4', '0', '0',
'7', '5', '8', '5', '4', '1', '4', '3', '1', '5',
'7', '6', '6', '3', '4', '4', '5', '0', '8', '7',
'5', '7', '5', '0', '1', '0', '1', '8', '4', '7',
'3', '1', '9', '9', '2', '7', '1', '1', '1', '2',
'3', '9', '9', '6', '5', '9', '2', '3', '2', '8',
'1', '5', '5', '1', '2', '6', '4', '9', '6', '6',
'4', '5', '1', '1', '6', '0', '0', '3', '2', '8',
'4', '8', '7', '1', '4', '9', '6', '8', '1', '6',
'5', '9', '8', '3', '4', '2', '9', '7', '0', '1',
'9', '2', '6', '6', '9', '1', '3', '5', '9', '3',
'2', '9', '6', '2', '3', '0', '6', '0', '1', '1',
'6', '5', '1', '7', '9', '0', '7', '5', '8', '6',
'8', '4', '2', '1', '0', '3', '8', '6', '6', '4',
'4', '9', '9', '7', '5', '8', '1', '7', '5', '7',
'9', '6', '6', '8', '8', '5', '8', '6', '7', '4',
'0', '7', '2', '0', '2', '9', '9', '4', '4', '1',
'9', '5', '8', '6', '5', '0', '6', '7', '4', '2',
'7', '3', '2', '3', '2', '7', '0', '2', '1', '3',
'0', '5', '9', '0', '3', '9', '1', '4', '5', '3',
'7', '2', '7', '0', '8', '5', '5', '4', '6', '1',
'1', '0', '0', '9', '2', '0', '4', '1', '6', '6',
'4', '6', '9', '1', '3', '2', '8', '5', '0', '3',
'3', '8', '9', '8', '7', '8', '5', '9', '5', '5',
'9', '1', '9', '3', '6', '5', '4', '1', '7', '4',
'0', '2', '4', '7', '2', '9', '7', '1', '2', '4',
'5', '8', '1', '4', '4', '6', '1', '8', '5', '8',
'7', '6', '9', '7', '2', '1', '2', '0', '8', '9',
'5', '9', '5', '5', '3', '8', '1', '2', '5', '4',
'3', '0', '7', '6', '5', '1', '7', '8', '2', '0',
'0', '7', '6', '7', '4', '8', '1', '0', '6', '3',
'2', '3', '0', '5', '2', '5', '0', '1', '1', '4',
'3', '8', '4', '5', '2', '3', '9', '5', '0', '9',
'8', '2', '6', '4', '7', '4', '8', '0', '1', '1',
'7', '1', '5', '4', '9', '0', '9', '2', '2', '3',
'8', '1', '6', '9', '0', '4', '6', '4', '5', '4',
'6', '3', '8', '7', '3', '6', '1', '7', '2', '3',
'4', '5', '5', '2', '0', '2', '5', '8', '1', '4',
'9', '3', '0', '7', '4', '1', '6', '8', '7', '8',
'2', '6', '2', '5', '1', '0', '7', '4', '7', '3',
'6', '6', '4', '5', '6', '6', '6', '6', '8', '5',
'1', '3', '5', '7', '1', '6', '2', '0', '9', '2',
'3', '2', '6', '0', '7', '9', '8', '1', '6', '2',
'0', '3', '8', '8', '0', '2', '8', '7', '7', '5',
'9', '3', '1', '0', '6', '7', '5', '7', '3', '1',
'2', '7', '7', '2', '0', '0', '4', '1', '2', '8',
'2', '0', '8', '4', '0', '5', '0', '5', '0', '1',
'9', '3', '3', '6', '3', '6', '9', '6', '2', '8',
'2', '9', '7', '5', '3', '8', '8', '9', '1', '1',
'4', '5', '7', '7', '5', '6', '0', '2', '7', '9',
'7', '2', '1', '7', '4', '3', '0', '3', '6', '7',
'3', '7', '2', '2', '7', '5', '6', '2', '3', '1',
'2', '1', '3', '1', '4', '2', '6', '9', '2', '3',
'\0' };
mp_exp_t e;
mpfr_init2 (x, 3322);
mpfr_set_str (x, xm, 10, GMP_RNDN);
mpfr_div_2exp (x, x, 4343, GMP_RNDN);
s = mpfr_get_str (NULL, &e, 10, 1000, x, GMP_RNDN);
if (s[999] != '1') /* s must be 5.04383...689071e-309 */
{
printf ("Error in check_large: expected '689071', got '%s'\n",
s + 994);
exit (1);
}
mpfr_free_str (s);
mpfr_mul_2exp (x, x, 4343, GMP_RNDN);
s = mpfr_get_str (NULL, &e, 10, 2, x, GMP_RNDN);
if (strcmp (s, "12") || (e != 1000))
{
printf ("Error in check_large: expected 0.12e1000\n");
printf ("got %se%d\n", s, (int) e);
exit (1);
}
mpfr_free_str (s);
mpfr_set_nan (x);
s = mpfr_get_str (NULL, &e, 10, 1000, x, GMP_RNDN);
if (strcmp (s, "@NaN@"))
{
printf ("Error for NaN\n");
exit (1);
}
mpfr_free_str (s);
mpfr_get_str (s1, &e, 10, 1000, x, GMP_RNDN);
mpfr_set_inf (x, 1);
s = mpfr_get_str (NULL, &e, 10, 1000, x, GMP_RNDN);
if (strcmp (s, "@Inf@"))
{
printf ("Error for Inf\n");
exit (1);
}
mpfr_free_str (s);
mpfr_get_str (s1, &e, 10, 1000, x, GMP_RNDN);
mpfr_set_inf (x, -1);
s = mpfr_get_str (NULL, &e, 10, 1000, x, GMP_RNDN);
if (strcmp (s, "-@Inf@"))
{
printf ("Error for -Inf\n");
exit (1);
}
mpfr_free_str (s);
mpfr_get_str (s1, &e, 10, 1000, x, GMP_RNDN);
mpfr_set_ui (x, 0, GMP_RNDN);
s = mpfr_get_str (NULL, &e, 10, 2, x, GMP_RNDN);
if (e != 0 || strcmp (s, "00"))
{
printf ("Error for 0.0\n");
exit (1);
}
mpfr_free_str (s);
mpfr_get_str (s1, &e, 10, 2, x, GMP_RNDN);
mpfr_neg (x, x, GMP_RNDN); /* -0.0 */
s = mpfr_get_str (NULL, &e, 10, 2, x, GMP_RNDN);
if (e != 0 || strcmp (s, "-00"))
{
printf ("Error for -0.0\ngot %se%d\n", s, (int) e);
exit (1);
}
mpfr_free_str (s);
mpfr_get_str (s1, &e, 10, 2, x, GMP_RNDN);
mpfr_clear (x);
}
static PyObject *
GMPy_Real_DivMod_2(PyObject *x, PyObject *y, CTXT_Object *context)
{
MPFR_Object *tempx = NULL, *tempy = NULL, *quo = NULL, *rem = NULL;
PyObject *result;
CHECK_CONTEXT(context);
if (!(result = PyTuple_New(2)) ||
!(rem = GMPy_MPFR_New(0, context)) ||
!(quo = GMPy_MPFR_New(0, context))
) {
Py_XDECREF((PyObject*)result);
Py_XDECREF((PyObject*)quo);
Py_XDECREF((PyObject*)rem);
return NULL;
}
if (IS_REAL(x) && IS_REAL(y)) {
if (!(tempx = GMPy_MPFR_From_Real(x, 1, context)) ||
!(tempy = GMPy_MPFR_From_Real(y, 1, context))
) {
goto error;
}
if (mpfr_zero_p(tempy->f)) {
context->ctx.divzero = 1;
if (context->ctx.traps & TRAP_DIVZERO) {
GMPY_DIVZERO("divmod() division by zero");
goto error;
}
}
if (mpfr_nan_p(tempx->f) || mpfr_nan_p(tempy->f) || mpfr_inf_p(tempx->f)) {
context->ctx.invalid = 1;
if (context->ctx.traps & TRAP_INVALID) {
GMPY_INVALID("divmod() invalid operation");
goto error;
}
else {
mpfr_set_nan(quo->f);
mpfr_set_nan(rem->f);
}
}
else if (mpfr_inf_p(tempy->f)) {
context->ctx.invalid = 1;
if (context->ctx.traps & TRAP_INVALID) {
GMPY_INVALID("divmod() invalid operation");
goto error;
}
if (mpfr_zero_p(tempx->f)) {
mpfr_set_zero(quo->f, mpfr_sgn(tempy->f));
mpfr_set_zero(rem->f, mpfr_sgn(tempy->f));
}
else if ((mpfr_signbit(tempx->f)) != (mpfr_signbit(tempy->f))) {
mpfr_set_si(quo->f, -1, MPFR_RNDN);
mpfr_set_inf(rem->f, mpfr_sgn(tempy->f));
}
else {
mpfr_set_si(quo->f, 0, MPFR_RNDN);
rem->rc = mpfr_set(rem->f, tempx->f, MPFR_RNDN);
}
}
else {
MPQ_Object *mpqx = NULL, *mpqy = NULL, *temp_rem = NULL;
MPZ_Object *temp_quo = NULL;
if (!(mpqx = GMPy_MPQ_From_MPFR(tempx, context)) ||
!(mpqy = GMPy_MPQ_From_MPFR(tempy, context))
) {
Py_XDECREF((PyObject*)mpqx);
Py_XDECREF((PyObject*)mpqy);
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
Py_DECREF(result);
return NULL;
}
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
temp_rem = GMPy_MPQ_New(context);
temp_quo = GMPy_MPZ_New(context);
if (!(temp_rem = GMPy_MPQ_New(context)) ||
!(temp_quo = GMPy_MPZ_New(context))
) {
Py_XDECREF((PyObject*)temp_rem);
Py_XDECREF((PyObject*)temp_quo);
Py_DECREF((PyObject*)mpqx);
Py_DECREF((PyObject*)mpqy);
Py_DECREF(result);
return NULL;
}
mpq_div(temp_rem->q, mpqx->q, mpqy->q);
mpz_fdiv_q(temp_quo->z, mpq_numref(temp_rem->q), mpq_denref(temp_rem->q));
/* Need to calculate x - quo * y. */
mpq_set_z(temp_rem->q, temp_quo->z);
mpq_mul(temp_rem->q, temp_rem->q, mpqy->q);
mpq_sub(temp_rem->q, mpqx->q, temp_rem->q);
Py_DECREF((PyObject*)mpqx);
Py_DECREF((PyObject*)mpqy);
quo->rc = mpfr_set_z(quo->f, temp_quo->z, MPFR_RNDD);
rem->rc = mpfr_set_q(rem->f, temp_rem->q, MPFR_RNDN);
Py_DECREF((PyObject*)temp_rem);
Py_DECREF((PyObject*)temp_quo);
PyTuple_SET_ITEM(result, 0, (PyObject*)quo);
PyTuple_SET_ITEM(result, 1, (PyObject*)rem);
return result;
}
}
Py_DECREF((PyObject*)rem);
Py_DECREF((PyObject*)quo);
Py_DECREF(result);
Py_RETURN_NOTIMPLEMENTED;
error:
Py_XDECREF((PyObject*)tempx);
Py_XDECREF((PyObject*)tempy);
Py_DECREF((PyObject*)rem);
Py_DECREF((PyObject*)quo);
Py_DECREF(result);
return NULL;
}
static void
special (void)
{
mpfr_t x, y;
mpfr_init (x);
mpfr_init (y);
MPFR_SET_INF(x);
mpfr_set_ui (y, 1, MPFR_RNDN);
mpfr_acosh (x, y, MPFR_RNDN);
if (MPFR_IS_INF(x) || MPFR_IS_NAN(x) )
{
printf ("Inf flag not clears in acosh!\n");
exit (1);
}
if (mpfr_cmp_ui (x, 0))
{
printf ("Error: mpfr_acosh(1) <> 0\n");
exit (1);
}
MPFR_SET_NAN(x);
mpfr_acosh (x, y, MPFR_RNDN);
if (MPFR_IS_NAN(x) || MPFR_IS_INF(x) )
{
printf ("NAN flag not clears in acosh!\n");
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_acosh (y, x, MPFR_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error: mpfr_acosh(0) <> NaN\n");
exit (1);
}
mpfr_set_si (x, -1, MPFR_RNDN);
mpfr_acosh (y, x, MPFR_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error: mpfr_acosh(-1) <> NaN\n");
exit (1);
}
MPFR_SET_NAN(x);
mpfr_acosh (y, x, MPFR_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error: mpfr_acosh(NaN) <> NaN\n");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_acosh (y, x, MPFR_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error: mpfr_acosh(+Inf) <> +Inf\n");
exit (1);
}
mpfr_set_inf (x, -1);
mpfr_acosh (y, x, MPFR_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error: mpfr_acosh(-Inf) <> NaN\n");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_div_2exp (x, x, 1, MPFR_RNDN);
mpfr_acosh (y, x, MPFR_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error: mpfr_acosh(1/2) <> NaN\n");
exit (1);
}
mpfr_set_prec (x, 32);
mpfr_set_prec (y, 32);
mpfr_set_str_binary (x, "1.000001101011101111001011");
mpfr_acosh (y, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.111010100101101001010001101001E-2");
if (mpfr_cmp (x, y))
{
printf ("Error: mpfr_acosh (1)\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
static void
check_get_d_2exp_inf_nan (void)
{
#if !defined(MPFR_ERRDIVZERO)
double var_d;
long exp;
mpfr_t var;
mpfr_init2 (var, MPFR_PREC_MIN);
mpfr_set_nan (var);
var_d = mpfr_get_d_2exp (&exp, var, MPFR_RNDN);
if (!DOUBLE_ISNAN (var_d))
{
printf ("mpfr_get_d_2exp with a NAN mpfr value returned a wrong value :\n"
" waiting for %g got %g\n", MPFR_DBL_NAN, var_d);
exit (1);
}
mpfr_set_zero (var, 1);
var_d = mpfr_get_d_2exp (&exp, var, MPFR_RNDN);
if ((exp != 0) || (var_d != 0.0))
{
printf ("mpfr_get_d_2exp with a +0.0 mpfr value returned a wrong value :\n"
" double waiting for 0.0 got %g\n exp waiting for 0 got %ld\n",
var_d, exp);
exit (1);
}
mpfr_set_zero (var, -1);
var_d = mpfr_get_d_2exp (&exp, var, MPFR_RNDN);
if ((exp != 0) || (var_d != DBL_NEG_ZERO))
{
printf ("mpfr_get_d_2exp with a +0.0 mpfr value returned a wrong value :\n"
" double waiting for %g got %g\n exp waiting for 0 got %ld\n",
DBL_NEG_ZERO, var_d, exp);
exit (1);
}
mpfr_set_inf (var, 1);
var_d = mpfr_get_d_2exp (&exp, var, MPFR_RNDN);
if (var_d != MPFR_DBL_INFP)
{
printf ("mpfr_get_d_2exp with a +Inf mpfr value returned a wrong value :\n"
" waiting for %g got %g\n", MPFR_DBL_INFP, var_d);
exit (1);
}
mpfr_set_inf (var, -1);
var_d = mpfr_get_d_2exp (&exp, var, MPFR_RNDN);
if (var_d != MPFR_DBL_INFM)
{
printf ("mpfr_get_d_2exp with a -Inf mpfr value returned a wrong value :\n"
" waiting for %g got %g\n", MPFR_DBL_INFM, var_d);
exit (1);
}
mpfr_clear (var);
#endif
}
int
main (int argc, char *argv[])
{
mpfr_t x, y;
tests_start_mpfr ();
mpfr_init (x);
mpfr_init (y);
/* special values */
mpfr_set_nan (x);
mpfr_y1 (y, x, GMP_RNDN);
MPFR_ASSERTN(mpfr_nan_p (y));
mpfr_set_inf (x, 1); /* +Inf */
mpfr_y1 (y, x, GMP_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS (y));
mpfr_set_inf (x, -1); /* -Inf */
mpfr_y1 (y, x, GMP_RNDN);
MPFR_ASSERTN(mpfr_nan_p (y));
mpfr_set_ui (x, 0, GMP_RNDN); /* +0 */
mpfr_y1 (y, x, GMP_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_NEG (y)); /* y1(+0)=-Inf */
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_neg (x, x, GMP_RNDN); /* -0 */
mpfr_y1 (y, x, GMP_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_NEG (y)); /* y1(-0)=-Inf */
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_ui (x, 1, GMP_RNDN);
mpfr_y1 (y, x, GMP_RNDN);
mpfr_set_str_binary (x, "-0.110001111111110110010000001111101011001101011100101");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_y1 for x=1, rnd=GMP_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_si (x, -1, GMP_RNDN);
mpfr_y1 (y, x, GMP_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error in mpfr_y1 for x=-1, rnd=GMP_RNDN\n");
printf ("Expected NaN\n");
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
test_generic (2, 100, 1);
data_check ("data/y1", mpfr_y1, "mpfr_y1");
tests_end_mpfr ();
return 0;
}
static
void check_special (void)
{
mpfr_t tab[3], r;
mpfr_ptr tabp[3];
int i;
mpfr_inits (tab[0], tab[1], tab[2], r, (mpfr_ptr) 0);
tabp[0] = tab[0];
tabp[1] = tab[1];
tabp[2] = tab[2];
i = mpfr_sum (r, tabp, 0, MPFR_RNDN);
if (!MPFR_IS_ZERO (r) || !MPFR_IS_POS (r) || i != 0)
{
printf ("Special case n==0 failed!\n");
exit (1);
}
mpfr_set_ui (tab[0], 42, MPFR_RNDN);
i = mpfr_sum (r, tabp, 1, MPFR_RNDN);
if (mpfr_cmp_ui (r, 42) || i != 0)
{
printf ("Special case n==1 failed!\n");
exit (1);
}
mpfr_set_ui (tab[1], 17, MPFR_RNDN);
MPFR_SET_NAN (tab[2]);
i = mpfr_sum (r, tabp, 3, MPFR_RNDN);
if (!MPFR_IS_NAN (r) || i != 0)
{
printf ("Special case NAN failed!\n");
exit (1);
}
MPFR_SET_INF (tab[2]);
MPFR_SET_POS (tab[2]);
i = mpfr_sum (r, tabp, 3, MPFR_RNDN);
if (!MPFR_IS_INF (r) || !MPFR_IS_POS (r) || i != 0)
{
printf ("Special case +INF failed!\n");
exit (1);
}
MPFR_SET_INF (tab[2]);
MPFR_SET_NEG (tab[2]);
i = mpfr_sum (r, tabp, 3, MPFR_RNDN);
if (!MPFR_IS_INF (r) || !MPFR_IS_NEG (r) || i != 0)
{
printf ("Special case -INF failed!\n");
exit (1);
}
MPFR_SET_ZERO (tab[1]);
i = mpfr_sum (r, tabp, 2, MPFR_RNDN);
if (mpfr_cmp_ui (r, 42) || i != 0)
{
printf ("Special case 42+0 failed!\n");
exit (1);
}
MPFR_SET_NAN (tab[0]);
i = mpfr_sum (r, tabp, 3, MPFR_RNDN);
if (!MPFR_IS_NAN (r) || i != 0)
{
printf ("Special case NAN+0+-INF failed!\n");
exit (1);
}
mpfr_set_inf (tab[0], 1);
mpfr_set_ui (tab[1], 59, MPFR_RNDN);
mpfr_set_inf (tab[2], -1);
i = mpfr_sum (r, tabp, 3, MPFR_RNDN);
if (!MPFR_IS_NAN (r) || i != 0)
{
printf ("Special case +INF + 59 +-INF failed!\n");
exit (1);
}
mpfr_clears (tab[0], tab[1], tab[2], r, (mpfr_ptr) 0);
}
static void
special (void)
{
mpfr_t x, y;
mpq_t z;
int res = 0;
mpfr_init (x);
mpfr_init (y);
mpq_init (z);
/* cancellation in mpfr_add_q */
mpfr_set_prec (x, 60);
mpfr_set_prec (y, 20);
mpz_set_str (mpq_numref (z), "-187207494", 10);
mpz_set_str (mpq_denref (z), "5721", 10);
mpfr_set_str_binary (x, "11111111101001011011100101100011011110010011100010000100001E-44");
mpfr_add_q (y, x, z, 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 (z), "187207494", 10);
mpz_set_str (mpq_denref (z), "5721", 10);
mpfr_set_prec (y, 29);
mpfr_add_q (y, x, z, 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 (z), "395877315", 10);
mpz_set_str (mpq_denref (z), "3508975966", 10);
mpfr_set_prec (y, 118);
mpfr_add_q (y, x, z, MPFR_RNDU);
CHECK_FOR ("inf", mpfr_inf_p (y) && mpfr_sgn (y) > 0);
mpfr_sub_q (y, x, z, MPFR_RNDU);
CHECK_FOR ("inf", mpfr_inf_p (y) && mpfr_sgn (y) > 0);
/* Nan */
MPFR_SET_NAN (x);
mpfr_add_q (y, x, z, MPFR_RNDU);
CHECK_FOR ("nan", mpfr_nan_p (y));
mpfr_sub_q (y, x, z, 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 (z), "3", 10);
mpz_set_str (mpq_denref (z), "2", 10);
res = mpfr_add_q (y, x, z, MPFR_RNDU);
CHECK_FOR ("0.5+3/2", mpfr_cmp_ui(y, 2)==0 && res==0);
res = mpfr_sub_q (y, x, z, MPFR_RNDU);
CHECK_FOR ("0.5-3/2", mpfr_cmp_si(y, -1)==0 && res==0);
/* Inf Rationnal */
mpq_set_ui (z, 1, 0);
mpfr_set_str1 (x, "0.5");
res = mpfr_add_q (y, x, z, MPFR_RNDN);
CHECK_FOR ("0.5+1/0", mpfr_inf_p (y) && MPFR_SIGN (y) > 0 && res == 0);
res = mpfr_sub_q (y, x, z, MPFR_RNDN);
CHECK_FOR ("0.5-1/0", mpfr_inf_p (y) && MPFR_SIGN (y) < 0 && res == 0);
mpq_set_si (z, -1, 0);
res = mpfr_add_q (y, x, z, MPFR_RNDN);
CHECK_FOR ("0.5+ -1/0", mpfr_inf_p (y) && MPFR_SIGN (y) < 0 && res == 0);
res = mpfr_sub_q (y, x, z, MPFR_RNDN);
CHECK_FOR ("0.5- -1/0", mpfr_inf_p (y) && MPFR_SIGN (y) > 0 && res == 0);
res = mpfr_div_q (y, x, z, MPFR_RNDN);
CHECK_FOR ("0.5 / (-1/0)", mpfr_zero_p (y) && MPFR_SIGN (y) < 0 && res == 0);
/* 0 */
mpq_set_ui (z, 0, 1);
mpfr_set_ui (x, 42, MPFR_RNDN);
res = mpfr_add_q (y, x, z, MPFR_RNDN);
CHECK_FOR ("42+0/1", mpfr_cmp_ui (y, 42) == 0 && res == 0);
res = mpfr_sub_q (y, x, z, MPFR_RNDN);
CHECK_FOR ("42-0/1", mpfr_cmp_ui (y, 42) == 0 && res == 0);
res = mpfr_mul_q (y, x, z, MPFR_RNDN);
CHECK_FOR ("42*0/1", mpfr_zero_p (y) && MPFR_SIGN (y) > 0 && res == 0);
res = mpfr_div_q (y, x, z, MPFR_RNDN);
CHECK_FOR ("42/(0/1)", mpfr_inf_p (y) && MPFR_SIGN (y) > 0 && res == 0);
mpq_clear (z);
mpfr_clear (x);
mpfr_clear (y);
}
static void
check_specials (void)
{
mpfr_t x, y;
mpfr_init2 (x, 123L);
mpfr_init2 (y, 123L);
mpfr_set_nan (x);
mpfr_eint (y, x, MPFR_RNDN);
if (! mpfr_nan_p (y))
{
printf ("Error: eint(NaN) != NaN\n");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_eint (y, x, MPFR_RNDN);
if (! (mpfr_inf_p (y) && mpfr_sgn (y) > 0))
{
printf ("Error: eint(+Inf) != +Inf\n");
exit (1);
}
mpfr_set_inf (x, -1);
mpfr_eint (y, x, MPFR_RNDN);
if (! mpfr_nan_p (y))
{
printf ("Error: eint(-Inf) != NaN\n");
exit (1);
}
/* eint(+/-0) = -Inf */
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_eint (y, x, MPFR_RNDN);
if (! (mpfr_inf_p (y) && mpfr_sgn (y) < 0))
{
printf ("Error: eint(+0) != -Inf\n");
exit (1);
}
mpfr_neg (x, x, MPFR_RNDN);
mpfr_eint (y, x, MPFR_RNDN);
if (! (mpfr_inf_p (y) && mpfr_sgn (y) < 0))
{
printf ("Error: eint(-0) != -Inf\n");
exit (1);
}
/* eint(x) = NaN for x < 0 */
mpfr_set_si (x, -1, MPFR_RNDN);
mpfr_eint (y, x, MPFR_RNDN);
if (! mpfr_nan_p (y))
{
printf ("Error: eint(-1) != NaN\n");
exit (1);
}
mpfr_set_prec (x, 17);
mpfr_set_prec (y, 17);
mpfr_set_str_binary (x, "1.0111110100100110e-2");
mpfr_set_str_binary (y, "-1.0010101001110100e-10");
mpfr_eint (x, x, MPFR_RNDZ);
if (mpfr_cmp (x, y))
{
printf ("Error for x=1.0111110100100110e-2, MPFR_RNDZ\n");
printf ("expected "); mpfr_dump (y);
printf ("got "); mpfr_dump (x);
exit (1);
}
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str_binary (x, "0.10E4");
mpfr_eint (x, x, MPFR_RNDN);
mpfr_set_str (y, "440.37989953483827", 10, MPFR_RNDN);
if (mpfr_cmp (x, y) != 0)
{
printf ("Error for x=0.10E4, MPFR_RNDZ\n");
printf ("expected "); mpfr_dump (y);
printf ("got "); mpfr_dump (x);
exit (1);
}
mpfr_set_prec (x, 63);
mpfr_set_prec (y, 63);
mpfr_set_str_binary (x, "1.01111101011100111000011010001000101101011000011001111101011010e-2");
mpfr_eint (x, x, MPFR_RNDZ);
mpfr_set_str_binary (y, "1.11010110001101000001010010000100001111001000100100000001011100e-17");
if (mpfr_cmp (x, y) != 0)
{
printf ("Error (1) for MPFR_RNDZ\n");
printf ("expected "); mpfr_dump (y);
printf ("got "); mpfr_dump (x);
exit (1);
}
/* check large x */
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str_binary (x, "1E6");
mpfr_eint (x, x, MPFR_RNDN);
mpfr_set_str_binary (y, "10100011110001101001110000110010111000100111010001E37");
if (mpfr_cmp (x, y) != 0)
{
printf ("Error for x=2^6, MPFR_RNDN\n");
printf ("expected "); mpfr_dump (y);
printf ("got "); mpfr_dump (x);
exit (1);
}
mpfr_set_str_binary (x, "1E7");
mpfr_eint (x, x, MPFR_RNDN);
mpfr_set_str_binary (y, "11001100100011110000101001011010110111111011110011E128");
if (mpfr_cmp (x, y) != 0)
{
printf ("Error for x=2^7, MPFR_RNDN\n");
printf ("expected "); mpfr_dump (y);
printf ("got "); mpfr_dump (x);
exit (1);
}
mpfr_set_str_binary (x, "1E8");
mpfr_eint (x, x, MPFR_RNDN);
mpfr_set_str_binary (y, "1010000110000101111111011011000101001000101011101001E310");
if (mpfr_cmp (x, y) != 0)
{
printf ("Error for x=2^8, MPFR_RNDN\n");
printf ("expected "); mpfr_dump (y);
printf ("got "); mpfr_dump (x);
exit (1);
}
mpfr_set_str_binary (x, "1E9");
mpfr_eint (x, x, MPFR_RNDN);
mpfr_set_str_binary (y, "11001010101000001010101101110000010110011101110010101E677");
if (mpfr_cmp (x, y) != 0)
{
printf ("Error for x=2^9, MPFR_RNDN\n");
printf ("expected "); mpfr_dump (y);
printf ("got "); mpfr_dump (x);
exit (1);
}
mpfr_set_str_binary (x, "1E10");
mpfr_eint (x, x, MPFR_RNDN);
mpfr_set_str_binary (y, "10011111111010010110110101101000101100101010101101101E1415");
if (mpfr_cmp (x, y) != 0)
{
printf ("Error for x=2^10, MPFR_RNDN\n");
printf ("expected "); mpfr_dump (y);
printf ("got "); mpfr_dump (x);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
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);
}
int
main (void)
{
mpfr_t x, y, z;
tests_start_mpfr ();
mpfr_init (x);
mpfr_init (y);
mpfr_init (z);
/* case x=NaN */
mpfr_set_nan (x);
mpfr_set_ui (y, 0, MPFR_RNDN);
mpfr_dim (z, x, y, MPFR_RNDN);
if (!mpfr_nan_p (z))
{
printf ("Error in mpfr_dim (NaN, 0)\n");
exit (1);
}
/* case x=+Inf */
mpfr_set_inf (x, 1);
mpfr_set_ui (y, 0, MPFR_RNDN);
mpfr_dim (z, x, y, MPFR_RNDN);
if (!mpfr_inf_p (z) || mpfr_sgn (z) < 0)
{
printf ("Error in mpfr_dim (+Inf, 0)\n");
exit (1);
}
/* case x=-Inf */
mpfr_set_inf (x, -1);
mpfr_set_ui (y, 0, MPFR_RNDN);
mpfr_dim (z, x, y, MPFR_RNDN);
if (mpfr_cmp_ui (z, 0) || mpfr_sgn (z) < 0)
{
printf ("Error in mpfr_dim (-Inf, 0)\n");
exit (1);
}
/* case x=y=+Inf */
mpfr_set_inf (x, 1);
mpfr_set_inf (y, 1);
mpfr_dim (z, x, y, MPFR_RNDN);
if (mpfr_cmp_ui (z, 0) || mpfr_sgn (z) < 0)
{
printf ("Error in mpfr_dim (+Inf, +Inf)\n");
exit (1);
}
/* case x > y */
mpfr_set_ui (x, 2, MPFR_RNDN);
mpfr_set_ui (y, 1, MPFR_RNDN);
mpfr_dim (z, x, y, MPFR_RNDN);
if (mpfr_cmp_ui (z, 1))
{
printf ("Error in mpfr_dim (2, 1)\n");
exit (1);
}
/* case x < y */
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_set_ui (y, 2, MPFR_RNDN);
mpfr_dim (z, x, y, MPFR_RNDN);
if (mpfr_cmp_ui (z, 0))
{
printf ("Error in mpfr_dim (1, 2)\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
test_generic (MPFR_PREC_MIN, 220, 42);
tests_end_mpfr ();
return 0;
}
static void
check_specials (void)
{
mpfr_t x, y;
mpfr_init2 (x, 123L);
mpfr_init2 (y, 123L);
mpfr_set_nan (x);
mpfr_sech (y, x, GMP_RNDN);
if (! mpfr_nan_p (y))
{
printf ("Error: sech(NaN) != NaN\n");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_sech (y, x, GMP_RNDN);
if (! (MPFR_IS_ZERO (y) && MPFR_SIGN (y) > 0))
{
printf ("Error: sech(+Inf) != +0\n");
exit (1);
}
mpfr_set_inf (x, -1);
mpfr_sech (y, x, GMP_RNDN);
if (! (MPFR_IS_ZERO (y) && MPFR_SIGN (y) > 0))
{
printf ("Error: sech(-Inf) != +0\n");
exit (1);
}
/* sec(+/-0) = 1 */
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_sech (y, x, GMP_RNDN);
if (mpfr_cmp_ui (y, 1))
{
printf ("Error: sech(+0) != 1\n");
exit (1);
}
mpfr_neg (x, x, GMP_RNDN);
mpfr_sech (y, x, GMP_RNDN);
if (mpfr_cmp_ui (y, 1))
{
printf ("Error: sech(-0) != 1\n");
exit (1);
}
/* check huge x */
mpfr_set_str (x, "8e8", 10, GMP_RNDN);
mpfr_sech (y, x, GMP_RNDN);
if (! (mpfr_zero_p (y) && MPFR_SIGN (y) > 0))
{
printf ("Error: sech(8e8) != +0\n");
exit (1);
}
mpfr_set_str (x, "-8e8", 10, GMP_RNDN);
mpfr_sech (y, x, GMP_RNDN);
if (! (mpfr_zero_p (y) && MPFR_SIGN (y) > 0))
{
printf ("Error: sech(-8e8) != +0\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
int
mpc_acos (mpc_ptr rop, mpc_srcptr op, mpc_rnd_t rnd)
{
int inex_re, inex_im, inex;
mpfr_prec_t p_re, p_im, p;
mpc_t z1;
mpfr_t pi_over_2;
mpfr_exp_t e1, e2;
mpfr_rnd_t rnd_im;
mpc_rnd_t rnd1;
inex_re = 0;
inex_im = 0;
/* special values */
if (mpfr_nan_p (mpc_realref (op)) || mpfr_nan_p (mpc_imagref (op)))
{
if (mpfr_inf_p (mpc_realref (op)) || mpfr_inf_p (mpc_imagref (op)))
{
mpfr_set_inf (mpc_imagref (rop), mpfr_signbit (mpc_imagref (op)) ? +1 : -1);
mpfr_set_nan (mpc_realref (rop));
}
else if (mpfr_zero_p (mpc_realref (op)))
{
inex_re = set_pi_over_2 (mpc_realref (rop), +1, MPC_RND_RE (rnd));
mpfr_set_nan (mpc_imagref (rop));
}
else
{
mpfr_set_nan (mpc_realref (rop));
mpfr_set_nan (mpc_imagref (rop));
}
return MPC_INEX (inex_re, 0);
}
if (mpfr_inf_p (mpc_realref (op)) || mpfr_inf_p (mpc_imagref (op)))
{
if (mpfr_inf_p (mpc_realref (op)))
{
if (mpfr_inf_p (mpc_imagref (op)))
{
if (mpfr_sgn (mpc_realref (op)) > 0)
{
inex_re =
set_pi_over_2 (mpc_realref (rop), +1, MPC_RND_RE (rnd));
mpfr_div_2ui (mpc_realref (rop), mpc_realref (rop), 1, GMP_RNDN);
}
else
{
/* the real part of the result is 3*pi/4
a = o(pi) error(a) < 1 ulp(a)
b = o(3*a) error(b) < 2 ulp(b)
c = b/4 exact
thus 1 bit is lost */
mpfr_t x;
mpfr_prec_t prec;
int ok;
mpfr_init (x);
prec = mpfr_get_prec (mpc_realref (rop));
p = prec;
do
{
p += mpc_ceil_log2 (p);
mpfr_set_prec (x, p);
mpfr_const_pi (x, GMP_RNDD);
mpfr_mul_ui (x, x, 3, GMP_RNDD);
ok =
mpfr_can_round (x, p - 1, GMP_RNDD, MPC_RND_RE (rnd),
prec+(MPC_RND_RE (rnd) == GMP_RNDN));
} while (ok == 0);
inex_re =
mpfr_div_2ui (mpc_realref (rop), x, 2, MPC_RND_RE (rnd));
mpfr_clear (x);
}
}
else
{
if (mpfr_sgn (mpc_realref (op)) > 0)
mpfr_set_ui (mpc_realref (rop), 0, GMP_RNDN);
else
inex_re = mpfr_const_pi (mpc_realref (rop), MPC_RND_RE (rnd));
}
}
else
inex_re = set_pi_over_2 (mpc_realref (rop), +1, MPC_RND_RE (rnd));
mpfr_set_inf (mpc_imagref (rop), mpfr_signbit (mpc_imagref (op)) ? +1 : -1);
return MPC_INEX (inex_re, 0);
}
/* pure real argument */
if (mpfr_zero_p (mpc_imagref (op)))
{
int s_im;
s_im = mpfr_signbit (mpc_imagref (op));
if (mpfr_cmp_ui (mpc_realref (op), 1) > 0)
{
if (s_im)
inex_im = mpfr_acosh (mpc_imagref (rop), mpc_realref (op),
MPC_RND_IM (rnd));
else
inex_im = -mpfr_acosh (mpc_imagref (rop), mpc_realref (op),
INV_RND (MPC_RND_IM (rnd)));
mpfr_set_ui (mpc_realref (rop), 0, GMP_RNDN);
}
else if (mpfr_cmp_si (mpc_realref (op), -1) < 0)
{
mpfr_t minus_op_re;
minus_op_re[0] = mpc_realref (op)[0];
MPFR_CHANGE_SIGN (minus_op_re);
if (s_im)
inex_im = mpfr_acosh (mpc_imagref (rop), minus_op_re,
MPC_RND_IM (rnd));
else
inex_im = -mpfr_acosh (mpc_imagref (rop), minus_op_re,
INV_RND (MPC_RND_IM (rnd)));
inex_re = mpfr_const_pi (mpc_realref (rop), MPC_RND_RE (rnd));
}
else
{
inex_re = mpfr_acos (mpc_realref (rop), mpc_realref (op), MPC_RND_RE (rnd));
mpfr_set_ui (mpc_imagref (rop), 0, MPC_RND_IM (rnd));
}
if (!s_im)
mpc_conj (rop, rop, MPC_RNDNN);
return MPC_INEX (inex_re, inex_im);
}
/* pure imaginary argument */
if (mpfr_zero_p (mpc_realref (op)))
{
inex_re = set_pi_over_2 (mpc_realref (rop), +1, MPC_RND_RE (rnd));
inex_im = -mpfr_asinh (mpc_imagref (rop), mpc_imagref (op),
INV_RND (MPC_RND_IM (rnd)));
mpc_conj (rop,rop, MPC_RNDNN);
return MPC_INEX (inex_re, inex_im);
}
/* regular complex argument: acos(z) = Pi/2 - asin(z) */
p_re = mpfr_get_prec (mpc_realref(rop));
p_im = mpfr_get_prec (mpc_imagref(rop));
p = p_re;
mpc_init3 (z1, p, p_im); /* we round directly the imaginary part to p_im,
with rounding mode opposite to rnd_im */
rnd_im = MPC_RND_IM(rnd);
/* the imaginary part of asin(z) has the same sign as Im(z), thus if
Im(z) > 0 and rnd_im = RNDZ, we want to round the Im(asin(z)) to -Inf
so that -Im(asin(z)) is rounded to zero */
if (rnd_im == GMP_RNDZ)
rnd_im = mpfr_sgn (mpc_imagref(op)) > 0 ? GMP_RNDD : GMP_RNDU;
else
rnd_im = rnd_im == GMP_RNDU ? GMP_RNDD
: rnd_im == GMP_RNDD ? GMP_RNDU
: rnd_im; /* both RNDZ and RNDA map to themselves for -asin(z) */
rnd1 = MPC_RND (GMP_RNDN, rnd_im);
mpfr_init2 (pi_over_2, p);
for (;;)
{
p += mpc_ceil_log2 (p) + 3;
mpfr_set_prec (mpc_realref(z1), p);
mpfr_set_prec (pi_over_2, p);
set_pi_over_2 (pi_over_2, +1, GMP_RNDN);
e1 = 1; /* Exp(pi_over_2) */
inex = mpc_asin (z1, op, rnd1); /* asin(z) */
MPC_ASSERT (mpfr_sgn (mpc_imagref(z1)) * mpfr_sgn (mpc_imagref(op)) > 0);
inex_im = MPC_INEX_IM(inex); /* inex_im is in {-1, 0, 1} */
e2 = mpfr_get_exp (mpc_realref(z1));
mpfr_sub (mpc_realref(z1), pi_over_2, mpc_realref(z1), GMP_RNDN);
if (!mpfr_zero_p (mpc_realref(z1)))
{
/* the error on x=Re(z1) is bounded by 1/2 ulp(x) + 2^(e1-p-1) +
2^(e2-p-1) */
e1 = e1 >= e2 ? e1 + 1 : e2 + 1;
/* the error on x is bounded by 1/2 ulp(x) + 2^(e1-p-1) */
e1 -= mpfr_get_exp (mpc_realref(z1));
/* the error on x is bounded by 1/2 ulp(x) [1 + 2^e1] */
e1 = e1 <= 0 ? 0 : e1;
/* the error on x is bounded by 2^e1 * ulp(x) */
mpfr_neg (mpc_imagref(z1), mpc_imagref(z1), GMP_RNDN); /* exact */
inex_im = -inex_im;
if (mpfr_can_round (mpc_realref(z1), p - e1, GMP_RNDN, GMP_RNDZ,
p_re + (MPC_RND_RE(rnd) == GMP_RNDN)))
break;
}
}
inex = mpc_set (rop, z1, rnd);
inex_re = MPC_INEX_RE(inex);
mpc_clear (z1);
mpfr_clear (pi_over_2);
return MPC_INEX(inex_re, inex_im);
}
static void
check_cmp (int argc, char *argv[])
{
mpfr_t x, y;
int n, k;
mpfr_inits2 (53, x, y, (mpfr_ptr) 0);
mpfr_set_ui(x, 1, GMP_RNDN);
(mpfr_abs) (x, x, GMP_RNDN);
if (mpfr_cmp_ui (x, 1))
{
printf ("Error in mpfr_abs(1.0)\n");
exit (1);
}
mpfr_set_si(x, -1, GMP_RNDN);
mpfr_abs(x, x, GMP_RNDN);
if (mpfr_cmp_ui (x, 1))
{
printf ("Error in mpfr_abs(1.0)\n");
exit (1);
}
mpfr_set_si(x, -1, GMP_RNDN);
mpfr_abs(x, x, GMP_RNDN);
if (mpfr_cmp_ui (x, 1))
{
printf ("Error in mpfr_abs(-1.0)\n");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_abs (x, x, GMP_RNDN);
if (!mpfr_inf_p(x) || (mpfr_sgn(x) <= 0))
{
printf ("Error in mpfr_abs(Inf).\n");
exit (1);
}
mpfr_set_inf (x, -1);
mpfr_abs (x, x, GMP_RNDN);
if (!mpfr_inf_p(x) || (mpfr_sgn(x) <= 0))
{
printf ("Error in mpfr_abs(-Inf).\n");
exit (1);
}
MPFR_SET_NAN(x);
mpfr_abs (x, x, GMP_RNDN);
if (!MPFR_IS_NAN(x))
{
printf ("Error in mpfr_abs(NAN).\n");
exit (1);
}
n = (argc==1) ? 25000 : atoi(argv[1]);
for (k = 1; k <= n; k++)
{
mp_rnd_t rnd;
int sign = SIGN_RAND ();
mpfr_urandomb (x, RANDS);
MPFR_SET_SIGN (x, sign);
rnd = RND_RAND ();
mpfr_abs (y, x, rnd);
MPFR_SET_POS (x);
if (mpfr_cmp (x, y))
{
printf ("Mismatch for sign=%d and x=", sign);
mpfr_print_binary (x);
printf ("\nResults=");
mpfr_print_binary (y);
putchar ('\n');
exit (1);
}
}
mpfr_clears (x, y, (mpfr_ptr) 0);
}
static PyObject *
GMPy_Real_DivMod_1(PyObject *x, PyObject *y, CTXT_Object *context)
{
MPFR_Object *tempx = NULL, *tempy = NULL, *quo, *rem;
PyObject *result;
CHECK_CONTEXT(context);
result = PyTuple_New(2);
rem = GMPy_MPFR_New(0, context);
quo = GMPy_MPFR_New(0, context);
if (!result || !rem || !quo) {
Py_XDECREF((PyObject*)result);
Py_XDECREF((PyObject*)quo);
Py_XDECREF((PyObject*)rem);
return NULL;
}
if (IS_REAL(x) && IS_REAL(y)) {
tempx = GMPy_MPFR_From_Real(x, 1, context);
tempy = GMPy_MPFR_From_Real(y, 1, context);
if (!tempx || !tempy) {
goto error;
}
if (mpfr_zero_p(tempy->f)) {
context->ctx.divzero = 1;
if (context->ctx.traps & TRAP_DIVZERO) {
GMPY_DIVZERO("divmod() division by zero");
goto error;
}
}
if (mpfr_nan_p(tempx->f) || mpfr_nan_p(tempy->f) || mpfr_inf_p(tempx->f)) {
context->ctx.invalid = 1;
if (context->ctx.traps & TRAP_INVALID) {
GMPY_INVALID("divmod() invalid operation");
goto error;
}
else {
mpfr_set_nan(quo->f);
mpfr_set_nan(rem->f);
}
}
else if (mpfr_inf_p(tempy->f)) {
context->ctx.invalid = 1;
if (context->ctx.traps & TRAP_INVALID) {
GMPY_INVALID("divmod() invalid operation");
goto error;
}
if (mpfr_zero_p(tempx->f)) {
mpfr_set_zero(quo->f, mpfr_sgn(tempy->f));
mpfr_set_zero(rem->f, mpfr_sgn(tempy->f));
}
else if ((mpfr_signbit(tempx->f)) != (mpfr_signbit(tempy->f))) {
mpfr_set_si(quo->f, -1, MPFR_RNDN);
mpfr_set_inf(rem->f, mpfr_sgn(tempy->f));
}
else {
mpfr_set_si(quo->f, 0, MPFR_RNDN);
rem->rc = mpfr_set(rem->f, tempx->f, MPFR_RNDN);
}
}
else {
MPFR_Object *temp;
if (!(temp = GMPy_MPFR_New(0, context))) {
goto error;
}
mpfr_fmod(rem->f, tempx->f, tempy->f, MPFR_RNDN);
mpfr_sub(temp->f, tempx->f, rem->f, MPFR_RNDN);
mpfr_div(quo->f, temp->f, tempy->f, MPFR_RNDN);
if (!mpfr_zero_p(rem->f)) {
if ((mpfr_sgn(tempy->f) < 0) != (mpfr_sgn(rem->f) < 0)) {
mpfr_add(rem->f, rem->f, tempy->f, MPFR_RNDN);
mpfr_sub_ui(quo->f, quo->f, 1, MPFR_RNDN);
}
}
else {
mpfr_copysign(rem->f, rem->f, tempy->f, MPFR_RNDN);
}
if (!mpfr_zero_p(quo->f)) {
mpfr_round(quo->f, quo->f);
}
else {
mpfr_setsign(quo->f, quo->f, mpfr_sgn(tempx->f) * mpfr_sgn(tempy->f) - 1, MPFR_RNDN);
}
Py_DECREF((PyObject*)temp);
}
GMPY_MPFR_CHECK_RANGE(quo, context);
GMPY_MPFR_CHECK_RANGE(rem, context);
GMPY_MPFR_SUBNORMALIZE(quo, context);
GMPY_MPFR_SUBNORMALIZE(rem, context);
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
PyTuple_SET_ITEM(result, 0, (PyObject*)quo);
PyTuple_SET_ITEM(result, 1, (PyObject*)rem);
return (PyObject*)result;
}
Py_DECREF((PyObject*)rem);
Py_DECREF((PyObject*)quo);
Py_DECREF(result);
Py_RETURN_NOTIMPLEMENTED;
error:
Py_XDECREF((PyObject*)tempx);
Py_XDECREF((PyObject*)tempy);
Py_DECREF((PyObject*)rem);
Py_DECREF((PyObject*)quo);
Py_DECREF(result);
return NULL;
}
int
main (int argc, char *argv[])
{
mpfr_t x, y;
long n;
mpfr_prec_t prec = 53;
tests_start_mpfr ();
mpfr_init (x);
mpfr_init (y);
if (argc != 1)
{
if (argc != 4)
{
printf ("Usage: tyn n x prec\n");
exit (1);
}
n = atoi (argv[1]);
prec = atoi (argv[3]);
mpfr_set_prec (x, prec);
mpfr_set_prec (y, prec);
mpfr_set_str (x, argv[2], 10, MPFR_RNDN);
mpfr_yn (y, n, x, MPFR_RNDN);
printf ("Y(%ld,", n);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
printf (")=");
mpfr_out_str (stdout, 10, 0, y, MPFR_RNDN);
printf ("\n");
goto end;
}
/* special values */
mpfr_set_nan (x);
mpfr_yn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (y));
mpfr_set_inf (x, 1); /* +Inf */
mpfr_yn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS (y));
mpfr_set_inf (x, -1); /* -Inf */
mpfr_yn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (y));
mpfr_set_ui (x, 0, MPFR_RNDN); /* +0 */
mpfr_yn (y, 0, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_NEG (y)); /* y0(+0)=-Inf */
mpfr_yn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_NEG (y)); /* y17(+0)=-Inf */
mpfr_yn (y, -17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_POS (y)); /* y(-17,+0)=+Inf */
mpfr_yn (y, -42, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_NEG (y)); /* y(-42,+0)=-Inf */
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_neg (x, x, MPFR_RNDN); /* -0 */
mpfr_yn (y, 0, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_NEG (y)); /* y0(-0)=-Inf */
mpfr_yn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_NEG (y)); /* y17(-0)=-Inf */
mpfr_yn (y, -17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_POS (y)); /* y(-17,-0)=+Inf */
mpfr_yn (y, -42, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_NEG (y)); /* y(-42,-0)=-Inf */
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_yn (y, 0, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.00010110100110000000001000100110111100110101100011011111");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=0, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_yn (y, 1, x, MPFR_RNDN);
mpfr_set_str_binary (x, "-0.110001111111110110010000001111101011001101011100101");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=1, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_yn (y, -1, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.110001111111110110010000001111101011001101011100101");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=-1, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_yn (y, 2, x, MPFR_RNDN);
mpfr_set_str_binary (x, "-1.101001101001001100100010101001000101101000010010001");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=2, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_yn (y, -2, x, MPFR_RNDN);
mpfr_set_str_binary (x, "-1.101001101001001100100010101001000101101000010010001");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=-2, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_yn (y, 17, x, MPFR_RNDN);
mpfr_set_str_binary (x, "-0.11000100111000100010101101011000110011001101100001011E60");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=17, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_yn (y, -17, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.11000100111000100010101101011000110011001101100001011E60");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=-17, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_yn (y, 1, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.00101010110011011111001100000001101011011001111111");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=1, x=17, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
end:
mpfr_clear (x);
mpfr_clear (y);
tests_end_mpfr ();
return 0;
}
static int
mpc_sin_cos_nonfinite (mpc_ptr rop_sin, mpc_ptr rop_cos, mpc_srcptr op,
mpc_rnd_t rnd_sin, mpc_rnd_t rnd_cos)
/* assumes that op (that is, its real or imaginary part) is not finite */
{
int overlap;
mpc_t op_loc;
overlap = (rop_sin == op || rop_cos == op);
if (overlap) {
mpc_init3 (op_loc, MPC_PREC_RE (op), MPC_PREC_IM (op));
mpc_set (op_loc, op, MPC_RNDNN);
}
else
op_loc [0] = op [0];
if (rop_sin != NULL) {
if (mpfr_nan_p (MPC_RE (op_loc)) || mpfr_nan_p (MPC_IM (op_loc))) {
mpc_set (rop_sin, op_loc, rnd_sin);
if (mpfr_nan_p (MPC_IM (op_loc))) {
/* sin(x +i*NaN) = NaN +i*NaN, except for x=0 */
/* sin(-0 +i*NaN) = -0 +i*NaN */
/* sin(+0 +i*NaN) = +0 +i*NaN */
if (!mpfr_zero_p (MPC_RE (op_loc)))
mpfr_set_nan (MPC_RE (rop_sin));
}
else /* op = NaN + i*y */
if (!mpfr_inf_p (MPC_IM (op_loc)) && !mpfr_zero_p (MPC_IM (op_loc)))
/* sin(NaN -i*Inf) = NaN -i*Inf */
/* sin(NaN -i*0) = NaN -i*0 */
/* sin(NaN +i*0) = NaN +i*0 */
/* sin(NaN +i*Inf) = NaN +i*Inf */
/* sin(NaN +i*y) = NaN +i*NaN, when 0<|y|<Inf */
mpfr_set_nan (MPC_IM (rop_sin));
}
else if (mpfr_inf_p (MPC_RE (op_loc))) {
mpfr_set_nan (MPC_RE (rop_sin));
if (!mpfr_inf_p (MPC_IM (op_loc)) && !mpfr_zero_p (MPC_IM (op_loc)))
/* sin(+/-Inf +i*y) = NaN +i*NaN, when 0<|y|<Inf */
mpfr_set_nan (MPC_IM (rop_sin));
else
/* sin(+/-Inf -i*Inf) = NaN -i*Inf */
/* sin(+/-Inf +i*Inf) = NaN +i*Inf */
/* sin(+/-Inf -i*0) = NaN -i*0 */
/* sin(+/-Inf +i*0) = NaN +i*0 */
mpfr_set (MPC_IM (rop_sin), MPC_IM (op_loc), MPC_RND_IM (rnd_sin));
}
else if (mpfr_zero_p (MPC_RE (op_loc))) {
/* sin(-0 -i*Inf) = -0 -i*Inf */
/* sin(+0 -i*Inf) = +0 -i*Inf */
/* sin(-0 +i*Inf) = -0 +i*Inf */
/* sin(+0 +i*Inf) = +0 +i*Inf */
mpc_set (rop_sin, op_loc, rnd_sin);
}
else {
/* sin(x -i*Inf) = +Inf*(sin(x) -i*cos(x)) */
/* sin(x +i*Inf) = +Inf*(sin(x) +i*cos(x)) */
mpfr_t s, c;
mpfr_init2 (s, 2);
mpfr_init2 (c, 2);
mpfr_sin_cos (s, c, MPC_RE (op_loc), GMP_RNDZ);
mpfr_set_inf (MPC_RE (rop_sin), MPFR_SIGN (s));
mpfr_set_inf (MPC_IM (rop_sin), MPFR_SIGN (c)*MPFR_SIGN (MPC_IM (op_loc)));
mpfr_clear (s);
mpfr_clear (c);
}
}
if (rop_cos != NULL) {
if (mpfr_nan_p (MPC_RE (op_loc))) {
/* cos(NaN + i * NaN) = NaN + i * NaN */
/* cos(NaN - i * Inf) = +Inf + i * NaN */
/* cos(NaN + i * Inf) = +Inf + i * NaN */
/* cos(NaN - i * 0) = NaN - i * 0 */
/* cos(NaN + i * 0) = NaN + i * 0 */
/* cos(NaN + i * y) = NaN + i * NaN, when y != 0 */
if (mpfr_inf_p (MPC_IM (op_loc)))
mpfr_set_inf (MPC_RE (rop_cos), +1);
else
mpfr_set_nan (MPC_RE (rop_cos));
if (mpfr_zero_p (MPC_IM (op_loc)))
mpfr_set (MPC_IM (rop_cos), MPC_IM (op_loc), MPC_RND_IM (rnd_cos));
else
mpfr_set_nan (MPC_IM (rop_cos));
}
else if (mpfr_nan_p (MPC_IM (op_loc))) {
/* cos(-Inf + i * NaN) = NaN + i * NaN */
/* cos(+Inf + i * NaN) = NaN + i * NaN */
/* cos(-0 + i * NaN) = NaN - i * 0 */
/* cos(+0 + i * NaN) = NaN + i * 0 */
/* cos(x + i * NaN) = NaN + i * NaN, when x != 0 */
if (mpfr_zero_p (MPC_RE (op_loc)))
mpfr_set (MPC_IM (rop_cos), MPC_RE (op_loc), MPC_RND_IM (rnd_cos));
else
mpfr_set_nan (MPC_IM (rop_cos));
mpfr_set_nan (MPC_RE (rop_cos));
}
else if (mpfr_inf_p (MPC_RE (op_loc))) {
/* cos(-Inf -i*Inf) = cos(+Inf +i*Inf) = -Inf +i*NaN */
/* cos(-Inf +i*Inf) = cos(+Inf -i*Inf) = +Inf +i*NaN */
/* cos(-Inf -i*0) = cos(+Inf +i*0) = NaN -i*0 */
/* cos(-Inf +i*0) = cos(+Inf -i*0) = NaN +i*0 */
/* cos(-Inf +i*y) = cos(+Inf +i*y) = NaN +i*NaN, when y != 0 */
const int same_sign =
mpfr_signbit (MPC_RE (op_loc)) == mpfr_signbit (MPC_IM (op_loc));
if (mpfr_inf_p (MPC_IM (op_loc)))
mpfr_set_inf (MPC_RE (rop_cos), (same_sign ? -1 : +1));
else
mpfr_set_nan (MPC_RE (rop_cos));
if (mpfr_zero_p (MPC_IM (op_loc)))
mpfr_setsign (MPC_IM (rop_cos), MPC_IM (op_loc), same_sign,
MPC_RND_IM(rnd_cos));
else
mpfr_set_nan (MPC_IM (rop_cos));
}
else if (mpfr_zero_p (MPC_RE (op_loc))) {
/* cos(-0 -i*Inf) = cos(+0 +i*Inf) = +Inf -i*0 */
/* cos(-0 +i*Inf) = cos(+0 -i*Inf) = +Inf +i*0 */
const int same_sign =
mpfr_signbit (MPC_RE (op_loc)) == mpfr_signbit (MPC_IM (op_loc));
mpfr_setsign (MPC_IM (rop_cos), MPC_RE (op_loc), same_sign,
MPC_RND_IM (rnd_cos));
mpfr_set_inf (MPC_RE (rop_cos), +1);
}
else {
/* cos(x -i*Inf) = +Inf*cos(x) +i*Inf*sin(x), when x != 0 */
/* cos(x +i*Inf) = +Inf*cos(x) -i*Inf*sin(x), when x != 0 */
mpfr_t s, c;
mpfr_init2 (c, 2);
mpfr_init2 (s, 2);
mpfr_sin_cos (s, c, MPC_RE (op_loc), GMP_RNDN);
mpfr_set_inf (MPC_RE (rop_cos), mpfr_sgn (c));
mpfr_set_inf (MPC_IM (rop_cos),
(mpfr_sgn (MPC_IM (op_loc)) == mpfr_sgn (s) ? -1 : +1));
mpfr_clear (s);
mpfr_clear (c);
}
}
if (overlap)
mpc_clear (op_loc);
return MPC_INEX12 (MPC_INEX (0,0), MPC_INEX (0,0));
/* everything is exact */
}
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;
long n;
if (argc > 1)
{
mpfr_init2 (x, atoi (argv[1]));
mpfr_set_str (x, argv[3], 10, MPFR_RNDN);
mpfr_jn (x, atoi (argv[2]), x, MPFR_RNDN);
mpfr_out_str (stdout, 10, 10, x, MPFR_RNDN);
printf ("\n");
mpfr_clear (x);
return 0;
}
tests_start_mpfr ();
mpfr_init (x);
mpfr_init (y);
/* special values */
mpfr_set_nan (x);
mpfr_jn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (y));
mpfr_set_inf (x, 1); /* +Inf */
mpfr_jn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS (y));
mpfr_set_inf (x, -1); /* -Inf */
mpfr_jn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS (y));
mpfr_set_ui (x, 0, MPFR_RNDN); /* +0 */
mpfr_jn (y, 0, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 1) == 0); /* j0(+0)=1 */
mpfr_jn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS (y)); /* j17(+0)=+0 */
mpfr_jn (y, -17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_NEG (y)); /* j-17(+0)=-0 */
mpfr_jn (y, 42, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS (y)); /* j42(+0)=+0 */
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_neg (x, x, MPFR_RNDN); /* -0 */
mpfr_jn (y, 0, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 1) == 0); /* j0(-0)=1 */
mpfr_jn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_NEG (y)); /* j17(-0)=-0 */
mpfr_jn (y, -17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS (y)); /* j-17(-0)=+0 */
mpfr_jn (y, 42, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS (y)); /* j42(-0)=+0 */
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_jn (y, 0, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.1100001111100011111111101101111010111101110001111");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=0, 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_jn (y, 0, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.1100001111100011111111101101111010111101110001111");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=0, x=-1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_jn (y, 1, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.0111000010100111001001111011101001011100001100011011");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=1, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_jn (y, 17, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.1100011111001010101001001001000110110000010001011E-65");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=17, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_jn (y, 42, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.10000111100011010100111011100111101101000100000001001E-211");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=42, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_jn (y, -42, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.10000111100011010100111011100111101101000100000001001E-211");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=-42, 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_jn (y, 42, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.10000111100011010100111011100111101101000100000001001E-211");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=42, 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_jn (y, -42, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.10000111100011010100111011100111101101000100000001001E-211");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=-42, x=-1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_jn (y, 4, x, MPFR_RNDN);
mpfr_set_str_binary (x, "-0.0001110001011001100010100111100111100000111110111011111");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=4, x=17, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_jn (y, 16, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.0011101111100111101111010100000111111001111001001010011");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=16, x=17, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_jn (y, 256, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.11111101111100110000000010111101101011101011110001011E-894");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=256, x=17, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_jn (y, 65536, x, MPFR_RNDN);
mpfr_set_str_binary (x, "100010010010011010110101100001000100011100010111011E-751747");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=65536, x=17, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_jn (y, 131072, x, MPFR_RNDN);
mpfr_set_str_binary (x, "1000001001110011111001110110000010011010000001001101E-1634508");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=131072, x=17, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_jn (y, 262144, x, MPFR_RNDN);
mpfr_set_str_binary (x, "1010011011000100111011001011110001000010000010111111E-3531100");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=262144, x=17, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_jn (y, 524288, x, MPFR_RNDN);
mpfr_set_str_binary (x, "110000001010001111011011000011001011010100010001011E-7586426");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=524288, x=17, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
n = LONG_MAX;
/* ensures n is odd */
if (n % 2 == 0)
n --;
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_jn (y, n, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.0");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=%ld, x=17, rnd=MPFR_RNDN\n", n);
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_si (x, -17, MPFR_RNDN);
mpfr_jn (y, n, x, MPFR_RNDN);
mpfr_set_str_binary (x, "-0.0");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=%ld, x=-17, rnd=MPFR_RNDN\n", n);
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_jn (y, -n, x, MPFR_RNDN);
mpfr_set_str_binary (x, "-0.0");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=%ld, x=17, rnd=MPFR_RNDN\n", -n);
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_si (x, -17, MPFR_RNDN);
mpfr_jn (y, -n, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.0");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_jn for n=%ld, x=-17, rnd=MPFR_RNDN\n", -n);
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
tests_end_mpfr ();
return 0;
}
static int
decimal (void)
{
mpfr_prec_t p = 128;
mpfr_t x;
mpfr_t z;
mpfr_init (z);
mpfr_init2 (x, p);
/* specifier 'P' for precision */
check_vsprintf ("128", "%Pu", p);
check_vsprintf ("00128", "%.5Pu", p);
/* special numbers */
mpfr_set_inf (x, 1);
check_sprintf (pinf_str, "%Re", x);
check_sprintf (pinf_str, "%RUe", x);
check_sprintf (pinf_uc_str, "%RE", x);
check_sprintf (pinf_uc_str, "%RDE", x);
check_sprintf (pinf_str, "%Rf", x);
check_sprintf (pinf_str, "%RYf", x);
check_sprintf (pinf_uc_str, "%RF", x);
check_sprintf (pinf_uc_str, "%RZF", x);
check_sprintf (pinf_str, "%Rg", x);
check_sprintf (pinf_str, "%RNg", x);
check_sprintf (pinf_uc_str, "%RG", x);
check_sprintf (pinf_uc_str, "%RUG", x);
check_sprintf (" inf", "%010Re", x);
check_sprintf (" inf", "%010RDe", x);
mpfr_set_inf (x, -1);
check_sprintf (minf_str, "%Re", x);
check_sprintf (minf_str, "%RYe", x);
check_sprintf (minf_uc_str, "%RE", x);
check_sprintf (minf_uc_str, "%RZE", x);
check_sprintf (minf_str, "%Rf", x);
check_sprintf (minf_str, "%RNf", x);
check_sprintf (minf_uc_str, "%RF", x);
check_sprintf (minf_uc_str, "%RUF", x);
check_sprintf (minf_str, "%Rg", x);
check_sprintf (minf_str, "%RDg", x);
check_sprintf (minf_uc_str, "%RG", x);
check_sprintf (minf_uc_str, "%RYG", x);
check_sprintf (" -inf", "%010Re", x);
check_sprintf (" -inf", "%010RZe", x);
mpfr_set_nan (x);
check_sprintf (nan_str, "%Re", x);
check_sprintf (nan_str, "%RNe", x);
check_sprintf (nan_uc_str, "%RE", x);
check_sprintf (nan_uc_str, "%RUE", x);
check_sprintf (nan_str, "%Rf", x);
check_sprintf (nan_str, "%RDf", x);
check_sprintf (nan_uc_str, "%RF", x);
check_sprintf (nan_uc_str, "%RYF", x);
check_sprintf (nan_str, "%Rg", x);
check_sprintf (nan_str, "%RZg", x);
check_sprintf (nan_uc_str, "%RG", x);
check_sprintf (nan_uc_str, "%RNG", x);
check_sprintf (" nan", "%010Re", x);
/* positive numbers */
mpfr_set_str (x, "18993474.61279296875", 10, MPFR_RNDN);
mpfr_set_ui (z, 0, MPFR_RNDD);
/* simplest case right justified */
check_sprintf (" 1.899347461279296875e+07", "%30Re", x);
check_sprintf (" 2e+07", "%30.0Re", x);
check_sprintf (" 18993474.612793", "%30Rf", x);
check_sprintf (" 18993474.6127930", "%30.7Rf", x);
check_sprintf (" 1.89935e+07", "%30Rg", x);
check_sprintf (" 2e+07", "%30.0Rg", x);
check_sprintf (" 18993474.61279296875", "%30.19Rg", x);
check_sprintf (" 0e+00", "%30.0Re", z);
check_sprintf (" 0", "%30.0Rf", z);
check_sprintf (" 0.0000", "%30.4Rf", z);
check_sprintf (" 0", "%30.0Rg", z);
check_sprintf (" 0", "%30.4Rg", z);
/* sign or space, pad with leading zeros */
check_sprintf (" 000001.899347461279296875E+07", "% 030RE", x);
check_sprintf (" 0000000000000000001.89935E+07", "% 030RG", x);
check_sprintf (" 0000000000000000000000002E+07", "% 030.0RE", x);
check_sprintf (" 0000000000000000000000000E+00", "% 030.0RE", z);
check_sprintf (" 00000000000000000000000000000", "% 030.0RF", z);
/* sign + or -, left justified */
check_sprintf ("+1.899347461279296875e+07 ", "%+-30Re", x);
check_sprintf ("+2e+07 ", "%+-30.0Re", x);
check_sprintf ("+0e+00 ", "%+-30.0Re", z);
check_sprintf ("+0 ", "%+-30.0Rf", z);
/* decimal point, left justified, precision and rounding parameter */
check_vsprintf ("1.9E+07 ", "%#-10.*R*E", 1, MPFR_RNDN, x);
check_vsprintf ("2.E+07 ", "%#*.*R*E", -10, 0, MPFR_RNDN, x);
check_vsprintf ("2.E+07 ", "%#-10.*R*G", 0, MPFR_RNDN, x);
check_vsprintf ("0.E+00 ", "%#-10.*R*E", 0, MPFR_RNDN, z);
check_vsprintf ("0. ", "%#-10.*R*F", 0, MPFR_RNDN, z);
check_vsprintf ("0. ", "%#-10.*R*G", 0, MPFR_RNDN, z);
/* sign or space */
check_sprintf (" 1.899e+07", "% .3RNe", x);
check_sprintf (" 2e+07", "% .0RNe", x);
/* sign + or -, decimal point, pad with leading zeros */
check_sprintf ("+0001.8E+07", "%0+#11.1RZE", x);
check_sprintf ("+00001.E+07", "%0+#11.0RZE", x);
check_sprintf ("+0000.0E+00", "%0+#11.1RZE", z);
check_sprintf ("+00000000.0", "%0+#11.1RZF", z);
/* pad with leading zero */
check_sprintf ("0000001.899347461279296875e+07", "%030RDe", x);
check_sprintf ("00000000000000000000000001e+07", "%030.0RDe", x);
/* sign or space, decimal point, left justified */
check_sprintf (" 1.8E+07 ", "%- #11.1RDE", x);
check_sprintf (" 1.E+07 ", "%- #11.0RDE", x);
/* negative numbers */
mpfr_mul_si (x, x, -1, MPFR_RNDD);
mpfr_mul_si (z, z, -1, MPFR_RNDD);
/* sign + or - */
check_sprintf (" -1.8e+07", "%+10.1RUe", x);
check_sprintf (" -1e+07", "%+10.0RUe", x);
check_sprintf (" -0e+00", "%+10.0RUe", z);
check_sprintf (" -0", "%+10.0RUf", z);
/* neighborhood of 1 */
mpfr_set_str (x, "0.99993896484375", 10, MPFR_RNDN);
check_sprintf ("9.9993896484375E-01 ", "%-20RE", x);
check_sprintf ("9.9993896484375E-01 ", "%-20.RE", x);
check_sprintf ("1E+00 ", "%-20.0RE", x);
check_sprintf ("1.0E+00 ", "%-20.1RE", x);
check_sprintf ("1.00E+00 ", "%-20.2RE", x);
check_sprintf ("9.999E-01 ", "%-20.3RE", x);
check_sprintf ("9.9994E-01 ", "%-20.4RE", x);
check_sprintf ("0.999939 ", "%-20RF", x);
check_sprintf ("0.999939 ", "%-20.RF", x);
check_sprintf ("1 ", "%-20.0RF", x);
check_sprintf ("1.0 ", "%-20.1RF", x);
check_sprintf ("1.00 ", "%-20.2RF", x);
check_sprintf ("1.000 ", "%-20.3RF", x);
check_sprintf ("0.9999 ", "%-20.4RF", x);
check_sprintf ("0.999939 ", "%-#20RF", x);
check_sprintf ("0.999939 ", "%-#20.RF", x);
check_sprintf ("1. ", "%-#20.0RF", x);
check_sprintf ("1.0 ", "%-#20.1RF", x);
check_sprintf ("1.00 ", "%-#20.2RF", x);
check_sprintf ("1.000 ", "%-#20.3RF", x);
check_sprintf ("0.9999 ", "%-#20.4RF", x);
check_sprintf ("1 ", "%-20.0RG", x);
check_sprintf ("1 ", "%-20.1RG", x);
check_sprintf ("1 ", "%-20.2RG", x);
check_sprintf ("1 ", "%-20.3RG", x);
check_sprintf ("0.9999 ", "%-20.4RG", x);
check_sprintf ("0.999939 ", "%-#20RG", x);
check_sprintf ("0.999939 ", "%-#20.RG", x);
check_sprintf ("1. ", "%-#20.0RG", x);
check_sprintf ("1. ", "%-#20.1RG", x);
check_sprintf ("1.0 ", "%-#20.2RG", x);
check_sprintf ("1.00 ", "%-#20.3RG", x);
check_sprintf ("0.9999 ", "%-#20.4RG", x);
/* multiple of 10 */
mpfr_set_str (x, "1e17", 10, MPFR_RNDN);
check_sprintf ("1e+17", "%Re", x);
check_sprintf ("1.000e+17", "%.3Re", x);
check_sprintf ("100000000000000000", "%.0Rf", x);
check_sprintf ("100000000000000000.0", "%.1Rf", x);
check_sprintf ("100000000000000000.000000", "%'Rf", x);
check_sprintf ("100000000000000000.0", "%'.1Rf", x);
mpfr_ui_div (x, 1, x, MPFR_RNDN); /* x=1e-17 */
check_sprintf ("1e-17", "%Re", x);
check_sprintf ("0.000000", "%Rf", x);
check_sprintf ("1e-17", "%Rg", x);
check_sprintf ("0.0", "%.1RDf", x);
check_sprintf ("0.0", "%.1RZf", x);
check_sprintf ("0.1", "%.1RUf", x);
check_sprintf ("0.1", "%.1RYf", x);
check_sprintf ("0", "%.0RDf", x);
check_sprintf ("0", "%.0RZf", x);
check_sprintf ("1", "%.0RUf", x);
check_sprintf ("1", "%.0RYf", x);
/* multiple of 10 with 'g' style */
mpfr_set_str (x, "10", 10, MPFR_RNDN);
check_sprintf ("10", "%Rg", x);
check_sprintf ("1e+01", "%.0Rg", x);
check_sprintf ("1e+01", "%.1Rg", x);
check_sprintf ("10", "%.2Rg", x);
mpfr_ui_div (x, 1, x, MPFR_RNDN);
check_sprintf ("0.1", "%Rg", x);
check_sprintf ("0.1", "%.0Rg", x);
check_sprintf ("0.1", "%.1Rg", x);
mpfr_set_str (x, "1000", 10, MPFR_RNDN);
check_sprintf ("1000", "%Rg", x);
check_sprintf ("1e+03", "%.0Rg", x);
check_sprintf ("1e+03", "%.3Rg", x);
check_sprintf ("1000", "%.4Rg", x);
mpfr_ui_div (x, 1, x, MPFR_RNDN);
check_sprintf ("0.001", "%Rg", x);
check_sprintf ("0.001", "%.0Rg", x);
check_sprintf ("0.001", "%.1Rg", x);
mpfr_set_str (x, "100000", 10, MPFR_RNDN);
check_sprintf ("100000", "%Rg", x);
check_sprintf ("1e+05", "%.0Rg", x);
check_sprintf ("1e+05", "%.5Rg", x);
check_sprintf ("100000", "%.6Rg", x);
mpfr_ui_div (x, 1, x, MPFR_RNDN);
check_sprintf ("1e-05", "%Rg", x);
check_sprintf ("1e-05", "%.0Rg", x);
check_sprintf ("1e-05", "%.1Rg", x);
/* check rounding mode */
mpfr_set_str (x, "0.0076", 10, MPFR_RNDN);
check_sprintf ("0.007", "%.3RDF", x);
check_sprintf ("0.007", "%.3RZF", x);
check_sprintf ("0.008", "%.3RF", x);
check_sprintf ("0.008", "%.3RUF", x);
check_sprintf ("0.008", "%.3RYF", x);
check_vsprintf ("0.008", "%.3R*F", MPFR_RNDA, x);
/* check limit between %f-style and %g-style */
mpfr_set_str (x, "0.0000999", 10, MPFR_RNDN);
check_sprintf ("0.0001", "%.0Rg", x);
check_sprintf ("9e-05", "%.0RDg", x);
check_sprintf ("0.0001", "%.1Rg", x);
check_sprintf ("0.0001", "%.2Rg", x);
check_sprintf ("9.99e-05", "%.3Rg", x);
/* trailing zeros */
mpfr_set_si_2exp (x, -1, -15, MPFR_RNDN); /* x=-2^-15 */
check_sprintf ("-3.0517578125e-05", "%.30Rg", x);
check_sprintf ("-3.051757812500000000000000000000e-05", "%.30Re", x);
check_sprintf ("-3.05175781250000000000000000000e-05", "%#.30Rg", x);
check_sprintf ("-0.000030517578125000000000000000", "%.30Rf", x);
/* bug 20081023 */
check_sprintf ("-3.0517578125e-05", "%.30Rg", x);
mpfr_set_str (x, "1.9999", 10, MPFR_RNDN);
check_sprintf ("1.999900 ", "%-#10.7RG", x);
check_sprintf ("1.9999 ", "%-10.7RG", x);
mpfr_set_ui (x, 1, MPFR_RNDN);
check_sprintf ("1.00000000000000000000000000000", "%#.30Rg", x);
check_sprintf ("1", "%.30Rg", x);
mpfr_set_ui (x, 0, MPFR_RNDN);
check_sprintf ("0.000000000000000000000000000000", "%#.30Rg", x);
check_sprintf ("0", "%.30Rg", x);
/* following tests with precision 53 bits */
mpfr_set_prec (x, 53);
/* Exponent zero has a plus sign */
mpfr_set_str (x, "-9.95645044213728791504536275169812142849e-01", 10,
MPFR_RNDN);
check_sprintf ("-1.0e+00", "%- #0.1Re", x);
/* Decimal point and no figure after it with '#' flag and 'G' style */
mpfr_set_str (x, "-9.90597761233942053494e-01", 10, MPFR_RNDN);
check_sprintf ("-1.", "%- #0.1RG", x);
/* precision zero */
mpfr_set_d (x, 9.5, MPFR_RNDN);
check_sprintf ("9", "%.0RDf", x);
check_sprintf ("10", "%.0RUf", x);
mpfr_set_d (x, 19.5, MPFR_RNDN);
check_sprintf ("19", "%.0RDf", x);
check_sprintf ("20", "%.0RUf", x);
mpfr_set_d (x, 99.5, MPFR_RNDN);
check_sprintf ("99", "%.0RDf", x);
check_sprintf ("100", "%.0RUf", x);
mpfr_set_d (x, -9.5, MPFR_RNDN);
check_sprintf ("-10", "%.0RDf", x);
check_sprintf ("-10", "%.0RYf", x);
check_sprintf ("-10", "%.0Rf", x);
check_sprintf ("-1e+01", "%.0Re", x);
check_sprintf ("-1e+01", "%.0Rg", x);
mpfr_set_ui_2exp (x, 1, -1, MPFR_RNDN);
check_sprintf ("0", "%.0Rf", x);
check_sprintf ("5e-01", "%.0Re", x);
check_sprintf ("0.5", "%.0Rg", x);
mpfr_set_ui_2exp (x, 3, -1, MPFR_RNDN);
check_sprintf ("2", "%.0Rf", x);
mpfr_set_ui_2exp (x, 5, -1, MPFR_RNDN);
check_sprintf ("2", "%.0Rf", x);
mpfr_set_ui (x, 0x1f, MPFR_RNDN);
check_sprintf ("0x1p+5", "%.0Ra", x);
mpfr_set_ui (x, 3, MPFR_RNDN);
check_sprintf ("1p+2", "%.0Rb", x);
/* round to next ten power with %f but not with %g */
mpfr_set_str (x, "-6.64464380544039223686e-02", 10, MPFR_RNDN);
check_sprintf ("-0.1", "%.1Rf", x);
check_sprintf ("-0.0", "%.1RZf", x);
check_sprintf ("-0.07", "%.1Rg", x);
check_sprintf ("-0.06", "%.1RZg", x);
/* round to next ten power and do not remove trailing zeros */
mpfr_set_str (x, "9.98429393291486722006e-02", 10, MPFR_RNDN);
check_sprintf ("0.1", "%#.1Rg", x);
check_sprintf ("0.10", "%#.2Rg", x);
check_sprintf ("0.099", "%#.2RZg", x);
/* Halfway cases */
mpfr_set_str (x, "1.5", 10, MPFR_RNDN);
check_sprintf ("2e+00", "%.0Re", x);
mpfr_set_str (x, "2.5", 10, MPFR_RNDN);
check_sprintf ("2e+00", "%.0Re", x);
mpfr_set_str (x, "9.5", 10, MPFR_RNDN);
check_sprintf ("1e+01", "%.0Re", x);
mpfr_set_str (x, "1.25", 10, MPFR_RNDN);
check_sprintf ("1.2e+00", "%.1Re", x);
mpfr_set_str (x, "1.75", 10, MPFR_RNDN);
check_sprintf ("1.8e+00", "%.1Re", x);
mpfr_set_str (x, "-0.5", 10, MPFR_RNDN);
check_sprintf ("-0", "%.0Rf", x);
mpfr_set_str (x, "1.25", 10, MPFR_RNDN);
check_sprintf ("1.2", "%.1Rf", x);
mpfr_set_str (x, "1.75", 10, MPFR_RNDN);
check_sprintf ("1.8", "%.1Rf", x);
mpfr_set_str (x, "1.5", 10, MPFR_RNDN);
check_sprintf ("2", "%.1Rg", x);
mpfr_set_str (x, "2.5", 10, MPFR_RNDN);
check_sprintf ("2", "%.1Rg", x);
mpfr_set_str (x, "9.25", 10, MPFR_RNDN);
check_sprintf ("9.2", "%.2Rg", x);
mpfr_set_str (x, "9.75", 10, MPFR_RNDN);
check_sprintf ("9.8", "%.2Rg", x);
/* assertion failure in r6320 */
mpfr_set_str (x, "-9.996", 10, MPFR_RNDN);
check_sprintf ("-10.0", "%.1Rf", x);
mpfr_clears (x, z, (mpfr_ptr) 0);
return 0;
}
static void
special (void)
{
mpfr_t x, y;
int i;
mpfr_init (x);
mpfr_init (y);
/* root(NaN) = NaN */
mpfr_set_nan (x);
mpfr_root (y, x, 17, MPFR_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error: root(NaN,17) <> NaN\n");
exit (1);
}
/* root(+Inf) = +Inf */
mpfr_set_inf (x, 1);
mpfr_root (y, x, 42, MPFR_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error: root(+Inf,42) <> +Inf\n");
exit (1);
}
/* root(-Inf, 17) = -Inf */
mpfr_set_inf (x, -1);
mpfr_root (y, x, 17, MPFR_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) > 0)
{
printf ("Error: root(-Inf,17) <> -Inf\n");
exit (1);
}
/* root(-Inf, 42) = NaN */
mpfr_set_inf (x, -1);
mpfr_root (y, x, 42, MPFR_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error: root(-Inf,42) <> -Inf\n");
exit (1);
}
/* root(+/-0) = +/-0 */
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_root (y, x, 17, MPFR_RNDN);
if (mpfr_cmp_ui (y, 0) || mpfr_sgn (y) < 0)
{
printf ("Error: root(+0,17) <> +0\n");
exit (1);
}
mpfr_neg (x, x, MPFR_RNDN);
mpfr_root (y, x, 42, MPFR_RNDN);
if (mpfr_cmp_ui (y, 0) || mpfr_sgn (y) > 0)
{
printf ("Error: root(-0,42) <> -0\n");
exit (1);
}
mpfr_set_prec (x, 53);
mpfr_set_str (x, "8.39005285514734966412e-01", 10, MPFR_RNDN);
mpfr_root (x, x, 3, MPFR_RNDN);
if (mpfr_cmp_str1 (x, "9.43166207799662426048e-01"))
{
printf ("Error in root3 (1)\n");
printf ("expected 9.43166207799662426048e-01\n");
printf ("got ");
mpfr_dump (x);
exit (1);
}
mpfr_set_prec (x, 32);
mpfr_set_prec (y, 32);
mpfr_set_str_binary (x, "0.10000100001100101001001001011001");
mpfr_root (x, x, 3, MPFR_RNDN);
mpfr_set_str_binary (y, "0.11001101011000100111000111111001");
if (mpfr_cmp (x, y))
{
printf ("Error in root3 (2)\n");
exit (1);
}
mpfr_set_prec (x, 32);
mpfr_set_prec (y, 32);
mpfr_set_str_binary (x, "-0.1100001110110000010101011001011");
mpfr_root (x, x, 3, MPFR_RNDD);
mpfr_set_str_binary (y, "-0.11101010000100100101000101011001");
if (mpfr_cmp (x, y))
{
printf ("Error in root3 (3)\n");
exit (1);
}
mpfr_set_prec (x, 82);
mpfr_set_prec (y, 27);
mpfr_set_str_binary (x, "0.1010001111011101011011000111001011001101100011110110010011011011011010011001100101e-7");
mpfr_root (y, x, 3, MPFR_RNDD);
mpfr_set_str_binary (x, "0.101011110001110001000100011E-2");
if (mpfr_cmp (x, y))
{
printf ("Error in root3 (4)\n");
exit (1);
}
mpfr_set_prec (x, 204);
mpfr_set_prec (y, 38);
mpfr_set_str_binary (x, "0.101000000001101000000001100111111011111001110110100001111000100110100111001101100111110001110001011011010110010011100101111001111100001010010100111011101100000011011000101100010000000011000101001010001001E-5");
mpfr_root (y, x, 3, MPFR_RNDD);
mpfr_set_str_binary (x, "0.10001001111010011011101000010110110010E-1");
if (mpfr_cmp (x, y))
{
printf ("Error in root3 (5)\n");
exit (1);
}
/* Worst case found on 2006-11-25 */
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str_binary (x, "1.0100001101101101001100110001001000000101001101100011E28");
mpfr_root (y, x, 35, MPFR_RNDN);
mpfr_set_str_binary (x, "1.1100000010110101100011101011000010100001101100100011E0");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_root (y, x, 35, MPFR_RNDN) for\n"
"x = 1.0100001101101101001100110001001000000101001101100011E28\n"
"Expected ");
mpfr_dump (x);
printf ("Got ");
mpfr_dump (y);
exit (1);
}
/* Worst cases found on 2006-11-26 */
mpfr_set_str_binary (x, "1.1111010011101110001111010110000101110000110110101100E17");
mpfr_root (y, x, 36, MPFR_RNDD);
mpfr_set_str_binary (x, "1.0110100111010001101001010111001110010100111111000010E0");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_root (y, x, 36, MPFR_RNDD) for\n"
"x = 1.1111010011101110001111010110000101110000110110101100E17\n"
"Expected ");
mpfr_dump (x);
printf ("Got ");
mpfr_dump (y);
exit (1);
}
mpfr_set_str_binary (x, "1.1100011101101101100010110001000001110001111110010000E23");
mpfr_root (y, x, 36, MPFR_RNDU);
mpfr_set_str_binary (x, "1.1001010100001110000110111111100011011101110011000100E0");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_root (y, x, 36, MPFR_RNDU) for\n"
"x = 1.1100011101101101100010110001000001110001111110010000E23\n"
"Expected ");
mpfr_dump (x);
printf ("Got ");
mpfr_dump (y);
exit (1);
}
/* Check for k = 1 */
mpfr_set_ui (x, 17, MPFR_RNDN);
i = mpfr_root (y, x, 1, MPFR_RNDN);
if (mpfr_cmp_ui (x, 17) || i != 0)
{
printf ("Error in root (17^(1/1))\n");
exit (1);
}
#if 0
/* Check for k == 0:
For 0 <= x < 1 => +0.
For x = 1 => 1.
For x > 1, => +Inf.
For x < 0 => NaN. */
i = mpfr_root (y, x, 0, MPFR_RNDN);
if (!MPFR_IS_INF (y) || !MPFR_IS_POS (y) || i != 0)
{
printf ("Error in root 17^(1/0)\n");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
i = mpfr_root (y, x, 0, MPFR_RNDN);
if (mpfr_cmp_ui (y, 1) || i != 0)
{
printf ("Error in root 1^(1/0)\n");
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN);
i = mpfr_root (y, x, 0, MPFR_RNDN);
if (!MPFR_IS_ZERO (y) || !MPFR_IS_POS (y) || i != 0)
{
printf ("Error in root 0+^(1/0)\n");
exit (1);
}
MPFR_CHANGE_SIGN (x);
i = mpfr_root (y, x, 0, MPFR_RNDN);
if (!MPFR_IS_ZERO (y) || !MPFR_IS_POS (y) || i != 0)
{
printf ("Error in root 0-^(1/0)\n");
exit (1);
}
mpfr_set_ui_2exp (x, 17, -5, MPFR_RNDD);
i = mpfr_root (y, x, 0, MPFR_RNDN);
if (!MPFR_IS_ZERO (y) || !MPFR_IS_POS (y) || i != 0)
{
printf ("Error in root (17/2^5)^(1/0)\n");
exit (1);
}
#endif
mpfr_set_ui (x, 0, MPFR_RNDN);
i = mpfr_root (y, x, 0, MPFR_RNDN);
if (!MPFR_IS_NAN (y) || i != 0)
{
printf ("Error in root 0+^(1/0)\n");
exit (1);
}
/* Check for k==2 */
mpfr_set_si (x, -17, MPFR_RNDD);
i = mpfr_root (y, x, 2, MPFR_RNDN);
if (!MPFR_IS_NAN (y) || i != 0)
{
printf ("Error in root (-17)^(1/2)\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
static int
hexadecimal (void)
{
mpfr_t x, z;
mpfr_inits2 (64, x, z, (mpfr_ptr) 0);
/* special */
mpfr_set_inf (x, 1);
check_sprintf (pinf_str, "%Ra", x);
check_sprintf (pinf_str, "%RUa", x);
check_sprintf (pinf_str, "%RDa", x);
check_sprintf (pinf_uc_str, "%RA", x);
check_sprintf (pinf_uc_str, "%RYA", x);
check_sprintf (pinf_uc_str, "%RZA", x);
check_sprintf (pinf_uc_str, "%RNA", x);
mpfr_set_inf (x, -1);
check_sprintf (minf_str, "%Ra", x);
check_sprintf (minf_str, "%RYa", x);
check_sprintf (minf_str, "%RZa", x);
check_sprintf (minf_str, "%RNa", x);
check_sprintf (minf_uc_str, "%RA", x);
check_sprintf (minf_uc_str, "%RUA", x);
check_sprintf (minf_uc_str, "%RDA", x);
mpfr_set_nan (x);
check_sprintf (nan_str, "%Ra", x);
check_sprintf (nan_uc_str, "%RA", x);
/* regular numbers */
mpfr_set_str (x, "FEDCBA9.87654321", 16, MPFR_RNDN);
mpfr_set_ui (z, 0, MPFR_RNDZ);
/* simplest case right justified */
check_sprintf (" 0xf.edcba987654321p+24", "%25Ra", x);
check_sprintf (" 0xf.edcba987654321p+24", "%25RUa", x);
check_sprintf (" 0xf.edcba987654321p+24", "%25RDa", x);
check_sprintf (" 0xf.edcba987654321p+24", "%25RYa", x);
check_sprintf (" 0xf.edcba987654321p+24", "%25RZa", x);
check_sprintf (" 0xf.edcba987654321p+24", "%25RNa", x);
check_sprintf (" 0x1p+28", "%25.0Ra", x);
check_sprintf (" 0x0p+0", "%25.0Ra", z);
/* sign or space, pad with leading zeros */
check_sprintf (" 0X00F.EDCBA987654321P+24", "% 025RA", x);
check_sprintf (" 0X000000000000000001P+28", "% 025.0RA", x);
check_sprintf (" 0X0000000000000000000P+0", "% 025.0RA", z);
/* sign + or -, left justified */
check_sprintf ("+0xf.edcba987654321p+24 ", "%+-25Ra", x);
check_sprintf ("+0x1p+28 ", "%+-25.0Ra", x);
check_sprintf ("+0x0p+0 ", "%+-25.0Ra", z);
/* decimal point, left justified, precision and rounding parameter */
check_vsprintf ("0XF.FP+24 ", "%#-10.*R*A", 1, MPFR_RNDN, x);
check_vsprintf ("0X1.P+28 ", "%#-10.*R*A", 0, MPFR_RNDN, x);
check_vsprintf ("0X0.P+0 ", "%#-10.*R*A", 0, MPFR_RNDN, z);
/* sign or space */
check_sprintf (" 0xf.eddp+24", "% .3RNa", x);
check_sprintf (" 0x1p+28", "% .0RNa", x);
/* sign + or -, decimal point, pad with leading zeros */
check_sprintf ("+0X0F.EP+24", "%0+#11.1RZA", x);
check_sprintf ("+0X00F.P+24", "%0+#11.0RZA", x);
check_sprintf ("+0X000.0P+0", "%0+#11.1RZA", z);
/* pad with leading zero */
check_sprintf ("0x0000f.edcba987654321p+24", "%026RDa", x);
check_sprintf ("0x0000000000000000000fp+24", "%026.0RDa", x);
/* sign or space, decimal point, left justified */
check_sprintf (" 0XF.EP+24 " , "%- #11.1RDA", x);
check_sprintf (" 0XF.P+24 " , "%- #11.0RDA", x);
mpfr_mul_si (x, x, -1, MPFR_RNDD);
mpfr_mul_si (z, z, -1, MPFR_RNDD);
/* sign + or - */
check_sprintf ("-0xf.ep+24", "%+10.1RUa", x);
check_sprintf (" -0xfp+24", "%+10.0RUa", x);
check_sprintf (" -0x0p+0", "%+10.0RUa", z);
/* rounding bit is zero */
mpfr_set_str (x, "0xF.7", 16, MPFR_RNDN);
check_sprintf ("0XFP+0", "%.0RNA", x);
/* tie case in round to nearest mode */
mpfr_set_str (x, "0x0.8800000000000000p+3", 16, MPFR_RNDN);
check_sprintf ("0x9.p-1", "%#.0RNa", x);
mpfr_set_str (x, "-0x0.9800000000000000p+3", 16, MPFR_RNDN);
check_sprintf ("-0xap-1", "%.0RNa", x);
/* trailing zeros in fractional part */
check_sprintf ("-0X4.C0000000000000000000P+0", "%.20RNA", x);
/* rounding bit is one and the first non zero bit is far away */
mpfr_set_prec (x, 1024);
mpfr_set_ui_2exp (x, 29, -1, MPFR_RNDN);
mpfr_nextabove (x);
check_sprintf ("0XFP+0", "%.0RNA", x);
/* with more than one limb */
mpfr_set_prec (x, 300);
mpfr_set_str (x, "0xf.ffffffffffffffffffffffffffffffffffffffffffffffffffff"
"fffffffffffffffff", 16, MPFR_RNDN);
check_sprintf ("0x1p+4 [300]", "%.0RNa [300]", x);
check_sprintf ("0xfp+0 [300]", "%.0RZa [300]", x);
check_sprintf ("0x1p+4 [300]", "%.0RYa [300]", x);
check_sprintf ("0xfp+0 [300]", "%.0RDa [300]", x);
check_sprintf ("0x1p+4 [300]", "%.0RUa [300]", x);
check_sprintf ("0x1.0000000000000000000000000000000000000000p+4",
"%.40RNa", x);
check_sprintf ("0xf.ffffffffffffffffffffffffffffffffffffffffp+0",
"%.40RZa", x);
check_sprintf ("0x1.0000000000000000000000000000000000000000p+4",
"%.40RYa", x);
check_sprintf ("0xf.ffffffffffffffffffffffffffffffffffffffffp+0",
"%.40RDa", x);
check_sprintf ("0x1.0000000000000000000000000000000000000000p+4",
"%.40RUa", x);
mpfr_set_str (x, "0xf.7fffffffffffffffffffffffffffffffffffffffffffffffffff"
"ffffffffffffffffff", 16, MPFR_RNDN);
check_sprintf ("0XFP+0", "%.0RNA", x);
check_sprintf ("0XFP+0", "%.0RZA", x);
check_sprintf ("0X1P+4", "%.0RYA", x);
check_sprintf ("0XFP+0", "%.0RDA", x);
check_sprintf ("0X1P+4", "%.0RUA", x);
check_sprintf ("0XF.8P+0", "%.1RNA", x);
check_sprintf ("0XF.7P+0", "%.1RZA", x);
check_sprintf ("0XF.8P+0", "%.1RYA", x);
check_sprintf ("0XF.7P+0", "%.1RDA", x);
check_sprintf ("0XF.8P+0", "%.1RUA", x);
/* do not round up to the next power of the base */
mpfr_set_str (x, "0xf.fffffffffffffffffffffffffffffffffffffeffffffffffffff"
"ffffffffffffffffff", 16, MPFR_RNDN);
check_sprintf ("0xf.ffffffffffffffffffffffffffffffffffffff00p+0",
"%.40RNa", x);
check_sprintf ("0xf.fffffffffffffffffffffffffffffffffffffeffp+0",
"%.40RZa", x);
check_sprintf ("0xf.ffffffffffffffffffffffffffffffffffffff00p+0",
"%.40RYa", x);
check_sprintf ("0xf.fffffffffffffffffffffffffffffffffffffeffp+0",
"%.40RDa", x);
check_sprintf ("0xf.ffffffffffffffffffffffffffffffffffffff00p+0",
"%.40RUa", x);
mpfr_clears (x, z, (mpfr_ptr) 0);
return 0;
}
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);
}
static int
binary (void)
{
mpfr_t x;
mpfr_t z;
mpfr_inits2 (64, x, z, (mpfr_ptr) 0);
/* special */
mpfr_set_inf (x, 1);
check_sprintf (pinf_str, "%Rb", x);
mpfr_set_inf (x, -1);
check_sprintf (minf_str, "%Rb", x);
mpfr_set_nan (x);
check_sprintf (nan_str, "%Rb", x);
/* regular numbers */
mpfr_set_str (x, "1110010101.1001101", 2, MPFR_RNDN);
mpfr_set_ui (z, 0, MPFR_RNDN);
/* simplest case: right justified */
check_sprintf (" 1.1100101011001101p+9", "%25Rb", x);
check_sprintf (" 0p+0", "%25Rb", z);
/* sign or space, pad with leading zeros */
check_sprintf (" 0001.1100101011001101p+9", "% 025Rb", x);
check_sprintf (" 000000000000000000000p+0", "% 025Rb", z);
/* sign + or -, left justified */
check_sprintf ("+1.1100101011001101p+9 ", "%+-25Rb", x);
check_sprintf ("+0p+0 ", "%+-25Rb", z);
/* sign or space */
check_sprintf (" 1.110p+9", "% .3RNb", x);
check_sprintf (" 1.1101p+9", "% .4RNb", x);
check_sprintf (" 0.0000p+0", "% .4RNb", z);
/* sign + or -, decimal point, pad with leading zeros */
check_sprintf ("+00001.1p+9", "%0+#11.1RZb", x);
check_sprintf ("+0001.0p+10", "%0+#11.1RNb", x);
check_sprintf ("+000000.p+0", "%0+#11.0RNb", z);
/* pad with leading zero */
check_sprintf ("00001.1100101011001101p+9", "%025RDb", x);
/* sign or space, decimal point (unused), left justified */
check_sprintf (" 1.1p+9 ", "%- #11.1RDb", x);
check_sprintf (" 1.p+9 ", "%- #11.0RDb", x);
check_sprintf (" 1.p+10 ", "%- #11.0RUb", x);
check_sprintf (" 1.p+9 ", "%- #11.0RZb", x);
check_sprintf (" 1.p+10 ", "%- #11.0RYb", x);
check_sprintf (" 1.p+10 ", "%- #11.0RNb", x);
mpfr_mul_si (x, x, -1, MPFR_RNDD);
mpfr_mul_si (z, z, -1, MPFR_RNDD);
/* sign + or - */
check_sprintf (" -1.1p+9", "%+10.1RUb", x);
check_sprintf (" -0.0p+0", "%+10.1RUb", z);
/* precision 0 */
check_sprintf ("-1p+10", "%.0RNb", x);
check_sprintf ("-1p+10", "%.0RDb", x);
check_sprintf ("-1p+9", "%.0RUb", x);
check_sprintf ("-1p+9", "%.0RZb", x);
check_sprintf ("-1p+10", "%.0RYb", x);
/* round to next base power */
check_sprintf ("-1.0p+10", "%.1RNb", x);
check_sprintf ("-1.0p+10", "%.1RDb", x);
check_sprintf ("-1.0p+10", "%.1RYb", x);
/* do not round to next base power */
check_sprintf ("-1.1p+9", "%.1RUb", x);
check_sprintf ("-1.1p+9", "%.1RZb", x);
/* rounding bit is zero */
check_sprintf ("-1.11p+9", "%.2RNb", x);
/* tie case in round to nearest mode */
check_sprintf ("-1.1100101011001101p+9", "%.16RNb", x);
/* trailing zeros in fractional part */
check_sprintf ("-1.110010101100110100000000000000p+9", "%.30RNb", x);
mpfr_clears (x, z, (mpfr_ptr) 0);
return 0;
}
static void
special (void)
{
mpfr_t x, y;
int inex;
mpfr_init (x);
mpfr_init (y);
mpfr_set_nan (x);
mpfr_lngamma (y, x, MPFR_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error for lngamma(NaN)\n");
exit (1);
}
mpfr_set_inf (x, -1);
mpfr_lngamma (y, x, MPFR_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error for lngamma(-Inf)\n");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_lngamma (y, x, MPFR_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error for lngamma(+Inf)\n");
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_lngamma (y, x, MPFR_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error for lngamma(+0)\n");
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_neg (x, x, MPFR_RNDN);
mpfr_lngamma (y, x, MPFR_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error for lngamma(-0)\n");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_lngamma (y, x, MPFR_RNDN);
if (MPFR_IS_NAN (y) || mpfr_cmp_ui (y, 0) || MPFR_IS_NEG (y))
{
printf ("Error for lngamma(1)\n");
exit (1);
}
mpfr_set_si (x, -1, MPFR_RNDN);
mpfr_lngamma (y, x, MPFR_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error for lngamma(-1)\n");
exit (1);
}
mpfr_set_ui (x, 2, MPFR_RNDN);
mpfr_lngamma (y, x, MPFR_RNDN);
if (MPFR_IS_NAN (y) || mpfr_cmp_ui (y, 0) || MPFR_IS_NEG (y))
{
printf ("Error for lngamma(2)\n");
exit (1);
}
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
#define CHECK_X1 "1.0762904832837976166"
#define CHECK_Y1 "-0.039418362817587634939"
mpfr_set_str (x, CHECK_X1, 10, MPFR_RNDN);
mpfr_lngamma (y, x, MPFR_RNDN);
mpfr_set_str (x, CHECK_Y1, 10, MPFR_RNDN);
if (MPFR_IS_NAN (y) || mpfr_cmp (y, x))
{
printf ("mpfr_lngamma("CHECK_X1") is wrong:\n"
"expected ");
mpfr_print_binary (x); putchar ('\n');
printf ("got ");
mpfr_print_binary (y); putchar ('\n');
exit (1);
}
#define CHECK_X2 "9.23709516716202383435e-01"
#define CHECK_Y2 "0.049010669407893718563"
mpfr_set_str (x, CHECK_X2, 10, MPFR_RNDN);
mpfr_lngamma (y, x, MPFR_RNDN);
mpfr_set_str (x, CHECK_Y2, 10, MPFR_RNDN);
if (MPFR_IS_NAN (y) || mpfr_cmp (y, x))
{
printf ("mpfr_lngamma("CHECK_X2") is wrong:\n"
"expected ");
mpfr_print_binary (x); putchar ('\n');
printf ("got ");
mpfr_print_binary (y); putchar ('\n');
exit (1);
}
mpfr_set_prec (x, 8);
mpfr_set_prec (y, 175);
mpfr_set_ui (x, 33, MPFR_RNDN);
mpfr_lngamma (y, x, MPFR_RNDU);
mpfr_set_prec (x, 175);
mpfr_set_str_binary (x, "0.1010001100011101101011001101110010100001000001000001110011000001101100001111001001000101011011100100010101011110100111110101010100010011010010000101010111001100011000101111E7");
if (MPFR_IS_NAN (y) || mpfr_cmp (x, y))
{
printf ("Error in mpfr_lngamma (1)\n");
exit (1);
}
mpfr_set_prec (x, 21);
mpfr_set_prec (y, 8);
mpfr_set_ui (y, 120, MPFR_RNDN);
mpfr_lngamma (x, y, MPFR_RNDZ);
mpfr_set_prec (y, 21);
mpfr_set_str_binary (y, "0.111000101000001100101E9");
if (MPFR_IS_NAN (x) || mpfr_cmp (x, y))
{
printf ("Error in mpfr_lngamma (120)\n");
printf ("Expected "); mpfr_print_binary (y); puts ("");
printf ("Got "); mpfr_print_binary (x); puts ("");
exit (1);
}
mpfr_set_prec (x, 3);
mpfr_set_prec (y, 206);
mpfr_set_str_binary (x, "0.110e10");
inex = mpfr_lngamma (y, x, MPFR_RNDN);
mpfr_set_prec (x, 206);
mpfr_set_str_binary (x, "0.10000111011000000011100010101001100110001110000111100011000100100110110010001011011110101001111011110110000001010100111011010000000011100110110101100111000111010011110010000100010111101010001101000110101001E13");
if (MPFR_IS_NAN (y) || mpfr_cmp (x, y))
{
printf ("Error in mpfr_lngamma (768)\n");
exit (1);
}
if (inex >= 0)
{
printf ("Wrong flag for mpfr_lngamma (768)\n");
exit (1);
}
mpfr_set_prec (x, 4);
mpfr_set_prec (y, 4);
mpfr_set_str_binary (x, "0.1100E-66");
mpfr_lngamma (y, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.1100E6");
if (MPFR_IS_NAN (y) || mpfr_cmp (x, y))
{
printf ("Error for lngamma(0.1100E-66)\n");
exit (1);
}
mpfr_set_prec (x, 256);
mpfr_set_prec (y, 32);
mpfr_set_si_2exp (x, -1, 200, MPFR_RNDN);
mpfr_add_ui (x, x, 1, MPFR_RNDN);
mpfr_div_2ui (x, x, 1, MPFR_RNDN);
mpfr_lngamma (y, x, MPFR_RNDN);
mpfr_set_prec (x, 32);
mpfr_set_str_binary (x, "-0.10001000111011111011000010100010E207");
if (MPFR_IS_NAN (y) || mpfr_cmp (x, y))
{
printf ("Error for lngamma(-2^199+0.5)\n");
printf ("Got ");
mpfr_dump (y);
printf ("instead of ");
mpfr_dump (x);
exit (1);
}
mpfr_set_prec (x, 256);
mpfr_set_prec (y, 32);
mpfr_set_si_2exp (x, -1, 200, MPFR_RNDN);
mpfr_sub_ui (x, x, 1, MPFR_RNDN);
mpfr_div_2ui (x, x, 1, MPFR_RNDN);
mpfr_lngamma (y, x, MPFR_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error for lngamma(-2^199-0.5)\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
static void
special (void)
{
mpfr_t x, y;
int i;
mpfr_init (x);
mpfr_init (y);
mpfr_set_nan (x);
mpfr_cosh (y, x, GMP_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error: cosh(NaN) != NaN\n");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_cosh (y, x, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error: cosh(+Inf) != +Inf\n");
exit (1);
}
mpfr_set_inf (x, -1);
mpfr_cosh (y, x, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error: cosh(-Inf) != +Inf\n");
exit (1);
}
/* cosh(+/-0) = 1 */
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_cosh (y, x, GMP_RNDN);
if (mpfr_cmp_ui (y, 1))
{
printf ("Error: cosh(+0) != 1\n");
exit (1);
}
mpfr_neg (x, x, GMP_RNDN);
mpfr_cosh (y, x, GMP_RNDN);
if (mpfr_cmp_ui (y, 1))
{
printf ("Error: cosh(-0) != 1\n");
exit (1);
}
mpfr_set_prec (x, 32);
mpfr_set_prec (y, 32);
mpfr_set_str_binary (x, "0.1101110111111111001011101000101");
mpfr_set_str_binary (y, "1.0110011001110000101100011001001");
mpfr_cosh (x, x, GMP_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error: mpfr_cosh for prec=32 (1)\n");
exit (1);
}
mpfr_set_str_binary (x, "-0.1110111000011101010111100000101E-1");
mpfr_set_str_binary (y, "1.0001110000101111111111100110101");
mpfr_cosh (x, x, GMP_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error: mpfr_cosh for prec=32 (2)\n");
exit (1);
}
mpfr_set_prec (x, 2);
mpfr_clear_flags ();
mpfr_set_str_binary (x, "1E1000000000");
i = mpfr_cosh (x, x, GMP_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_cosh (x, x, GMP_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_cosh (x, x, GMP_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_cosh (x, x, GMP_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);
mpfr_clear (y);
}
