static void
check53 (const char *xs, const char *ys, mpfr_rnd_t rnd_mode, const char *zs)
{
mpfr_t xx, yy, zz;
mpfr_inits2 (53, xx, yy, zz, (mpfr_ptr) 0);
mpfr_set_str1 (xx, xs);
mpfr_set_str1 (yy, ys);
test_mul (zz, xx, yy, rnd_mode);
if (mpfr_cmp_str1 (zz, zs) )
{
printf ("(2) mpfr_mul failed for x=%s y=%s with rnd=%s\n",
xs, ys, mpfr_print_rnd_mode(rnd_mode));
printf ("correct result is %s,\n mpfr_mul gives ", zs);
mpfr_out_str(stdout, 10, 0, zz, MPFR_RNDN);
/*
printf("\nBinary forms:\nxx=");
mpfr_print_binary (xx);
printf("\nyy=");
mpfr_print_binary (yy);
printf("\nzz=");
mpfr_print_binary(zz);
printf("\nre=");
mpfr_set_str1 (zz, zs);
mpfr_print_binary(zz);
putchar('\n'); */
exit (1);
}
mpfr_clears (xx, yy, zz, (mpfr_ptr) 0);
}
/* checks that xs * ys gives the expected result res */
static void
check (const char *xs, const char *ys, mpfr_rnd_t rnd_mode,
unsigned int px, unsigned int py, unsigned int pz, const char *res)
{
mpfr_t xx, yy, zz;
mpfr_init2 (xx, px);
mpfr_init2 (yy, py);
mpfr_init2 (zz, pz);
mpfr_set_str1 (xx, xs);
mpfr_set_str1 (yy, ys);
test_mul(zz, xx, yy, rnd_mode);
if (mpfr_cmp_str1 (zz, res) )
{
printf ("(1)mpfr_mul failed for x=%s y=%s with rnd=%s\n",
xs, ys, mpfr_print_rnd_mode (rnd_mode));
printf ("correct is %s, mpfr_mul gives ", res);
mpfr_out_str(stdout, 10, 0, zz, MPFR_RNDN);
/*
printf("\nBinary forms:\nxx=");
mpfr_print_binary (xx);
printf("\nyy=");
mpfr_print_binary (yy);
printf("\nzz=");
mpfr_print_binary(zz);
printf("\nre=");
mpfr_set_str1 (zz, res);
mpfr_print_binary(zz);
putchar('\n');*/
exit (1);
}
mpfr_clear(xx); mpfr_clear(yy); mpfr_clear(zz);
}
static void
check_overflow (void)
{
mpfr_t x, y, z1, z2;
mpfr_exp_t emin, emax;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
set_emin (-1021);
set_emax (1024);
mpfr_inits (x, y, z1, z2, (mpfr_ptr) 0);
mpfr_set_str1 (x, "8.00468257869324898448e+307");
mpfr_set_str1 (y, "7.44784712422708645156e+307");
mpfr_add1sp (z1, x, y, MPFR_RNDN);
mpfr_add1 (z2, x, y, MPFR_RNDN);
if (mpfr_cmp (z1, z2))
{
printf ("Overflow bug in add1sp.\n");
exit (1);
}
mpfr_clears (x, y, z1, z2, (mpfr_ptr) 0);
set_emin (emin);
set_emax (emax);
}
static void
coverage_01032011 (void)
{
mpfr_t val, cval, sval, svalf;
int status_f, status;
mpfr_init2 (val, MPFR_PREC_MIN);
mpfr_init2 (cval, MPFR_PREC_MIN);
mpfr_init2 (sval, MPFR_PREC_MIN);
mpfr_init2 (svalf, MPFR_PREC_MIN);
mpfr_set_str1 (val, "-0.7");
status_f = mpfr_sincos_fast (svalf, NULL, val, MPFR_RNDN);
status = mpfr_sin_cos (sval, cval, val, MPFR_RNDN);
if (! mpfr_equal_p (svalf, sval) || SIGN (status_f) != SIGN (status))
{
printf ("mpfr_sincos_fast differ from mpfr_sin_cos result:\n"
" sin fast is ");
mpfr_dump (svalf);
printf (" sin is ");
mpfr_dump (sval);
printf ("status_f = %d, status = %d\n", status_f, status);
exit (1);
}
mpfr_clears(val, cval, sval, svalf, (mpfr_ptr) 0);
}
static void
check53 (const char *xs, const char *sin_xs, const char *cos_xs,
mpfr_rnd_t rnd_mode)
{
mpfr_t xx, s, c;
mpfr_inits2 (53, xx, s, c, (mpfr_ptr) 0);
mpfr_set_str1 (xx, xs); /* should be exact */
mpfr_sin_cos (s, c, xx, rnd_mode);
if (mpfr_cmp_str1 (s, sin_xs))
{
printf ("mpfr_sin_cos failed for x=%s, rnd=%s\n",
xs, mpfr_print_rnd_mode (rnd_mode));
printf ("mpfr_sin_cos gives sin(x)=");
mpfr_out_str(stdout, 10, 0, s, MPFR_RNDN);
printf(", expected %s\n", sin_xs);
exit (1);
}
if (mpfr_cmp_str1 (c, cos_xs))
{
printf ("mpfr_sin_cos failed for x=%s, rnd=%s\n",
xs, mpfr_print_rnd_mode (rnd_mode));
printf ("mpfr_sin_cos gives cos(x)=");
mpfr_out_str(stdout, 10, 0, c, MPFR_RNDN);
printf(", expected %s\n", cos_xs);
exit (1);
}
mpfr_clears (xx, s, c, (mpfr_ptr) 0);
}
static void
test2 (void)
{
mpfr_t x, y;
int i, n = numberof(val);
mpfr_inits2 (55, x, y, (mpfr_ptr) 0);
for(i = 0 ; i < n ; i+=2)
{
mpfr_set_str1 (x, val[i]);
mpfr_zeta(y, x, MPFR_RNDZ);
if (mpfr_cmp_str (y, val[i+1] , 2, MPFR_RNDZ))
{
printf("Wrong result for zeta(%s=", val[i]);
mpfr_print_binary (x);
printf (").\nGot : ");
mpfr_print_binary(y); putchar('\n');
printf("Expected: ");
mpfr_set_str (y, val[i+1], 2, MPFR_RNDZ);
mpfr_print_binary(y); putchar('\n');
mpfr_set_prec(y, 65);
mpfr_zeta(y, x, MPFR_RNDZ);
printf("+ Prec : ");
mpfr_print_binary(y); putchar('\n');
exit(1);
}
}
mpfr_clears (x, y, (mpfr_ptr) 0);
}
static void check_intmax (void)
{
#ifdef _MPFR_H_HAVE_INTMAX_T
mpfr_t x;
mpfr_init2 (x, sizeof(uintmax_t)*CHAR_BIT);
/* Check NAN */
mpfr_set_nan(x);
if (mpfr_fits_uintmax_p(x, GMP_RNDN))
ERROR1;
if (mpfr_fits_intmax_p(x, GMP_RNDN))
ERROR1;
/* Check INF */
mpfr_set_inf(x, 1);
if (mpfr_fits_uintmax_p(x, GMP_RNDN))
ERROR1;
if (mpfr_fits_intmax_p(x, GMP_RNDN))
ERROR1;
/* Check Zero */
MPFR_SET_ZERO(x);
if (!mpfr_fits_uintmax_p(x, GMP_RNDN))
ERROR2;
if (!mpfr_fits_intmax_p(x, GMP_RNDN))
ERROR2;
/* Check small op */
mpfr_set_str1 (x, "1@-1");
if (!mpfr_fits_uintmax_p(x, GMP_RNDN))
ERROR2;
if (!mpfr_fits_intmax_p(x, GMP_RNDN))
ERROR2;
/* Check all other values */
mpfr_set_uj (x, UINTMAX_MAX, GMP_RNDN);
mpfr_add_ui (x, x, 1, GMP_RNDN);
if (mpfr_fits_uintmax_p (x, GMP_RNDN))
ERROR1;
mpfr_set_uj (x, UINTMAX_MAX, GMP_RNDN);
if (!mpfr_fits_uintmax_p (x, GMP_RNDN))
ERROR2;
mpfr_set_sj (x, INTMAX_MAX, GMP_RNDN);
mpfr_add_ui (x, x, 1, GMP_RNDN);
if (mpfr_fits_intmax_p (x, GMP_RNDN))
ERROR1;
mpfr_set_sj (x, INTMAX_MAX, GMP_RNDN);
if (!mpfr_fits_intmax_p (x, GMP_RNDN))
ERROR2;
mpfr_set_sj (x, INTMAX_MIN, GMP_RNDN);
if (!mpfr_fits_intmax_p (x, GMP_RNDN))
ERROR2;
mpfr_sub_ui (x, x, 1, GMP_RNDN);
if (mpfr_fits_intmax_p (x, GMP_RNDN))
ERROR1;
mpfr_clear (x);
#endif
}
static void
check_special (void)
{
mpfr_t a1,a2,b,c;
int r;
mpfr_prec_t p;
int i = -1, inexact1, inexact2;
mpfr_inits (a1, a2, b, c, (mpfr_ptr) 0);
for (r = 0 ; r < MPFR_RND_MAX ; r++)
{
SET_PREC(53);
mpfr_set_str1 (b, "1@100");
mpfr_set_str1 (c, "1@1");
inexact1 = mpfr_add1(a1, b, c, (mpfr_rnd_t) r);
inexact2 = mpfr_add1sp(a2, b, c, (mpfr_rnd_t) r);
if (mpfr_cmp(a1, a2))
STD_ERROR;
if (inexact1 != inexact2)
STD_ERROR2;
mpfr_set_str_binary (b, "1E53");
mpfr_set_str_binary (c, "1E0");
inexact1 = mpfr_add1(a1, b, c, (mpfr_rnd_t) r);
inexact2 = mpfr_add1sp(a2, b, c, (mpfr_rnd_t) r);
if (mpfr_cmp(a1, a2))
STD_ERROR;
if (inexact1 != inexact2)
STD_ERROR2;
}
mpfr_set_prec (c, 2);
mpfr_set_prec (a1, 2);
mpfr_set_prec (a2, 2);
mpfr_set_str_binary (c, "1.0e1");
mpfr_set_str_binary (a2, "1.1e-1");
mpfr_set_str_binary (a1, "0.11E2");
mpfr_add1sp (a2, c, a2, MPFR_RNDN);
if (mpfr_cmp (a1, a2))
{
printf ("Regression reuse test failed!\n");
exit (1);
}
mpfr_clears (a1, a2, b, c, (mpfr_ptr) 0);
}
static void
check_min(void)
{
mpfr_t xx, yy, zz;
mpfr_init2(xx, 4);
mpfr_init2(yy, 4);
mpfr_init2(zz, 3);
mpfr_set_str1(xx, "0.9375");
mpfr_mul_2si(xx, xx, MPFR_EMIN_DEFAULT/2, MPFR_RNDN);
mpfr_set_str1(yy, "0.9375");
mpfr_mul_2si(yy, yy, MPFR_EMIN_DEFAULT - MPFR_EMIN_DEFAULT/2 - 1, MPFR_RNDN);
test_mul(zz, xx, yy, MPFR_RNDD);
if (mpfr_sgn(zz) != 0)
{
printf("check_min failed: got ");
mpfr_out_str(stdout, 2, 0, zz, MPFR_RNDZ);
printf(" instead of 0\n");
exit(1);
}
test_mul(zz, xx, yy, MPFR_RNDU);
mpfr_set_str1 (xx, "0.5");
mpfr_mul_2si(xx, xx, MPFR_EMIN_DEFAULT, MPFR_RNDN);
if (mpfr_sgn(xx) <= 0)
{
printf("check_min failed (internal error)\n");
exit(1);
}
if (mpfr_cmp(xx, zz) != 0)
{
printf("check_min failed: got ");
mpfr_out_str(stdout, 2, 0, zz, MPFR_RNDZ);
printf(" instead of ");
mpfr_out_str(stdout, 2, 0, xx, MPFR_RNDZ);
printf("\n");
exit(1);
}
mpfr_clear(xx);
mpfr_clear(yy);
mpfr_clear(zz);
}
static void
check24 (const char *Ns, const char *Ds, mpfr_rnd_t rnd_mode, const char *Qs)
{
mpfr_t q, n, d;
mpfr_inits2 (24, q, n, d, (mpfr_ptr) 0);
mpfr_set_str1 (n, Ns);
mpfr_set_str1 (d, Ds);
test_div(q, n, d, rnd_mode);
if (mpfr_cmp_str1 (q, Qs) )
{
printf ("mpfr_div failed for n=%s, d=%s, prec=24, rnd_mode=%s\n",
Ns, Ds, mpfr_print_rnd_mode(rnd_mode));
printf ("expected quotient is %s, got ", Qs);
mpfr_out_str(stdout,10,0,q, MPFR_RNDN); putchar('\n');
exit (1);
}
mpfr_clears (q, n, d, (mpfr_ptr) 0);
}
/* checks that x*y gives the right result with 24 bits of precision */
static void
check24 (const char *xs, const char *ys, mpfr_rnd_t rnd_mode, const char *zs)
{
mpfr_t xx, yy, zz;
mpfr_inits2 (24, xx, yy, zz, (mpfr_ptr) 0);
mpfr_set_str1 (xx, xs);
mpfr_set_str1 (yy, ys);
test_mul (zz, xx, yy, rnd_mode);
if (mpfr_cmp_str1 (zz, zs) )
{
printf ("(3) mpfr_mul failed for x=%s y=%s with "
"rnd=%s\n", xs, ys, mpfr_print_rnd_mode(rnd_mode));
printf ("correct result is gives %s, mpfr_mul gives ", zs);
mpfr_out_str(stdout, 10, 0, zz, MPFR_RNDN);
putchar('\n');
exit (1);
}
mpfr_clears (xx, yy, zz, (mpfr_ptr) 0);
}
static void
check4 (const char *as, const char *bs, mpfr_rnd_t rnd_mode, const char *res)
{
mpfr_t ta, tb, tres;
mpfr_inits2 (53, ta, tb, tres, (mpfr_ptr) 0);
mpfr_set_str1 (ta, as);
mpfr_set_str1 (tb, bs);
mpfr_agm(tres, ta, tb, rnd_mode);
if (mpfr_cmp_str1 (tres, res))
{
printf ("mpfr_agm failed for a=%s, b=%s, rnd_mode=%d\n",as,bs,rnd_mode);
printf ("expected result is %s, got ",res);
mpfr_out_str(stdout, 10, 0, tres, MPFR_RNDN);
putchar('\n');
exit (1);
}
mpfr_clears (ta, tb, tres, (mpfr_ptr) 0);
}
static void
check4 (const char *Ns, const char *Ds, mpfr_rnd_t rnd_mode, int p,
const char *Qs)
{
mpfr_t q, n, d;
mpfr_inits2 (p, q, n, d, (mpfr_ptr) 0);
mpfr_set_str1 (n, Ns);
mpfr_set_str1 (d, Ds);
test_div(q, n, d, rnd_mode);
if (mpfr_cmp_str (q, Qs, ((p==53) ? 10 : 2), MPFR_RNDN) )
{
printf ("mpfr_div failed for n=%s, d=%s, p=%d, rnd_mode=%s\n",
Ns, Ds, p, mpfr_print_rnd_mode (rnd_mode));
printf ("got ");mpfr_print_binary(q);
mpfr_set_str (q, Qs, ((p==53) ? 10 : 2), MPFR_RNDN);
printf("\nexpected "); mpfr_print_binary(q);
putchar('\n');
exit (1);
}
mpfr_clears (q, n, d, (mpfr_ptr) 0);
}
/* expx is the value of exp(X) rounded towards -infinity */
static void
check_worst_case (const char *Xs, const char *expxs)
{
mpfr_t x, y;
mpfr_inits2(53, x, y, NULL);
mpfr_set_str1(x, Xs);
mpfr_exp(y, x, GMP_RNDD);
if (mpfr_cmp_str1 (y, expxs))
{
printf ("exp(x) rounded towards -infinity is wrong\n");
exit(1);
}
mpfr_set_str1(x, Xs);
mpfr_exp(x, x, GMP_RNDU);
mpfr_add_one_ulp(y, GMP_RNDN);
if (mpfr_cmp(x,y))
{
printf ("exp(x) rounded towards +infinity is wrong\n");
exit(1);
}
mpfr_clears(x,y,NULL);
}
/* checks that xs+ys gives the expected result zs */
static void
check (const char *xs, const char *ys, mpfr_rnd_t rnd_mode,
unsigned int px, unsigned int py, unsigned int pz, const char *zs)
{
mpfr_t xx,yy,zz;
mpfr_init2 (xx, px);
mpfr_init2 (yy, py);
mpfr_init2 (zz, pz);
mpfr_set_str1 (xx, xs);
mpfr_set_str1 (yy, ys);
test_add (zz, xx, yy, rnd_mode);
if (mpfr_cmp_str1 (zz, zs) )
{
printf ("expected sum is %s, got ", zs);
mpfr_out_str(stdout, 10, 0, zz, MPFR_RNDN);
printf ("mpfr_add failed for x=%s y=%s with rnd_mode=%s\n",
xs, ys, mpfr_print_rnd_mode (rnd_mode));
exit (1);
}
mpfr_clears (xx, yy, zz, (mpfr_ptr) 0);
}
/* expx is the value of exp(X) rounded toward -infinity */
static void
check_worst_case (const char *Xs, const char *expxs)
{
mpfr_t x, y;
mpfr_inits2 (53, x, y, (mpfr_ptr) 0);
mpfr_set_str1(x, Xs);
test_exp(y, x, MPFR_RNDD);
if (mpfr_cmp_str1 (y, expxs))
{
printf ("exp(x) rounded toward -infinity is wrong\n");
exit(1);
}
mpfr_set_str1(x, Xs);
test_exp(x, x, MPFR_RNDU);
mpfr_nexttoinf (y);
if (mpfr_cmp(x,y))
{
printf ("exp(x) rounded toward +infinity is wrong\n");
exit(1);
}
mpfr_clears (x, y, (mpfr_ptr) 0);
}
int
main (int argc, char *argv[])
{
mpfr_t x, z;
int y;
int i;
tests_start_mpfr ();
mpfr_inits2 (53, x, z, (mpfr_ptr) 0);
for(i = 0 ; i < numberof (tab) ; i++)
{
mpfr_set_str (x, tab[i].op1, 16, MPFR_RNDN);
y = tab[i].op2;
mpfr_add_si (z, x, y, MPFR_RNDZ);
if (mpfr_cmp_str (z, tab[i].res_add, 16, MPFR_RNDN))
ERROR1("add_si", i, z, tab[i].res_add);
mpfr_sub_si (z, x, y, MPFR_RNDZ);
if (mpfr_cmp_str (z, tab[i].res_sub, 16, MPFR_RNDN))
ERROR1("sub_si", i, z, tab[i].res_sub);
mpfr_si_sub (z, y, x, MPFR_RNDZ);
mpfr_neg (z, z, MPFR_RNDZ);
if (mpfr_cmp_str (z, tab[i].res_sub, 16, MPFR_RNDN))
ERROR1("si_sub", i, z, tab[i].res_sub);
mpfr_mul_si (z, x, y, MPFR_RNDZ);
if (mpfr_cmp_str (z, tab[i].res_mul, 16, MPFR_RNDN))
ERROR1("mul_si", i, z, tab[i].res_mul);
mpfr_div_si (z, x, y, MPFR_RNDZ);
if (mpfr_cmp_str (z, tab[i].res_div, 16, MPFR_RNDN))
ERROR1("div_si", i, z, tab[i].res_div);
}
mpfr_set_str1 (x, "1");
mpfr_si_div (z, 1024, x, MPFR_RNDN);
if (mpfr_cmp_str1 (z, "1024"))
ERROR1("si_div", i, z, "1024");
mpfr_si_div (z, -1024, x, MPFR_RNDN);
if (mpfr_cmp_str1 (z, "-1024"))
ERROR1("si_div", i, z, "-1024");
mpfr_clears (x, z, (mpfr_ptr) 0);
check_invert ();
test_generic_add_si (2, 200, 17);
test_generic_sub_si (2, 200, 17);
test_generic_mul_si (2, 200, 17);
test_generic_div_si (2, 200, 17);
tests_end_mpfr ();
return 0;
}
/* checks that y/x gives the right result with 53 bits of precision */
static void
check (unsigned long y, const char *xs, mpfr_rnd_t rnd_mode, const char *zs)
{
mpfr_t xx, zz;
mpfr_inits2 (53, xx, zz, (mpfr_ptr) 0);
mpfr_set_str1 (xx, xs);
mpfr_ui_div (zz, y, xx, rnd_mode);
if (mpfr_cmp_str1(zz, zs))
{
printf ("expected quotient is %s, got ", zs);
mpfr_out_str (stdout, 10, 0, zz, MPFR_RNDN);
printf ("mpfr_ui_div failed for y=%lu x=%s with rnd_mode=%s\n",
y, xs, mpfr_print_rnd_mode (rnd_mode));
exit (1);
}
mpfr_clears (xx, zz, (mpfr_ptr) 0);
}
/* checks that x-y gives the right results with 53 bits of precision */
static void
check3 (const char *xs, unsigned long y, mpfr_rnd_t rnd_mode, const char *zs)
{
mpfr_t xx,zz;
mpfr_inits2 (53, xx, zz, (mpfr_ptr) 0);
mpfr_set_str1 (xx, xs);
mpfr_sub_ui (zz, xx, y, rnd_mode);
if (mpfr_cmp_str1(zz, zs))
{
printf ("expected sum is %s, got ", zs);
mpfr_print_binary(zz);
printf ("\nmpfr_sub_ui failed for x=%s y=%lu with rnd_mode=%s\n",
xs, y, mpfr_print_rnd_mode (rnd_mode));
exit (1);
}
mpfr_clears (xx, zz, (mpfr_ptr) 0);
}
/* checks that x+y gives the right results with 53 bits of precision */
static void
check3 (const char *xs, unsigned long y, mp_rnd_t rnd_mode, const char *zs)
{
mpfr_t xx, zz;
mpfr_inits2 (53, xx, zz, (void *) 0);
mpfr_set_str1 (xx, xs);
mpfr_add_ui (zz, xx, y, rnd_mode);
if (mpfr_cmp_str1(zz, zs) )
{
printf ("expected sum is %s, got ",zs);
mpfr_out_str(stdout, 10, 0, zz, GMP_RNDN);
printf ("\nmpfr_add_ui failed for x=%s y=%lu with rnd_mode=%s\n",
xs, y, mpfr_print_rnd_mode(rnd_mode));
exit (1);
}
mpfr_clears (xx, zz, (void *) 0);
}
/* checks that (y-x) gives the right results with 53 bits of precision */
static void
check (unsigned long y, const char *xs, mp_rnd_t rnd_mode, const char *zs)
{
mpfr_t xx, zz;
mpfr_inits2 (53, xx, zz, NULL);
mpfr_set_str1 (xx, xs);
mpfr_ui_sub (zz, y, xx, rnd_mode);
if (mpfr_cmp_str1 (zz, zs) )
{
printf ("expected difference is %s, got\n",zs);
mpfr_out_str(stdout, 10, 0, zz, GMP_RNDN);
printf ("mpfr_ui_sub failed for y=%lu x=%s with rnd_mode=%s\n",
y, xs, mpfr_print_rnd_mode (rnd_mode));
exit (1);
}
mpfr_clears (xx, zz, NULL);
}
static void
check_diverse (const char *as, mpfr_prec_t p, const char *qs)
{
mpfr_t q;
mpfr_init2 (q, p);
mpfr_set_str1 (q, as);
test_sqrt (q, q, MPFR_RNDN);
if (mpfr_cmp_str1 (q, qs))
{
printf ("mpfr_sqrt failed for a=%s, prec=%lu, rnd_mode=%s\n",
as, (unsigned long) p, mpfr_print_rnd_mode (MPFR_RNDN));
printf ("expected sqrt is %s, got ", qs);
mpfr_out_str (stdout, 10, 0, q, MPFR_RNDN);
printf ("\n");
exit (1);
}
mpfr_clear (q);
}
static void
check24 (const char *as, mpfr_rnd_t rnd_mode, const char *qs)
{
mpfr_t q;
mpfr_init2 (q, 24);
mpfr_set_str1 (q, as);
test_sqrt (q, q, rnd_mode);
if (mpfr_cmp_str1 (q, qs))
{
printf ("mpfr_sqrt failed for a=%s, prec=24, rnd_mode=%s\n",
as, mpfr_print_rnd_mode(rnd_mode));
printf ("expected sqrt is %s, got ",qs);
mpfr_out_str (stdout, 10, 0, q, MPFR_RNDN);
printf ("\n");
exit (1);
}
mpfr_clear (q);
}
static void
check4 (const char *as, mpfr_rnd_t rnd_mode, const char *Qs)
{
mpfr_t q;
mpfr_init2 (q, 53);
mpfr_set_str1 (q, as);
test_sqrt (q, q, rnd_mode);
if (mpfr_cmp_str (q, Qs, 16, MPFR_RNDN))
{
printf ("mpfr_sqrt failed for a=%s, rnd_mode=%s\n",
as, mpfr_print_rnd_mode(rnd_mode));
printf ("expected ");
mpfr_out_str (stdout, 16, 0, q, MPFR_RNDN);
printf ("\ngot %s\n", Qs);
mpfr_clear (q);
exit (1);
}
mpfr_clear (q);
}
static void
check (const char *ds, unsigned long u, mpfr_rnd_t rnd, const char *es)
{
mpfr_t x, y;
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
mpfr_set_str1 (x, ds);
mpfr_div_ui (y, x, u, rnd);
if (mpfr_cmp_str1 (y, es))
{
printf ("mpfr_div_ui failed for x=%s, u=%lu, rnd=%s\n", ds, u,
mpfr_print_rnd_mode (rnd));
printf ("expected result is %s, got", es);
mpfr_out_str(stdout, 10, 0, y, MPFR_RNDN);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
static void
check2 (const char *as, mp_rnd_t rnd_mode, const char *res1s)
{
mpfr_t ta, tres;
mpfr_inits2 (53, ta, tres, (mpfr_ptr) 0);
mpfr_set_str1 (ta, as);
test_log (tres, ta, rnd_mode);
if (mpfr_cmp_str1 (tres, res1s))
{
printf ("mpfr_log failed for a=%s, rnd_mode=%s\n",
as, mpfr_print_rnd_mode (rnd_mode));
printf ("correct result is %s\n mpfr_log gives ",
res1s);
mpfr_out_str(stdout, 10, 0, tres, GMP_RNDN);
exit (1);
}
mpfr_clears (ta, tres, (mpfr_ptr) 0);
}
/* returns the number of ulp of error */
static void
check3 (const char *op, mpfr_rnd_t rnd, const char *res)
{
mpfr_t x, y;
mpfr_inits2 (53, x, y, (mpfr_ptr) 0);
/* y negative. If we forget to set the sign in mpfr_exp, we'll see it. */
mpfr_set_si (y, -1, MPFR_RNDN);
mpfr_set_str1 (x, op);
test_exp (y, x, rnd);
if (mpfr_cmp_str1 (y, res) )
{
printf ("mpfr_exp failed for x=%s, rnd=%s\n",
op, mpfr_print_rnd_mode (rnd));
printf ("expected result is %s, got ", res);
mpfr_out_str (stdout, 10, 0, y, MPFR_RNDN);
putchar('\n');
exit (1);
}
mpfr_clears (x, y, (mpfr_ptr) 0);
}
static void
check53 (const char *xs, const char *sin_xs, mpfr_rnd_t rnd_mode)
{
mpfr_t xx, s;
mpfr_init2 (xx, 53);
mpfr_init2 (s, 53);
mpfr_set_str1 (xx, xs); /* should be exact */
test_sin (s, xx, rnd_mode);
if (mpfr_cmp_str1 (s, sin_xs))
{
printf ("mpfr_sin failed for x=%s, rnd=%s\n",
xs, mpfr_print_rnd_mode (rnd_mode));
printf ("mpfr_sin gives sin(x)=");
mpfr_out_str (stdout, 10, 0, s, MPFR_RNDN);
printf (", expected %s\n", sin_xs);
exit (1);
}
mpfr_clear (xx);
mpfr_clear (s);
}
static void
check (const char *xis, const char *xfs, const char *xs,
mpfr_prec_t xip, mpfr_prec_t xfp, mpfr_prec_t xp,
int expected_return, mpfr_rnd_t rnd_mode)
{
int inexact;
mpfr_t xi, xf, x;
mpfr_init2 (xi, xip);
mpfr_init2 (xf, xfp);
mpfr_init2 (x, xp);
mpfr_set_str1 (x, xs);
inexact = mpfr_modf (xi, xf, x, rnd_mode);
if (mpfr_cmp_str1 (xi, xis))
{
printf ("mpfr_modf failed for x=%s, rnd=%s\n",
xs, mpfr_print_rnd_mode(rnd_mode));
printf ("got integer value: ");
mpfr_out_str (stdout, 10, 0, xi, MPFR_RNDN);
printf ("\nexpected %s\n", xis);
exit (1);
}
if (mpfr_cmp_str1 (xf, xfs))
{
printf ("mpfr_modf failed for x=%s, rnd=%s\n",
xs, mpfr_print_rnd_mode(rnd_mode));
printf ("got fractional value: ");
mpfr_out_str (stdout, 10, 0, xf, MPFR_RNDN);
printf ("\nexpected %s\n", xfs);
exit (1);
}
if (inexact != expected_return)
{
printf ("mpfr_modf failed for x=%s, rnd=%s\n",
xs, mpfr_print_rnd_mode(rnd_mode));
printf ("got return value: %d, expected %d\n", inexact, expected_return);
exit (1);
}
mpfr_clears (xi, xf, x, (mpfr_ptr) 0);
}
int
main (void)
{
mpfr_t u, v;
tests_start_mpfr ();
mpfr_init2 (u, 24);
mpfr_init2 (v, 53);
mpfr_set_ui (u, 16777215, MPFR_RNDN); /* 2^24 - 1 */
mpfr_set_str1 (v, "9007199254740991.0"); /* 2^53 - 1 */
mpfr_swap (u, v);
mpfr_swap (u, v);
if (mpfr_cmp_ui (u, 16777215) || mpfr_cmp_str1 (v, "9007199254740991.0"))
{
printf ("Error in mpfr_swap\n");
exit (1);
}
mpfr_clear (u);
mpfr_clear (v);
tests_end_mpfr ();
return 0;
}
