int
main (int argc, char **argv)
{
mpfr_t x, y;
mpq_t a, b;
mpfi_t i;
mpq_init (a);
mpq_init (b);
mpfi_init2 (i, 53);
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
mpq_set_si (a, -1, 3);
mpq_set_ui (b, +1, 1024);
mpfr_set_q (x, a, MPFI_RNDD);
mpfr_set_q (y, b, MPFI_RNDU);
check (i, a, b, x, y, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
check (i, b, a, x, y, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
check (i, b, b, y, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
mpfr_set_q (y, a, MPFI_RNDU);
check (i, a, a, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_INEXACT);
mpq_clear (a);
mpq_clear (b);
mpfi_clear (i);
mpfr_clear (x);
mpfr_clear (y);
return 0;
}
int main(void) {
sollya_obj_t a;
mpfi_t res;
int s;
mpfi_init2(res, 100);
sollya_lib_init();
sollya_lib_install_msg_callback(callback, NULL);
a = SOLLYA_CONST(4);
s = sollya_lib_get_interval_from_range(res, a);
if (s==0) sollya_lib_printf("%b is not a range\n\n", a);
else sollya_lib_printf("%b has been converted to %w.\n\n", a, res);
sollya_lib_clear_obj(a);
/* Exact conversion */
a = sollya_lib_parse_string("[1, 3]");
s = sollya_lib_get_interval_from_range(res, a);
if (s==0) sollya_lib_printf("%b is not a range\n\n", a);
else sollya_lib_printf("%b has been converted to %w.\n\n", a, res);
sollya_lib_clear_obj(a);
/* Another exact conversion */
a = SOLLYA_CONST(100);
sollya_lib_set_prec_and_print(a);
sollya_lib_clear_obj(a);
a = sollya_lib_powers();
sollya_lib_set_display(a);
sollya_lib_clear_obj(a);
a = sollya_lib_parse_string("[exp(1), pi]");
s = sollya_lib_get_interval_from_range(res, a);
if (s==0) sollya_lib_printf("%b is not a range\n\n", a);
else sollya_lib_printf("%b has been converted to\n%w (should be [430728948929449700355022696705 * 2^(-97), 995610453248924340922087778489 * 2^(-98)]).\n\n", a, res);
sollya_lib_clear_obj(a);
/* Inexact conversion */
a = SOLLYA_CONST(165);
sollya_lib_set_prec_and_print(a);
sollya_lib_clear_obj(a);
a = sollya_lib_decimal();
sollya_lib_set_display(a);
sollya_lib_clear_obj(a);
a = sollya_lib_parse_string("[exp(1), pi]");
s = sollya_lib_get_interval_from_range(res, a);
if (s==0) sollya_lib_printf("%b is not a range\n\n", a);
else sollya_lib_printf("%b has been converted to\n%w (the first one should be enclosed in the second one).\n\n", a, res);
sollya_lib_clear_obj(a);
mpfi_clear(res);
sollya_lib_close();
return 0;
}
static void
check_overflow ()
{
mpfr_t max;
mpfi_t a;
mpfr_t b;
int inexact;
mpfi_init2 (a, 53);
mpfr_init2 (max, 53);
mpfr_init2 (b, 53);
mpfr_set_ui (&(a->left), 1, MPFI_RNDD);
mpfr_set_inf (max, +1);
mpfr_nextbelow (max);
mpfr_set (&(a->right), max, MPFI_RNDU);
mpfr_set_ui (b, +1, MPFI_RNDD);
inexact = mpfi_add_fr (a, a, b);
if (!mpfr_inf_p (&(a->right))) {
printf ("Error: mpfi_add_fr does not correctly handle positive "
"overflow.\n");
exit (1);
}
if (!MPFI_RIGHT_IS_INEXACT (inexact)) {
printf ("Error: mpfi_add_fr does not return correct value when positive "
"overflow.\n");
exit (1);
}
mpfr_set_inf (max, -1);
mpfr_nextabove (max);
mpfr_set (&(a->left), max, MPFI_RNDD);
mpfr_set_ui (&(a->right), 1, MPFI_RNDU);
mpfr_set_si (b, -1, MPFI_RNDD);
inexact = mpfi_add_fr (a, a, b);
if (!mpfr_inf_p (&(a->left))) {
printf ("Error: mpfi_add_fr does not correctly handle negative "
"overflow.\n");
exit (1);
}
if (!MPFI_LEFT_IS_INEXACT (inexact)) {
printf ("Error: mpfi_add_fr does not return correct value when negative "
"overflow.\n");
exit (1);
}
mpfi_clear (a);
mpfr_clear (b);
mpfr_clear (max);
}
void
check ()
{
mpfi_t interval;
long a, b, c;
int cmp;
int i;
i = 1;
a = LONG_MAX;
while (a >>= 1) i++;
mpfi_init2 (interval, i);
for (i = 0; i <= 1000; ++i) {
/* random numbers a < b < c */
a = random_si ();
b = random_si ();
c = random_si ();
ORDER (a, b);
ORDER (a, c);
ORDER (b, c);
mpfi_interv_si (interval, b, c);
cmp = mpfi_cmp_si (interval, a);
if (cmp < 0 || (cmp == 0 && a != b)) {
print_error (a, interval);
}
mpfr_set_nan (&(interval->right));
if (mpfi_cmp_si (interval, a) != 1) {
print_error (a, interval);
}
mpfi_interv_si (interval, a, c);
if (mpfi_cmp_si (interval, b) != 0) {
print_error (b, interval);
}
mpfr_set_nan (&(interval->right));
if (mpfi_cmp_si (interval, b) != 1) {
print_error (b, interval);
}
mpfi_interv_si (interval, a, b);
cmp = mpfi_cmp_si (interval, c);
if (cmp > 0 || (cmp == 0 && c != b)) {
print_error (c, interval);
}
mpfr_set_nan (&(interval->right));
if (mpfi_cmp_si (interval, c) != 1) {
print_error (c, interval);
}
}
mpfi_clear (interval);
}
int
main (int argc, char **argv)
{
mpfr_t x, y;
long a, b;
mpfi_t i;
mpfi_init2 (i, 53);
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
a = 0;
b = 42;
mpfr_set_ui (x, a, MPFI_RNDD);
mpfr_set_ui (y, b, MPFI_RNDU);
check (i, a, b, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, b, a, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, b, b, y, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
mpfr_neg (y, x, MPFI_RNDD);
check (i, a, a, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
a = +1;
b = +123456;
mpfr_set_si (x, a, MPFI_RNDD);
mpfr_set_si (y, b, MPFI_RNDU);
check (i, a, b, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, b, a, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, a, a, x, x, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
a = -1920;
b = -17;
mpfr_set_si (x, a, MPFI_RNDD);
mpfr_set_si (y, b, MPFI_RNDU);
check (i, a, b, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, b, a, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, a, a, x, x, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
mpfi_set_prec (i, 4);
mpfr_set_prec (x, 4);
mpfr_set_prec (y, 4);
mpfr_set_si (x, a, MPFI_RNDD);
mpfr_set_si (y, b, MPFI_RNDU);
check (i, a, b, x, y, MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT);
check (i, b, a, x, y, MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT);
check (i, a, a, x, x, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
mpfr_set_si (x, b, MPFI_RNDD);
check (i, b, b, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_INEXACT);
mpfi_clear (i);
mpfr_clear (x);
mpfr_clear (y);
return 0;
}
int
main (int argc, char **argv)
{
FILE *stream;
mpfi_t interval;
mpfi_t left;
mpfi_t right;
mpfi_t expected_left;
mpfi_t expected_right;
int retval;
mpfi_init2 (interval, 1024);
mpfi_init2 (left, 1024);
mpfi_init2 (right, 1024);
mpfi_init2 (expected_left, 1024);
mpfi_init2 (expected_right, 1024);
stream = open_file ("bisect.dat");
init_reading (stream);
while (nextchar != EOF) {
test_line_number = line_number;
read_sign (stream, &retval);
read_mpfi (stream, expected_left);
mpfi_set_prec (left, mpfi_get_prec (expected_left));
read_mpfi (stream, expected_right);
mpfi_set_prec (right, mpfi_get_prec (expected_right));
read_mpfi (stream, interval);
check (left, right, interval, expected_left, expected_right, retval);
}
close_file (stream);
mpfi_clear (interval);
mpfi_clear (left);
mpfi_clear (right);
mpfi_clear (expected_left);
mpfi_clear (expected_right);
return 0;
}
int
mpfi_is_inside_z (mpz_srcptr a, mpfi_srcptr b)
{
int res;
mpfi_t tmp;
mpfi_init2 (tmp, mpfi_get_prec (b));
mpfi_set_z (tmp, a);
res = mpfi_is_inside (tmp, b);
MPFI_CLEAR (tmp);
return res;
}
int
mpfi_is_inside_d (const double a, mpfi_srcptr b)
{
int res;
mpfi_t tmp;
mpfi_init2 (tmp, mpfi_get_prec (b));
mpfi_set_d (tmp, a);
res = mpfi_is_inside (tmp, b);
MPFI_CLEAR (tmp);
return res;
}
void
check_overflow ()
{
mpfr_t max;
mpfi_t a;
mpq_t q;
int inexact;
mpq_init (q);
mpfi_init2 (a, 53);
mpfr_init2 (max, 53);
mpq_set_ui (q, 42, 17);
mpfr_set_ui (&(a->left), 1, MPFI_RNDD);
mpfr_set_inf (max, +1);
mpfr_nextbelow (max);
mpfr_set (&(a->right), max, MPFI_RNDU);
inexact = mpfi_add_q (a, a, q);
if (!mpfr_inf_p (&(a->right))) {
printf ("Error: mpfi_add_q does not correctly handle overflow.\n");
exit (1);
}
if (!MPFI_RIGHT_IS_INEXACT (inexact)) {
printf ("Error: mpfi_add_q does not return correct value "
"when overflow.\n");
exit (1);
}
mpfr_set_inf (max, -1);
mpfr_nextabove (max);
mpfr_set (&(a->left), max, MPFI_RNDD);
mpfr_set_ui (&(a->right), 1, MPFI_RNDU);
mpq_set_si (q, -42, 17);
inexact = mpfi_add_q (a, a, q);
if (!mpfr_inf_p (&(a->left))) {
printf ("Error: mpfi_add_q does not correctly handle negative "
"overflow.\n");
exit (1);
}
if (!MPFI_LEFT_IS_INEXACT (inexact)) {
printf ("Error: mpfi_add_q does not return correct value when negative "
"overflow.\n");
exit (1);
}
mpfi_clear (a);
mpfr_clear (max);
mpq_clear (q);
}
int
mpfi_is_inside_q (mpq_srcptr a, mpfi_srcptr b)
{
int res;
mpfi_t tmp;
/* Returns 0 if one of the operands is a NaN */
if (MPFI_NAN_P (b))
return 0;
mpfi_init2 (tmp, mpfi_get_prec (b));
mpfi_set_q (tmp, a);
res = mpfi_is_inside (tmp, b);
MPFI_CLEAR (tmp);
return res;
}
int
mpfi_div_fr (mpfi_ptr a, mpfi_srcptr b, mpfr_srcptr c)
{
mpfi_t tmp;
int inexact;
mpfi_init2 (tmp, mpfr_get_prec (c));
mpfi_set_fr (tmp, c); /* exact */
inexact = mpfi_div (a, b, tmp);
MPFI_CLEAR (tmp);
if (MPFI_NAN_P (a))
MPFR_RET_NAN;
return inexact;
}
int
main (int argc, char **argv)
{
mpfr_t minf, pinf;
mpfr_t mzero, pzero;
mpfr_t nan;
mpfr_t x, y;
mpfr_t xx, yy;
mpfi_t i;
mpfi_init2 (i, 53);
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
mpfr_init2 (xx, 53);
mpfr_init2 (yy, 53);
mpfr_init2 (minf, 53);
mpfr_init2 (pinf, 53);
mpfr_init2 (mzero, 53);
mpfr_init2 (pzero, 53);
mpfr_init2 (nan, 53);
mpfr_set_nan (nan);
mpfr_set_inf (minf, -1);
mpfr_set_inf (pinf, +1);
mpfr_set_ui (pzero, 0, MPFI_RNDU);
mpfr_neg (mzero, pzero, MPFI_RNDD);
/* special values */
check (i, minf, minf, minf, minf, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, minf, mzero, minf, mzero, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, mzero, minf, minf, mzero, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, minf, pzero, minf, mzero, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pzero, minf, minf, mzero, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, minf, pinf, minf, pinf, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pinf, minf, minf, pinf, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, minf, nan, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, nan, minf, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, mzero, mzero, pzero, mzero, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, mzero, pzero, pzero, mzero, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pzero, mzero, pzero, mzero, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, mzero, pinf, pzero, pinf, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pinf, mzero, pzero, pinf, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, mzero, nan, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, nan, mzero, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pzero, pzero, pzero, mzero, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pzero, pzero, pzero, mzero, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pzero, pinf, pzero, pinf, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pinf, pzero, pzero, pinf, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pzero, nan, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, nan, pzero, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pinf, pinf, pinf, pinf, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pinf, nan, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, nan, pinf, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, nan, nan, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
/* regular values */
mpfr_set_si (x, -456789, MPFI_RNDD);
mpfr_set_si (y, 123456, MPFI_RNDU);
check (i, x, y, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, y, x, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, x, minf, minf, x, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, minf, x, minf, x, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, x, mzero, x, mzero, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, mzero, x, x, mzero, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, y, mzero, pzero, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, mzero, y, pzero, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, x, pzero, x, mzero, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pzero, x, x, mzero, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, y, pzero, pzero, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pzero, y, pzero, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, x, pinf, x, pinf, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pinf, x, x, pinf, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, y, pinf, y, pinf, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, pinf, y, y, pinf, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, x, nan, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, nan, x, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, y, nan, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, nan, x, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
mpfr_set_si (x, -400009, MPFI_RNDD);
mpfr_set_si (y, 100007, MPFI_RNDU);
mpfi_set_prec (i, 12);
mpfr_set_prec (xx, 12);
mpfr_set_prec (yy, 12);
mpfr_set (xx, x, MPFI_RNDD);
mpfr_set (yy, y, MPFI_RNDU);
check (i, x, y, xx, yy, MPFI_FLAGS_BOTH_ENDPOINTS_INEXACT);
check (i, y, x, xx, yy, MPFI_FLAGS_BOTH_ENDPOINTS_INEXACT);
mpfr_set (xx, x, MPFI_RNDU);
check (i, x, minf, minf, xx, MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT);
check (i, minf, x, minf, xx, MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT);
check (i, y, minf, minf, yy, MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT);
check (i, minf, y, minf, yy, MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT);
mpfr_set (xx, x, MPFI_RNDD);
check (i, x, mzero, xx, mzero, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
check (i, mzero, x, xx, mzero, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
check (i, y, mzero, pzero, yy, MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT);
check (i, mzero, y, pzero, yy, MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT);
check (i, x, pzero, xx, mzero, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
check (i, pzero, x, xx, mzero, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
check (i, y, pzero, pzero, yy, MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT);
check (i, pzero, y, pzero, yy, MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT);
check (i, x, pinf, xx, pinf, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
check (i, pinf, x, xx, pinf, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
mpfr_set (yy, y, MPFI_RNDD);
check (i, y, pinf, yy, pinf, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
check (i, pinf, y, yy, pinf, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
check (i, x, nan, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, nan, x, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, y, nan, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, nan, y, nan, nan, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
mpfi_clear (i);
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (xx);
mpfr_clear (yy);
mpfr_clear (minf);
mpfr_clear (pinf);
mpfr_clear (mzero);
mpfr_clear (pzero);
mpfr_clear (nan);
return 0;
}
int
main (int argc, char **argv)
{
mpfr_t x, y;
double a, b;
mpfi_t i;
mpfi_init2 (i, 53);
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
a = -1;
b = +1;
mpfr_set_d (x, -1, MPFI_RNDD);
mpfr_set_d (y, +1, MPFI_RNDU);
check (i, a, b, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, b, a, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, a, a, x, x, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
mpfi_set_prec (i, 4);
mpfr_set_prec (x, 4);
mpfr_set_prec (y, 4);
a = -1;
b = +40;
mpfr_set_d (x, -1, MPFI_RNDD);
mpfr_set_d (y, +40, MPFI_RNDU);
check (i, a, b, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, b, a, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, a, a, x, x, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
a = -1;
b = +42.35;
mpfr_set_d (x, -1, MPFI_RNDD);
mpfr_set_d (y, +42.35, MPFI_RNDU);
check (i, a, b, x, y, MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT);
check (i, b, a, x, y, MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT);
a = -0.1;
mpfr_set_d (x, -0.1, MPFI_RNDD);
mpfr_set_d (y, +42.35, MPFI_RNDU);
check (i, a, b, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_INEXACT);
check (i, b, a, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_INEXACT);
a = -1e-4;
b = +16;
mpfr_set_d (x, -1e-4, MPFI_RNDD);
mpfr_set_d (y, +16, MPFI_RNDU);
check (i, a, b, x, y, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
check (i, b, a, x, y, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
mpfr_set_nan (x);
a = mpfr_get_d (x, MPFI_RNDD); /* a = NaN, if supported */
check (i, a, b, y, x, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, b, a, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, a, a, x, x, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
mpfr_set_ui (x, 0, MPFI_RNDD);
mpfr_neg (x, x, MPFI_RNDD);
a = mpfr_get_d (x, MPFI_RNDD); /* a = -0, if supported */
mpfr_neg (x, x, MPFI_RNDU);
check (i, a, b, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
check (i, b, a, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
mpfi_clear (i);
mpfr_clear (x);
mpfr_clear (y);
return 0;
}
