void
fmpr_divappr_abs_ubound(fmpr_t z, const fmpr_t x, const fmpr_t y, slong prec)
{
if (fmpr_is_special(x) || fmpr_is_special(y) || fmpz_is_pm1(fmpr_manref(y)))
{
fmpr_div(z, x, y, prec, FMPR_RND_UP);
fmpr_abs(z, z);
}
else
{
fmpz_t t, u;
slong xbits, ybits, tbits, ubits, shift;
xbits = fmpz_bits(fmpr_manref(x));
ybits = fmpz_bits(fmpr_manref(y));
fmpz_init(t);
fmpz_init(u);
ubits = FLINT_MIN(ybits, prec);
tbits = prec + ubits + 1;
/* upper bound for |x|, shifted */
if (xbits <= tbits)
{
fmpz_mul_2exp(t, fmpr_manref(x), tbits - xbits);
fmpz_abs(t, t);
}
else if (fmpz_sgn(fmpr_manref(x)) > 0)
{
fmpz_cdiv_q_2exp(t, fmpr_manref(x), xbits - tbits);
}
else
{
fmpz_fdiv_q_2exp(t, fmpr_manref(x), xbits - tbits);
fmpz_neg(t, t);
}
/* lower bound for |y|, shifted */
if (ybits <= ubits)
fmpz_mul_2exp(u, fmpr_manref(y), ubits - ybits);
else
fmpz_tdiv_q_2exp(u, fmpr_manref(y), ybits - ubits);
fmpz_abs(u, u);
fmpz_cdiv_q(fmpr_manref(z), t, u);
shift = (ubits - ybits) - (tbits - xbits);
fmpz_sub(fmpr_expref(z), fmpr_expref(x), fmpr_expref(y));
if (shift >= 0)
fmpz_add_ui(fmpr_expref(z), fmpr_expref(z), shift);
else
fmpz_sub_ui(fmpr_expref(z), fmpr_expref(z), -shift);
_fmpr_normalise(fmpr_manref(z), fmpr_expref(z), prec, FMPR_RND_UP);
fmpz_clear(t);
fmpz_clear(u);
}
}
int
main(void)
{
long iter;
int result;
flint_rand_t state;
printf("abs_ubound_ui_2exp....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
fmpz_t x, y;
long bits, yexp;
long exp;
mp_limb_t man;
fmpz_init(x);
fmpz_init(y);
fmpz_randtest_not_zero(x, state, 1 + n_randint(state, 400));
bits = 1 + n_randint(state, FLINT_BITS - 1);
/* compute an exactly rounded mantissa */
fmpz_abs(y, x);
if (fmpz_is_zero(y))
{
yexp = 0;
}
else
{
yexp = fmpz_bits(y) - bits;
if (yexp >= 0)
{
fmpz_cdiv_q_2exp(y, y, yexp);
if (fmpz_bits(y) == bits + 1)
{
fmpz_tdiv_q_2exp(y, y, 1);
yexp--;
}
}
else
{
fmpz_mul_2exp(y, y, -yexp);
}
}
man = fmpz_abs_ubound_ui_2exp(&exp, x, bits);
if (FLINT_BIT_COUNT(man) != bits)
{
printf("wrong number of bits!\n");
printf("bits = %ld, count = %u\n\n", bits, FLINT_BIT_COUNT(man));
printf("x = "); fmpz_print(x); printf("\n\n");
printf("bits(x) = %ld\n\n", fmpz_bits(x));
printf("y = "); fmpz_print(y); printf("\n\n");
printf("yexp = %ld\n\n", yexp);
printf("man = %lu, exp = %ld\n", man, exp);
abort();
}
/* ok if equal */
result = (fmpz_cmp_ui(y, man) == 0);
/* ok if mantissa is 1 larger */
if (!result)
{
result = ((exp == yexp) && (fmpz_cmp_ui(y, man - 1) == 0));
}
/* ok if the exact mantissa is 2^r-1 and overflow to 2^r happened */
if (!result)
{
fmpz_t t;
fmpz_init(t);
fmpz_set_ui(t, man);
fmpz_mul_ui(t, t, 2);
fmpz_sub_ui(t, t, 1);
result = (exp == yexp + 1) && fmpz_equal(t, y);
fmpz_clear(t);
}
if (!result)
{
printf("different from exact ceiling division\n");
printf("bits = %ld\n\n", bits);
printf("x = "); fmpz_print(x); printf("\n\n");
printf("bits(x) = %ld\n\n", fmpz_bits(x));
printf("y = "); fmpz_print(y); printf(", yexp = %ld\n\n", yexp);
printf("man = %lu, exp = %ld\n", man, exp);
abort();
}
fmpz_clear(x);
fmpz_clear(y);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
arb_get_unique_fmpz(fmpz_t z, const arb_t x)
{
if (!arb_is_finite(x))
{
return 0;
}
else if (arb_is_exact(x))
{
/* x = b*2^e, e >= 0 */
if (arf_is_int(arb_midref(x)))
{
/* arf_get_fmpz aborts on overflow */
arf_get_fmpz(z, arb_midref(x), ARF_RND_DOWN);
return 1;
}
else
{
return 0;
}
}
/* if the radius is >= 1, there are at least two integers */
else if (mag_cmp_2exp_si(arb_radref(x), 0) >= 0)
{
return 0;
}
/* there are 0 or 1 integers if the radius is < 1 */
else
{
fmpz_t a, b, exp;
int res;
/* if the midpoint is exactly an integer, it is what we want */
if (arf_is_int(arb_midref(x)))
{
/* arf_get_fmpz aborts on overflow */
arf_get_fmpz(z, arb_midref(x), ARF_RND_DOWN);
return 1;
}
fmpz_init(a);
fmpz_init(b);
fmpz_init(exp);
/* if the radius is tiny, it can't be an integer */
arf_bot(a, arb_midref(x));
if (fmpz_cmp(a, MAG_EXPREF(arb_radref(x))) > 0)
{
res = 0;
}
else
{
arb_get_interval_fmpz_2exp(a, b, exp, x);
if (COEFF_IS_MPZ(*exp))
{
flint_printf("arb_get_unique_fmpz: input too large\n");
abort();
}
if (*exp >= 0)
{
res = fmpz_equal(a, b);
if (res)
{
fmpz_mul_2exp(a, a, *exp);
fmpz_mul_2exp(b, b, *exp);
}
}
else
{
fmpz_cdiv_q_2exp(a, a, -(*exp));
fmpz_fdiv_q_2exp(b, b, -(*exp));
res = fmpz_equal(a, b);
}
if (res)
fmpz_set(z, a);
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(exp);
return res;
}
}
void
_arb_bell_sum_taylor(arb_t res, const fmpz_t n,
const fmpz_t a, const fmpz_t b, const fmpz_t mmag, long tol)
{
fmpz_t m, r, R, tmp;
mag_t B, C, D, bound;
arb_t t, u;
long wp, k, N;
if (_fmpz_sub_small(b, a) < 5)
{
arb_bell_sum_bsplit(res, n, a, b, mmag, tol);
return;
}
fmpz_init(m);
fmpz_init(r);
fmpz_init(R);
fmpz_init(tmp);
/* r = max(m - a, b - m) */
/* m = a + (b - a) / 2 */
fmpz_sub(r, b, a);
fmpz_cdiv_q_2exp(r, r, 1);
fmpz_add(m, a, r);
fmpz_mul_2exp(R, r, RADIUS_BITS);
mag_init(B);
mag_init(C);
mag_init(D);
mag_init(bound);
arb_init(t);
arb_init(u);
if (fmpz_cmp(R, m) >= 0)
{
mag_inf(C);
mag_inf(D);
}
else
{
/* C = exp(R * |F'(m)| + (1/2) R^2 * (n/(m-R)^2 + 1/(m-R))) */
/* C = exp(R * (|F'(m)| + (1/2) R * (n/(m-R) + 1)/(m-R))) */
/* D = (1/2) R * (n/(m-R) + 1)/(m-R) */
fmpz_sub(tmp, m, R);
mag_set_fmpz(D, n);
mag_div_fmpz(D, D, tmp);
mag_one(C);
mag_add(D, D, C);
mag_div_fmpz(D, D, tmp);
mag_mul_fmpz(D, D, R);
mag_mul_2exp_si(D, D, -1);
/* C = |F'(m)| */
wp = 20 + 1.05 * fmpz_bits(n);
arb_set_fmpz(t, n);
arb_div_fmpz(t, t, m, wp);
fmpz_add_ui(tmp, m, 1);
arb_set_fmpz(u, tmp);
arb_digamma(u, u, wp);
arb_sub(t, t, u, wp);
arb_get_mag(C, t);
/* C = exp(R * (C + D)) */
mag_add(C, C, D);
mag_mul_fmpz(C, C, R);
mag_exp(C, C);
}
if (mag_cmp_2exp_si(C, tol / 4 + 2) > 0)
{
_arb_bell_sum_taylor(res, n, a, m, mmag, tol);
_arb_bell_sum_taylor(t, n, m, b, mmag, tol);
arb_add(res, res, t, 2 * tol);
}
else
{
arb_ptr mx, ser1, ser2, ser3;
/* D = T(m) */
wp = 20 + 1.05 * fmpz_bits(n);
arb_set_fmpz(t, m);
arb_pow_fmpz(t, t, n, wp);
fmpz_add_ui(tmp, m, 1);
arb_gamma_fmpz(u, tmp, wp);
arb_div(t, t, u, wp);
arb_get_mag(D, t);
/* error bound: (b-a) * C * D * B^N / (1 - B), B = r/R */
/* ((b-a) * C * D * 2) * 2^(-N*RADIUS_BITS) */
/* ((b-a) * C * D * 2) */
mag_mul(bound, C, D);
mag_mul_2exp_si(bound, bound, 1);
fmpz_sub(tmp, b, a);
mag_mul_fmpz(bound, bound, tmp);
/* N = (tol + log2((b-a)*C*D*2) - mmag) / RADIUS_BITS */
if (mmag == NULL)
{
/* estimate D ~= 2^mmag */
fmpz_add_ui(tmp, MAG_EXPREF(C), tol);
fmpz_cdiv_q_ui(tmp, tmp, RADIUS_BITS);
}
else
{
fmpz_sub(tmp, MAG_EXPREF(bound), mmag);
fmpz_add_ui(tmp, tmp, tol);
fmpz_cdiv_q_ui(tmp, tmp, RADIUS_BITS);
}
if (fmpz_cmp_ui(tmp, 5 * tol / 4) > 0)
N = 5 * tol / 4;
else if (fmpz_cmp_ui(tmp, 2) < 0)
N = 2;
else
N = fmpz_get_ui(tmp);
/* multiply by 2^(-N*RADIUS_BITS) */
mag_mul_2exp_si(bound, bound, -N * RADIUS_BITS);
mx = _arb_vec_init(2);
ser1 = _arb_vec_init(N);
ser2 = _arb_vec_init(N);
ser3 = _arb_vec_init(N);
/* estimate (this should work for moderate n and tol) */
wp = 1.1 * tol + 1.05 * fmpz_bits(n) + 5;
/* increase precision until convergence */
while (1)
{
/* (m+x)^n / gamma(m+1+x) */
arb_set_fmpz(mx, m);
arb_one(mx + 1);
_arb_poly_log_series(ser1, mx, 2, N, wp);
for (k = 0; k < N; k++)
arb_mul_fmpz(ser1 + k, ser1 + k, n, wp);
arb_add_ui(mx, mx, 1, wp);
_arb_poly_lgamma_series(ser2, mx, 2, N, wp);
_arb_vec_sub(ser1, ser1, ser2, N, wp);
_arb_poly_exp_series(ser3, ser1, N, N, wp);
/* t = a - m, u = b - m */
arb_set_fmpz(t, a);
arb_sub_fmpz(t, t, m, wp);
arb_set_fmpz(u, b);
arb_sub_fmpz(u, u, m, wp);
arb_power_sum_vec(ser1, t, u, N, wp);
arb_zero(res);
for (k = 0; k < N; k++)
arb_addmul(res, ser3 + k, ser1 + k, wp);
if (mmag != NULL)
{
if (_fmpz_sub_small(MAG_EXPREF(arb_radref(res)), mmag) <= -tol)
break;
}
else
{
if (arb_rel_accuracy_bits(res) >= tol)
break;
}
wp = 2 * wp;
}
/* add the series truncation bound */
arb_add_error_mag(res, bound);
_arb_vec_clear(mx, 2);
_arb_vec_clear(ser1, N);
_arb_vec_clear(ser2, N);
_arb_vec_clear(ser3, N);
}
mag_clear(B);
mag_clear(C);
mag_clear(D);
mag_clear(bound);
arb_clear(t);
arb_clear(u);
fmpz_clear(m);
fmpz_clear(r);
fmpz_clear(R);
fmpz_clear(tmp);
}
