static void
test_fct (double (*f)(double), int (*g)(), char *s, mpfr_rnd_t r)
{
double d, y;
mpfr_t dd, yy;
mpfr_init2 (dd, 53);
mpfr_init2 (yy, 53);
for (d = -5.0; d <= 5.0; d += 0.25)
{
mpfr_set_d (dd, d, r);
y = (*f)(d);
if (g == &mpfr_rint)
mpfr_rint (yy, dd, r);
else
(*g)(yy, dd);
mpfr_set_d (dd, y, r);
if (mpfr_cmp (yy, dd))
{
printf ("test_against_libc: incorrect result for %s, rnd = %s,"
" d = %g\ngot ", s, mpfr_print_rnd_mode (r), d);
mpfr_out_str (stdout, 10, 0, yy, MPFR_RNDN);
printf (" instead of %g\n", y);
exit (1);
}
}
mpfr_clear (dd);
mpfr_clear (yy);
}
real round(const real & a)
{
real x;
mpfr_rint(x.r, a.r, MPFR_RNDN);
return x;
}
SeedValue seed_mpfr_rint (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue args[],
SeedException *exception)
{
mpfr_rnd_t rnd;
mpfr_ptr rop, op;
gint ret;
CHECK_ARG_COUNT("mpfr.rint", 2);
rop = seed_object_get_private(this_object);
rnd = seed_value_to_mpfr_rnd_t(ctx, args[1], exception);
if ( seed_value_is_object_of_class(ctx, args[0], mpfr_class) )
{
op = seed_object_get_private(args[0]);
}
else
{
TYPE_EXCEPTION("mpfr.rint", "mpfr_t");
}
ret = mpfr_rint(rop, op, rnd);
return seed_value_from_int(ctx, ret, exception);
}
uintmax_t
mpfr_get_uj (mpfr_srcptr f, mpfr_rnd_t rnd)
{
uintmax_t r;
mpfr_prec_t prec;
mpfr_t x;
if (MPFR_UNLIKELY (!mpfr_fits_uintmax_p (f, rnd)))
{
MPFR_SET_ERANGEFLAG ();
return MPFR_IS_NAN (f) || MPFR_IS_NEG (f) ?
(uintmax_t) 0 : MPFR_UINTMAX_MAX;
}
if (MPFR_IS_ZERO (f))
return (uintmax_t) 0;
/* determine the precision of uintmax_t */
for (r = MPFR_UINTMAX_MAX, prec = 0; r != 0; r /= 2, prec++)
{ }
/* Now, r = 0. */
mpfr_init2 (x, prec);
mpfr_rint (x, f, rnd);
MPFR_ASSERTN (MPFR_IS_FP (x));
if (MPFR_NOTZERO (x))
{
mp_limb_t *xp;
int sh, n; /* An int should be sufficient in this context. */
MPFR_ASSERTN (MPFR_IS_POS (x));
xp = MPFR_MANT (x);
sh = MPFR_GET_EXP (x);
MPFR_ASSERTN ((mpfr_prec_t) sh <= prec);
for (n = MPFR_LIMB_SIZE(x) - 1; n >= 0; n--)
{
sh -= GMP_NUMB_BITS;
r += (sh >= 0
? (uintmax_t) xp[n] << sh
: (uintmax_t) xp[n] >> (- sh));
}
}
mpfr_clear (x);
return r;
}
int
mpfr_get_z (mpz_ptr z, mpfr_srcptr f, mpfr_rnd_t rnd)
{
int inex;
mpfr_t r;
mpfr_exp_t exp;
MPFR_SAVE_EXPO_DECL (expo);
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (f)))
{
if (MPFR_UNLIKELY (MPFR_NOTZERO (f)))
MPFR_SET_ERANGEFLAG ();
mpz_set_ui (z, 0);
/* The ternary value is 0 even for infinity. Giving the rounding
direction in this case would not make much sense anyway, and
the direction would not necessarily match rnd. */
return 0;
}
MPFR_SAVE_EXPO_MARK (expo);
exp = MPFR_GET_EXP (f);
/* if exp <= 0, then |f|<1, thus |o(f)|<=1 */
MPFR_ASSERTN (exp < 0 || exp <= MPFR_PREC_MAX);
mpfr_init2 (r, (exp < (mpfr_exp_t) MPFR_PREC_MIN ?
MPFR_PREC_MIN : (mpfr_prec_t) exp));
inex = mpfr_rint (r, f, rnd);
MPFR_ASSERTN (inex != 1 && inex != -1); /* integral part of f is
representable in r */
MPFR_ASSERTN (MPFR_IS_FP (r));
/* The flags from mpfr_rint are the wanted ones. In particular,
it sets the inexact flag when necessary. */
MPFR_SAVE_EXPO_UPDATE_FLAGS (expo, __gmpfr_flags);
exp = mpfr_get_z_2exp (z, r);
if (exp >= 0)
mpz_mul_2exp (z, z, exp);
else
mpz_fdiv_q_2exp (z, z, -exp);
mpfr_clear (r);
MPFR_SAVE_EXPO_FREE (expo);
return inex;
}
void
mpfr_get_z (mpz_ptr z, mpfr_srcptr f, mp_rnd_t rnd)
{
mpfr_t r;
mp_exp_t exp = MPFR_EXP (f);
/* if exp <= 0, then |f|<1, thus |o(f)|<=1 */
MPFR_ASSERTN (exp < 0 || exp <= MPFR_PREC_MAX);
mpfr_init2 (r, (exp < (mp_exp_t) MPFR_PREC_MIN ?
MPFR_PREC_MIN : (mpfr_prec_t) exp));
mpfr_rint (r, f, rnd);
MPFR_ASSERTN (MPFR_IS_FP (r) );
exp = mpfr_get_z_exp (z, r);
if (exp >= 0)
mpz_mul_2exp (z, z, exp);
else
mpz_div_2exp (z, z, -exp);
mpfr_clear (r);
}
int
mpfr_floor (mpfr_ptr r, mpfr_srcptr u)
{
return mpfr_rint(r, u, GMP_RNDD);
}
int
mpfr_ceil (mpfr_ptr r, mpfr_srcptr u)
{
return mpfr_rint(r, u, GMP_RNDU);
}
int
mpfr_trunc (mpfr_ptr r, mpfr_srcptr u)
{
return mpfr_rint(r, u, GMP_RNDZ);
}
int
mpfr_round (mpfr_ptr r, mpfr_srcptr u)
{
return mpfr_rint(r, u, GMP_RNDNA);
}
int
main (void)
{
mpfr_t x, y;
int i, r;
tests_start_mpfr ();
mpfr_init2 (x, 256);
mpfr_init2 (y, 8);
RND_LOOP (r)
{
/* Check NAN */
mpfr_set_nan (x);
if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
ERROR1 (1);
if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
ERROR1 (2);
if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
ERROR1 (3);
if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
ERROR1 (4);
if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
ERROR1 (5);
if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
ERROR1 (6);
/* Check INF */
mpfr_set_inf (x, 1);
if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
ERROR1 (7);
if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
ERROR1 (8);
if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
ERROR1 (9);
if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
ERROR1 (10);
if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
ERROR1 (11);
if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
ERROR1 (12);
/* Check Zero */
MPFR_SET_ZERO (x);
if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
ERROR1 (13);
if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
ERROR1 (14);
if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
ERROR1 (15);
if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
ERROR1 (16);
if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
ERROR1 (17);
if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
ERROR1 (18);
/* Check small positive op */
mpfr_set_str1 (x, "1@-1");
if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
ERROR1 (19);
if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
ERROR1 (20);
if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
ERROR1 (21);
if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
ERROR1 (22);
if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
ERROR1 (23);
if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
ERROR1 (24);
/* Check 17 */
mpfr_set_ui (x, 17, MPFR_RNDN);
if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
ERROR1 (25);
if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
ERROR1 (26);
if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
ERROR1 (27);
if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
ERROR1 (28);
if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
ERROR1 (29);
if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
ERROR1 (30);
/* Check all other values */
mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1, MPFR_RNDN);
if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
ERROR1 (31);
if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
ERROR1 (32);
mpfr_mul_2exp (x, x, 40, MPFR_RNDN);
if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
ERROR1 (33);
if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
ERROR1 (34);
if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
ERROR1 (35);
if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
ERROR1 (36);
if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
ERROR1 (37);
mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
ERROR1 (38);
mpfr_set_ui (x, LONG_MAX, MPFR_RNDN);
if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
ERROR1 (39);
mpfr_set_ui (x, UINT_MAX, MPFR_RNDN);
if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
ERROR1 (40);
mpfr_set_ui (x, INT_MAX, MPFR_RNDN);
if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
ERROR1 (41);
mpfr_set_ui (x, USHRT_MAX, MPFR_RNDN);
if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
ERROR1 (42);
mpfr_set_ui (x, SHRT_MAX, MPFR_RNDN);
if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
ERROR1 (43);
mpfr_set_si (x, 1, MPFR_RNDN);
if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
ERROR1 (44);
if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
ERROR1 (45);
/* Check negative op */
for (i = 1; i <= 4; i++)
{
int inv;
mpfr_set_si_2exp (x, -i, -2, MPFR_RNDN);
mpfr_rint (y, x, (mpfr_rnd_t) r);
inv = MPFR_NOTZERO (y);
if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r) ^ inv)
ERROR1 (46);
if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
ERROR1 (47);
if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r) ^ inv)
ERROR1 (48);
if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
ERROR1 (49);
if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r) ^ inv)
ERROR1 (50);
if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
ERROR1 (51);
}
}
mpfr_clear (x);
mpfr_clear (y);
check_intmax ();
tests_end_mpfr ();
return 0;
}
static void
check_intmax (void)
{
#ifdef _MPFR_H_HAVE_INTMAX_T
mpfr_t x, y;
int i, r;
mpfr_init2 (x, sizeof (uintmax_t) * CHAR_BIT);
mpfr_init2 (y, 8);
RND_LOOP (r)
{
/* Check NAN */
mpfr_set_nan (x);
if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
ERROR1 (52);
if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
ERROR1 (53);
/* Check INF */
mpfr_set_inf (x, 1);
if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
ERROR1 (54);
if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
ERROR1 (55);
/* Check Zero */
MPFR_SET_ZERO (x);
if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
ERROR1 (56);
if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
ERROR1 (57);
/* Check positive small op */
mpfr_set_str1 (x, "1@-1");
if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
ERROR1 (58);
if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
ERROR1 (59);
/* Check 17 */
mpfr_set_ui (x, 17, MPFR_RNDN);
if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
ERROR1 (60);
if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
ERROR1 (61);
/* Check hugest */
mpfr_set_ui_2exp (x, 42, sizeof (uintmax_t) * 32, MPFR_RNDN);
if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
ERROR1 (62);
if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
ERROR1 (63);
/* Check all other values */
mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
mpfr_add_ui (x, x, 1, MPFR_RNDN);
if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
ERROR1 (64);
mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
ERROR1 (65);
mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
mpfr_add_ui (x, x, 1, MPFR_RNDN);
if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
ERROR1 (66);
mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
ERROR1 (67);
mpfr_set_sj (x, MPFR_INTMAX_MIN, MPFR_RNDN);
if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
ERROR1 (68);
mpfr_sub_ui (x, x, 1, MPFR_RNDN);
if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
ERROR1 (69);
/* Check negative op */
for (i = 1; i <= 4; i++)
{
int inv;
mpfr_set_si_2exp (x, -i, -2, MPFR_RNDN);
mpfr_rint (y, x, (mpfr_rnd_t) r);
inv = MPFR_NOTZERO (y);
if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r) ^ inv)
ERROR1 (70);
if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
ERROR1 (71);
}
}
mpfr_clear (x);
mpfr_clear (y);
#endif
}
int
main (int argc, char *argv[])
{
mp_size_t s;
mpz_t z;
mpfr_prec_t p;
mpfr_t x, y, t, u, v;
int r;
int inexact, sign_t;
tests_start_mpfr ();
mpfr_init (x);
mpfr_init (y);
mpz_init (z);
mpfr_init (t);
mpfr_init (u);
mpfr_init (v);
mpz_set_ui (z, 1);
for (s = 2; s < 100; s++)
{
/* z has exactly s bits */
mpz_mul_2exp (z, z, 1);
if (randlimb () % 2)
mpz_add_ui (z, z, 1);
mpfr_set_prec (x, s);
mpfr_set_prec (t, s);
mpfr_set_prec (u, s);
if (mpfr_set_z (x, z, MPFR_RNDN))
{
printf ("Error: mpfr_set_z should be exact (s = %u)\n",
(unsigned int) s);
exit (1);
}
if (randlimb () % 2)
mpfr_neg (x, x, MPFR_RNDN);
if (randlimb () % 2)
mpfr_div_2ui (x, x, randlimb () % s, MPFR_RNDN);
for (p = 2; p < 100; p++)
{
int trint;
mpfr_set_prec (y, p);
mpfr_set_prec (v, p);
for (r = 0; r < MPFR_RND_MAX ; r++)
for (trint = 0; trint < 3; trint++)
{
if (trint == 2)
inexact = mpfr_rint (y, x, (mpfr_rnd_t) r);
else if (r == MPFR_RNDN)
inexact = mpfr_round (y, x);
else if (r == MPFR_RNDZ)
inexact = (trint ? mpfr_trunc (y, x) :
mpfr_rint_trunc (y, x, MPFR_RNDZ));
else if (r == MPFR_RNDU)
inexact = (trint ? mpfr_ceil (y, x) :
mpfr_rint_ceil (y, x, MPFR_RNDU));
else /* r = MPFR_RNDD */
inexact = (trint ? mpfr_floor (y, x) :
mpfr_rint_floor (y, x, MPFR_RNDD));
if (mpfr_sub (t, y, x, MPFR_RNDN))
err ("subtraction 1 should be exact",
s, x, y, p, (mpfr_rnd_t) r, trint, inexact);
sign_t = mpfr_cmp_ui (t, 0);
if (trint != 0 &&
(((inexact == 0) && (sign_t != 0)) ||
((inexact < 0) && (sign_t >= 0)) ||
((inexact > 0) && (sign_t <= 0))))
err ("wrong inexact flag", s, x, y, p, (mpfr_rnd_t) r, trint, inexact);
if (inexact == 0)
continue; /* end of the test for exact results */
if (((r == MPFR_RNDD || (r == MPFR_RNDZ && MPFR_SIGN (x) > 0))
&& inexact > 0) ||
((r == MPFR_RNDU || (r == MPFR_RNDZ && MPFR_SIGN (x) < 0))
&& inexact < 0))
err ("wrong rounding direction",
s, x, y, p, (mpfr_rnd_t) r, trint, inexact);
if (inexact < 0)
{
mpfr_add_ui (v, y, 1, MPFR_RNDU);
if (mpfr_cmp (v, x) <= 0)
err ("representable integer between x and its "
"rounded value", s, x, y, p, (mpfr_rnd_t) r, trint, inexact);
}
else
{
mpfr_sub_ui (v, y, 1, MPFR_RNDD);
if (mpfr_cmp (v, x) >= 0)
err ("representable integer between x and its "
"rounded value", s, x, y, p, (mpfr_rnd_t) r, trint, inexact);
}
if (r == MPFR_RNDN)
{
int cmp;
if (mpfr_sub (u, v, x, MPFR_RNDN))
err ("subtraction 2 should be exact",
s, x, y, p, (mpfr_rnd_t) r, trint, inexact);
cmp = mpfr_cmp_abs (t, u);
if (cmp > 0)
err ("faithful rounding, but not the nearest integer",
s, x, y, p, (mpfr_rnd_t) r, trint, inexact);
if (cmp < 0)
continue;
/* |t| = |u|: x is the middle of two consecutive
representable integers. */
if (trint == 2)
{
/* halfway case for mpfr_rint in MPFR_RNDN rounding
mode: round to an even integer or significand. */
mpfr_div_2ui (y, y, 1, MPFR_RNDZ);
if (!mpfr_integer_p (y))
err ("halfway case for mpfr_rint, result isn't an"
" even integer", s, x, y, p, (mpfr_rnd_t) r, trint, inexact);
/* If floor(x) and ceil(x) aren't both representable
integers, the significand must be even. */
mpfr_sub (v, v, y, MPFR_RNDN);
mpfr_abs (v, v, MPFR_RNDN);
if (mpfr_cmp_ui (v, 1) != 0)
{
mpfr_div_2si (y, y, MPFR_EXP (y) - MPFR_PREC (y)
+ 1, MPFR_RNDN);
if (!mpfr_integer_p (y))
err ("halfway case for mpfr_rint, significand isn't"
" even", s, x, y, p, (mpfr_rnd_t) r, trint, inexact);
}
}
else
{ /* halfway case for mpfr_round: x must have been
rounded away from zero. */
if ((MPFR_SIGN (x) > 0 && inexact < 0) ||
(MPFR_SIGN (x) < 0 && inexact > 0))
err ("halfway case for mpfr_round, bad rounding"
" direction", s, x, y, p, (mpfr_rnd_t) r, trint, inexact);
}
}
}
}
}
mpfr_clear (x);
mpfr_clear (y);
mpz_clear (z);
mpfr_clear (t);
mpfr_clear (u);
mpfr_clear (v);
special ();
coverage_03032011 ();
#if __MPFR_STDC (199901L)
if (argc > 1 && strcmp (argv[1], "-s") == 0)
test_against_libc ();
#endif
tests_end_mpfr ();
return 0;
}
static void
special (void)
{
mpfr_t x, y;
mpfr_exp_t emax;
mpfr_init (x);
mpfr_init (y);
mpfr_set_nan (x);
mpfr_rint (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (y));
mpfr_set_inf (x, 1);
mpfr_rint (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && mpfr_sgn (y) > 0);
mpfr_set_inf (x, -1);
mpfr_rint (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && mpfr_sgn (y) < 0);
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_rint (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS(y));
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_neg (x, x, MPFR_RNDN);
mpfr_rint (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_NEG(y));
/* coverage test */
mpfr_set_prec (x, 2);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, mp_bits_per_limb, MPFR_RNDN);
mpfr_rint (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp (y, x) == 0);
/* another coverage test */
emax = mpfr_get_emax ();
set_emax (1);
mpfr_set_prec (x, 3);
mpfr_set_str_binary (x, "1.11E0");
mpfr_set_prec (y, 2);
mpfr_rint (y, x, MPFR_RNDU); /* x rounds to 1.0E1=0.1E2 which overflows */
MPFR_ASSERTN(mpfr_inf_p (y) && mpfr_sgn (y) > 0);
set_emax (emax);
/* yet another */
mpfr_set_prec (x, 97);
mpfr_set_prec (y, 96);
mpfr_set_str_binary (x, "-0.1011111001101111000111011100011100000110110110110000000111010001000101001111101010101011010111100E97");
mpfr_rint (y, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp (y, x) == 0);
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str_binary (x, "0.10101100000000101001010101111111000000011111010000010E-1");
mpfr_rint (y, x, MPFR_RNDU);
MPFR_ASSERTN(mpfr_cmp_ui (y, 1) == 0);
mpfr_rint (y, x, MPFR_RNDD);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS(y));
mpfr_set_prec (x, 36);
mpfr_set_prec (y, 2);
mpfr_set_str_binary (x, "-11000110101010111111110111001.0000100");
mpfr_rint (y, x, MPFR_RNDN);
mpfr_set_str_binary (x, "-11E27");
MPFR_ASSERTN(mpfr_cmp (y, x) == 0);
mpfr_set_prec (x, 39);
mpfr_set_prec (y, 29);
mpfr_set_str_binary (x, "-0.100010110100011010001111001001001100111E39");
mpfr_rint (y, x, MPFR_RNDN);
mpfr_set_str_binary (x, "-0.10001011010001101000111100101E39");
MPFR_ASSERTN(mpfr_cmp (y, x) == 0);
mpfr_set_prec (x, 46);
mpfr_set_prec (y, 32);
mpfr_set_str_binary (x, "-0.1011100110100101000001011111101011001001101001E32");
mpfr_rint (y, x, MPFR_RNDN);
mpfr_set_str_binary (x, "-0.10111001101001010000010111111011E32");
MPFR_ASSERTN(mpfr_cmp (y, x) == 0);
/* coverage test for mpfr_round */
mpfr_set_prec (x, 3);
mpfr_set_str_binary (x, "1.01E1"); /* 2.5 */
mpfr_set_prec (y, 2);
mpfr_round (y, x);
/* since mpfr_round breaks ties away, should give 3 and not 2 as with
the "round to even" rule */
MPFR_ASSERTN(mpfr_cmp_ui (y, 3) == 0);
/* same test for the function */
(mpfr_round) (y, x);
MPFR_ASSERTN(mpfr_cmp_ui (y, 3) == 0);
mpfr_set_prec (x, 6);
mpfr_set_prec (y, 3);
mpfr_set_str_binary (x, "110.111");
mpfr_round (y, x);
if (mpfr_cmp_ui (y, 7))
{
printf ("Error in round(110.111)\n");
exit (1);
}
/* Bug found by Mark J Watkins */
mpfr_set_prec (x, 84);
mpfr_set_str_binary (x,
"0.110011010010001000000111101101001111111100101110010000000000000" \
"000000000000000000000E32");
mpfr_round (x, x);
if (mpfr_cmp_str (x, "0.1100110100100010000001111011010100000000000000" \
"00000000000000000000000000000000000000E32", 2, MPFR_RNDN))
{
printf ("Rounding error when dest=src\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
static void
coverage_03032011 (void)
{
mpfr_t in, out, cmp;
int status;
int precIn;
char strData[(GMP_NUMB_BITS * 4)+256];
precIn = GMP_NUMB_BITS * 4;
mpfr_init2 (in, precIn);
mpfr_init2 (out, GMP_NUMB_BITS);
mpfr_init2 (cmp, GMP_NUMB_BITS);
/* cmp = "0.1EprecIn+2" */
/* The buffer size is sufficient, as precIn is small in practice. */
sprintf (strData, "0.1E%d", precIn+2);
mpfr_set_str_binary (cmp, strData);
/* in = "0.10...01EprecIn+2" use all (precIn) significand bits */
memset ((void *)strData, '0', precIn+2);
strData[1] = '.';
strData[2] = '1';
sprintf (&strData[precIn+1], "1E%d", precIn+2);
mpfr_set_str_binary (in, strData);
status = mpfr_rint (out, in, MPFR_RNDN);
if ((mpfr_cmp (out, cmp) != 0) || (status >= 0))
{
printf("mpfr_rint error :\n status is %d instead of 0\n", status);
printf(" out value is ");
mpfr_dump(out);
printf(" instead of ");
mpfr_dump(cmp);
exit (1);
}
mpfr_clear (cmp);
mpfr_clear (out);
mpfr_init2 (out, GMP_NUMB_BITS);
mpfr_init2 (cmp, GMP_NUMB_BITS);
/* cmp = "0.10...01EprecIn+2" use all (GMP_NUMB_BITS) significand bits */
strcpy (&strData[GMP_NUMB_BITS+1], &strData[precIn+1]);
mpfr_set_str_binary (cmp, strData);
(MPFR_MANT(in))[2] = MPFR_LIMB_HIGHBIT;
status = mpfr_rint (out, in, MPFR_RNDN);
if ((mpfr_cmp (out, cmp) != 0) || (status <= 0))
{
printf("mpfr_rint error :\n status is %d instead of 0\n", status);
printf(" out value is\n");
mpfr_dump(out);
printf(" instead of\n");
mpfr_dump(cmp);
exit (1);
}
mpfr_clear (cmp);
mpfr_clear (out);
mpfr_clear (in);
}