static void
test_specialq (mp_prec_t p0, mp_prec_t p1, unsigned int N,
int (*mpfr_func)(mpfr_ptr, mpfr_srcptr, mpq_srcptr, mp_rnd_t),
void (*mpq_func)(mpq_ptr, mpq_srcptr, mpq_srcptr),
const char *op)
{
mpfr_t fra, frb, frq;
mpq_t q1, q2, qr;
unsigned int n;
mp_prec_t prec;
for (prec = p0 ; prec < p1 ; prec++)
{
mpfr_inits2 (prec, fra, frb, frq, (void *) 0);
mpq_init (q1); mpq_init(q2); mpq_init (qr);
for( n = 0 ; n < N ; n++)
{
mpq_set_ui(q1, randlimb(), randlimb() );
mpq_set_ui(q2, randlimb(), randlimb() );
mpq_canonicalize (q1);
mpq_canonicalize (q2);
mpq_func (qr, q1, q2);
mpfr_set_q (fra, q1, GMP_RNDD);
mpfr_func (fra, fra, q2, GMP_RNDD);
mpfr_set_q (frb, q1, GMP_RNDU);
mpfr_func (frb, frb, q2, GMP_RNDU);
mpfr_set_q (frq, qr, GMP_RNDN);
/* We should have fra <= qr <= frb */
if ( (mpfr_cmp(fra, frq) > 0) || (mpfr_cmp (frq, frb) > 0))
{
printf("Range error for prec=%lu and %s", prec, op);
printf ("\nq1="); mpq_out_str(stdout, 2, q1);
printf ("\nq2="); mpq_out_str(stdout, 2, q2);
printf ("\nfr_dn="); mpfr_print_binary (fra);
printf ("\nfr_q ="); mpfr_print_binary (frq);
printf ("\nfr_up="); mpfr_print_binary (frb);
putchar('\n');
exit (1);
}
}
mpq_clear (q1); mpq_clear (q2); mpq_clear (qr);
mpfr_clears (fra, frb, frq, (void *) 0);
}
}
static void
test2ui (int (*testfunc)(mpfr_ptr, mpfr_srcptr, unsigned long int, mp_rnd_t),
char *foo, mp_prec_t prec, mp_rnd_t rnd)
{
mpfr_t ref1, ref2;
unsigned int ref3;
mpfr_t res1;
int i;
#ifdef DEBUG
printf("checking %s\n", foo);
#endif
mpfr_init2 (ref1, prec);
mpfr_init2 (ref2, prec);
mpfr_init2 (res1, prec);
/* ref2 can be NaN, +Inf, -Inf, +0, -0 or any number
ref3 can be 0 or any number */
for (i=0; i<SPECIAL_MAX*2; i++)
{
set_special (ref2, i%SPECIAL_MAX);
ref3 = i/SPECIAL_MAX == 0 ? 0 : randlimb ();
/* reference call: foo(a, b, c) */
testfunc (ref1, ref2, ref3, rnd);
/* foo(a, a, c) */
mpfr_set (res1, ref2, rnd); /* exact operation */
testfunc (res1, res1, ref3, rnd);
if (mpfr_compare (res1, ref1))
{
printf ("Error for %s(a, a, c) for c=%u\n", foo, ref3);
DISP2("a=",ref2);
printf ("expected "); mpfr_print_binary (ref1); puts ("");
printf ("got "); mpfr_print_binary (res1); puts ("");
exit (1);
}
}
mpfr_clear (ref1);
mpfr_clear (ref2);
mpfr_clear (res1);
}
/* 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
compare_exp2_exp3 (mpfr_prec_t p0, mpfr_prec_t p1)
{
mpfr_t x, y, z;
mpfr_prec_t prec;
mpfr_rnd_t rnd;
mpfr_init (x);
mpfr_init (y);
mpfr_init (z);
for (prec = p0; prec <= p1; prec ++)
{
mpfr_set_prec (x, prec);
mpfr_set_prec (y, prec);
mpfr_set_prec (z, prec);
do
mpfr_urandomb (x, RANDS);
while (MPFR_IS_ZERO (x)); /* 0 is handled by mpfr_exp only */
rnd = 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);
}
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
}
void
check2a (double x, int px, double y, int py, int pz, mp_rnd_t rnd_mode,
char *res)
{
mpfr_t xx, yy, zz;
mpfr_init2(xx,px); mpfr_init2(yy,py); mpfr_init2(zz,pz);
mpfr_set_d(xx, x, rnd_mode);
mpfr_set_d(yy, y, rnd_mode);
mpfr_add(zz, xx, yy, rnd_mode);
mpfr_set_prec(xx, pz);
mpfr_set_str(xx, res, 16, GMP_RNDN);
if (mpfr_cmp(xx, zz)) {
printf("x=%1.20e,%d y=%1.20e,%d pz=%d,rnd=%s\n",
x,px,y,py,pz,mpfr_print_rnd_mode(rnd_mode));
printf("got "); mpfr_print_binary(zz); putchar('\n');
printf("instead of "); mpfr_print_binary(xx); putchar('\n');
exit(1);
}
mpfr_clear(xx); mpfr_clear(yy); mpfr_clear(zz);
}
static void
teq (mpfr_t x)
{
mpfr_t y;
unsigned long k, px, mx;
mpfr_init2 (y, MPFR_PREC(x));
mx = (MPFR_PREC(x) - 1) / mp_bits_per_limb;
px = mp_bits_per_limb - 2;
for (k = 2; k < MPFR_PREC(x); k++)
{
mpfr_set (y, x, MPFR_RNDN);
MPFR_MANT(y) [mx] ^= (mp_limb_t) 1 << px;
if (mpfr_eq(y, x, k) || !mpfr_eq(y, x, k - 1))
{
printf ("Error in eq.\n");
printf ("x = "); mpfr_print_binary (x); printf ("\n");
printf ("y = "); mpfr_print_binary (y); printf ("\n");
printf ("k = %lu\n", k);
printf ("mpfr_eq(y, x, k) = %d\nmpfr_eq(y, x, k - 1) = %d\n",
mpfr_eq (y, x, k), mpfr_eq (y, x, k - 1));
exit (1);
}
if (px)
{
--px;
}
else
{
--mx;
px = mp_bits_per_limb - 1;
}
}
mpfr_clear (y);
}
static void
atan2_pow_of_2 (void)
{
mpfr_t x, y, r, g;
int i;
int d[] = { 0, -1, 1 };
int ntests = numberof (d);
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
mpfr_init2 (r, 53);
mpfr_init2 (g, 53);
/* atan(42) */
mpfr_set_str_binary (g, "1100011000000011110011111001100110101000011010010011E-51");
for (i = 0; i < ntests; ++i)
{
mpfr_set_ui (y, 42, MPFR_RNDN);
mpfr_mul_2si (y, y, d[i], MPFR_RNDN);
mpfr_set_ui_2exp (x, 1, d[i], MPFR_RNDN);
mpfr_atan2 (r, y, x, MPFR_RNDN);
if (mpfr_equal_p (r, g) == 0)
{
printf ("Error in mpfr_atan2 (5)\n");
printf ("Expected ");
mpfr_print_binary (g);
printf ("\n");
printf ("Got ");
mpfr_print_binary (r);
printf ("\n");
exit (1);
}
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (r);
mpfr_clear (g);
}
static void
bug_ddefour(void)
{
mpfr_t ex, ex1, ex2, ex3, tot, tot1;
mpfr_init2(ex, 53);
mpfr_init2(ex1, 53);
mpfr_init2(ex2, 53);
mpfr_init2(ex3, 53);
mpfr_init2(tot, 150);
mpfr_init2(tot1, 150);
mpfr_set_ui( ex, 1, MPFR_RNDN);
mpfr_mul_2exp( ex, ex, 906, MPFR_RNDN);
mpfr_log( tot, ex, MPFR_RNDN);
mpfr_set( ex1, tot, MPFR_RNDN); /* ex1 = high(tot) */
test_sub( ex2, tot, ex1, MPFR_RNDN); /* ex2 = high(tot - ex1) */
test_sub( tot1, tot, ex1, MPFR_RNDN); /* tot1 = tot - ex1 */
mpfr_set( ex3, tot1, MPFR_RNDN); /* ex3 = high(tot - ex1) */
if (mpfr_cmp(ex2, ex3))
{
printf ("Error in ddefour test.\n");
printf ("ex2=");
mpfr_print_binary (ex2);
puts ("");
printf ("ex3=");
mpfr_print_binary (ex3);
puts ("");
exit (1);
}
mpfr_clear (ex);
mpfr_clear (ex1);
mpfr_clear (ex2);
mpfr_clear (ex3);
mpfr_clear (tot);
mpfr_clear (tot1);
}
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);
}
static void
check2b (const char *xs, int px,
const char *ys, int py,
const char *rs, int pz,
mp_rnd_t rnd_mode)
{
mpfr_t xx, yy, zz;
mpfr_init2(xx,px); mpfr_init2(yy,py); mpfr_init2(zz,pz);
mpfr_set_str_binary (xx, xs);
mpfr_set_str_binary (yy, ys);
test_add (zz, xx, yy, rnd_mode);
if (mpfr_cmp_str (zz, rs, 2, GMP_RNDN))
{
printf ("(2) x=%s,%d y=%s,%d pz=%d,rnd=%s\n",
xs, px, ys, py, pz, mpfr_print_rnd_mode (rnd_mode));
printf ("got "); mpfr_print_binary(zz); puts ("");
mpfr_set_str(zz, rs, 2, GMP_RNDN);
printf ("instead of "); mpfr_print_binary(zz); puts ("");
exit (1);
}
mpfr_clear(xx); mpfr_clear(yy); mpfr_clear(zz);
}
static void
check_inexact (mpfr_prec_t p)
{
mpfr_t x, y, z;
mpfr_rnd_t rnd;
int inexact, sign;
mpfr_init2 (x, p);
mpfr_init2 (y, p);
mpfr_init2 (z, 2*p);
mpfr_urandomb (x, RANDS);
rnd = RND_RAND ();
inexact = test_sqrt (y, x, rnd);
if (mpfr_mul (z, y, y, rnd)) /* exact since prec(z) = 2*prec(y) */
{
printf ("Error: multiplication should be exact\n");
exit (1);
}
mpfr_sub (z, z, x, rnd); /* exact also */
sign = mpfr_cmp_ui (z, 0);
if (((inexact == 0) && (sign)) ||
((inexact > 0) && (sign <= 0)) ||
((inexact < 0) && (sign >= 0)))
{
printf ("Error: wrong inexact flag, expected %d, got %d\n",
sign, inexact);
printf ("x=");
mpfr_print_binary (x);
printf (" rnd=%s\n", mpfr_print_rnd_mode (rnd));
printf ("y="); mpfr_print_binary (y); puts ("");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
}
static void
check_64(void)
{
mpfr_t x,y,z;
mpfr_inits2 (64, x, y, z, (mpfr_ptr) 0);
mpfr_set_str_binary(x, "1.00100100110110101001010010101111000001011100100101010000000000E54");
mpfr_set_str_binary(y, "1.00000000000000000000000000000000000000000000000000000000000000E584");
test_div(z, x, y, MPFR_RNDU);
if (mpfr_cmp_str (z, "0.1001001001101101010010100101011110000010111001001010100000000000E-529", 2, MPFR_RNDN))
{
printf("Error for tdiv for MPFR_RNDU and p=64\nx=");
mpfr_print_binary(x);
printf("\ny=");
mpfr_print_binary(y);
printf("\ngot ");
mpfr_print_binary(z);
printf("\nexpected 0.1001001001101101010010100101011110000010111001001010100000000000E-529\n");
exit(1);
}
mpfr_clears (x, y, z, (mpfr_ptr) 0);
}
/* FastTwoSum: if EXP(x) >= EXP(y), u = o(x+y), v = o(u-x), w = o(y-v),
then x + y = u + w
thus if u = o(y-x), v = o(u+x), w = o(v-y), then y-x = u-w */
static void
check_two_sum (mpfr_prec_t p)
{
unsigned int x;
mpfr_t y, u, v, w;
mpfr_rnd_t rnd;
int inexact;
mpfr_inits2 (p, y, u, v, w, (mpfr_ptr) 0);
do
{
x = randlimb ();
}
while (x < 1);
mpfr_urandomb (y, RANDS);
rnd = MPFR_RNDN;
inexact = mpfr_sub_ui (u, y, x, rnd);
mpfr_add_ui (v, u, x, rnd);
mpfr_sub (w, v, y, rnd);
/* as u - (y-x) = w, we should have inexact and w of same sign */
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 int) p, mpfr_print_rnd_mode (rnd));
printf ("x=%u\n", x);
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_clears (y, u, v, w, (mpfr_ptr) 0);
}
static void
check3 (double d, unsigned long prec, mp_rnd_t rnd)
{
mpfr_t x, y;
mpfr_init2 (x, prec);
mpfr_init2 (y, prec);
mpfr_set_d (x, d, rnd);
test_log (y, x, rnd);
mpfr_out_str (stdout, 10, 0, y, rnd);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
}
static void
coverage_mpfr_mul_q_20110218 (void)
{
mpfr_t cmp, res, op1;
mpq_t op2;
int status;
mpfr_init2 (cmp, MPFR_PREC_MIN);
mpfr_init2 (res, MPFR_PREC_MIN);
mpfr_init_set_si (op1, 1, MPFR_RNDN);
mpq_init (op2);
mpq_set_si (op2, 0, 0);
mpz_set_si (mpq_denref (op2), 0);
status = mpfr_mul_q (res, op1, op2, MPFR_RNDN);
if ((status != 0) || (mpfr_cmp (cmp, res) != 0))
{
printf ("Results differ %d.\nres=", status);
mpfr_dump (res);
printf ("cmp=");
mpfr_dump (cmp);
exit (1);
}
mpfr_set_si (op1, 1, MPFR_RNDN);
mpq_set_si (op2, -1, 0);
status = mpfr_mul_q (res, op1, op2, MPFR_RNDN);
mpfr_set_inf (cmp, -1);
if ((status != 0) || (mpfr_cmp(res, cmp) != 0))
{
printf ("mpfr_mul_q 1 * (-1/0) returned a wrong value :\n waiting for ");
mpfr_print_binary (cmp);
printf (" got ");
mpfr_dump (res);
printf ("ternary value is %d\n", status);
exit (1);
}
mpq_clear (op2);
mpfr_clear (op1);
mpfr_clear (res);
mpfr_clear (cmp);
}
void
check_inexact (mp_prec_t p)
{
mpfr_t x, y, z, t;
unsigned long u;
mp_prec_t q;
int inexact, cmp;
mp_rnd_t rnd;
mpfr_init2 (x, p);
mpfr_init (y);
mpfr_init (z);
mpfr_init (t);
mpfr_random (x);
u = LONG_RAND() % 2;
for (q=2; q<=p; q++)
for (rnd=0; rnd<4; rnd++)
{
mpfr_set_prec (y, q);
mpfr_set_prec (z, q + 10);
mpfr_set_prec (t, q);
inexact = mpfr_pow_ui (y, x, u, rnd);
cmp = mpfr_pow_ui (z, x, u, rnd);
if (mpfr_can_round (z, q + 10, rnd, rnd, q))
{
cmp = mpfr_set (t, z, rnd) || cmp;
if (mpfr_cmp (y, t))
{
fprintf (stderr, "results differ for u=%lu rnd=%s\n", u,
mpfr_print_rnd_mode(rnd));
printf ("x="); mpfr_print_binary (x); putchar ('\n');
printf ("y="); mpfr_print_binary (y); putchar ('\n');
printf ("t="); mpfr_print_binary (t); putchar ('\n');
printf ("z="); mpfr_print_binary (z); putchar ('\n');
exit (1);
}
if (((inexact == 0) && (cmp != 0)) ||
((inexact != 0) && (cmp == 0)))
{
fprintf (stderr, "Wrong inexact flag for p=%u, q=%u, rnd=%s\n",
(unsigned) p, (unsigned) q, mpfr_print_rnd_mode (rnd));
printf ("expected %d, got %d\n", cmp, inexact);
printf ("u=%lu x=", u); mpfr_print_binary (x); putchar ('\n');
printf ("y="); mpfr_print_binary (y); putchar ('\n');
exit (1);
}
}
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (t);
}
/* 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);
}
static void
special (void)
{
mpfr_t x, y;
int inex1, inex2;
mpfr_init2 (x, 32);
mpfr_init2 (y, 32);
mpfr_set_str_binary (x, "0.10001000001001011000100001E-6");
mpfr_acos (y, x, MPFR_RNDN);
mpfr_set_str_binary (x, "1.10001111111111110001110110001");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_acos (1)\n");
exit (1);
}
mpfr_set_str_binary (x, "-0.01101011110111100111010011001011");
mpfr_acos (y, x, MPFR_RNDZ);
mpfr_set_str_binary (x, "10.0000000101111000011101000101");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_acos (2)\n");
mpfr_print_binary (y); printf ("\n");
exit (1);
}
mpfr_set_prec (x, 2);
mpfr_set_ui (x, 0, MPFR_RNDN);
inex1 = mpfr_acos (x, x, MPFR_RNDN); /* Pi/2 */
inex2 = mpfr_const_pi (x, MPFR_RNDN);
if (inex1 != inex2)
{
printf ("Error in mpfr_acos (3) for prec=2\n");
exit (1);
}
mpfr_clear (y);
mpfr_clear (x);
}
void
check2 (double x, int px, double y, int py, int pz, mp_rnd_t rnd_mode)
{
mpfr_t xx, yy, zz; double z,z2; int u;
mpfr_init2(xx,px); mpfr_init2(yy,py); mpfr_init2(zz,pz);
mpfr_set_d(xx, x, rnd_mode);
mpfr_set_d(yy, y, rnd_mode);
mpfr_add(zz, xx, yy, rnd_mode);
mpfr_set_machine_rnd_mode(rnd_mode);
z = x+y; z2=mpfr_get_d1 (zz); u=ulp(z,z2);
/* one ulp difference is possible due to composed rounding */
if (px>=53 && py>=53 && pz>=53 && ABS(u)>1) {
printf("x=%1.20e,%d y=%1.20e,%d pz=%d,rnd=%s\n",
x,px,y,py,pz,mpfr_print_rnd_mode(rnd_mode));
printf("got %1.20e\n",z2);
printf("result should be %1.20e (diff=%d ulp)\n",z,u);
mpfr_set_d(zz, z, rnd_mode);
printf("i.e."); mpfr_print_binary(zz); putchar('\n');
exit(1); }
mpfr_clear(xx); mpfr_clear(yy); mpfr_clear(zz);
}
int
main (int argc, char *argv[])
{
unsigned int prec, err, yprec, n, k, zeros;
int rnd;
mpfr_t x, y, z, t;
int inexact;
tests_start_mpfr ();
special ();
test_int ();
mpfr_init (x);
mpfr_init (y);
mpfr_init (z);
mpfr_init (t);
mpfr_fac_ui (y, 0, GMP_RNDN);
if (mpfr_cmp_ui (y, 1))
{
printf ("mpfr_fac_ui(0) does not give 1\n");
exit (1);
}
for (prec = 2; prec <= 100; prec++)
{
mpfr_set_prec (x, prec);
mpfr_set_prec (z, prec);
mpfr_set_prec (t, prec);
yprec = prec + 10;
mpfr_set_prec (y, yprec);
for (n = 0; n < 50; n++)
for (rnd = 0; rnd < GMP_RND_MAX; rnd++)
{
inexact = mpfr_fac_ui (y, n, (mp_rnd_t) rnd);
err = (rnd == GMP_RNDN) ? yprec + 1 : yprec;
if (mpfr_can_round (y, err, (mp_rnd_t) rnd, (mp_rnd_t) rnd, prec))
{
mpfr_set (t, y, (mp_rnd_t) rnd);
inexact = mpfr_fac_ui (z, n, (mp_rnd_t) rnd);
/* fact(n) ends with floor(n/2)+floor(n/4)+... zeros */
for (k=n/2, zeros=0; k; k >>= 1)
zeros += k;
if (MPFR_EXP(y) <= (mp_exp_t) (prec + zeros))
/* result should be exact */
{
if (inexact)
{
printf ("Wrong inexact flag: expected exact\n");
exit (1);
}
}
else /* result is inexact */
{
if (!inexact)
{
printf ("Wrong inexact flag: expected inexact\n");
printf ("n=%u prec=%u\n", n, prec);
mpfr_print_binary(z); puts ("");
exit (1);
}
}
if (mpfr_cmp (t, z))
{
printf ("results differ for x=");
mpfr_out_str (stdout, 2, prec, x, GMP_RNDN);
printf (" prec=%u rnd_mode=%s\n", prec,
mpfr_print_rnd_mode ((mp_rnd_t) rnd));
printf (" got ");
mpfr_out_str (stdout, 2, prec, z, GMP_RNDN);
puts ("");
printf (" expected ");
mpfr_out_str (stdout, 2, prec, t, GMP_RNDN);
puts ("");
printf (" approximation was ");
mpfr_print_binary (y);
puts ("");
exit (1);
}
}
}
}
static void
overflowed_sec0 (void)
{
mpfr_t x, y;
int emax, i, inex, rnd, err = 0;
mpfr_exp_t old_emax;
old_emax = mpfr_get_emax ();
mpfr_init2 (x, 8);
mpfr_init2 (y, 8);
for (emax = -1; emax <= 0; emax++)
{
mpfr_set_ui_2exp (y, 1, emax, MPFR_RNDN);
mpfr_nextbelow (y);
set_emax (emax); /* 1 is not representable. */
for (i = -1; i <= 1; i++)
RND_LOOP (rnd)
{
mpfr_set_si_2exp (x, i, -512 * ABS (i), MPFR_RNDN);
mpfr_clear_flags ();
inex = mpfr_sec (x, x, (mpfr_rnd_t) rnd);
if (! mpfr_overflow_p ())
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" The overflow flag is not set.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
if (rnd == MPFR_RNDZ || rnd == MPFR_RNDD)
{
if (inex >= 0)
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" The inexact value must be negative.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
if (! mpfr_equal_p (x, y))
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" Got ", i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpfr_print_binary (x);
printf (" instead of 0.11111111E%d.\n", emax);
err = 1;
}
}
else
{
if (inex <= 0)
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" The inexact value must be positive.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
if (! (mpfr_inf_p (x) && MPFR_SIGN (x) > 0))
{
printf ("Error in overflowed_sec0 (i = %d, rnd = %s):\n"
" Got ", i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpfr_print_binary (x);
printf (" instead of +Inf.\n");
err = 1;
}
}
}
set_emax (old_emax);
}
if (err)
exit (1);
mpfr_clear (x);
mpfr_clear (y);
}
static void
test_urandomb (long nbtests, mpfr_prec_t prec, int verbose)
{
mpfr_t x;
int *tab, size_tab, k, sh, xn;
double d, av = 0, var = 0, chi2 = 0, th;
mpfr_exp_t emin;
size_tab = (nbtests >= 1000 ? nbtests / 50 : 20);
tab = (int *) calloc (size_tab, sizeof(int));
if (tab == NULL)
{
fprintf (stderr, "trandom: can't allocate memory in test_urandomb\n");
exit (1);
}
mpfr_init2 (x, prec);
xn = 1 + (prec - 1) / mp_bits_per_limb;
sh = xn * mp_bits_per_limb - prec;
for (k = 0; k < nbtests; k++)
{
mpfr_urandomb (x, RANDS);
/* check that lower bits are zero */
if (MPFR_MANT(x)[0] & MPFR_LIMB_MASK(sh))
{
printf ("Error: mpfr_urandomb() returns invalid numbers:\n");
mpfr_print_binary (x); puts ("");
exit (1);
}
d = mpfr_get_d1 (x); av += d; var += d*d;
tab[(int)(size_tab * d)]++;
}
/* coverage test */
emin = mpfr_get_emin ();
set_emin (1); /* the generated number in [0,1[ is not in the exponent
range, except if it is zero */
k = mpfr_urandomb (x, RANDS);
if (MPFR_IS_ZERO(x) == 0 && (k == 0 || mpfr_nan_p (x) == 0))
{
printf ("Error in mpfr_urandomb, expected NaN, got ");
mpfr_dump (x);
exit (1);
}
set_emin (emin);
mpfr_clear (x);
if (!verbose)
{
free(tab);
return;
}
av /= nbtests;
var = (var / nbtests) - av * av;
th = (double)nbtests / size_tab;
printf("Average = %.5f\nVariance = %.5f\n", av, var);
printf("Repartition for urandomb. Each integer should be close to %d.\n",
(int)th);
for (k = 0; k < size_tab; k++)
{
chi2 += (tab[k] - th) * (tab[k] - th) / th;
printf("%d ", tab[k]);
if (((k+1) & 7) == 0)
printf("\n");
}
printf("\nChi2 statistics value (with %d degrees of freedom) : %.5f\n\n",
size_tab - 1, chi2);
free(tab);
return;
}
int
main (int argc, char *argv[])
{
mpfr_t x, y, z, s;
tests_start_mpfr ();
mpfr_init (x);
mpfr_init (s);
mpfr_init (y);
mpfr_init (z);
/* check special cases */
mpfr_set_prec (x, 2);
mpfr_set_prec (y, 2);
mpfr_set_prec (z, 2);
mpfr_set_prec (s, 2);
mpfr_set_str (x, "-0.75", 10, GMP_RNDN);
mpfr_set_str (y, "0.5", 10, GMP_RNDN);
mpfr_set_str (z, "0.375", 10, GMP_RNDN);
mpfr_fma (s, x, y, z, GMP_RNDU); /* result is 0 */
if (mpfr_cmp_ui(s, 0))
{
printf("Error: -0.75 * 0.5 + 0.375 should be equal to 0 for prec=2\n");
exit(1);
}
mpfr_set_prec (x, 27);
mpfr_set_prec (y, 27);
mpfr_set_prec (z, 27);
mpfr_set_prec (s, 27);
mpfr_set_str_binary (x, "1.11111111111111111111111111e-1");
mpfr_set (y, x, GMP_RNDN);
mpfr_set_str_binary (z, "-1.00011110100011001011001001e-1");
if (mpfr_fma (s, x, y, z, GMP_RNDN) >= 0)
{
printf ("Wrong inexact flag for x=y=1-2^(-27)\n");
exit (1);
}
mpfr_set_nan (x);
mpfr_random (y);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_nan_p (s))
{
printf ("evaluation of function in x=NAN does not return NAN");
exit (1);
}
mpfr_set_nan (y);
mpfr_random (x);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_nan_p(s))
{
printf ("evaluation of function in y=NAN does not return NAN");
exit (1);
}
mpfr_set_nan (z);
mpfr_random (y);
mpfr_random (x);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_nan_p (s))
{
printf ("evaluation of function in z=NAN does not return NAN");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_set_inf (y, 1);
mpfr_set_inf (z, 1);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_inf_p (s) || mpfr_sgn (s) < 0)
{
printf ("Error for (+inf) * (+inf) + (+inf)\n");
exit (1);
}
mpfr_set_inf (x, -1);
mpfr_set_inf (y, -1);
mpfr_set_inf (z, 1);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_inf_p (s) || mpfr_sgn (s) < 0)
{
printf ("Error for (-inf) * (-inf) + (+inf)\n");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_set_inf (y, -1);
mpfr_set_inf (z, -1);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_inf_p (s) || mpfr_sgn (s) > 0)
{
printf ("Error for (+inf) * (-inf) + (-inf)\n");
exit (1);
}
mpfr_set_inf (x, -1);
mpfr_set_inf (y, 1);
mpfr_set_inf (z, -1);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_inf_p (s) || mpfr_sgn (s) > 0)
{
printf ("Error for (-inf) * (+inf) + (-inf)\n");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_set_ui (y, 0, GMP_RNDN);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_nan_p (s))
{
printf ("evaluation of function in x=INF y=0 does not return NAN");
exit (1);
}
mpfr_set_inf (y, 1);
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_nan_p (s))
{
printf ("evaluation of function in x=0 y=INF does not return NAN");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_random (y); /* always positive */
mpfr_set_inf (z, -1);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_nan_p (s))
{
printf ("evaluation of function in x=INF y>0 z=-INF does not return NAN");
exit (1);
}
mpfr_set_inf (y, 1);
mpfr_random (x);
mpfr_set_inf (z, -1);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_nan_p (s))
{
printf ("evaluation of function in x>0 y=INF z=-INF does not return NAN");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_random (y);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_inf_p (s) || mpfr_sgn (s) < 0)
{
printf ("evaluation of function in x=INF does not return INF");
exit (1);
}
mpfr_set_inf (y, 1);
mpfr_random (x);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_inf_p (s) || mpfr_sgn (s) < 0)
{
printf ("evaluation of function in y=INF does not return INF");
exit (1);
}
mpfr_set_inf (z, 1);
mpfr_random (x);
mpfr_random (y);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_inf_p (s) || mpfr_sgn (s) < 0)
{
printf ("evaluation of function in z=INF does not return INF");
exit (1);
}
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_random (y);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (mpfr_cmp (s, z))
{
printf ("evaluation of function in x=0 does not return z\n");
exit (1);
}
mpfr_set_ui (y, 0, GMP_RNDN);
mpfr_random (x);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (mpfr_cmp (s, z))
{
printf ("evaluation of function in y=0 does not return z\n");
exit (1);
}
{
mp_prec_t prec;
mpfr_t t, slong;
mp_rnd_t rnd;
int inexact, compare;
unsigned int n;
mp_prec_t p0=2, p1=200;
unsigned int N=200;
mpfr_init (t);
mpfr_init (slong);
/* generic test */
for (prec = p0; prec <= p1; prec++)
{
mpfr_set_prec (x, prec);
mpfr_set_prec (y, prec);
mpfr_set_prec (z, prec);
mpfr_set_prec (s, prec);
mpfr_set_prec (t, prec);
for (n=0; n<N; n++)
{
mpfr_random (x);
mpfr_random (y);
mpfr_random (z);
if (randlimb () % 2)
mpfr_neg (x, x, GMP_RNDN);
if (randlimb () % 2)
mpfr_neg (y, y, GMP_RNDN);
if (randlimb () % 2)
mpfr_neg (z, z, GMP_RNDN);
rnd = (mp_rnd_t) RND_RAND ();
mpfr_set_prec (slong, 2 * prec);
if (mpfr_mul (slong, x, y, rnd))
{
printf ("x*y should be exact\n");
exit (1);
}
compare = mpfr_add (t, slong, z, rnd);
inexact = mpfr_fma (s, x, y, z, rnd);
if (mpfr_cmp (s, t))
{
printf ("results differ for x=");
mpfr_out_str (stdout, 2, prec, x, GMP_RNDN);
printf (" y=");
mpfr_out_str (stdout, 2, prec, y, GMP_RNDN);
printf (" z=");
mpfr_out_str (stdout, 2, prec, z, GMP_RNDN);
printf (" prec=%u rnd_mode=%s\n", (unsigned int) prec,
mpfr_print_rnd_mode (rnd));
printf ("got ");
mpfr_out_str (stdout, 2, prec, s, GMP_RNDN);
puts ("");
printf ("expected ");
mpfr_out_str (stdout, 2, prec, t, GMP_RNDN);
puts ("");
printf ("approx ");
mpfr_print_binary (slong);
puts ("");
exit (1);
}
if (((inexact == 0) && (compare != 0)) ||
((inexact < 0) && (compare >= 0)) ||
((inexact > 0) && (compare <= 0)))
{
printf ("Wrong inexact flag for rnd=%s: expected %d, got %d\n",
mpfr_print_rnd_mode (rnd), compare, inexact);
printf (" x="); mpfr_out_str (stdout, 2, 0, x, GMP_RNDN);
printf (" y="); mpfr_out_str (stdout, 2, 0, y, GMP_RNDN);
printf (" z="); mpfr_out_str (stdout, 2, 0, z, GMP_RNDN);
printf (" s="); mpfr_out_str (stdout, 2, 0, s, GMP_RNDN);
printf ("\n");
exit (1);
}
}
}
mpfr_clear (t);
mpfr_clear (slong);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (s);
test_exact ();
test_overflow1 ();
test_overflow2 ();
test_underflow1 ();
test_underflow2 ();
tests_end_mpfr ();
return 0;
}
static void
test_underflow1 (void)
{
mpfr_t x, y, z, r;
int inex, signy, signz, rnd, err = 0;
mpfr_inits2 (8, x, y, z, r, (void *) 0);
MPFR_SET_POS (x);
mpfr_setmin (x, mpfr_get_emin ()); /* x = 0.1@emin */
for (signy = -1; signy <= 1; signy += 2)
{
mpfr_set_si_2exp (y, signy, -1, GMP_RNDN); /* |y| = 1/2 */
for (signz = -3; signz <= 3; signz += 2)
{
RND_LOOP (rnd)
{
mpfr_set_si (z, signz, GMP_RNDN);
if (ABS (signz) != 1)
mpfr_setmax (z, mpfr_get_emax ());
/* |z| = 1 or 2^emax - ulp */
mpfr_clear_flags ();
inex = mpfr_fma (r, x, y, z, rnd);
#define ERRTU1 "Error in test_underflow1 (signy = %d, signz = %d, %s)\n "
if (mpfr_nanflag_p ())
{
printf (ERRTU1 "NaN flag is set\n", signy, signz,
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (signy < 0 && (rnd == GMP_RNDD ||
(rnd == GMP_RNDZ && signz > 0)))
mpfr_nextbelow (z);
if (signy > 0 && (rnd == GMP_RNDU ||
(rnd == GMP_RNDZ && signz < 0)))
mpfr_nextabove (z);
if ((mpfr_overflow_p () != 0) ^ (mpfr_inf_p (z) != 0))
{
printf (ERRTU1 "wrong overflow flag\n", signy, signz,
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (mpfr_underflow_p ())
{
printf (ERRTU1 "underflow flag is set\n", signy, signz,
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (! mpfr_equal_p (r, z))
{
printf (ERRTU1 "got ", signy, signz,
mpfr_print_rnd_mode (rnd));
mpfr_print_binary (r);
printf (" instead of ");
mpfr_print_binary (z);
printf ("\n");
err = 1;
}
if (inex >= 0 && (rnd == GMP_RNDD ||
(rnd == GMP_RNDZ && signz > 0) ||
(rnd == GMP_RNDN && signy > 0)))
{
printf (ERRTU1 "ternary value = %d instead of < 0\n",
signy, signz, mpfr_print_rnd_mode (rnd), inex);
err = 1;
}
if (inex <= 0 && (rnd == GMP_RNDU ||
(rnd == GMP_RNDZ && signz < 0) ||
(rnd == GMP_RNDN && signy < 0)))
{
printf (ERRTU1 "ternary value = %d instead of > 0\n",
signy, signz, mpfr_print_rnd_mode (rnd), inex);
err = 1;
}
}
}
}
if (err)
exit (1);
mpfr_clears (x, y, z, r, (void *) 0);
}
static void
underflowed_cothinf (void)
{
mpfr_t x, y;
int i, inex, rnd, err = 0;
mpfr_exp_t old_emin;
old_emin = mpfr_get_emin ();
mpfr_init2 (x, 8);
mpfr_init2 (y, 8);
for (i = -1; i <= 1; i += 2)
RND_LOOP (rnd)
{
mpfr_set_inf (x, i);
mpfr_clear_flags ();
set_emin (2); /* 1 is not representable. */
inex = mpfr_coth (x, x, (mpfr_rnd_t) rnd);
set_emin (old_emin);
if (! mpfr_underflow_p ())
{
printf ("Error in underflowed_cothinf (i = %d, rnd = %s):\n"
" The underflow flag is not set.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
mpfr_set_si (y, (i < 0 && (rnd == MPFR_RNDD || rnd == MPFR_RNDA)) ||
(i > 0 && (rnd == MPFR_RNDU || rnd == MPFR_RNDA))
? 2 : 0, MPFR_RNDN);
if (i < 0)
mpfr_neg (y, y, MPFR_RNDN);
if (! (mpfr_equal_p (x, y) &&
MPFR_MULT_SIGN (MPFR_SIGN (x), MPFR_SIGN (y)) > 0))
{
printf ("Error in underflowed_cothinf (i = %d, rnd = %s):\n"
" Got ", i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
mpfr_print_binary (x);
printf (" instead of ");
mpfr_print_binary (y);
printf (".\n");
err = 1;
}
if ((rnd == MPFR_RNDD ||
(i > 0 && (rnd == MPFR_RNDN || rnd == MPFR_RNDZ))) && inex >= 0)
{
printf ("Error in underflowed_cothinf (i = %d, rnd = %s):\n"
" The inexact value must be negative.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
if ((rnd == MPFR_RNDU ||
(i < 0 && (rnd == MPFR_RNDN || rnd == MPFR_RNDZ))) && inex <= 0)
{
printf ("Error in underflowed_cothinf (i = %d, rnd = %s):\n"
" The inexact value must be positive.\n",
i, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd));
err = 1;
}
}
if (err)
exit (1);
mpfr_clear (x);
mpfr_clear (y);
}
int
main (int argc, char *argv[])
{
mpfr_t gamma, y, z, t;
unsigned int err, prec, yprec, p0 = 2, p1 = 200;
int rnd;
tests_start_mpfr ();
prec = (argc < 2) ? 53 : atoi(argv[1]);
if (argc > 1)
{
mpfr_init2 (gamma, prec);
mpfr_const_euler (gamma, GMP_RNDN);
printf("gamma="); mpfr_out_str (stdout, 10, 0, gamma, GMP_RNDD);
puts ("");
mpfr_clear (gamma);
return 0;
}
mpfr_init (y);
mpfr_init (z);
mpfr_init (t);
mpfr_set_prec (y, 32);
mpfr_set_prec (z, 32);
mpfr_const_euler (y, GMP_RNDN);
mpfr_set_str_binary (z, "0.10010011110001000110011111100011");
if (mpfr_cmp (y, z))
{
printf ("Error for prec=32\n");
exit (1);
}
for (prec = p0; prec <= p1; prec++)
{
mpfr_set_prec (z, prec);
mpfr_set_prec (t, prec);
yprec = prec + 10;
for (rnd = 0; rnd < GMP_RND_MAX; rnd++)
{
mpfr_set_prec (y, yprec);
mpfr_const_euler (y, (mp_rnd_t) rnd);
err = (rnd == GMP_RNDN) ? yprec + 1 : yprec;
if (mpfr_can_round (y, err, (mp_rnd_t) rnd, (mp_rnd_t) rnd, prec))
{
mpfr_set (t, y, (mp_rnd_t) rnd);
mpfr_const_euler (z, (mp_rnd_t) rnd);
if (mpfr_cmp (t, z))
{
printf ("results differ for prec=%u rnd_mode=%s\n", prec,
mpfr_print_rnd_mode ((mp_rnd_t) rnd));
printf (" got ");
mpfr_out_str (stdout, 2, prec, z, GMP_RNDN);
puts ("");
printf (" expected ");
mpfr_out_str (stdout, 2, prec, t, GMP_RNDN);
puts ("");
printf (" approximation was ");
mpfr_print_binary (y);
puts ("");
exit (1);
}
}
}
}
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (t);
tests_end_mpfr ();
return 0;
}
static void
overflowed_fac0 (void)
{
mpfr_t x, y;
int inex, rnd, err = 0;
mp_exp_t old_emax;
old_emax = mpfr_get_emax ();
mpfr_init2 (x, 8);
mpfr_init2 (y, 8);
mpfr_set_ui (y, 1, GMP_RNDN);
mpfr_nextbelow (y);
set_emax (0); /* 1 is not representable. */
RND_LOOP (rnd)
{
mpfr_clear_flags ();
inex = mpfr_fac_ui (x, 0, rnd);
if (! mpfr_overflow_p ())
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" The overflow flag is not set.\n",
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (rnd == GMP_RNDZ || rnd == GMP_RNDD)
{
if (inex >= 0)
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" The inexact value must be negative.\n",
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (! mpfr_equal_p (x, y))
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" Got ", mpfr_print_rnd_mode (rnd));
mpfr_print_binary (x);
printf (" instead of 0.11111111E0.\n");
err = 1;
}
}
else
{
if (inex <= 0)
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" The inexact value must be positive.\n",
mpfr_print_rnd_mode (rnd));
err = 1;
}
if (! (mpfr_inf_p (x) && MPFR_SIGN (x) > 0))
{
printf ("Error in overflowed_fac0 (rnd = %s):\n"
" Got ", mpfr_print_rnd_mode (rnd));
mpfr_print_binary (x);
printf (" instead of +Inf.\n");
err = 1;
}
}
}
set_emax (old_emax);
if (err)
exit (1);
mpfr_clear (x);
mpfr_clear (y);
}
static void
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, MPFR_RNDN);
(mpfr_abs) (x, x, MPFR_RNDN);
if (mpfr_cmp_ui (x, 1))
{
printf ("Error in mpfr_abs(1.0)\n");
exit (1);
}
mpfr_set_si(x, -1, MPFR_RNDN);
mpfr_abs(x, x, MPFR_RNDN);
if (mpfr_cmp_ui (x, 1))
{
printf ("Error in mpfr_abs(1.0)\n");
exit (1);
}
mpfr_set_si(x, -1, MPFR_RNDN);
mpfr_abs(x, x, MPFR_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, MPFR_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, MPFR_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, MPFR_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++)
{
mpfr_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);
}
int
main (void)
{
int j, k;
mpfr_t x, y, z, t, y2, z2, t2;
tests_start_mpfr ();
mpfr_inits2 (SIZEX, x, y, z, t, y2, z2, t2, (mpfr_ptr) 0);
mpfr_set_str1 (x, "0.5");
mpfr_ceil(y, x);
if (mpfr_cmp_ui (y, 1))
{
printf ("Error in mpfr_ceil for x=0.5: expected 1.0, got ");
mpfr_print_binary(y);
putchar('\n');
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_ceil(y, x);
if (mpfr_cmp_ui(y,0))
{
printf ("Error in mpfr_ceil for x=0.0: expected 0.0, got ");
mpfr_print_binary(y);
putchar('\n');
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_ceil(y, x);
if (mpfr_cmp_ui(y,1))
{
printf ("Error in mpfr_ceil for x=1.0: expected 1.0, got ");
mpfr_print_binary(y);
putchar('\n');
exit (1);
}
for (j=0;j<1000;j++)
{
mpfr_urandomb (x, RANDS);
MPFR_EXP (x) = 2;
for (k = 2; k <= SIZEX; k++)
{
mpfr_set_prec(y, k);
mpfr_set_prec(y2, k);
mpfr_set_prec(z, k);
mpfr_set_prec(z2, k);
mpfr_set_prec(t, k);
mpfr_set_prec(t2, k);
mpfr_floor(y, x);
mpfr_set(y2, x, MPFR_RNDD);
mpfr_trunc(z, x);
mpfr_set(z2, x, MPFR_RNDZ);
mpfr_ceil(t, x);
mpfr_set(t2, x, MPFR_RNDU);
if (!mpfr_eq(y, y2, k))
{
printf("Error in floor, x = "); mpfr_print_binary(x);
printf("\n");
printf("floor(x) = "); mpfr_print_binary(y);
printf("\n");
printf("round(x, RNDD) = "); mpfr_print_binary(y2);
printf("\n");
exit(1);
}
if (!mpfr_eq(z, z2, k))
{
printf("Error in trunc, x = "); mpfr_print_binary(x);
printf("\n");
printf("trunc(x) = "); mpfr_print_binary(z);
printf("\n");
printf("round(x, RNDZ) = "); mpfr_print_binary(z2);
printf("\n");
exit(1);
}
if (!mpfr_eq(y, y2, k))
{
printf("Error in ceil, x = "); mpfr_print_binary(x);
printf("\n");
printf("ceil(x) = "); mpfr_print_binary(t);
printf("\n");
printf("round(x, RNDU) = "); mpfr_print_binary(t2);
printf("\n");
exit(1);
}
MPFR_EXP(x)++;
}
}
mpfr_clears (x, y, z, t, y2, z2, t2, (mpfr_ptr) 0);
tests_end_mpfr ();
return 0;
}
static void
special (void)
{
mpfr_t x, y;
unsigned xprec, yprec;
mpfr_init (x);
mpfr_init (y);
mpfr_set_prec (x, 32);
mpfr_set_prec (y, 32);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_div_ui (y, x, 3, MPFR_RNDN);
mpfr_set_prec (x, 100);
mpfr_set_prec (y, 100);
mpfr_urandomb (x, RANDS);
mpfr_div_ui (y, x, 123456, MPFR_RNDN);
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_div_ui (y, x, 123456789, MPFR_RNDN);
if (mpfr_cmp_ui (y, 0))
{
printf ("mpfr_div_ui gives non-zero for 0/ui\n");
exit (1);
}
/* bug found by Norbert Mueller, 21 Aug 2001 */
mpfr_set_prec (x, 110);
mpfr_set_prec (y, 60);
mpfr_set_str_binary (x, "0.110101110011111110011111001110011001110111000000111110001000111011000011E-44");
mpfr_div_ui (y, x, 17, MPFR_RNDN);
mpfr_set_str_binary (x, "0.11001010100101100011101110000001100001010110101001010011011E-48");
if (mpfr_cmp (x, y))
{
printf ("Error in x/17 for x=1/16!\n");
printf ("Expected ");
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN);
printf ("\nGot ");
mpfr_out_str (stdout, 2, 0, y, MPFR_RNDN);
printf ("\n");
exit (1);
}
/* corner case */
mpfr_set_prec (x, 2 * mp_bits_per_limb);
mpfr_set_prec (y, 2);
mpfr_set_ui (x, 4, MPFR_RNDN);
mpfr_nextabove (x);
mpfr_div_ui (y, x, 2, MPFR_RNDN); /* exactly in the middle */
MPFR_ASSERTN(mpfr_cmp_ui (y, 2) == 0);
mpfr_set_prec (x, 3 * mp_bits_per_limb);
mpfr_set_prec (y, 2);
mpfr_set_ui (x, 2, MPFR_RNDN);
mpfr_nextabove (x);
mpfr_div_ui (y, x, 2, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 1) == 0);
mpfr_set_prec (x, 3 * mp_bits_per_limb);
mpfr_set_prec (y, 2);
mpfr_set_si (x, -4, MPFR_RNDN);
mpfr_nextbelow (x);
mpfr_div_ui (y, x, 2, MPFR_RNDD);
MPFR_ASSERTN(mpfr_cmp_si (y, -3) == 0);
for (xprec = 53; xprec <= 128; xprec++)
{
mpfr_set_prec (x, xprec);
mpfr_set_str_binary (x, "0.1100100100001111110011111000000011011100001100110111E2");
for (yprec = 53; yprec <= 128; yprec++)
{
mpfr_set_prec (y, yprec);
mpfr_div_ui (y, x, 1, MPFR_RNDN);
if (mpfr_cmp(x,y))
{
printf ("division by 1.0 fails for xprec=%u, yprec=%u\n", xprec, yprec);
printf ("expected "); mpfr_print_binary (x); puts ("");
printf ("got "); mpfr_print_binary (y); puts ("");
exit (1);
}
}
}
/* Bug reported by Mark Dickinson, 6 Nov 2007 */
mpfr_set_si (x, 0, MPFR_RNDN);
mpfr_set_si (y, -1, MPFR_RNDN);
mpfr_div_ui (y, x, 4, MPFR_RNDN);
MPFR_ASSERTN(MPFR_IS_ZERO(y) && MPFR_IS_POS(y));
mpfr_clear (x);
mpfr_clear (y);
}
