void
acb_hypgeom_laguerre_l(acb_t res, const acb_t n, const acb_t m, const acb_t z, slong prec)
{
acb_t t, u, v;
if (use_recurrence(n, m, prec))
{
acb_hypgeom_laguerre_l_ui_recurrence(res,
arf_get_si(arb_midref(acb_realref(n)), ARF_RND_DOWN), m, z, prec);
return;
}
/* todo: should be a test of whether n contains any negative integer */
if (acb_contains_int(n) && !arb_is_nonnegative(acb_realref(n)))
{
acb_indeterminate(res);
return;
}
acb_init(t);
acb_init(u);
acb_init(v);
acb_neg(t, n);
acb_add_ui(u, m, 1, prec);
acb_hypgeom_m(t, t, u, z, 1, prec);
acb_add_ui(u, n, 1, prec);
acb_rising(u, u, m, prec);
acb_mul(res, t, u, prec);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
void
acb_hurwitz_zeta(acb_t z, const acb_t s, const acb_t a, slong prec)
{
if (acb_is_one(a) && acb_is_int(s) &&
arf_cmpabs_2exp_si(arb_midref(acb_realref(s)), FLINT_BITS - 1) < 0)
{
acb_zeta_si(z, arf_get_si(arb_midref(acb_realref(s)), ARF_RND_DOWN), prec);
return;
}
_acb_poly_zeta_cpx_series(z, s, a, 0, 1, prec);
}
void
acb_hypgeom_jacobi_p(acb_t res, const acb_t n, const acb_t a, const acb_t b,
const acb_t z, slong prec)
{
acb_t t, u, v, w;
if (use_recurrence(n, a, b, prec))
{
acb_hypgeom_jacobi_p_ui_direct(res,
arf_get_si(arb_midref(acb_realref(n)), ARF_RND_DOWN), a, b, z, prec);
return;
}
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(w);
acb_neg(t, n);
acb_add_ui(v, a, 1, prec);
acb_add(u, n, v, prec);
acb_add(u, u, b, prec);
acb_sub_ui(w, z, 1, prec);
acb_mul_2exp_si(w, w, -1);
acb_neg(w, w);
acb_hypgeom_2f1(w, t, u, v, w, 0, prec);
acb_rising(t, v, n, prec);
acb_mul(w, w, t, prec);
acb_add_ui(t, n, 1, prec);
acb_rgamma(t, t, prec);
acb_mul(w, w, t, prec);
acb_set(res, w);
acb_clear(t);
acb_clear(u);
acb_clear(v);
acb_clear(w);
}
slong
hypgeom_root_bound(const mag_t z, int r)
{
if (r == 0)
{
return 0;
}
else
{
arf_t t;
slong v;
arf_init(t);
arf_set_mag(t, z);
arf_root(t, t, r, MAG_BITS, ARF_RND_UP);
arf_add_ui(t, t, 1, MAG_BITS, ARF_RND_UP);
v = arf_get_si(t, ARF_RND_UP);
arf_clear(t);
return v;
}
}
void
acb_rising(acb_t y, const acb_t x, const acb_t n, long prec)
{
if (acb_is_int(n) && arf_sgn(arb_midref(acb_realref(n))) >= 0 &&
arf_cmpabs_ui(arb_midref(acb_realref(n)), FLINT_MAX(prec, 100)) < 0)
{
acb_rising_ui_rec(y, x,
arf_get_si(arb_midref(acb_realref(n)), ARF_RND_DOWN), prec);
}
else
{
acb_t t;
acb_init(t);
acb_add(t, x, n, prec);
acb_gamma(t, t, prec);
acb_rgamma(y, x, prec);
acb_mul(y, y, t, prec);
acb_clear(t);
}
}
/* todo: use euler product for complex s, and check efficiency
for large negative integers */
void
acb_dirichlet_zeta(acb_t res, const acb_t s, slong prec)
{
acb_t a;
double cutoff;
if (acb_is_int(s) &&
arf_cmpabs_2exp_si(arb_midref(acb_realref(s)), FLINT_BITS - 1) < 0)
{
acb_zeta_si(res, arf_get_si(arb_midref(acb_realref(s)), ARF_RND_DOWN), prec);
return;
}
cutoff = 24.0 * prec * sqrt(prec);
if (arf_cmpabs_d(arb_midref(acb_imagref(s)), cutoff) >= 0 &&
arf_cmpabs_d(arb_midref(acb_realref(s)), 10 + prec * 0.1) <= 0)
{
acb_dirichlet_zeta_rs(res, s, 0, prec);
return;
}
acb_init(a);
acb_one(a);
if (arf_sgn(arb_midref(acb_realref(s))) < 0)
{
acb_t t, u, v;
slong wp = prec + 6;
acb_init(t);
acb_init(u);
acb_init(v);
acb_sub_ui(t, s, 1, wp);
/* 2 * (2pi)^(s-1) */
arb_const_pi(acb_realref(u), wp);
acb_mul_2exp_si(u, u, 1);
acb_pow(u, u, t, wp);
acb_mul_2exp_si(u, u, 1);
/* sin(pi*s/2) */
acb_mul_2exp_si(v, s, -1);
acb_sin_pi(v, v, wp);
acb_mul(u, u, v, wp);
/* gamma(1-s) zeta(1-s) */
acb_neg(t, t);
acb_gamma(v, t, wp);
acb_mul(u, u, v, wp);
acb_hurwitz_zeta(v, t, a, wp);
acb_mul(res, u, v, prec);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
else
{
acb_hurwitz_zeta(res, s, a, prec);
}
acb_clear(a);
}
void
acb_hypgeom_chebyshev_t(acb_t res, const acb_t n, const acb_t z, slong prec)
{
acb_t t;
if (acb_is_int(n) &&
arf_cmpabs_2exp_si(arb_midref(acb_realref(n)), FLINT_BITS - 1) < 0)
{
slong k = arf_get_si(arb_midref(acb_realref(n)), ARF_RND_DOWN);
acb_chebyshev_t_ui(res, FLINT_ABS(k), z, prec);
return;
}
if (acb_is_zero(z))
{
acb_mul_2exp_si(res, n, -1);
acb_cos_pi(res, res, prec);
return;
}
if (acb_is_one(z))
{
acb_one(res);
return;
}
acb_init(t);
acb_set_si(t, -1);
if (acb_equal(t, z))
{
acb_cos_pi(res, n, prec);
}
else
{
acb_sub_ui(t, z, 1, prec);
if (arf_cmpabs_2exp_si(arb_midref(acb_realref(t)), -2 - prec / 10) < 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(t)), -2 - prec / 10) < 0)
{
acb_t a, c;
acb_init(a);
acb_init(c);
acb_neg(a, n);
acb_one(c);
acb_mul_2exp_si(c, c, -1);
acb_neg(t, t);
acb_mul_2exp_si(t, t, -1);
acb_hypgeom_2f1(res, a, n, c, t, 0, prec);
acb_clear(a);
acb_clear(c);
}
else if (arb_is_nonnegative(acb_realref(t)))
{
acb_acosh(t, z, prec);
acb_mul(t, t, n, prec);
acb_cosh(res, t, prec);
}
else
{
acb_acos(t, z, prec);
acb_mul(t, t, n, prec);
acb_cos(res, t, prec);
}
}
acb_clear(t);
}
void
_arb_poly_rgamma_series(arb_ptr res, arb_srcptr h, long hlen, long len, long prec)
{
int reflect;
long i, rflen, r, n, wp;
arb_ptr t, u, v;
arb_struct f[2];
hlen = FLINT_MIN(hlen, len);
wp = prec + FLINT_BIT_COUNT(prec);
t = _arb_vec_init(len);
u = _arb_vec_init(len);
v = _arb_vec_init(len);
arb_init(f);
arb_init(f + 1);
/* use zeta values at small integers */
if (arb_is_int(h) && (arf_cmpabs_ui(arb_midref(h), prec / 2) < 0))
{
r = arf_get_si(arb_midref(h), ARF_RND_DOWN);
_arb_poly_lgamma_series_at_one(u, len, wp);
_arb_vec_neg(u, u, len);
_arb_poly_exp_series(t, u, len, len, wp);
if (r == 1)
{
_arb_vec_swap(v, t, len);
}
else if (r <= 0)
{
arb_set(f, h);
arb_one(f + 1);
rflen = FLINT_MIN(len, 2 - r);
_arb_poly_rising_ui_series(u, f, FLINT_MIN(2, len), 1 - r, rflen, wp);
_arb_poly_mullow(v, t, len, u, rflen, len, wp);
}
else
{
arb_one(f);
arb_one(f + 1);
rflen = FLINT_MIN(len, r);
_arb_poly_rising_ui_series(v, f, FLINT_MIN(2, len), r - 1, rflen, wp);
/* TODO: use div_series? */
_arb_poly_inv_series(u, v, rflen, len, wp);
_arb_poly_mullow(v, t, len, u, len, len, wp);
}
}
else
{
/* otherwise use Stirling series */
arb_gamma_stirling_choose_param(&reflect, &r, &n, h, 1, 0, wp);
/* rgamma(h) = (gamma(1-h+r) sin(pi h)) / (rf(1-h, r) * pi), h = h0 + t*/
if (reflect)
{
/* u = gamma(r+1-h) */
arb_sub_ui(f, h, r + 1, wp);
arb_neg(f, f);
_arb_poly_gamma_stirling_eval(t, f, n, len, wp);
_arb_poly_exp_series(u, t, len, len, wp);
for (i = 1; i < len; i += 2)
arb_neg(u + i, u + i);
/* v = sin(pi x) */
arb_const_pi(f + 1, wp);
arb_mul(f, h, f + 1, wp);
_arb_poly_sin_series(v, f, 2, len, wp);
_arb_poly_mullow(t, u, len, v, len, len, wp);
/* rf(1-h,r) * pi */
if (r == 0)
{
arb_const_pi(u, wp);
_arb_vec_scalar_div(v, t, len, u, wp);
}
else
{
arb_sub_ui(f, h, 1, wp);
arb_neg(f, f);
arb_set_si(f + 1, -1);
rflen = FLINT_MIN(len, r + 1);
_arb_poly_rising_ui_series(v, f, FLINT_MIN(2, len), r, rflen, wp);
arb_const_pi(u, wp);
_arb_vec_scalar_mul(v, v, rflen, u, wp);
/* divide by rising factorial */
/* TODO: might better to use div_series, when it has a good basecase */
_arb_poly_inv_series(u, v, rflen, len, wp);
_arb_poly_mullow(v, t, len, u, len, len, wp);
}
}
else
{
/* rgamma(h) = rgamma(h+r) rf(h,r) */
if (r == 0)
{
arb_add_ui(f, h, r, wp);
_arb_poly_gamma_stirling_eval(t, f, n, len, wp);
_arb_vec_neg(t, t, len);
_arb_poly_exp_series(v, t, len, len, wp);
}
else
{
arb_set(f, h);
arb_one(f + 1);
rflen = FLINT_MIN(len, r + 1);
_arb_poly_rising_ui_series(t, f, FLINT_MIN(2, len), r, rflen, wp);
arb_add_ui(f, h, r, wp);
_arb_poly_gamma_stirling_eval(v, f, n, len, wp);
_arb_vec_neg(v, v, len);
_arb_poly_exp_series(u, v, len, len, wp);
_arb_poly_mullow(v, u, len, t, rflen, len, wp);
}
}
}
/* compose with nonconstant part */
arb_zero(t);
_arb_vec_set(t + 1, h + 1, hlen - 1);
_arb_poly_compose_series(res, v, len, t, hlen, len, prec);
arb_clear(f);
arb_clear(f + 1);
_arb_vec_clear(t, len);
_arb_vec_clear(u, len);
_arb_vec_clear(v, len);
}
void
acb_hypgeom_m(acb_t res, const acb_t a, const acb_t b, const acb_t z, int regularized, long prec)
{
long m = LONG_MAX;
long n = LONG_MAX;
if (acb_is_int(a) &&
arf_cmpabs_2exp_si(arb_midref(acb_realref(a)), 30) < 0)
{
m = arf_get_si(arb_midref(acb_realref(a)), ARF_RND_DOWN);
}
if (acb_is_int(b) &&
arf_cmpabs_2exp_si(arb_midref(acb_realref(b)), 30) < 0)
{
n = arf_get_si(arb_midref(acb_realref(b)), ARF_RND_DOWN);
}
/* terminating */
if (m <= 0 && m < n && m > -10 * prec && (n > 0 || !regularized))
{
acb_hypgeom_m_1f1(res, a, b, z, regularized, prec);
return;
}
/* large */
if (acb_hypgeom_u_use_asymp(z, prec))
{
acb_hypgeom_m_asymp(res, a, b, z, regularized, prec);
return;
}
/* remove singularity */
if (n <= 0 && n > -10 * prec && regularized)
{
acb_t c, d, t, u;
acb_init(c);
acb_init(d);
acb_init(t);
acb_init(u);
acb_sub(c, a, b, prec);
acb_add_ui(c, c, 1, prec);
acb_neg(d, b);
acb_add_ui(d, d, 2, prec);
acb_hypgeom_m_1f1(t, c, d, z, 0, prec);
acb_pow_ui(u, z, 1 - n, prec);
acb_mul(t, t, u, prec);
acb_rising_ui(u, a, 1 - n, prec);
acb_mul(t, t, u, prec);
arb_fac_ui(acb_realref(u), 1 - n, prec);
acb_div_arb(res, t, acb_realref(u), prec);
acb_clear(c);
acb_clear(d);
acb_clear(t);
acb_clear(u);
}
else
{
acb_hypgeom_m_1f1(res, a, b, z, regularized, prec);
}
}
void
_acb_hypgeom_m_1f1(acb_t res, const acb_t a, const acb_t b, const acb_t z,
int regularized, slong prec, slong gamma_prec, int kummer)
{
if (regularized)
{
/* Remove singularity */
if (acb_is_int(b) && arb_is_nonpositive(acb_realref(b)) &&
arf_cmpabs_2exp_si(arb_midref(acb_realref(b)), 30) < 0)
{
acb_t c, d, t, u;
slong n;
n = arf_get_si(arb_midref(acb_realref(b)), ARF_RND_DOWN);
acb_init(c);
acb_init(d);
acb_init(t);
acb_init(u);
acb_sub(c, a, b, prec);
acb_add_ui(c, c, 1, prec);
acb_neg(d, b);
acb_add_ui(d, d, 2, prec);
_acb_hypgeom_m_1f1(t, c, d, z, 0, prec, gamma_prec, kummer);
acb_pow_ui(u, z, 1 - n, prec);
acb_mul(t, t, u, prec);
acb_rising_ui(u, a, 1 - n, prec);
acb_mul(t, t, u, prec);
arb_fac_ui(acb_realref(u), 1 - n, prec);
acb_div_arb(res, t, acb_realref(u), prec);
acb_clear(c);
acb_clear(d);
acb_clear(t);
acb_clear(u);
}
else
{
acb_t t;
acb_init(t);
acb_rgamma(t, b, gamma_prec);
_acb_hypgeom_m_1f1(res, a, b, z, 0, prec, gamma_prec, kummer);
acb_mul(res, res, t, prec);
acb_clear(t);
}
return;
}
/* Kummer's transformation */
if (kummer)
{
acb_t u, v;
acb_init(u);
acb_init(v);
acb_sub(u, b, a, prec);
acb_neg(v, z);
_acb_hypgeom_m_1f1(u, u, b, v, regularized, prec, gamma_prec, 0);
acb_exp(v, z, prec);
acb_mul(res, u, v, prec);
acb_clear(u);
acb_clear(v);
return;
}
if (acb_is_one(a))
{
acb_hypgeom_pfq_direct(res, NULL, 0, b, 1, z, -1, prec);
}
else
{
acb_struct c[3];
c[0] = *a;
c[1] = *b;
acb_init(c + 2);
acb_one(c + 2);
acb_hypgeom_pfq_direct(res, c, 1, c + 1, 2, z, -1, prec);
acb_clear(c + 2);
}
}
void
acb_hypgeom_m_choose(int * asymp, int * kummer, slong * wp,
const acb_t a, const acb_t b, const acb_t z, int regularized, slong prec)
{
double x, y, t, cancellation;
double input_accuracy, direct_accuracy, asymp_accuracy;
slong m = WORD_MAX;
slong n = WORD_MAX;
if (acb_is_int(a) &&
arf_cmpabs_2exp_si(arb_midref(acb_realref(a)), 30) < 0)
{
m = arf_get_si(arb_midref(acb_realref(a)), ARF_RND_DOWN);
}
if (acb_is_int(b) &&
arf_cmpabs_2exp_si(arb_midref(acb_realref(b)), 30) < 0)
{
n = arf_get_si(arb_midref(acb_realref(b)), ARF_RND_DOWN);
}
*asymp = 0;
*kummer = 0;
*wp = prec;
/* The 1F1 series terminates. */
/* TODO: for large m, estimate extra precision here. */
if (m <= 0 && m < n && m > -10 * prec && (n > 0 || !regularized))
{
*asymp = 0;
return;
}
/* The 1F1 series terminates with the Kummer transform. */
/* TODO: for large m, estimate extra precision here. */
if (m >= 1 && n >= 1 && m < 0.1 * prec && n < 0.1 * prec && n <= m)
{
*asymp = 0;
*kummer = 1;
return;
}
input_accuracy = acb_rel_accuracy_bits(z);
t = acb_rel_accuracy_bits(a);
input_accuracy = FLINT_MIN(input_accuracy, t);
t = acb_rel_accuracy_bits(b);
input_accuracy = FLINT_MIN(input_accuracy, t);
input_accuracy = FLINT_MAX(input_accuracy, 0.0);
/* From here we ignore the values of a, b. Taking them into account is
a possible future improvement... */
/* Tiny |z|. */
if ((arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), 2) < 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), 2) < 0))
{
*asymp = 0;
*wp = FLINT_MAX(2, FLINT_MIN(input_accuracy + 20, prec));
return;
}
/* Huge |z|. */
if ((arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), 64) > 0 ||
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), 64) > 0))
{
*asymp = 1;
*wp = FLINT_MAX(2, FLINT_MIN(input_accuracy + 20, prec));
return;
}
x = arf_get_d(arb_midref(acb_realref(z)), ARF_RND_DOWN);
y = arf_get_d(arb_midref(acb_imagref(z)), ARF_RND_DOWN);
asymp_accuracy = sqrt(x * x + y * y) * 1.44269504088896 - 5.0;
/* The Kummer transformation gives less cancellation with the 1F1 series. */
if (x < 0.0)
{
*kummer = 1;
x = -x;
}
if (asymp_accuracy >= prec)
{
*asymp = 1;
*wp = FLINT_MAX(2, FLINT_MIN(input_accuracy + 20, prec));
return;
}
cancellation = hypotmx(x, y) * 1.44269504088896;
direct_accuracy = input_accuracy - cancellation;
if (direct_accuracy > asymp_accuracy)
{
*asymp = 0;
*wp = FLINT_MAX(2, FLINT_MIN(input_accuracy + 20, prec + cancellation));
}
else
{
*asymp = 1;
*wp = FLINT_MAX(2, FLINT_MIN(input_accuracy + 20, prec));
}
}
void
_arb_poly_lgamma_series(arb_ptr res, arb_srcptr h, slong hlen, slong len, slong prec)
{
int reflect;
slong r, n, wp;
arb_t zr;
arb_ptr t, u;
if (!arb_is_positive(h))
{
_arb_vec_indeterminate(res, len);
return;
}
hlen = FLINT_MIN(hlen, len);
wp = prec + FLINT_BIT_COUNT(prec);
t = _arb_vec_init(len);
u = _arb_vec_init(len);
arb_init(zr);
/* use zeta values at small integers */
if (arb_is_int(h) && (arf_cmpabs_ui(arb_midref(h), prec / 2) < 0))
{
r = arf_get_si(arb_midref(h), ARF_RND_DOWN);
if (r <= 0)
{
_arb_vec_indeterminate(res, len);
goto cleanup;
}
else
{
_arb_poly_lgamma_series_at_one(u, len, wp);
if (r != 1)
{
arb_one(zr);
_log_rising_ui_series(t, zr, r - 1, len, wp);
_arb_vec_add(u, u, t, len, wp);
}
}
}
else if (len <= 2)
{
arb_lgamma(u, h, wp);
if (len == 2)
arb_digamma(u + 1, h, wp);
}
else
{
/* otherwise use Stirling series */
arb_gamma_stirling_choose_param(&reflect, &r, &n, h, 0, 0, wp);
arb_add_ui(zr, h, r, wp);
_arb_poly_gamma_stirling_eval(u, zr, n, len, wp);
if (r != 0)
{
_log_rising_ui_series(t, h, r, len, wp);
_arb_vec_sub(u, u, t, len, wp);
}
}
/* compose with nonconstant part */
arb_zero(t);
_arb_vec_set(t + 1, h + 1, hlen - 1);
_arb_poly_compose_series(res, u, len, t, hlen, len, prec);
cleanup:
arb_clear(zr);
_arb_vec_clear(t, len);
_arb_vec_clear(u, len);
}
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);
}
int32_t Lib_Arb_Get_Si(ArbPtr x)
{
return arf_get_si( arb_midref((arb_ptr) x), ARF_RND_DOWN);
}
