static slong _fmpr_sub_special(fmpr_t z, const fmpr_t x, const fmpr_t y, slong prec, fmpr_rnd_t rnd)
{
if (fmpr_is_zero(x))
{
return fmpr_neg_round(z, y, prec, rnd);
}
else if (fmpr_is_zero(y))
{
return fmpr_set_round(z, x, prec, rnd);
}
else if (fmpr_is_nan(x) || fmpr_is_nan(y)
|| (fmpr_is_pos_inf(x) && fmpr_is_pos_inf(y))
|| (fmpr_is_neg_inf(x) && fmpr_is_neg_inf(y)))
{
fmpr_nan(z);
return FMPR_RESULT_EXACT;
}
else if (fmpr_is_special(x))
{
fmpr_set(z, x);
return FMPR_RESULT_EXACT;
}
else
{
fmpr_neg(z, y);
return FMPR_RESULT_EXACT;
}
}
int
fmpr_get_mpfr(mpfr_t x, const fmpr_t y, mpfr_rnd_t rnd)
{
int r;
if (fmpr_is_special(y))
{
if (fmpr_is_zero(y)) mpfr_set_zero(x, 0);
else if (fmpr_is_pos_inf(y)) mpfr_set_inf(x, 1);
else if (fmpr_is_neg_inf(y)) mpfr_set_inf(x, -1);
else mpfr_set_nan(x);
r = 0;
}
else if (COEFF_IS_MPZ(*fmpr_expref(y)))
{
flint_printf("exception: exponent too large to convert to mpfr");
abort();
}
else
{
if (!COEFF_IS_MPZ(*fmpr_manref(y)))
#if defined(__MINGW64__)
r = mpfr_set_sj_2exp(x, *fmpr_manref(y), *fmpr_expref(y), rnd);
#else
r = mpfr_set_si_2exp(x, *fmpr_manref(y), *fmpr_expref(y), rnd);
#endif
else
r = mpfr_set_z_2exp(x, COEFF_TO_PTR(*fmpr_manref(y)), *fmpr_expref(y), rnd);
if (!mpfr_regular_p(x))
{
flint_printf("exception: exponent too large to convert to mpfr");
abort();
}
}
void
fmpr_get_fmpq(fmpq_t y, const fmpr_t x)
{
if (fmpr_is_zero(x))
{
fmpq_zero(y);
}
else if (fmpr_is_special(x) || COEFF_IS_MPZ(*fmpr_expref(x)))
{
printf("exception: fmpr_get_fmpq: cannot convert to rational\n");
abort();
}
else
{
long exp = *fmpr_expref(x);
fmpz_set_ui(fmpq_denref(y), 1UL);
if (exp >= 0)
{
fmpz_mul_2exp(fmpq_numref(y), fmpr_manref(x), exp);
}
else
{
fmpz_set(fmpq_numref(y), fmpr_manref(x));
fmpz_mul_2exp(fmpq_denref(y), fmpq_denref(y), -exp);
}
}
}
void
fmprb_mul_fmpr_naive(fmprb_t z, const fmprb_t x, const fmpr_t y, slong prec)
{
/* (x+a) * y = x*y + y*a */
if (fmpr_is_pos_inf(fmprb_radref(x)))
{
fmpr_mul(fmprb_midref(z), fmprb_midref(x), y, prec, FMPR_RND_DOWN);
fmpr_pos_inf(fmprb_radref(z));
}
else if (fmpr_is_zero(fmprb_radref(x)))
{
slong r;
r = fmpr_mul(fmprb_midref(z), fmprb_midref(x), y, prec, FMPR_RND_DOWN);
fmpr_set_error_result(fmprb_radref(z), fmprb_midref(z), r);
}
else
{
slong r;
fmpr_mul(fmprb_radref(z), fmprb_radref(x), y, FMPRB_RAD_PREC, FMPR_RND_UP);
fmpr_abs(fmprb_radref(z), fmprb_radref(z));
r = fmpr_mul(fmprb_midref(z), fmprb_midref(x), y, prec, FMPR_RND_DOWN);
fmpr_add_error_result(fmprb_radref(z), fmprb_radref(z),
fmprb_midref(z), r, FMPRB_RAD_PREC, FMPR_RND_UP);
}
}
static void
_fmpr_div_special(fmpr_t z, const fmpr_t x, const fmpr_t y)
{
if ((fmpr_is_zero(x) && !fmpr_is_zero(y) && !fmpr_is_nan(y)) ||
(fmpr_is_inf(y) && !fmpr_is_special(x)))
{
fmpr_zero(z);
}
else if (fmpr_is_zero(y) || (fmpr_is_special(x) && fmpr_is_special(y)) ||
fmpr_is_nan(x) || fmpr_is_nan(y))
{
fmpr_nan(z);
}
else if (fmpr_sgn(x) == fmpr_sgn(y))
fmpr_pos_inf(z);
else
fmpr_neg_inf(z);
}
int
fmpr_cmpabs(const fmpr_t x, const fmpr_t y)
{
int res, xsign, ysign;
fmpr_t t;
if (fmpr_equal(x, y))
return 0;
if (fmpr_is_special(x) || fmpr_is_special(y))
{
if (fmpr_is_nan(x) || fmpr_is_nan(y))
return 0;
if (fmpr_is_zero(x)) return -1;
if (fmpr_is_zero(y)) return 1;
if (fmpr_is_inf(x)) return fmpr_is_inf(y) ? 0 : 1;
if (fmpr_is_inf(y)) return -1;
return -1;
}
/* Reduces to integer comparison if bottom exponents are the same */
if (fmpz_equal(fmpr_expref(x), fmpr_expref(y)))
{
res = fmpz_cmpabs(fmpr_manref(x), fmpr_manref(y));
if (res != 0)
res = (res < 0) ? -1 : 1;
}
else
{
/* TODO: compare position of top exponents to avoid subtraction */
xsign = fmpr_sgn(x);
ysign = fmpr_sgn(y);
fmpr_init(t);
if (xsign == ysign)
fmpr_sub(t, x, y, 2, FMPR_RND_DOWN);
else
fmpr_add(t, x, y, 2, FMPR_RND_DOWN);
res = fmpr_sgn(t) * xsign;
fmpr_clear(t);
}
return res;
}
slong
fmpr_rsqrt(fmpr_t y, const fmpr_t x, slong prec, fmpr_rnd_t rnd)
{
slong r;
if (fmpr_is_special(x))
{
if (fmpr_is_zero(x))
fmpr_pos_inf(y);
else if (fmpr_is_pos_inf(x))
fmpr_zero(y);
else
fmpr_nan(y);
return FMPR_RESULT_EXACT;
}
if (fmpr_sgn(x) < 0)
{
fmpr_nan(y);
return FMPR_RESULT_EXACT;
}
/* special case: 4^n */
if (fmpz_is_one(fmpr_manref(x)) && fmpz_is_even(fmpr_expref(x)))
{
r = fmpr_set_round(y, x, prec, rnd);
fmpz_tdiv_q_2exp(fmpr_expref(y), fmpr_expref(y), 1);
fmpz_neg(fmpr_expref(y), fmpr_expref(y));
return r;
}
{
fmpr_t t;
fmpz_t e;
fmpr_init(t);
fmpz_init(e);
fmpz_neg(e, fmpr_expref(x));
if (fmpz_is_odd(e))
fmpz_add_ui(e, e, 1);
fmpr_mul_2exp_fmpz(t, x, e);
CALL_MPFR_FUNC(r, mpfr_rec_sqrt, y, t, prec, rnd);
fmpz_tdiv_q_2exp(e, e, 1);
fmpr_mul_2exp_fmpz(y, y, e);
fmpr_clear(t);
fmpz_clear(e);
return r;
}
}
int
fmpr_cmp(const fmpr_t x, const fmpr_t y)
{
int res, xsign, ysign;
fmpr_t t;
if (fmpr_equal(x, y))
return 0;
if (fmpr_is_special(x) || fmpr_is_special(y))
{
if (fmpr_is_nan(x) || fmpr_is_nan(y))
return 0;
if (fmpr_is_zero(y)) return fmpr_sgn(x);
if (fmpr_is_zero(x)) return -fmpr_sgn(y);
if (fmpr_is_pos_inf(x)) return 1;
if (fmpr_is_neg_inf(y)) return 1;
return -1;
}
xsign = fmpr_sgn(x);
ysign = fmpr_sgn(y);
if (xsign != ysign)
return (xsign < 0) ? -1 : 1;
/* Reduces to integer comparison if bottom exponents are the same */
if (fmpz_equal(fmpr_expref(x), fmpr_expref(y)))
return fmpz_cmp(fmpr_manref(x), fmpr_manref(y)) < 0 ? -1 : 1;
/* TODO: compare position of top exponents to avoid subtraction */
fmpr_init(t);
fmpr_sub(t, x, y, 2, FMPR_RND_DOWN);
res = fmpr_sgn(t);
fmpr_clear(t);
return res;
}
slong
fmpr_mul_fmpz(fmpr_t z, const fmpr_t x, const fmpz_t y, slong prec, fmpr_rnd_t rnd)
{
fmpz xv, yv;
fmpz yexp;
if (fmpr_is_special(x) || fmpz_is_zero(y))
{
if (fmpr_is_zero(x))
{
fmpr_zero(z);
}
else if (fmpz_is_zero(y) && fmpr_is_finite(x))
{
fmpr_zero(z);
}
else if (fmpr_is_inf(x) && !fmpz_is_zero(y))
{
if (fmpr_sgn(x) == fmpz_sgn(y))
fmpr_pos_inf(z);
else
fmpr_neg_inf(z);
}
else
{
fmpr_nan(z);
}
return FMPR_RESULT_EXACT;
}
xv = *fmpr_manref(x);
yv = *y;
if (!COEFF_IS_MPZ(xv) && !COEFF_IS_MPZ(yv))
{
mp_limb_t ytmp;
unsigned int bc;
ytmp = FLINT_ABS(yv);
count_trailing_zeros(bc, ytmp);
ytmp >>= bc;
yexp = bc;
return _fmpr_mul_1x1(z, FLINT_ABS(xv), fmpr_expref(x),
ytmp, &yexp, (xv ^ yv) < 0, prec, rnd);
}
void
arf_set_fmpr(arf_t y, const fmpr_t x)
{
if (fmpr_is_special(x))
{
if (fmpr_is_zero(x))
arf_zero(y);
else if (fmpr_is_pos_inf(x))
arf_pos_inf(y);
else if (fmpr_is_neg_inf(x))
arf_neg_inf(y);
else
arf_nan(y);
}
else
{
arf_set_fmpz(y, fmpr_manref(x));
fmpz_add_inline(ARF_EXPREF(y), ARF_EXPREF(y), fmpr_expref(x));
}
}
int _fmprb_poly_mid_get_hull(fmpz_t bot_exp, fmpz_t top_exp, fmprb_srcptr A, long lenA)
{
long i;
fmpz_t t;
int have_nonzero = 0;
fmpz_init(t);
fmpz_zero(bot_exp);
fmpz_zero(top_exp);
for (i = 0; i < lenA; i++)
{
if (fmpr_is_normal(fmprb_midref(A + i)))
{
if (!have_nonzero)
{
have_nonzero = 1;
fmpr_get_bot_exp(bot_exp, fmprb_midref(A + i));
fmpr_get_top_exp(top_exp, fmprb_midref(A + i));
}
else
{
fmpr_get_bot_exp(t, fmprb_midref(A + i));
if (fmpz_cmp(t, bot_exp) < 0)
fmpz_swap(t, bot_exp);
fmpr_get_top_exp(t, fmprb_midref(A + i));
if (fmpz_cmp(t, top_exp) > 0)
fmpz_swap(t, top_exp);
}
}
else if (!fmpr_is_zero(fmprb_midref(A + i)))
{
printf("exception: inf or nan encountered in polynomial\n");
abort();
}
}
fmpz_clear(t);
return have_nonzero;
}
void
fmprb_sqrtpos(fmprb_t z, const fmprb_t x, slong prec)
{
if (!fmprb_is_finite(x))
{
if (fmpr_is_zero(fmprb_radref(x)) && fmpr_is_pos_inf(fmprb_midref(x)))
fmprb_pos_inf(z);
else
fmprb_zero_pm_inf(z);
}
else if (fmprb_contains_nonpositive(x))
{
fmpr_t t;
fmpr_init(t);
fmpr_add(t, fmprb_midref(x), fmprb_radref(x),
FMPRB_RAD_PREC, FMPR_RND_CEIL);
if (fmpr_sgn(t) <= 0)
{
fmprb_zero(z);
}
else
{
fmpr_sqrt(t, t, FMPRB_RAD_PREC, FMPR_RND_CEIL);
fmpr_mul_2exp_si(t, t, -1);
fmpr_set(fmprb_midref(z), t);
fmpr_set(fmprb_radref(z), t);
}
fmpr_clear(t);
}
else
{
fmprb_sqrt(z, x, prec);
}
fmprb_nonnegative_part(z, z, prec);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sub....");
fflush(stdout);
flint_randinit(state);
/* test exact subtraction: (x - y) - z == (x - z) - y */
for (iter = 0; iter < 100000; iter++)
{
slong bits, res1, res2, res3, res4;
fmpr_t x, y, z, t, u;
bits = 2 + n_randint(state, 200);
fmpr_init(x);
fmpr_init(y);
fmpr_init(z);
fmpr_init(t);
fmpr_init(u);
fmpr_randtest_special(x, state, bits, 10);
fmpr_randtest_special(y, state, bits, 10);
fmpr_randtest_special(z, state, bits, 10);
fmpr_randtest_special(t, state, bits, 10);
fmpr_randtest_special(u, state, bits, 10);
res1 = fmpr_sub(t, x, y, FMPR_PREC_EXACT, FMPR_RND_DOWN);
res2 = fmpr_sub(t, t, z, FMPR_PREC_EXACT, FMPR_RND_DOWN);
res3 = fmpr_sub(u, x, z, FMPR_PREC_EXACT, FMPR_RND_DOWN);
res4 = fmpr_sub(u, u, y, FMPR_PREC_EXACT, FMPR_RND_DOWN);
if (!fmpr_equal(t, u) ||
res1 != FMPR_RESULT_EXACT || res2 != FMPR_RESULT_EXACT ||
res3 != FMPR_RESULT_EXACT || res4 != FMPR_RESULT_EXACT)
{
flint_printf("FAIL\n\n");
flint_printf("bits = %wd\n", bits);
flint_printf("x = "); fmpr_print(x); flint_printf("\n\n");
flint_printf("y = "); fmpr_print(y); flint_printf("\n\n");
flint_printf("z = "); fmpr_print(z); flint_printf("\n\n");
flint_printf("t = "); fmpr_print(t); flint_printf("\n\n");
flint_printf("u = "); fmpr_print(u); flint_printf("\n\n");
abort();
}
fmpr_clear(x);
fmpr_clear(y);
fmpr_clear(z);
fmpr_clear(t);
fmpr_clear(u);
}
/* compare rounding with mpfr */
for (iter = 0; iter < 100000; iter++)
{
slong bits, res;
int mpfr_res;
fmpr_t x, y, z, w;
mpfr_t X, Y, Z;
bits = 2 + n_randint(state, 200);
fmpr_init(x);
fmpr_init(y);
fmpr_init(z);
fmpr_init(w);
mpfr_init2(X, bits + 100);
mpfr_init2(Y, bits + 100);
mpfr_init2(Z, bits);
fmpr_randtest_special(x, state, bits + n_randint(state, 100), 10);
fmpr_randtest_special(y, state, bits + n_randint(state, 100), 10);
fmpr_randtest_special(z, state, bits, 10);
fmpr_get_mpfr(X, x, MPFR_RNDN);
fmpr_get_mpfr(Y, y, MPFR_RNDN);
switch (n_randint(state, 4))
{
case 0:
mpfr_res = mpfr_sub(Z, X, Y, MPFR_RNDZ);
res = fmpr_sub(z, x, y, bits, FMPR_RND_DOWN);
break;
case 1:
mpfr_res = mpfr_sub(Z, X, Y, MPFR_RNDA);
res = fmpr_sub(z, x, y, bits, FMPR_RND_UP);
break;
case 2:
mpfr_res = mpfr_sub(Z, X, Y, MPFR_RNDD);
res = fmpr_sub(z, x, y, bits, FMPR_RND_FLOOR);
break;
default:
mpfr_res = mpfr_sub(Z, X, Y, MPFR_RNDU);
res = fmpr_sub(z, x, y, bits, FMPR_RND_CEIL);
break;
}
fmpr_set_mpfr(w, Z);
if (!fmpr_equal(z, w) || (res == FMPR_RESULT_EXACT) != (mpfr_res == 0)
|| !fmpr_check_ulp(z, res, bits))
{
flint_printf("FAIL\n\n");
flint_printf("bits = %wd\n", bits);
flint_printf("x = "); fmpr_print(x); flint_printf("\n\n");
flint_printf("y = "); fmpr_print(y); flint_printf("\n\n");
flint_printf("z = "); fmpr_print(z); flint_printf("\n\n");
flint_printf("w = "); fmpr_print(w); flint_printf("\n\n");
flint_printf("returned: %wd, %d\n", res, mpfr_res);
abort();
}
/* check error bound */
if (!fmpr_is_nan(z) && !fmpr_is_inf(z))
{
fmpr_t z_exact, error_bound, true_error;
fmpr_init(z_exact);
fmpr_init(error_bound);
fmpr_init(true_error);
fmpr_set_error_result(error_bound, z, res);
fmpr_sub(z_exact, x, y, FMPR_PREC_EXACT, FMPR_RND_DOWN);
fmpr_sub(true_error, z, z_exact, FMPR_PREC_EXACT, FMPR_RND_DOWN);
fmpr_abs(true_error, true_error);
if (fmpr_is_zero(error_bound) != fmpr_is_zero(true_error) ||
fmpr_cmp(true_error, error_bound) > 0)
{
flint_printf("FAIL: error bound\n\n");
flint_printf("bits = %wd\n", bits);
flint_printf("x = "); fmpr_print(x); flint_printf("\n\n");
flint_printf("y = "); fmpr_print(y); flint_printf("\n\n");
flint_printf("z = "); fmpr_print(z); flint_printf("\n\n");
flint_printf("z_exact = "); fmpr_print(z_exact); flint_printf("\n\n");
flint_printf("true_error = "); fmpr_print(true_error); flint_printf("\n\n");
flint_printf("error_bound = "); fmpr_print(error_bound); flint_printf("\n\n");
abort();
}
fmpr_clear(z_exact);
fmpr_clear(error_bound);
fmpr_clear(true_error);
}
fmpr_clear(x);
fmpr_clear(y);
fmpr_clear(z);
fmpr_clear(w);
mpfr_clear(X);
mpfr_clear(Y);
mpfr_clear(Z);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("add....");
fflush(stdout);
flint_randinit(state);
/* test exact addition: (x + y) + z == x + (y + z) */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
slong bits, res1, res2, res3, res4;
fmpr_t x, y, z, t, u;
bits = 2 + n_randint(state, 200);
fmpr_init(x);
fmpr_init(y);
fmpr_init(z);
fmpr_init(t);
fmpr_init(u);
fmpr_randtest_special(x, state, bits, 10);
fmpr_randtest_special(y, state, bits, 10);
fmpr_randtest_special(z, state, bits, 10);
fmpr_randtest_special(t, state, bits, 10);
fmpr_randtest_special(u, state, bits, 10);
res1 = fmpr_add(t, x, y, FMPR_PREC_EXACT, FMPR_RND_DOWN);
res2 = fmpr_add(t, t, z, FMPR_PREC_EXACT, FMPR_RND_DOWN);
res3 = fmpr_add(u, y, z, FMPR_PREC_EXACT, FMPR_RND_DOWN);
res4 = fmpr_add(u, x, u, FMPR_PREC_EXACT, FMPR_RND_DOWN);
if (!fmpr_equal(t, u) ||
res1 != FMPR_RESULT_EXACT || res2 != FMPR_RESULT_EXACT ||
res3 != FMPR_RESULT_EXACT || res4 != FMPR_RESULT_EXACT)
{
flint_printf("FAIL\n\n");
flint_printf("bits = %wd\n", bits);
flint_printf("x = "); fmpr_print(x); flint_printf("\n\n");
flint_printf("y = "); fmpr_print(y); flint_printf("\n\n");
flint_printf("z = "); fmpr_print(z); flint_printf("\n\n");
flint_printf("t = "); fmpr_print(t); flint_printf("\n\n");
flint_printf("u = "); fmpr_print(u); flint_printf("\n\n");
abort();
}
fmpr_clear(x);
fmpr_clear(y);
fmpr_clear(z);
fmpr_clear(t);
fmpr_clear(u);
}
/* compare with add_naive */
for (iter = 0; iter < 1000000 * arb_test_multiplier(); iter++)
{
slong prec, ret1, ret2;
fmpr_t x, y, z, w;
fmpr_rnd_t rnd;
fmpr_init(x);
fmpr_init(y);
fmpr_init(z);
fmpr_init(w);
fmpr_randtest_special(x, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 200));
fmpr_randtest_special(y, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 200));
fmpr_randtest_special(z, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 200));
prec = 2 + n_randint(state, 1000);
if (n_randint(state, 10) == 0 &&
fmpz_bits(fmpr_expref(x)) < 10 &&
fmpz_bits(fmpr_expref(y)) < 10)
prec = FMPR_PREC_EXACT;
switch (n_randint(state, 4))
{
case 0: rnd = FMPR_RND_DOWN; break;
case 1: rnd = FMPR_RND_UP; break;
case 2: rnd = FMPR_RND_FLOOR; break;
default: rnd = FMPR_RND_CEIL; break;
}
ret1 = fmpr_add(z, x, y, prec, rnd);
ret2 = fmpr_add_naive(w, x, y, prec, rnd);
if (!fmpr_equal(z, w) || ret1 != ret2 ||
!fmpr_check_ulp(z, ret1, prec) || !fmpr_check_ulp(w, ret2, prec))
{
flint_printf("FAIL\n\n");
flint_printf("iter %wd\n", iter);
flint_printf("prec = %wd\n", prec);
flint_printf("x = "); fmpr_print(x); flint_printf("\n\n");
flint_printf("y = "); fmpr_print(y); flint_printf("\n\n");
flint_printf("z = "); fmpr_print(z); flint_printf("\n\n");
flint_printf("w = "); fmpr_print(w); flint_printf("\n\n");
flint_printf("ret1 = %wd, ret2 = %wd\n", ret1, ret2);
abort();
}
fmpr_clear(x);
fmpr_clear(y);
fmpr_clear(z);
fmpr_clear(w);
}
/* compare rounding with mpfr */
for (iter = 0; iter < 1000000 * arb_test_multiplier(); iter++)
{
slong bits, res;
int mpfr_res;
fmpr_t x, y, z, w;
mpfr_t X, Y, Z;
bits = 2 + n_randint(state, 500);
fmpr_init(x);
fmpr_init(y);
fmpr_init(z);
fmpr_init(w);
mpfr_init2(X, bits + 500);
mpfr_init2(Y, bits + 500);
mpfr_init2(Z, bits);
fmpr_randtest_special(x, state, bits + n_randint(state, 500), 10);
fmpr_randtest_special(y, state, bits + n_randint(state, 500), 10);
fmpr_randtest_special(z, state, bits, 10);
fmpr_get_mpfr(X, x, MPFR_RNDN);
fmpr_get_mpfr(Y, y, MPFR_RNDN);
switch (n_randint(state, 4))
{
case 0:
mpfr_res = mpfr_add(Z, X, Y, MPFR_RNDZ);
res = fmpr_add(z, x, y, bits, FMPR_RND_DOWN);
break;
case 1:
mpfr_res = mpfr_add(Z, X, Y, MPFR_RNDA);
res = fmpr_add(z, x, y, bits, FMPR_RND_UP);
break;
case 2:
mpfr_res = mpfr_add(Z, X, Y, MPFR_RNDD);
res = fmpr_add(z, x, y, bits, FMPR_RND_FLOOR);
break;
default:
mpfr_res = mpfr_add(Z, X, Y, MPFR_RNDU);
res = fmpr_add(z, x, y, bits, FMPR_RND_CEIL);
break;
}
fmpr_set_mpfr(w, Z);
if (!fmpr_equal(z, w) || (res == FMPR_RESULT_EXACT) != (mpfr_res == 0)
|| !fmpr_check_ulp(z, res, bits))
{
flint_printf("FAIL\n\n");
flint_printf("iter %wd\n", iter);
flint_printf("bits = %wd\n", bits);
flint_printf("x = "); fmpr_print(x); flint_printf("\n\n");
flint_printf("y = "); fmpr_print(y); flint_printf("\n\n");
flint_printf("z = "); fmpr_print(z); flint_printf("\n\n");
flint_printf("w = "); fmpr_print(w); flint_printf("\n\n");
flint_printf("returned: %wd, %d\n", res, mpfr_res);
abort();
}
/* check error bound */
if (!fmpr_is_nan(z) && !fmpr_is_inf(z))
{
fmpr_t z_exact, error_bound, true_error;
fmpr_init(z_exact);
fmpr_init(error_bound);
fmpr_init(true_error);
fmpr_set_error_result(error_bound, z, res);
fmpr_add(z_exact, x, y, FMPR_PREC_EXACT, FMPR_RND_DOWN);
fmpr_sub(true_error, z, z_exact, FMPR_PREC_EXACT, FMPR_RND_DOWN);
fmpr_abs(true_error, true_error);
if (fmpr_is_zero(error_bound) != fmpr_is_zero(true_error) ||
fmpr_cmp(true_error, error_bound) > 0)
{
flint_printf("FAIL: error bound\n\n");
flint_printf("bits = %wd\n", bits);
flint_printf("x = "); fmpr_print(x); flint_printf("\n\n");
flint_printf("y = "); fmpr_print(y); flint_printf("\n\n");
flint_printf("z = "); fmpr_print(z); flint_printf("\n\n");
flint_printf("z_exact = "); fmpr_print(z_exact); flint_printf("\n\n");
flint_printf("true_error = "); fmpr_print(true_error); flint_printf("\n\n");
flint_printf("error_bound = "); fmpr_print(error_bound); flint_printf("\n\n");
abort();
}
fmpr_clear(z_exact);
fmpr_clear(error_bound);
fmpr_clear(true_error);
}
fmpr_clear(x);
fmpr_clear(y);
fmpr_clear(z);
fmpr_clear(w);
mpfr_clear(X);
mpfr_clear(Y);
mpfr_clear(Z);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("abs_bound_lt_2exp_si....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
fmpr_t x;
fmpz_t b;
slong c;
fmpr_init(x);
fmpz_init(b);
fmpr_randtest_special(x, state, 2 + n_randint(state, 1000), 100);
fmpr_abs_bound_lt_2exp_fmpz(b, x);
c = fmpr_abs_bound_lt_2exp_si(x);
if (c == -FMPR_PREC_EXACT)
{
if (!(fmpr_is_zero(x) || fmpz_cmp_si(b, -FMPR_PREC_EXACT) <= 0))
{
flint_printf("FAIL (small/zero)\n\n");
abort();
}
}
else if (c == FMPR_PREC_EXACT)
{
if (!(fmpr_is_inf(x) || fmpr_is_nan(x) ||
fmpz_cmp_si(b, FMPR_PREC_EXACT) >= 0))
{
flint_printf("FAIL (large/inf/nan)\n\n");
abort();
}
}
else
{
if (fmpz_cmp_si(b, c) != 0)
{
flint_printf("FAIL (normal)\n\n");
flint_printf("x = "); fmpr_print(x); flint_printf("\n\n");
flint_printf("b = "); fmpz_print(b); flint_printf("\n\n");
flint_printf("c = %wd\n\n", c);
abort();
}
}
fmpr_clear(x);
fmpz_clear(b);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
