void
acb_modular_theta_const_sum(acb_t theta2, acb_t theta3, acb_t theta4,
const acb_t q, slong prec)
{
mag_t qmag, err;
double log2q_approx;
int is_real, is_real_or_imag;
slong N;
mag_init(qmag);
mag_init(err);
acb_get_mag(qmag, q);
log2q_approx = mag_get_d_log2_approx(qmag);
is_real = arb_is_zero(acb_imagref(q));
is_real_or_imag = is_real || arb_is_zero(acb_realref(q));
if (log2q_approx >= 0.0)
{
N = 1;
mag_inf(err);
}
else
{
N = 0;
while (0.05 * N * N < prec)
{
if (log2q_approx * ((N+2)*(N+2)/4) < -prec - 2)
break;
N++;
}
N = (N+2)*(N+2)/4;
mag_geom_series(err, qmag, N);
mag_mul_2exp_si(err, err, 1); /* each term is taken twice */
if (mag_is_inf(err))
N = 1;
}
if (N < 1800)
acb_modular_theta_const_sum_basecase(theta2, theta3, theta4, q, N, prec);
else
acb_modular_theta_const_sum_rs(theta2, theta3, theta4, q, N, prec);
if (is_real_or_imag)
arb_add_error_mag(acb_realref(theta2), err);
else
acb_add_error_mag(theta2, err);
if (is_real)
{
arb_add_error_mag(acb_realref(theta3), err);
arb_add_error_mag(acb_realref(theta4), err);
}
else
{
acb_add_error_mag(theta3, err);
acb_add_error_mag(theta4, err);
}
mag_clear(qmag);
mag_clear(err);
}
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);
}
void acb_hypgeom_u_asymp(acb_t res, const acb_t a, const acb_t b,
const acb_t z, slong n, slong prec)
{
acb_struct aa[3];
acb_t s, t, w, winv;
int R, p, q, is_real, is_terminating;
slong n_terminating;
if (!acb_is_finite(a) || !acb_is_finite(b) || !acb_is_finite(z))
{
acb_indeterminate(res);
return;
}
acb_init(aa);
acb_init(aa + 1);
acb_init(aa + 2);
acb_init(s);
acb_init(t);
acb_init(w);
acb_init(winv);
is_terminating = 0;
n_terminating = WORD_MAX;
/* special case, for incomplete gamma
[todo: also when they happen to be exact and with difference 1...] */
if (a == b)
{
acb_set(aa, a);
p = 1;
q = 0;
}
else
{
acb_set(aa, a);
acb_sub(aa + 1, a, b, prec);
acb_add_ui(aa + 1, aa + 1, 1, prec);
acb_one(aa + 2);
p = 2;
q = 1;
}
if (acb_is_nonpositive_int(aa))
{
is_terminating = 1;
if (arf_cmpabs_ui(arb_midref(acb_realref(aa)), prec) < 0)
n_terminating = 1 - arf_get_si(arb_midref(acb_realref(aa)), ARF_RND_DOWN);
}
if (p == 2 && acb_is_nonpositive_int(aa + 1))
{
is_terminating = 1;
if (arf_cmpabs_ui(arb_midref(acb_realref(aa + 1)), n_terminating) < 0)
n_terminating = 1 - arf_get_si(arb_midref(acb_realref(aa + 1)), ARF_RND_DOWN);
}
acb_neg(w, z);
acb_inv(w, w, prec);
acb_neg(winv, z);
/* low degree polynomial -- no need to try to terminate sooner */
if (is_terminating && n_terminating < 8)
{
acb_hypgeom_pfq_sum_invz(s, t, aa, p, aa + p, q, w, winv,
n_terminating, prec);
acb_set(res, s);
}
else
{
mag_t C1, Cn, alpha, nu, sigma, rho, zinv, tmp, err;
mag_init(C1);
mag_init(Cn);
mag_init(alpha);
mag_init(nu);
mag_init(sigma);
mag_init(rho);
mag_init(zinv);
mag_init(tmp);
mag_init(err);
acb_hypgeom_u_asymp_bound_factors(&R, alpha, nu,
sigma, rho, zinv, a, b, z);
is_real = acb_is_real(a) && acb_is_real(b) && acb_is_real(z) &&
(is_terminating || arb_is_positive(acb_realref(z)));
if (R == 0)
{
/* if R == 0, the error bound is infinite unless terminating */
if (is_terminating && n_terminating < prec)
{
acb_hypgeom_pfq_sum_invz(s, t, aa, p, aa + p, q, w, winv,
n_terminating, prec);
acb_set(res, s);
}
else
{
acb_indeterminate(res);
}
}
else
{
/* C1 */
acb_hypgeom_mag_Cn(C1, R, nu, sigma, 1);
/* err = 2 * alpha * exp(...) */
mag_mul(tmp, C1, rho);
mag_mul(tmp, tmp, alpha);
mag_mul(tmp, tmp, zinv);
mag_mul_2exp_si(tmp, tmp, 1);
mag_exp(err, tmp);
mag_mul(err, err, alpha);
mag_mul_2exp_si(err, err, 1);
/* choose n automatically */
if (n < 0)
{
slong moreprec;
/* take err into account when finding truncation point */
/* we should take Cn into account as well, but this depends
on n which is to be determined; it's easier to look
only at exp(...) which should be larger anyway */
if (mag_cmp_2exp_si(err, 10 * prec) > 0)
moreprec = 10 * prec;
else if (mag_cmp_2exp_si(err, 0) < 0)
moreprec = 0;
else
moreprec = MAG_EXP(err);
n = acb_hypgeom_pfq_choose_n_max(aa, p, aa + p, q, w,
prec + moreprec, FLINT_MIN(WORD_MAX / 2, 50 + 10.0 * prec));
}
acb_hypgeom_pfq_sum_invz(s, t, aa, p, aa + p, q, w, winv, n, prec);
/* add error bound, if not terminating */
if (!(is_terminating && n == n_terminating))
{
acb_hypgeom_mag_Cn(Cn, R, nu, sigma, n);
mag_mul(err, err, Cn);
/* nth term * factor */
acb_get_mag(tmp, t);
mag_mul(err, err, tmp);
if (is_real)
arb_add_error_mag(acb_realref(s), err);
else
acb_add_error_mag(s, err);
}
acb_set(res, s);
}
mag_clear(C1);
mag_clear(Cn);
mag_clear(alpha);
mag_clear(nu);
mag_clear(sigma);
mag_clear(rho);
mag_clear(zinv);
mag_clear(tmp);
mag_clear(err);
}
acb_clear(aa);
acb_clear(aa + 1);
acb_clear(aa + 2);
acb_clear(s);
acb_clear(t);
acb_clear(w);
acb_clear(winv);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("add_error....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c;
arf_t m, r;
arb_init(a);
arb_init(b);
arb_init(c);
arf_init(m);
arf_init(r);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(c, state, 1 + n_randint(state, 2000), 10);
arf_randtest_special(m, state, 1 + n_randint(state, 2000), 10);
arf_randtest_special(r, state, 1 + n_randint(state, 2000), 10);
/* c = a plus error bounds */
arb_set(c, a);
arf_set(arb_midref(b), m);
arf_get_mag(arb_radref(b), r);
arb_add_error(c, b);
/* b = a + random point */
arb_set(b, a);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), m, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), m, ARF_PREC_EXACT, ARF_RND_DOWN);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), r, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), r, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
flint_printf("FAIL (arb_add_error)\n\n");
flint_printf("a = "); arb_printn(a, 50, 0); flint_printf("\n\n");
flint_printf("b = "); arb_printn(b, 50, 0); flint_printf("\n\n");
flint_printf("c = "); arb_printn(c, 50, 0); flint_printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arf_clear(m);
arf_clear(r);
}
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c;
arf_t m;
arb_init(a);
arb_init(b);
arb_init(c);
arf_init(m);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(c, state, 1 + n_randint(state, 2000), 10);
arf_randtest_special(m, state, 1 + n_randint(state, 2000), 10);
/* c = a plus error bounds */
arb_set(c, a);
arb_add_error_arf(c, m);
/* b = a + random point */
arb_set(b, a);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), m, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), m, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
flint_printf("FAIL (arb_add_error_arf)\n\n");
flint_printf("a = "); arb_printn(a, 50, 0); flint_printf("\n\n");
flint_printf("b = "); arb_printn(b, 50, 0); flint_printf("\n\n");
flint_printf("c = "); arb_printn(c, 50, 0); flint_printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arf_clear(m);
}
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c;
arf_t t;
mag_t r;
arb_init(a);
arb_init(b);
arb_init(c);
mag_init(r);
arf_init(t);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
mag_randtest(r, state, 10);
/* c = a plus error bounds */
arb_set(c, a);
arb_add_error_mag(c, r);
/* b = a + random point */
arb_set(b, a);
arf_set_mag(t, r);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
flint_printf("FAIL (arb_add_error_mag)\n\n");
flint_printf("a = "); arb_printn(a, 50, 0); flint_printf("\n\n");
flint_printf("b = "); arb_printn(b, 50, 0); flint_printf("\n\n");
flint_printf("c = "); arb_printn(c, 50, 0); flint_printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
mag_clear(r);
arf_clear(t);
}
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c;
arf_t t;
slong e;
arb_init(a);
arb_init(b);
arb_init(c);
arf_init(t);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
e = n_randint(state, 10) - 10;
/* c = a plus error bounds */
arb_set(c, a);
arb_add_error_2exp_si(c, e);
/* b = a + random point */
arb_set(b, a);
arf_one(t);
arf_mul_2exp_si(t, t, e);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
flint_printf("FAIL (arb_add_error_2exp_si)\n\n");
flint_printf("a = "); arb_printn(a, 50, 0); flint_printf("\n\n");
flint_printf("b = "); arb_printn(b, 50, 0); flint_printf("\n\n");
flint_printf("c = "); arb_printn(c, 50, 0); flint_printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arf_clear(t);
}
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c;
arf_t t;
fmpz_t e;
arb_init(a);
arb_init(b);
arb_init(c);
arf_init(t);
fmpz_init(e);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
fmpz_randtest(e, state, 10);
/* c = a plus error bounds */
arb_set(c, a);
arb_add_error_2exp_fmpz(c, e);
/* b = a + random point */
arb_set(b, a);
arf_one(t);
arf_mul_2exp_fmpz(t, t, e);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
flint_printf("FAIL (arb_add_error_2exp_fmpz)\n\n");
flint_printf("a = "); arb_printn(a, 50, 0); flint_printf("\n\n");
flint_printf("b = "); arb_printn(b, 50, 0); flint_printf("\n\n");
flint_printf("c = "); arb_printn(c, 50, 0); flint_printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arf_clear(t);
fmpz_clear(e);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
