void
acb_hypgeom_fresnel(acb_t res1, acb_t res2, const acb_t z, int normalized, slong prec)
{
slong wp;
acb_t w;
arb_t c;
if (!acb_is_finite(z))
{
if (res1 != NULL) acb_indeterminate(res1);
if (res2 != NULL) acb_indeterminate(res2);
return;
}
acb_init(w);
arb_init(c);
wp = prec + 8;
if (normalized)
{
arb_const_pi(c, wp);
arb_sqrt(c, c, wp);
arb_mul_2exp_si(c, c, -1);
acb_mul_arb(w, z, c, wp);
acb_hypgeom_fresnel_erf_error(res1, res2, w, wp);
}
else
{
arb_sqrt_ui(c, 2, wp);
arb_mul_2exp_si(c, c, -1);
acb_mul_arb(w, z, c, wp);
acb_hypgeom_fresnel_erf_error(res1, res2, w, wp);
arb_const_pi(c, wp);
arb_mul_2exp_si(c, c, -1);
arb_sqrt(c, c, wp);
if (res1 != NULL) acb_mul_arb(res1, res1, c, wp);
if (res2 != NULL) acb_mul_arb(res2, res2, c, wp);
}
if (res1 != NULL)
{
acb_mul_2exp_si(res1, res1, -2);
acb_set_round(res1, res1, prec);
}
if (res2 != NULL)
{
acb_mul_2exp_si(res2, res2, -2);
acb_set_round(res2, res2, prec);
}
acb_clear(w);
arb_clear(c);
}
void
acb_sin_cos_pi(acb_t s, acb_t c, const acb_t z, slong prec)
{
#define a acb_realref(z)
#define b acb_imagref(z)
if (arb_is_zero(b))
{
arb_sin_cos_pi(acb_realref(s), acb_realref(c), a, prec);
arb_zero(acb_imagref(s));
arb_zero(acb_imagref(c));
}
else if (arb_is_zero(a))
{
arb_t t;
arb_init(t);
arb_const_pi(t, prec);
arb_mul(t, t, b, prec);
arb_sinh_cosh(acb_imagref(s), acb_realref(c), t, prec);
arb_zero(acb_realref(s));
arb_zero(acb_imagref(c));
arb_clear(t);
}
else
{
arb_t sa, ca, sb, cb;
arb_init(sa);
arb_init(ca);
arb_init(sb);
arb_init(cb);
arb_const_pi(sb, prec);
arb_mul(sb, sb, b, prec);
arb_sin_cos_pi(sa, ca, a, prec);
arb_sinh_cosh(sb, cb, sb, prec);
arb_mul(acb_realref(s), sa, cb, prec);
arb_mul(acb_imagref(s), sb, ca, prec);
arb_mul(acb_realref(c), ca, cb, prec);
arb_mul(acb_imagref(c), sa, sb, prec);
arb_neg(acb_imagref(c), acb_imagref(c));
arb_clear(sa);
arb_clear(ca);
arb_clear(sb);
arb_clear(cb);
}
#undef a
#undef b
}
void
_arb_poly_sin_cos_pi_series(arb_ptr s, arb_ptr c, arb_srcptr h, slong hlen, slong n, slong prec)
{
hlen = FLINT_MIN(hlen, n);
if (hlen == 1)
{
arb_sin_cos_pi(s, c, h, prec);
_arb_vec_zero(s + 1, n - 1);
_arb_vec_zero(c + 1, n - 1);
}
else if (n == 2)
{
arb_t t;
arb_init(t);
arb_const_pi(t, prec);
arb_mul(t, t, h + 1, prec);
arb_sin_cos_pi(s, c, h, prec);
arb_mul(s + 1, c, t, prec);
arb_neg(t, t);
arb_mul(c + 1, s, t, prec);
arb_clear(t);
}
else if (hlen < TANGENT_CUTOFF)
_arb_poly_sin_cos_series_basecase(s, c, h, hlen, n, prec, 1);
else
_arb_poly_sin_cos_series_tangent(s, c, h, hlen, n, prec, 1);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sin_cos_pi....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c, d, e;
slong prec = 2 + n_randint(state, 200);
arb_init(a);
arb_init(b);
arb_init(c);
arb_init(d);
arb_init(e);
arb_randtest(a, state, 1 + n_randint(state, 200), 10);
arb_randtest(b, state, 1 + n_randint(state, 200), 10);
arb_randtest(c, state, 1 + n_randint(state, 200), 10);
arb_randtest(d, state, 1 + n_randint(state, 200), 10);
arb_randtest(e, state, 1 + n_randint(state, 200), 10);
arb_const_pi(b, prec);
arb_mul(b, b, a, prec);
arb_sin_cos(b, d, b, prec);
arb_sin_cos_pi(c, e, a, prec);
if (!arb_overlaps(b, c) || !arb_overlaps(d, e))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("c = "); arb_print(c); flint_printf("\n\n");
flint_printf("d = "); arb_print(d); flint_printf("\n\n");
flint_printf("e = "); arb_print(e); flint_printf("\n\n");
flint_abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arb_clear(d);
arb_clear(e);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_tan_pi(acb_t r, const acb_t z, slong prec)
{
if (arb_is_zero(acb_imagref(z)))
{
arb_tan_pi(acb_realref(r), acb_realref(z), prec);
arb_zero(acb_imagref(r));
}
else if (arb_is_zero(acb_realref(z)))
{
arb_t t;
arb_init(t);
arb_const_pi(t, prec + 4);
arb_mul(t, acb_imagref(z), t, prec + 4);
arb_tanh(acb_imagref(r), t, prec);
arb_zero(acb_realref(r));
arb_clear(t);
}
else
{
acb_t t;
acb_init(t);
if (arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), 0) < 0)
{
acb_sin_cos_pi(r, t, z, prec + 4);
acb_div(r, r, t, prec);
}
else
{
acb_mul_2exp_si(t, z, 1);
if (arf_sgn(arb_midref(acb_imagref(z))) > 0)
{
acb_exp_pi_i(t, t, prec + 4);
acb_add_ui(r, t, 1, prec + 4);
acb_div(r, t, r, prec + 4);
acb_mul_2exp_si(r, r, 1);
acb_sub_ui(r, r, 1, prec);
acb_div_onei(r, r);
}
else
{
acb_neg(t, t);
acb_exp_pi_i(t, t, prec + 4);
acb_add_ui(r, t, 1, prec + 4);
acb_div(r, t, r, prec + 4);
acb_mul_2exp_si(r, r, 1);
acb_sub_ui(r, r, 1, prec);
acb_mul_onei(r, r);
}
}
acb_clear(t);
}
}
/*
Bound for scaled Bessel function: 2/(2 pi x)^(1/2)
Bound for tail of integral: 2 N (k / (pi N))^(k / 2) / (k - 2).
*/
void
scaled_bessel_tail_bound(arb_t b, ulong k, const arb_t N, slong prec)
{
arb_const_pi(b, prec);
arb_mul(b, b, N, prec);
arb_ui_div(b, k, b, prec);
arb_sqrt(b, b, prec);
arb_pow_ui(b, b, k, prec);
arb_mul(b, b, N, prec);
arb_mul_ui(b, b, 2, prec);
arb_div_ui(b, b, k - 2, prec);
}
void
arb_sin_cos_pi(arb_t s, arb_t c, const arb_t x, long prec)
{
arb_t t;
arb_t u;
fmpz_t v;
if (arf_cmpabs_2exp_si(arb_midref(x), FLINT_MAX(65536, (4*prec))) > 0)
{
arf_zero(arb_midref(s));
mag_one(arb_radref(s));
arf_zero(arb_midref(c));
mag_one(arb_radref(c));
return;
}
arb_init(t);
arb_init(u);
fmpz_init(v);
arb_mul_2exp_si(t, x, 1);
arf_get_fmpz(v, arb_midref(t), ARF_RND_NEAR);
arb_sub_fmpz(t, t, v, prec);
arb_const_pi(u, prec);
arb_mul(t, t, u, prec);
arb_mul_2exp_si(t, t, -1);
switch (fmpz_fdiv_ui(v, 4))
{
case 0:
arb_sin_cos(s, c, t, prec);
break;
case 1:
arb_sin_cos(c, s, t, prec);
arb_neg(c, c);
break;
case 2:
arb_sin_cos(s, c, t, prec);
arb_neg(s, s);
arb_neg(c, c);
break;
default:
arb_sin_cos(c, s, t, prec);
arb_neg(s, s);
break;
}
fmpz_clear(v);
arb_clear(t);
arb_clear(u);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("const_pi....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 250; iter++)
{
arb_t r;
mpfr_t s;
slong accuracy, prec;
prec = 2 + n_randint(state, 1 << n_randint(state, 18));
arb_init(r);
mpfr_init2(s, prec + 1000);
arb_const_pi(r, prec);
mpfr_const_pi(s, MPFR_RNDN);
if (!arb_contains_mpfr(r, s))
{
flint_printf("FAIL: containment\n\n");
flint_printf("prec = %wd\n", prec);
flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n");
abort();
}
accuracy = arb_rel_accuracy_bits(r);
if (accuracy < prec - 4)
{
flint_printf("FAIL: poor accuracy\n\n");
flint_printf("prec = %wd\n", prec);
flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n");
abort();
}
arb_clear(r);
mpfr_clear(s);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sin_pi_fmpq....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t s1, s2;
fmpq_t x;
slong prec;
prec = 2 + n_randint(state, 5000);
arb_init(s1);
arb_init(s2);
fmpq_init(x);
fmpq_randtest(x, state, 1 + n_randint(state, 200));
arb_sin_pi_fmpq(s1, x, prec);
arb_const_pi(s2, prec);
arb_mul_fmpz(s2, s2, fmpq_numref(x), prec);
arb_div_fmpz(s2, s2, fmpq_denref(x), prec);
arb_sin(s2, s2, prec);
if (!arb_overlaps(s1, s2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("x = "); fmpq_print(x); flint_printf("\n\n");
flint_printf("s1 = "); arb_printd(s1, 15); flint_printf("\n\n");
flint_printf("s2 = "); arb_printd(s2, 15); flint_printf("\n\n");
abort();
}
arb_clear(s1);
arb_clear(s2);
fmpq_clear(x);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
/* atan(x) = pi/2 - eps, eps < 1/x <= 2^(1-mag) */
void
arb_atan_inf_eps(arb_t z, const arf_t x, slong prec)
{
fmpz_t mag;
fmpz_init(mag);
fmpz_neg(mag, ARF_EXPREF(x));
fmpz_add_ui(mag, mag, 1);
if (arf_sgn(x) > 0)
{
arb_const_pi(z, prec);
}
else
{
arb_const_pi(z, prec);
arb_neg(z, z);
}
arb_mul_2exp_si(z, z, -1);
arb_add_error_2exp_fmpz(z, mag);
fmpz_clear(mag);
}
void
_arb_cos_pi_fmpq_oct(arb_t c, const fmpz_t v, const fmpz_t w, slong prec)
{
if (use_algebraic(v, w, prec))
{
_arb_cos_pi_fmpq_algebraic(c, *v, *w, prec);
}
else
{
arb_const_pi(c, prec);
arb_mul_fmpz(c, c, v, prec);
arb_div_fmpz(c, c, w, prec);
arb_cos(c, c, prec);
}
}
void
_arb_sin_pi_fmpq_oct(arb_t s, const fmpz_t v, const fmpz_t w, slong prec)
{
if (use_algebraic(v, w, prec))
{
_arb_sin_pi_fmpq_algebraic(s, *v, *w, prec);
}
else
{
arb_const_pi(s, prec);
arb_mul_fmpz(s, s, v, prec);
arb_div_fmpz(s, s, w, prec);
arb_sin(s, s, prec);
}
}
static void
_acb_gamma(acb_t y, const acb_t x, long prec, int inverse)
{
int reflect;
long r, n, wp;
acb_t t, u, v;
wp = prec + FLINT_BIT_COUNT(prec);
acb_gamma_stirling_choose_param(&reflect, &r, &n, x, 1, 0, wp);
acb_init(t);
acb_init(u);
acb_init(v);
if (reflect)
{
/* gamma(x) = (rf(1-x, r) * pi) / (gamma(1-x+r) sin(pi x)) */
acb_sub_ui(t, x, 1, wp);
acb_neg(t, t);
acb_rising_ui_rec(u, t, r, wp);
arb_const_pi(acb_realref(v), wp);
acb_mul_arb(u, u, acb_realref(v), wp);
acb_add_ui(t, t, r, wp);
acb_gamma_stirling_eval(v, t, n, 0, wp);
acb_exp(v, v, wp);
acb_sin_pi(t, x, wp);
acb_mul(v, v, t, wp);
}
else
{
/* gamma(x) = gamma(x+r) / rf(x,r) */
acb_add_ui(t, x, r, wp);
acb_gamma_stirling_eval(u, t, n, 0, wp);
acb_exp(u, u, prec);
acb_rising_ui_rec(v, x, r, wp);
}
if (inverse)
acb_div(y, v, u, prec);
else
acb_div(y, u, v, prec);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
void
arb_bernoulli_fmpz(arb_t res, const fmpz_t n, slong prec)
{
if (fmpz_cmp_ui(n, UWORD_MAX) <= 0)
{
if (fmpz_sgn(n) >= 0)
arb_bernoulli_ui(res, fmpz_get_ui(n), prec);
else
arb_zero(res);
}
else if (fmpz_is_odd(n))
{
arb_zero(res);
}
else
{
arb_t t;
slong wp;
arb_init(t);
wp = prec + 2 * fmpz_bits(n);
/* zeta(n) ~= 1 */
arf_one(arb_midref(res));
mag_one(arb_radref(res));
mag_mul_2exp_si(arb_radref(res), arb_radref(res), WORD_MIN);
/* |B_n| = 2 * n! / (2*pi)^n * zeta(n) */
arb_gamma_fmpz(t, n, wp);
arb_mul_fmpz(t, t, n, wp);
arb_mul(res, res, t, wp);
arb_const_pi(t, wp);
arb_mul_2exp_si(t, t, 1);
arb_pow_fmpz(t, t, n, wp);
arb_div(res, res, t, prec);
arb_mul_2exp_si(res, res, 1);
if (fmpz_fdiv_ui(n, 4) == 0)
arb_neg(res, res);
arb_clear(t);
}
}
/* sin((pi/2)x) */
static int
sin_pi2_x(arb_ptr out, const arb_t inp, void * params, slong order, slong prec)
{
arb_ptr x;
x = _arb_vec_init(2);
arb_set(x, inp);
arb_one(x + 1);
arb_const_pi(out, prec);
arb_mul_2exp_si(out, out, -1);
_arb_vec_scalar_mul(x, x, 2, out, prec);
_arb_poly_sin_series(out, x, order, order, prec);
_arb_vec_clear(x, 2);
return 0;
}
void
acb_digamma(acb_t y, const acb_t x, long prec)
{
int reflect;
long r, n, wp;
acb_t t, u, v;
wp = prec + FLINT_BIT_COUNT(prec);
acb_gamma_stirling_choose_param(&reflect, &r, &n, x, 1, 1, wp);
acb_init(t);
acb_init(u);
acb_init(v);
/* psi(x) = psi((1-x)+r) - h(1-x,r) - pi*cot(pi*x) */
if (reflect)
{
acb_sub_ui(t, x, 1, wp);
acb_neg(t, t);
acb_cot_pi(v, x, wp);
arb_const_pi(acb_realref(u), wp);
acb_mul_arb(v, v, acb_realref(u), wp);
acb_rising2_ui(y, u, t, r, wp);
acb_div(u, u, y, wp);
acb_add(v, v, u, wp);
acb_add_ui(t, t, r, wp);
acb_gamma_stirling_eval(u, t, n, 1, wp);
acb_sub(y, u, v, wp);
}
else
{
acb_add_ui(t, x, r, wp);
acb_gamma_stirling_eval(u, t, n, 1, wp);
acb_rising2_ui(y, t, x, r, wp);
acb_div(t, t, y, wp);
acb_sub(y, u, t, prec);
}
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
int
f_aj(arb_t m, const arb_t t, params_t * p, slong prec)
{
slong k;
acb_t z, zu;
arb_t abs;
arb_init(abs);
acb_init(z);
acb_init(zu);
arb_const_pi(abs, prec);
arb_mul_2exp_si(abs, abs, -2); /* Pi/4 */
arb_set(acb_realref(z), t);
arb_set(acb_imagref(z), abs);
acb_sinh(z, z, prec);
arb_mul_2exp_si(abs, abs, 1); /* Pi/2 */
acb_mul_arb(z, z, abs, prec);
acb_tanh(z, z, prec);
arb_one(m);
for (k = 0; k < p->len; k++)
{
acb_sub(zu, z, p->z + k, prec);
if (acb_contains_zero(zu))
{
arb_clear(abs);
acb_clear(zu);
acb_clear(z);
return 0;
}
acb_abs(abs, zu, prec);
arb_mul(m, m, abs, prec);
}
arb_inv(m, m, prec);
arb_clear(abs);
acb_clear(zu);
acb_clear(z);
return 1;
}
void
acb_hypgeom_bessel_k_0f1_series(acb_poly_t res,
const acb_poly_t nu, const acb_poly_t z,
slong len, slong prec)
{
acb_poly_t s, u, A, B;
acb_poly_struct b[2];
arb_t c;
slong wlen;
int singular;
acb_poly_init(s);
acb_poly_init(u);
acb_poly_init(A);
acb_poly_init(B);
acb_poly_init(b + 0);
acb_poly_init(b + 1);
arb_init(c);
singular = (nu->length == 0) || acb_is_int(nu->coeffs);
wlen = len + (singular != 0);
/* A = (z/2)^nu, B = 1/A */
acb_poly_scalar_mul_2exp_si(A, z, -1);
acb_poly_pow_series(A, A, nu, wlen, prec);
acb_poly_inv_series(B, A, wlen, prec);
acb_poly_mullow(u, z, z, wlen, prec);
acb_poly_scalar_mul_2exp_si(u, u, -2);
acb_poly_one(b + 1);
acb_poly_add_si(b + 0, nu, 1, prec);
acb_hypgeom_pfq_series_direct(s, NULL, 0, b, 2, u, 1, -1, wlen, prec);
acb_poly_mullow(A, A, s, wlen, prec);
acb_poly_add_si(b + 0, nu, -1, prec);
acb_poly_neg(b + 0, b + 0);
acb_hypgeom_pfq_series_direct(s, NULL, 0, b, 2, u, 1, -1, wlen, prec);
acb_poly_mullow(B, B, s, wlen, prec);
acb_poly_sub(A, B, A, prec);
acb_poly_scalar_mul_2exp_si(A, A, -1);
/* multiply by pi csc(pi nu) */
acb_poly_sin_pi_series(B, nu, wlen, prec);
if (singular)
{
acb_poly_shift_right(A, A, 1);
acb_poly_shift_right(B, B, 1);
}
acb_poly_div_series(res, A, B, len, prec);
arb_const_pi(c, prec);
_acb_vec_scalar_mul_arb(res->coeffs, res->coeffs, res->length, c, prec);
acb_poly_clear(s);
acb_poly_clear(u);
acb_poly_clear(A);
acb_poly_clear(B);
acb_poly_clear(b + 0);
acb_poly_clear(b + 1);
arb_clear(c);
}
void
_arb_poly_zeta_series(arb_ptr res, arb_srcptr h, long hlen, const arb_t a, int deflate, long len, long prec)
{
long i;
acb_t cs, ca;
acb_ptr z;
arb_ptr t, u;
if (arb_contains_nonpositive(a))
{
_arb_vec_indeterminate(res, len);
return;
}
hlen = FLINT_MIN(hlen, len);
z = _acb_vec_init(len);
t = _arb_vec_init(len);
u = _arb_vec_init(len);
acb_init(cs);
acb_init(ca);
/* use reflection formula */
if (arf_sgn(arb_midref(h)) < 0 && arb_is_one(a))
{
/* zeta(s) = (2*pi)**s * sin(pi*s/2) / pi * gamma(1-s) * zeta(1-s) */
arb_t pi;
arb_ptr f, s1, s2, s3, s4;
arb_init(pi);
f = _arb_vec_init(2);
s1 = _arb_vec_init(len);
s2 = _arb_vec_init(len);
s3 = _arb_vec_init(len);
s4 = _arb_vec_init(len);
arb_const_pi(pi, prec);
/* s1 = (2*pi)**s */
arb_mul_2exp_si(pi, pi, 1);
_arb_poly_pow_cpx(s1, pi, h, len, prec);
arb_mul_2exp_si(pi, pi, -1);
/* s2 = sin(pi*s/2) / pi */
arb_set(f, h);
arb_one(f + 1);
arb_mul_2exp_si(f, f, -1);
arb_mul_2exp_si(f + 1, f + 1, -1);
_arb_poly_sin_pi_series(s2, f, 2, len, prec);
_arb_vec_scalar_div(s2, s2, len, pi, prec);
/* s3 = gamma(1-s) */
arb_sub_ui(f, h, 1, prec);
arb_neg(f, f);
arb_set_si(f + 1, -1);
_arb_poly_gamma_series(s3, f, 2, len, prec);
/* s4 = zeta(1-s) */
arb_sub_ui(f, h, 1, prec);
arb_neg(f, f);
acb_set_arb(cs, f);
acb_one(ca);
_acb_poly_zeta_cpx_series(z, cs, ca, 0, len, prec);
for (i = 0; i < len; i++)
arb_set(s4 + i, acb_realref(z + i));
for (i = 1; i < len; i += 2)
arb_neg(s4 + i, s4 + i);
_arb_poly_mullow(u, s1, len, s2, len, len, prec);
_arb_poly_mullow(s1, s3, len, s4, len, len, prec);
_arb_poly_mullow(t, u, len, s1, len, len, prec);
/* add 1/(1-(s+t)) = 1/(1-s) + t/(1-s)^2 + ... */
if (deflate)
{
arb_sub_ui(u, h, 1, prec);
arb_neg(u, u);
arb_inv(u, u, prec);
for (i = 1; i < len; i++)
arb_mul(u + i, u + i - 1, u, prec);
_arb_vec_add(t, t, u, len, prec);
}
arb_clear(pi);
_arb_vec_clear(f, 2);
_arb_vec_clear(s1, len);
_arb_vec_clear(s2, len);
_arb_vec_clear(s3, len);
_arb_vec_clear(s4, len);
}
else
{
acb_set_arb(cs, h);
acb_set_arb(ca, a);
_acb_poly_zeta_cpx_series(z, cs, ca, deflate, len, prec);
for (i = 0; i < len; i++)
arb_set(t + i, acb_realref(z + i));
}
/* compose with nonconstant part */
arb_zero(u);
_arb_vec_set(u + 1, h + 1, hlen - 1);
_arb_poly_compose_series(res, t, len, u, hlen, len, prec);
_acb_vec_clear(z, len);
_arb_vec_clear(t, len);
_arb_vec_clear(u, len);
acb_init(cs);
acb_init(ca);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("cos_pi_fmpq_algebraic....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t c1, c2;
ulong p, q, g;
slong prec;
prec = 2 + n_randint(state, 5000);
q = 1 + n_randint(state, 500);
p = n_randint(state, q / 2 + 1);
g = n_gcd(q, p);
q /= g;
p /= g;
arb_init(c1);
arb_init(c2);
_arb_cos_pi_fmpq_algebraic(c1, p, q, prec);
arb_const_pi(c2, prec);
arb_mul_ui(c2, c2, p, prec);
arb_div_ui(c2, c2, q, prec);
arb_cos(c2, c2, prec);
if (!arb_overlaps(c1, c2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("p/q = %wu/%wu", p, q); flint_printf("\n\n");
flint_printf("c1 = "); arb_printd(c1, 15); flint_printf("\n\n");
flint_printf("c2 = "); arb_printd(c2, 15); flint_printf("\n\n");
abort();
}
if (arb_rel_accuracy_bits(c1) < prec - 2)
{
flint_printf("FAIL: accuracy\n\n");
flint_printf("p/q = %wu/%wu", p, q); flint_printf("\n\n");
flint_printf("prec=%wd eff=%wd\n", prec, arb_rel_accuracy_bits(c1));
flint_printf("c1 = "); arb_printd(c1, 15); flint_printf("\n\n");
flint_printf("c2 = "); arb_printd(c2, 15); flint_printf("\n\n");
abort();
}
arb_clear(c1);
arb_clear(c2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_ci_asymp(acb_t res, const acb_t z, slong prec)
{
acb_t t, u, w, v, one;
acb_init(t);
acb_init(u);
acb_init(w);
acb_init(v);
acb_init(one);
acb_one(one);
acb_mul_onei(w, z);
/* u = U(1,1,iz) */
acb_hypgeom_u_asymp(u, one, one, w, -1, prec);
/* v = e^(-iz) */
acb_neg(v, w);
acb_exp(v, v, prec);
acb_mul(t, u, v, prec);
if (acb_is_real(z))
{
arb_div(acb_realref(t), acb_imagref(t), acb_realref(z), prec);
arb_zero(acb_imagref(t));
acb_neg(t, t);
}
else
{
/* u = U(1,1,-iz) */
acb_neg(w, w);
acb_hypgeom_u_asymp(u, one, one, w, -1, prec);
acb_inv(v, v, prec);
acb_submul(t, u, v, prec);
acb_div(t, t, w, prec);
acb_mul_2exp_si(t, t, -1);
}
if (arb_is_zero(acb_realref(z)))
{
if (arb_is_positive(acb_imagref(z)))
{
arb_const_pi(acb_imagref(t), prec);
arb_mul_2exp_si(acb_imagref(t), acb_imagref(t), -1);
}
else if (arb_is_negative(acb_imagref(z)))
{
arb_const_pi(acb_imagref(t), prec);
arb_mul_2exp_si(acb_imagref(t), acb_imagref(t), -1);
arb_neg(acb_imagref(t), acb_imagref(t));
}
else
{
acb_const_pi(u, prec);
acb_mul_2exp_si(u, u, -1);
arb_zero(acb_imagref(t));
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
else
{
/* 0 if positive or positive imaginary
pi if upper left quadrant (including negative real axis)
-pi if lower left quadrant (including negative imaginary axis) */
if (arb_is_positive(acb_realref(z)))
{
/* do nothing */
}
else if (arb_is_negative(acb_realref(z)) && arb_is_nonnegative(acb_imagref(z)))
{
acb_const_pi(u, prec);
arb_add(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else if (arb_is_nonpositive(acb_realref(z)) && arb_is_negative(acb_imagref(z)))
{
acb_const_pi(u, prec);
arb_sub(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else
{
/* add [-pi,pi] */
acb_const_pi(u, prec);
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
acb_swap(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(w);
acb_clear(v);
acb_clear(one);
}
void
keiper_li_series(arb_ptr z, slong len, slong prec)
{
arb_ptr t, u, v;
t = _arb_vec_init(len);
u = _arb_vec_init(len);
v = _arb_vec_init(len);
/* -zeta(s) */
flint_printf("zeta: ");
TIMEIT_ONCE_START
arb_zero(t + 0);
arb_one(t + 1);
arb_one(u);
_arb_poly_zeta_series(v, t, 2, u, 0, len, prec);
_arb_vec_neg(v, v, len);
TIMEIT_ONCE_STOP
SHOW_MEMORY_USAGE
/* logarithm */
flint_printf("log: ");
TIMEIT_ONCE_START
_arb_poly_log_series(t, v, len, len, prec);
TIMEIT_ONCE_STOP
/* add log(gamma(1+s/2)) */
flint_printf("gamma: ");
TIMEIT_ONCE_START
arb_one(u);
arb_one(u + 1);
arb_mul_2exp_si(u + 1, u + 1, -1);
_arb_poly_lgamma_series(v, u, 2, len, prec);
_arb_vec_add(t, t, v, len, prec);
TIMEIT_ONCE_STOP
/* subtract 0.5 s log(pi) */
arb_const_pi(u, prec);
arb_log(u, u, prec);
arb_mul_2exp_si(u, u, -1);
arb_sub(t + 1, t + 1, u, prec);
/* add log(1-s) */
arb_one(u);
arb_set_si(u + 1, -1);
_arb_poly_log_series(v, u, 2, len, prec);
_arb_vec_add(t, t, v, len, prec);
/* binomial transform */
flint_printf("binomial transform: ");
TIMEIT_ONCE_START
arb_set(z, t);
_arb_vec_neg(t + 1, t + 1, len - 1);
_arb_poly_binomial_transform(z + 1, t + 1, len - 1, len - 1, prec);
TIMEIT_ONCE_STOP
_arb_vec_clear(t, len);
_arb_vec_clear(u, len);
_arb_vec_clear(v, len);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("get_mpn_fixed_mod_pi4....");
fflush(stdout);
flint_randinit(state);
/* _flint_rand_init_gmp(state); */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arf_t x;
int octant;
fmpz_t q;
mp_ptr w;
arb_t wb, t, u;
mp_size_t wn;
slong prec, prec2;
int success;
mp_limb_t error;
prec = 2 + n_randint(state, 10000);
wn = 1 + n_randint(state, 200);
prec2 = FLINT_MAX(prec, wn * FLINT_BITS) + 100;
arf_init(x);
arb_init(wb);
arb_init(t);
arb_init(u);
fmpz_init(q);
w = flint_malloc(sizeof(mp_limb_t) * wn);
arf_randtest(x, state, prec, 14);
/* this should generate numbers close to multiples of pi/4 */
if (n_randint(state, 4) == 0)
{
arb_const_pi(t, prec);
arb_mul_2exp_si(t, t, -2);
fmpz_randtest(q, state, 200);
arb_mul_fmpz(t, t, q, prec);
arf_add(x, x, arb_midref(t), prec, ARF_RND_DOWN);
}
arf_abs(x, x);
success = _arb_get_mpn_fixed_mod_pi4(w, q, &octant, &error, x, wn);
if (success)
{
/* could round differently */
if (fmpz_fdiv_ui(q, 8) != octant)
{
flint_printf("bad octant\n");
abort();
}
_arf_set_mpn_fixed(arb_midref(wb), w, wn, wn, 0, FLINT_BITS * wn, ARB_RND);
mag_set_ui_2exp_si(arb_radref(wb), error, -FLINT_BITS * wn);
arb_const_pi(u, prec2);
arb_mul_2exp_si(u, u, -2);
arb_set(t, wb);
if (octant % 2 == 1)
arb_sub(t, u, t, prec2);
arb_addmul_fmpz(t, u, q, prec2);
if (!arb_contains_arf(t, x))
{
flint_printf("FAIL (containment)\n");
flint_printf("x = "); arf_printd(x, 50); flint_printf("\n\n");
flint_printf("q = "); fmpz_print(q); flint_printf("\n\n");
flint_printf("w = "); arb_printd(wb, 50); flint_printf("\n\n");
flint_printf("t = "); arb_printd(t, 50); flint_printf("\n\n");
abort();
}
arb_const_pi(t, prec2);
arb_mul_2exp_si(t, t, -2);
if (arf_sgn(arb_midref(wb)) < 0 ||
arf_cmp(arb_midref(wb), arb_midref(t)) >= 0)
{
flint_printf("FAIL (expected 0 <= w < pi/4)\n");
flint_printf("x = "); arf_printd(x, 50); flint_printf("\n\n");
flint_printf("w = "); arb_printd(wb, 50); flint_printf("\n\n");
abort();
}
}
flint_free(w);
fmpz_clear(q);
arf_clear(x);
arb_clear(wb);
arb_clear(t);
arb_clear(u);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("cos_pi_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
slong m, n1, n2, bits1, bits2, bits3;
arb_poly_t S, A, B, C;
arb_t pi;
bits1 = 2 + n_randint(state, 200);
bits2 = 2 + n_randint(state, 200);
bits3 = 2 + n_randint(state, 200);
m = 1 + n_randint(state, 30);
n1 = 1 + n_randint(state, 30);
n2 = 1 + n_randint(state, 30);
arb_poly_init(S);
arb_poly_init(A);
arb_poly_init(B);
arb_poly_init(C);
arb_init(pi);
arb_poly_randtest(S, state, m, bits1, 3);
arb_poly_randtest(A, state, m, bits1, 3);
arb_poly_randtest(B, state, m, bits1, 3);
arb_poly_cos_pi_series(A, S, n1, bits2);
arb_const_pi(pi, bits3);
arb_poly_set_arb(B, pi);
arb_poly_mul(B, S, B, bits3);
arb_poly_cos_series(B, B, n2, bits3);
arb_poly_set(C, A);
arb_poly_truncate(C, FLINT_MIN(n1, n2));
arb_poly_truncate(B, FLINT_MIN(n1, n2));
if (!arb_poly_overlaps(B, C))
{
flint_printf("FAIL\n\n");
flint_printf("S = "); arb_poly_printd(S, 15); flint_printf("\n\n");
flint_printf("A = "); arb_poly_printd(A, 15); flint_printf("\n\n");
flint_printf("B = "); arb_poly_printd(B, 15); flint_printf("\n\n");
abort();
}
arb_poly_cos_pi_series(S, S, n1, bits2);
if (!arb_poly_overlaps(A, S))
{
flint_printf("FAIL (aliasing)\n\n");
abort();
}
arb_poly_clear(S);
arb_poly_clear(A);
arb_poly_clear(B);
arb_poly_clear(C);
arb_clear(pi);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("eta....");
fflush(stdout);
flint_randinit(state);
/* Test functional equation */
for (iter = 0; iter < 10000; iter++)
{
acb_t tau1, tau2, z1, z2, z3, t;
fmpq_t arg;
long e0, prec0, prec1, prec2;
psl2z_t g;
psl2z_init(g);
fmpq_init(arg);
acb_init(tau1);
acb_init(tau2);
acb_init(z1);
acb_init(z2);
acb_init(z3);
acb_init(t);
e0 = 1 + n_randint(state, 200);
prec0 = 2 + n_randint(state, 2000);
prec1 = 2 + n_randint(state, 2000);
prec2 = 2 + n_randint(state, 2000);
acb_randtest(tau1, state, prec0, e0);
acb_randtest(tau2, state, prec0, e0);
acb_randtest(z1, state, prec0, e0);
acb_randtest(z2, state, prec0, e0);
psl2z_randtest(g, state, 1 + n_randint(state, 200));
acb_modular_transform(tau2, g, tau1, prec0);
acb_modular_eta(z1, tau1, prec1);
acb_modular_eta(z2, tau2, prec2);
/* apply transformation */
fmpq_set_si(arg, acb_modular_epsilon_arg(g), 12);
arb_sin_cos_pi_fmpq(acb_imagref(t), acb_realref(t), arg, prec1);
acb_mul(z3, z1, t, prec1);
acb_mul_fmpz(t, tau1, &g->c, prec1);
acb_add_fmpz(t, t, &g->d, prec1);
acb_sqrt(t, t, prec1);
acb_mul(z3, z3, t, prec1);
if (!acb_overlaps(z3, z2))
{
printf("FAIL (overlap)\n");
printf("tau1 = "); acb_printd(tau1, 15); printf("\n\n");
printf("tau2 = "); acb_printd(tau2, 15); printf("\n\n");
printf("g = "); psl2z_print(g); printf("\n\n");
printf("z1 = "); acb_printd(z1, 15); printf("\n\n");
printf("z2 = "); acb_printd(z2, 15); printf("\n\n");
printf("z3 = "); acb_printd(z3, 15); printf("\n\n");
abort();
}
acb_modular_eta(tau1, tau1, prec2);
if (!acb_overlaps(z1, tau1))
{
printf("FAIL (aliasing)\n");
printf("tau1 = "); acb_print(tau1); printf("\n\n");
printf("tau2 = "); acb_print(tau2); printf("\n\n");
printf("z1 = "); acb_print(z1); printf("\n\n");
printf("z2 = "); acb_print(z2); printf("\n\n");
abort();
}
acb_clear(tau1);
acb_clear(tau2);
acb_clear(z1);
acb_clear(z2);
acb_clear(z3);
acb_clear(t);
psl2z_clear(g);
fmpq_clear(arg);
}
/* Test special values */
for (iter = 0; iter < 100; iter++)
{
acb_t tau, z;
arb_t t, u;
long prec;
acb_init(tau);
acb_init(z);
arb_init(t);
arb_init(u);
prec = 2 + n_randint(state, 2000);
acb_randtest(z, state, prec, 10);
acb_onei(tau);
acb_modular_eta(z, tau, prec);
arb_one(t);
arb_mul_2exp_si(t, t, -2);
arb_gamma(t, t, prec);
arb_const_pi(u, prec);
arb_root(u, u, 4, prec);
arb_pow_ui(u, u, 3, prec);
arb_div(t, t, u, prec);
arb_mul_2exp_si(t, t, -1);
if (!arb_overlaps(acb_realref(z), t) ||
!arb_contains_zero(acb_imagref(z)))
{
printf("FAIL (value 1)\n");
printf("tau = "); acb_print(tau); printf("\n\n");
printf("z = "); acb_print(z); printf("\n\n");
abort();
}
acb_clear(tau);
acb_clear(z);
arb_clear(t);
arb_clear(u);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_calc_cauchy_bound(arb_t bound, acb_calc_func_t func, void * param,
const acb_t x, const arb_t radius, slong maxdepth, slong prec)
{
slong i, n, depth, wp;
arb_t pi, theta, v, s1, c1, s2, c2, st, ct;
acb_t t, u;
arb_t b;
arb_init(pi);
arb_init(theta);
arb_init(v);
arb_init(s1);
arb_init(c1);
arb_init(s2);
arb_init(c2);
arb_init(st);
arb_init(ct);
acb_init(t);
acb_init(u);
arb_init(b);
wp = prec + 20;
arb_const_pi(pi, wp);
arb_zero_pm_inf(b);
for (depth = 0, n = 16; depth < maxdepth; n *= 2, depth++)
{
arb_zero(b);
/* theta = 2 pi / n */
arb_div_ui(theta, pi, n, wp);
arb_mul_2exp_si(theta, theta, 1);
/* sine and cosine of i*theta and (i+1)*theta */
arb_zero(s1);
arb_one(c1);
arb_sin_cos(st, ct, theta, wp);
arb_set(s2, st);
arb_set(c2, ct);
for (i = 0; i < n; i++)
{
/* sine and cosine of 2 pi ([i,i+1]/n) */
/* since we use power of two subdivision points, the
sine and cosine are monotone on each subinterval */
arb_union(acb_realref(t), c1, c2, wp);
arb_union(acb_imagref(t), s1, s2, wp);
acb_mul_arb(t, t, radius, wp);
acb_add(t, t, x, prec);
/* next angle */
arb_mul(v, c2, ct, wp);
arb_mul(c1, s2, st, wp);
arb_sub(c1, v, c1, wp);
arb_mul(v, c2, st, wp);
arb_mul(s1, s2, ct, wp);
arb_add(s1, v, s1, wp);
arb_swap(c1, c2);
arb_swap(s1, s2);
func(u, t, param, 1, prec);
acb_abs(v, u, prec);
arb_add(b, b, v, prec);
}
arb_div_ui(b, b, n, prec);
if (arb_is_positive(b))
break;
}
arb_set(bound, b);
arb_clear(pi);
arb_clear(theta);
arb_clear(v);
acb_clear(t);
acb_clear(u);
arb_clear(b);
arb_clear(s1);
arb_clear(c1);
arb_clear(s2);
arb_clear(c2);
arb_clear(st);
arb_clear(ct);
}
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_chi_asymp(acb_t res, const acb_t z, slong prec)
{
acb_t t, u, v, one;
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(one);
acb_one(one);
/* u = U(1,1,z) */
acb_hypgeom_u_asymp(u, one, one, z, -1, prec);
/* v = e^(-z) */
acb_neg(v, z);
acb_exp(v, v, prec);
acb_mul(t, u, v, prec);
if (arb_is_zero(acb_realref(z)))
{
arb_div(acb_realref(t), acb_imagref(t), acb_imagref(z), prec);
arb_zero(acb_imagref(t));
acb_neg(t, t);
}
else
{
/* u = U(1,1,-z) */
acb_neg(u, z);
acb_hypgeom_u_asymp(u, one, one, u, -1, prec);
acb_inv(v, v, prec);
acb_submul(t, u, v, prec);
acb_div(t, t, z, prec);
acb_mul_2exp_si(t, t, -1);
acb_neg(t, t);
}
if (acb_is_real(z))
{
if (arb_is_positive(acb_realref(z)))
{
arb_zero(acb_imagref(t));
}
else if (arb_is_negative(acb_realref(z)))
{
arb_const_pi(acb_imagref(t), prec);
}
else
{
/* add [-pi,pi]/2 i */
acb_const_pi(u, prec);
arb_zero(acb_imagref(t));
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
else
{
/* -pi/2 if positive real or in lower half plane
pi/2 if negative real or in upper half plane */
if (arb_is_negative(acb_imagref(z)))
{
acb_const_pi(u, prec);
acb_mul_2exp_si(u, u, -1);
arb_sub(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else if (arb_is_positive(acb_imagref(z)))
{
acb_const_pi(u, prec);
acb_mul_2exp_si(u, u, -1);
arb_add(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else
{
/* add [-pi,pi]/2 i */
acb_const_pi(u, prec);
acb_mul_2exp_si(u, u, -1);
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
acb_swap(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(v);
acb_clear(one);
}
/* 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
gc_integrals_precomp(acb_ptr res, acb_srcptr u, slong d1, slong d, slong g, const gc_int_t gc, int flag, slong prec)
{
slong l;
arb_t w, x;
acb_t y, yxi;
void (*sqrt_pol) (acb_t y, acb_srcptr u, slong d1, slong d,
const arb_t x, slong prec);
arb_init(w);
arb_init(x);
acb_init(y);
acb_init(yxi);
#if DEBUG
flint_printf("\ngc integral : d1 = %ld, d = %ld, g = %ld, n = %ld, prec = %ld",
d1, d, g, gc->n, prec);
#endif
sqrt_pol = &sqrt_pol_turn;
if (flag & AJ_ROOT_DEF)
sqrt_pol = &sqrt_pol_def;
else if (flag & AJ_ROOT_TURN)
sqrt_pol = &sqrt_pol_turn;
/* compute integral */
_acb_vec_zero(res, g);
for (l = 0; l < gc->len; l++)
{
/* compute 1/y(x) */
sqrt_pol(y, u, d1, d, gc->x + l, prec);
acb_inv(y, y, prec);
/* differentials */
acb_vec_add_geom_arb(res, g, y, gc->x + l, prec);
/* now on -x */
arb_neg(x, gc->x + l);
sqrt_pol(y, u, d1, d, x, prec);
acb_inv(y, y, prec);
acb_vec_add_geom_arb(res, g, y, x, prec);
}
if (gc->n % 2)
{
arb_zero(x);
/* FIXME: pb with turn */
sqrt_pol_def(y, u, d1, d, x, prec);
#if DEBUG > 1
flint_printf("\nend integration sum");
_acb_vec_printd(res, g, 30, "\n");
flint_printf("\nroots (d1=%ld, d=%ld)\n",d1,d);
_acb_vec_printd(u, d, 30, "\n");
flint_printf("\n -> y = ");
acb_printd(y, 30);
#endif
acb_inv(y, y, prec);
acb_add(res + 0, res + 0, y, prec);
}
/* multiply by weight = Pi / n */
arb_const_pi(w, prec);
arb_div_ui(w, w, gc->n, prec);
_acb_vec_scalar_mul_arb(res, res, g, w, prec);
#if DEBUG > 1
flint_printf("\nend integration ");
_acb_vec_printd(res, g, 30, "\n");
#endif
arb_clear(x);
arb_clear(w);
acb_clear(y);
acb_clear(yxi);
}
