static void
error2 (mpfr_rnd_t rnd, mpfr_prec_t prec, mpfr_t in, mpfr_t out,
int inexactmul, int inexactsqr)
{
printf("ERROR: for %s and prec=%lu\nINPUT=", mpfr_print_rnd_mode(rnd), prec);
mpfr_dump(in);
printf("Output="); mpfr_dump(out);
printf("InexactMul= %d InexactSqr= %d\n", inexactmul, inexactsqr);
exit(1);
}
static void
error1 (mpfr_rnd_t rnd, mpfr_prec_t prec,
mpfr_t in, mpfr_t outmul, mpfr_t outsqr)
{
printf("ERROR: for %s and prec=%lu\nINPUT=", mpfr_print_rnd_mode(rnd), prec);
mpfr_dump(in);
printf("OutputMul="); mpfr_dump(outmul);
printf("OutputSqr="); mpfr_dump(outsqr);
exit(1);
}
/* for functions with one mpc_t output, two mpc_t inputs */
static void
tgeneric_c_cc (mpc_function *function, mpc_ptr op1, mpc_ptr op2,
mpc_ptr rop, mpc_ptr rop4, mpc_ptr rop4rnd, mpc_rnd_t rnd)
{
known_signs_t ks = {1, 1};
/* We compute the result with four times the precision and check whether the
rounding is correct. Error reports in this part of the algorithm might
still be wrong, though, since there are two consecutive roundings (but we
try to avoid them). */
function->pointer.C_CC (rop4, op1, op2, rnd);
function->pointer.C_CC (rop, op1, op2, rnd);
/* can't use mpfr_can_round when argument is singular */
if (MPFR_CAN_ROUND (mpc_realref (rop4), 1, MPC_PREC_RE (rop),
MPC_RND_RE (rnd))
&& MPFR_CAN_ROUND (mpc_imagref (rop4), 1, MPC_PREC_IM (rop),
MPC_RND_IM (rnd)))
mpc_set (rop4rnd, rop4, rnd);
else
/* avoid double rounding error */
return;
if (same_mpc_value (rop, rop4rnd, ks))
return;
/* rounding failed */
printf ("Rounding in %s might be incorrect for\n", function->name);
MPC_OUT (op1);
MPC_OUT (op2);
printf ("with rounding mode (%s, %s)",
mpfr_print_rnd_mode (MPC_RND_RE (rnd)),
mpfr_print_rnd_mode (MPC_RND_IM (rnd)));
printf ("\n%s gives ", function->name);
MPC_OUT (rop);
printf ("%s quadruple precision gives ", function->name);
MPC_OUT (rop4);
printf ("and is rounded to ");
MPC_OUT (rop4rnd);
exit (1);
}
static void
check_inexact (void)
{
mpfr_t x, y, z;
mpfr_prec_t px, py;
int inexact, cmp;
unsigned long int u;
int rnd;
mpfr_init (x);
mpfr_init (y);
mpfr_init (z);
for (px=2; px<300; px++)
{
mpfr_set_prec (x, px);
mpfr_urandomb (x, RANDS);
do
{
u = randlimb ();
}
while (u == 0);
for (py=2; py<300; py++)
{
mpfr_set_prec (y, py);
mpfr_set_prec (z, py + mp_bits_per_limb);
for (rnd = 0; rnd < MPFR_RND_MAX; rnd++)
{
inexact = mpfr_div_ui (y, x, u, (mpfr_rnd_t) rnd);
if (mpfr_mul_ui (z, y, u, (mpfr_rnd_t) rnd))
{
printf ("z <- y * u should be exact for u=%lu\n", u);
printf ("y="); mpfr_print_binary (y); puts ("");
printf ("z="); mpfr_print_binary (z); puts ("");
exit (1);
}
cmp = mpfr_cmp (z, x);
if (((inexact == 0) && (cmp != 0)) ||
((inexact > 0) && (cmp <= 0)) ||
((inexact < 0) && (cmp >= 0)))
{
printf ("Wrong inexact flag for u=%lu, rnd=%s\n", u,
mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
printf ("x="); mpfr_print_binary (x); puts ("");
printf ("y="); mpfr_print_binary (y); puts ("");
exit (1);
}
}
}
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
}
static void
check_inexact (void)
{
mpfr_t x, y, z;
mp_prec_t px, py;
int inexact, cmp;
unsigned long int u;
int rnd;
mpfr_init (x);
mpfr_init (y);
mpfr_init (z);
for (px=2; px<300; px++)
{
mpfr_set_prec (x, px);
do
{
mpfr_urandomb (x, RANDS);
}
while (mpfr_cmp_ui (x, 0) == 0);
u = randlimb ();
for (py=2; py<300; py++)
{
mpfr_set_prec (y, py);
mpfr_set_prec (z, py + px);
for (rnd = 0; rnd < GMP_RND_MAX; rnd++)
{
inexact = mpfr_ui_div (y, u, x, (mp_rnd_t) rnd);
if (mpfr_mul (z, y, x, (mp_rnd_t) rnd))
{
printf ("z <- y * x should be exact\n");
exit (1);
}
cmp = mpfr_cmp_ui (z, u);
if (((inexact == 0) && (cmp != 0)) ||
((inexact > 0) && (cmp <= 0)) ||
((inexact < 0) && (cmp >= 0)))
{
printf ("Wrong inexact flag for u=%lu, rnd=%s\n",
u, mpfr_print_rnd_mode ((mp_rnd_t) rnd));
printf ("expected %d, got %d\n", cmp, inexact);
printf ("x="); mpfr_print_binary (x); puts ("");
printf ("y="); mpfr_print_binary (y); puts ("");
printf ("y*x="); mpfr_print_binary (z); puts ("");
exit (1);
}
}
}
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
}
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);
}
static void
check_overflow (void)
{
mpfr_t sum1, sum2, x, y;
mpfr_ptr t[2 * NOVFL];
mpfr_exp_t emin, emax;
int i, r;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
set_emin (MPFR_EMIN_MIN);
set_emax (MPFR_EMAX_MAX);
mpfr_inits2 (32, sum1, sum2, x, y, (mpfr_ptr) 0);
mpfr_setmax (x, mpfr_get_emax ());
mpfr_neg (y, x, MPFR_RNDN);
for (i = 0; i < 2 * NOVFL; i++)
t[i] = i < NOVFL ? x : y;
/* Two kinds of test:
* i = 1: overflow.
* i = 2: intermediate overflow (exact sum is 0).
*/
for (i = 1; i <= 2; i++)
RND_LOOP(r)
{
int inex1, inex2;
inex1 = mpfr_add (sum1, x, i == 1 ? x : y, (mpfr_rnd_t) r);
inex2 = mpfr_sum (sum2, t, i * NOVFL, (mpfr_rnd_t) r);
MPFR_ASSERTN (mpfr_check (sum1));
MPFR_ASSERTN (mpfr_check (sum2));
if (!(mpfr_equal_p (sum1, sum2) && SAME_SIGN (inex1, inex2)))
{
printf ("Error in check_overflow on %s, i = %d\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r), i);
printf ("Expected ");
mpfr_dump (sum1);
printf ("with inex = %d\n", inex1);
printf ("Got ");
mpfr_dump (sum2);
printf ("with inex = %d\n", inex2);
exit (1);
}
}
mpfr_clears (sum1, sum2, x, y, (mpfr_ptr) 0);
set_emin (emin);
set_emax (emax);
}
static void
err (const char *s, int i, int j, int rnd, mpfr_srcptr z, int inex)
{
puts (s);
if (ext)
puts ("extended exponent range");
printf ("x = %s, y = %s, %s\n", val[i], val[j],
mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
printf ("z = ");
mpfr_out_str (stdout, 10, 0, z, MPFR_RNDN);
printf ("\ninex = %d\n", inex);
exit (1);
}
static void
err (const char *str, mp_size_t s, mpfr_t x, mpfr_t y, mpfr_prec_t p,
mpfr_rnd_t r, int trint, int inexact)
{
printf ("Error: %s\ns = %u, p = %u, r = %s, trint = %d, inexact = %d\nx = ",
str, (unsigned int) s, (unsigned int) p, mpfr_print_rnd_mode (r),
trint, inexact);
mpfr_print_binary (x);
printf ("\ny = ");
mpfr_print_binary (y);
printf ("\n");
exit (1);
}
/* Arguments:
* spx: non-zero if px is a stringm zero if px is a MPFR number.
* px: value of x (string or MPFR number).
* sy: value of y (string).
* rnd: rounding mode.
* z1: expected result (null pointer if unknown pure FP value).
* inex1: expected ternary value (if z1 is not a null pointer).
* z2: computed result.
* inex2: computed ternary value.
* flags1: expected flags (computed flags in __gmpfr_flags).
* s1, s2: strings about the context.
*/
static void
cmpres (int spx, const void *px, const char *sy, mpfr_rnd_t rnd,
mpfr_srcptr z1, int inex1, mpfr_srcptr z2, int inex2,
unsigned int flags1, const char *s1, const char *s2)
{
unsigned int flags2 = __gmpfr_flags;
if (flags1 == flags2)
{
/* Note: the test on the sign of z1 and z2 is needed
in case they are both zeros. */
if (z1 == NULL)
{
if (MPFR_IS_PURE_FP (z2))
return;
}
else if (SAME_SIGN (inex1, inex2) &&
((MPFR_IS_NAN (z1) && MPFR_IS_NAN (z2)) ||
((MPFR_IS_NEG (z1) ^ MPFR_IS_NEG (z2)) == 0 &&
mpfr_equal_p (z1, z2))))
return;
}
printf ("Error in %s\nwith %s%s\nx = ", s1, s2,
ext ? ", extended exponent range" : "");
if (spx)
printf ("%s, ", (char *) px);
else
{
mpfr_out_str (stdout, 16, 0, (mpfr_ptr) px, MPFR_RNDN);
puts (",");
}
printf ("y = %s, %s\n", sy, mpfr_print_rnd_mode (rnd));
printf ("Expected ");
if (z1 == NULL)
{
printf ("pure FP value, flags = %u\n", flags1);
}
else
{
mpfr_out_str (stdout, 16, 0, z1, MPFR_RNDN);
printf (", inex = %d, flags = %u\n", SIGN (inex1), flags1);
}
printf ("Got ");
mpfr_out_str (stdout, 16, 0, z2, MPFR_RNDN);
printf (", inex = %d, flags = %u\n", SIGN (inex2), flags2);
if (all_cmpres_errors != 0)
all_cmpres_errors = -1;
else
exit (1);
}
/* if u = o(x-y), v = o(u-x), w = o(v+y), then x-y = u-w */
static void
check_two_sum (mpfr_prec_t p)
{
mpfr_t x, y, u, v, w;
mpfr_rnd_t rnd;
int inexact;
mpfr_init2 (x, p);
mpfr_init2 (y, p);
mpfr_init2 (u, p);
mpfr_init2 (v, p);
mpfr_init2 (w, p);
mpfr_urandomb (x, RANDS);
mpfr_urandomb (y, RANDS);
if (mpfr_cmpabs (x, y) < 0)
mpfr_swap (x, y);
rnd = MPFR_RNDN;
inexact = test_sub (u, x, y, rnd);
test_sub (v, u, x, rnd);
mpfr_add (w, v, y, rnd);
/* as u = (x-y) - w, we should have inexact and w of opposite signs */
if (((inexact == 0) && mpfr_cmp_ui (w, 0)) ||
((inexact > 0) && (mpfr_cmp_ui (w, 0) <= 0)) ||
((inexact < 0) && (mpfr_cmp_ui (w, 0) >= 0)))
{
printf ("Wrong inexact flag for prec=%u, rnd=%s\n", (unsigned)p,
mpfr_print_rnd_mode (rnd));
printf ("x=");
mpfr_print_binary(x);
puts ("");
printf ("y=");
mpfr_print_binary(y);
puts ("");
printf ("u=");
mpfr_print_binary(u);
puts ("");
printf ("v=");
mpfr_print_binary(v);
puts ("");
printf ("w=");
mpfr_print_binary(w);
puts ("");
printf ("inexact = %d\n", inexact);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (u);
mpfr_clear (v);
mpfr_clear (w);
}
static void
bug20120829 (void)
{
mpfr_t x1, x2, e;
int inex1, inex2, i, r;
char s[48] = "1e-1";
mpfr_init2 (e, 128);
mpfr_inits2 (4, x1, x2, (mpfr_ptr) 0);
inex1 = mpfr_set_si (e, -1, MPFR_RNDN);
MPFR_ASSERTN (inex1 == 0);
for (i = 1; i <= sizeof(s) - 5; i++)
{
s[3+i] = '0';
s[4+i] = 0;
inex1 = mpfr_mul_ui (e, e, 10, MPFR_RNDN);
MPFR_ASSERTN (inex1 == 0);
RND_LOOP(r)
{
mpfr_rnd_t rnd = (mpfr_rnd_t) r;
inex1 = mpfr_exp10 (x1, e, rnd);
inex1 = SIGN (inex1);
inex2 = mpfr_strtofr (x2, s, NULL, 0, rnd);
inex2 = SIGN (inex2);
/* On 32-bit machines, for i = 7, r8389, r8391 and r8394 do:
strtofr.c:...: MPFR assertion failed: cy == 0
r8396 is OK.
On 64-bit machines, for i = 15,
r8389 does: strtofr.c:678: MPFR assertion failed: err < (64 - 0)
r8391 does: strtofr.c:680: MPFR assertion failed: h < ysize
r8394 and r8396 are OK.
*/
if (! mpfr_equal_p (x1, x2) || inex1 != inex2)
{
printf ("Error in bug20120829 for i = %d, rnd = %s\n",
i, mpfr_print_rnd_mode (rnd));
printf ("Expected inex = %d, x = ", inex1);
mpfr_dump (x1);
printf ("Got inex = %d, x = ", inex2);
mpfr_dump (x2);
exit (1);
}
}
}
mpfr_clears (e, x1, x2, (mpfr_ptr) 0);
}
/* Test default rounding mode */
static void
check_default_rnd (void)
{
int r;
mpfr_rnd_t t;
for(r = 0 ; r < MPFR_RND_MAX ; r++)
{
mpfr_set_default_rounding_mode ((mpfr_rnd_t) r);
t = (mpfr_get_default_rounding_mode) ();
if ((mpfr_rnd_t) r != t)
{
printf ("%s %s\n", mpfr_print_rnd_mode ((mpfr_rnd_t) r),
mpfr_print_rnd_mode (t));
ERROR("ERROR in setting / getting default rounding mode (1)");
}
}
mpfr_set_default_rounding_mode ((mpfr_rnd_t) MPFR_RND_MAX);
if (mpfr_get_default_rounding_mode() != MPFR_RNDA)
ERROR("ERROR in setting / getting default rounding mode (2)");
mpfr_set_default_rounding_mode((mpfr_rnd_t) -1);
if (mpfr_get_default_rounding_mode() != MPFR_RNDA)
ERROR("ERROR in setting / getting default rounding mode (3)");
}
static void
tgeneric_cuuc (mpc_function *function, unsigned long int op1,
unsigned long int op2, mpc_ptr op3, mpc_ptr rop,
mpc_ptr rop4, mpc_ptr rop4rnd, mpc_rnd_t rnd)
{
known_signs_t ks = {1, 1};
function->pointer.CUUC (rop4, op1, op2, op3, rnd);
function->pointer.CUUC (rop, op1, op2, op3, rnd);
if (MPFR_CAN_ROUND (mpc_realref (rop4), 1, MPC_PREC_RE (rop),
MPC_RND_RE (rnd))
&& MPFR_CAN_ROUND (mpc_imagref (rop4), 1, MPC_PREC_IM (rop),
MPC_RND_IM (rnd)))
mpc_set (rop4rnd, rop4, rnd);
else
return;
if (same_mpc_value (rop, rop4rnd, ks))
return;
printf ("Rounding in %s might be incorrect for\n", function->name);
printf ("op1=%lu\n", op1);
printf ("op2=%lu\n", op2);
MPC_OUT (op3);
printf ("with rounding mode (%s, %s)",
mpfr_print_rnd_mode (MPC_RND_RE (rnd)),
mpfr_print_rnd_mode (MPC_RND_IM (rnd)));
printf ("\n%s gives ", function->name);
MPC_OUT (rop);
printf ("%s quadruple precision gives ", function->name);
MPC_OUT (rop4);
printf ("and is rounded to ");
MPC_OUT (rop4rnd);
exit (1);
}
/* Occurs in branches/new-sum/src/sum.c@9344 on a 64-bit machine. */
static void
bug20150327 (void)
{
mpfr_t sum1, sum2, t[3];
mpfr_ptr p[3];
char *s[3] = { "0.10000111110101000010101011100001", "1E-100", "0.1E95" };
int i, r;
mpfr_inits2 (58, sum1, sum2, (mpfr_ptr) 0);
for (i = 0; i < 3; i++)
{
mpfr_init2 (t[i], 64);
mpfr_set_str (t[i], s[i], 2, MPFR_RNDN);
p[i] = t[i];
}
RND_LOOP(r)
{
int inex1, inex2;
mpfr_set (sum1, t[2], MPFR_RNDN);
inex1 = -1;
if (MPFR_IS_LIKE_RNDU ((mpfr_rnd_t) r, 1))
{
mpfr_nextabove (sum1);
inex1 = 1;
}
inex2 = mpfr_sum (sum2, p, 3, (mpfr_rnd_t) r);
if (!(mpfr_equal_p (sum1, sum2) && SAME_SIGN (inex1, inex2)))
{
printf ("mpfr_sum incorrect in bug20150327 for %s:\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r));
printf ("Expected ");
mpfr_dump (sum1);
printf ("with inex = %d\n", inex1);
printf ("Got ");
mpfr_dump (sum2);
printf ("with inex = %d\n", inex2);
exit (1);
}
}
for (i = 0; i < 3; i++)
mpfr_clear (t[i]);
mpfr_clears (sum1, sum2, (mpfr_ptr) 0);
}
static void
cmpmul (mpc_srcptr x, mpc_srcptr y, mpc_rnd_t rnd)
/* computes the product of x and y with the naive and Karatsuba methods */
/* using the rounding mode rnd and compares the results and return */
/* values. */
/* In our current test suite, the real and imaginary parts of x and y */
/* all have the same precision, and we use this precision also for the */
/* result. */
{
mpc_t z, t;
int inex_z, inex_t;
mpc_init2 (z, MPC_MAX_PREC (x));
mpc_init2 (t, MPC_MAX_PREC (x));
inex_z = mpc_mul_naive (z, x, y, rnd);
inex_t = mpc_mul_karatsuba (t, x, y, rnd);
if (mpc_cmp (z, t) != 0 || inex_z != inex_t) {
fprintf (stderr, "mul_naive and mul_karatsuba differ for rnd=(%s,%s)\n",
mpfr_print_rnd_mode(MPC_RND_RE(rnd)),
mpfr_print_rnd_mode(MPC_RND_IM(rnd)));
MPC_OUT (x);
MPC_OUT (y);
MPC_OUT (z);
MPC_OUT (t);
if (inex_z != inex_t) {
fprintf (stderr, "inex_re (z): %s\n", MPC_INEX_STR (inex_z));
fprintf (stderr, "inex_re (t): %s\n", MPC_INEX_STR (inex_t));
}
exit (1);
}
mpc_clear (z);
mpc_clear (t);
}
static void
check_convergence (void)
{
mpfr_t x, y; int i, j;
mpfr_init2(x, 130);
mpfr_set_str_binary(x, "0.1011111101011010101000001010011111101000011100011101010011111011000011001010000000111100100111110011001010110100100001001000111001E6944");
mpfr_init2(y, 130);
mpfr_set_ui(y, 5, MPFR_RNDN);
test_div(x, x, y, MPFR_RNDD); /* exact division */
mpfr_set_prec(x, 64);
mpfr_set_prec(y, 64);
mpfr_set_str_binary(x, "0.10010010011011010100101001010111100000101110010010101E55");
mpfr_set_str_binary(y, "0.1E585");
test_div(x, x, y, MPFR_RNDN);
mpfr_set_str_binary(y, "0.10010010011011010100101001010111100000101110010010101E-529");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_div for prec=64, rnd=MPFR_RNDN\n");
printf ("got "); mpfr_print_binary(x); puts ("");
printf ("instead of "); mpfr_print_binary(y); puts ("");
exit(1);
}
for (i=32; i<=64; i+=32)
{
mpfr_set_prec(x, i);
mpfr_set_prec(y, i);
mpfr_set_ui(x, 1, MPFR_RNDN);
RND_LOOP(j)
{
mpfr_set_ui (y, 1, MPFR_RNDN);
test_div (y, x, y, (mpfr_rnd_t) j);
if (mpfr_cmp_ui (y, 1))
{
printf ("mpfr_div failed for x=1.0, y=1.0, prec=%d rnd=%s\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) j));
printf ("got "); mpfr_print_binary(y); puts ("");
exit (1);
}
}
}
mpfr_clear (x);
mpfr_clear (y);
}
static void
check (unsigned long a, mp_rnd_t rnd_mode, const char *qs)
{
mpfr_t q;
mpfr_init2 (q, 53);
mpfr_sqrt_ui (q, a, rnd_mode);
if (mpfr_cmp_str1 (q, qs))
{
printf ("mpfr_sqrt_ui failed for a=%lu, rnd_mode=%s\n",
a, mpfr_print_rnd_mode (rnd_mode));
printf ("sqrt gives %s, mpfr_sqrt_ui gives ", qs);
mpfr_out_str(stdout, 10, 0, q, GMP_RNDN);
exit (1);
}
mpfr_clear (q);
}
static void
compare_exp2_exp3 (int n)
{
mpfr_t x, y, z; int prec; mp_rnd_t rnd;
mpfr_init (x);
mpfr_init (y);
mpfr_init (z);
for (prec = 20; prec <= n; prec++)
{
mpfr_set_prec (x, prec);
mpfr_set_prec (y, prec);
mpfr_set_prec (z, prec);
mpfr_random (x);
rnd = (mp_rnd_t) RND_RAND();
mpfr_exp_2 (y, x, rnd);
mpfr_exp_3 (z, x, rnd);
if (mpfr_cmp (y,z))
{
printf ("mpfr_exp_2 and mpfr_exp_3 disagree for rnd=%s and\nx=",
mpfr_print_rnd_mode (rnd));
mpfr_print_binary (x);
puts ("");
printf ("mpfr_exp_2 gives ");
mpfr_print_binary (y);
puts ("");
printf ("mpfr_exp_3 gives ");
mpfr_print_binary (z);
puts ("");
exit (1);
}
}
/* bug found by Patrick Pe'lissier on 7 Jun 2004 */
prec = 203780;
mpfr_set_prec (x, prec);
mpfr_set_prec (z, prec);
mpfr_set_d (x, 3.0, GMP_RNDN);
mpfr_sqrt (x, x, GMP_RNDN);
mpfr_sub_ui (x, x, 1, GMP_RNDN);
mpfr_exp_3 (z, x, GMP_RNDN);
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
}
/* bug reported by Joseph S. Myers on 2013-10-27
https://sympa.inria.fr/sympa/arc/mpfr/2013-10/msg00015.html */
static void
bug20131027 (void)
{
mpfr_t sum, t[4];
mpfr_ptr p[4];
char *s[4] = {
"0x1p1000",
"-0x0.fffffffffffff80000000000000001p1000",
"-0x1p947",
"0x1p880"
};
int i, r;
mpfr_init2 (sum, 53);
for (i = 0; i < 4; i++)
{
mpfr_init2 (t[i], i == 0 ? 53 : 1000);
mpfr_set_str (t[i], s[i], 0, MPFR_RNDN);
p[i] = t[i];
}
RND_LOOP(r)
{
int expected_sign = (mpfr_rnd_t) r == MPFR_RNDD ? -1 : 1;
int inex;
inex = mpfr_sum (sum, p, 4, (mpfr_rnd_t) r);
if (MPFR_NOTZERO (sum) || MPFR_SIGN (sum) != expected_sign || inex != 0)
{
printf ("mpfr_sum incorrect in bug20131027 for %s:\n"
"expected %c0 with inex = 0, got ",
mpfr_print_rnd_mode ((mpfr_rnd_t) r),
expected_sign > 0 ? '+' : '-');
mpfr_dump (sum);
printf ("with inex = %d\n", inex);
exit (1);
}
}
for (i = 0; i < 4; i++)
mpfr_clear (t[i]);
mpfr_clear (sum);
}
static void
check_equal (mpfr_srcptr a, mpfr_srcptr a2, char *s,
mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t r)
{
if ((MPFR_IS_NAN (a) && MPFR_IS_NAN (a2)) ||
mpfr_equal_p (a, a2))
return;
printf ("Error in %s\n", mpfr_print_rnd_mode (r));
printf ("b = ");
mpfr_dump (b);
printf ("c = ");
mpfr_dump (c);
printf ("mpfr_div result: ");
mpfr_dump (a);
printf ("%s result: ", s);
mpfr_dump (a2);
exit (1);
}
/* 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 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, 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 (long int n, long int d, mpfr_rnd_t rnd, const char *ys)
{
mpq_t q;
mpfr_t x, t;
int inexact, compare;
mpfr_init2 (x, 53);
mpfr_init2 (t, mpfr_get_prec (x) + mp_bits_per_limb);
mpq_init (q);
mpq_set_si (q, n, d);
inexact = mpfr_set_q (x, q, rnd);
/* check values */
if (mpfr_cmp_str1(x, ys))
{
printf ("Error for q=%ld/%ld and rnd=%s\n", n, d,
mpfr_print_rnd_mode (rnd));
printf ("correct result is %s, mpfr_set_q gives ", ys);
mpfr_out_str(stdout, 10, 0, x, MPFR_RNDN);
putchar('\n');
exit (1);
}
/* check inexact flag */
if (mpfr_mul_ui (t, x, (d < 0) ? (-d) : d, rnd))
{
printf ("t <- x * d should be exact\n");
exit (1);
}
compare = mpfr_cmp_si (t, n);
if (((inexact == 0) && (compare != 0)) ||
((inexact < 0) && (compare >= 0)) ||
((inexact > 0) && (compare <= 0)))
{
printf ("wrong inexact flag: expected %d, got %d\n", compare,
inexact);
exit (1);
}
mpfr_clear (x);
mpfr_clear (t);
mpq_clear (q);
}
static void
check_sj (intmax_t s, mpfr_ptr x)
{
mpfr_t y;
int i;
mpfr_init2 (y, MPFR_PREC (x));
for (i = -1; i <= 1; i++)
{
int rnd;
mpfr_set_si_2exp (y, i, -2, MPFR_RNDN);
mpfr_add (y, y, x, MPFR_RNDN);
for (rnd = 0; rnd < MPFR_RND_MAX; rnd++)
{
intmax_t r;
if (rnd == MPFR_RNDZ && i < 0 && s >= 0)
continue;
if (rnd == MPFR_RNDZ && i > 0 && s <= 0)
continue;
if (rnd == MPFR_RNDD && i < 0)
continue;
if (rnd == MPFR_RNDU && i > 0)
continue;
if (rnd == MPFR_RNDA && ((MPFR_IS_POS(y) && i > 0) ||
(MPFR_IS_NEG(y) && i < 0)))
continue;
/* rint (y) == x == s */
r = mpfr_get_sj (y, (mpfr_rnd_t) rnd);
if (r != s)
{
printf ("Error in check_sj for y = ");
mpfr_out_str (stdout, 2, 0, y, MPFR_RNDN);
printf (" in %s\n", mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
printf ("Got %jd instead of %jd.\n", r, s);
exit (1);
}
}
}
mpfr_clear (y);
}
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
check53 (const char *xs, const char *cos_xs, mpfr_rnd_t rnd_mode)
{
mpfr_t xx, c;
mpfr_inits2 (53, xx, c, (mpfr_ptr) 0);
mpfr_set_str1 (xx, xs); /* should be exact */
test_cos (c, xx, rnd_mode);
if (mpfr_cmp_str1 (c, cos_xs))
{
printf ("mpfr_cos failed for x=%s, rnd=%s\n",
xs, mpfr_print_rnd_mode (rnd_mode));
printf ("mpfr_cos gives cos(x)=");
mpfr_out_str(stdout, 10, 0, c, MPFR_RNDN);
printf(", expected %s\n", cos_xs);
exit (1);
}
mpfr_clears (xx, c, (mpfr_ptr) 0);
}
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);
}
