void
_acb_poly_sin_cos_pi_series(acb_ptr s, acb_ptr c, const acb_srcptr h, slong hlen, slong n, slong prec)
{
hlen = FLINT_MIN(hlen, n);
if (hlen == 1)
{
acb_sin_cos_pi(s, c, h, prec);
_acb_vec_zero(s + 1, n - 1);
_acb_vec_zero(c + 1, n - 1);
}
else if (n == 2)
{
acb_t t;
acb_init(t);
acb_const_pi(t, prec);
acb_mul(t, t, h + 1, prec);
acb_sin_cos_pi(s, c, h, prec);
acb_mul(s + 1, c, t, prec);
acb_neg(t, t);
acb_mul(c + 1, s, t, prec);
acb_clear(t);
}
else if (hlen < TANGENT_CUTOFF)
_acb_poly_sin_cos_series_basecase(s, c, h, hlen, n, prec, 1);
else
_acb_poly_sin_cos_series_tangent(s, c, h, hlen, n, prec, 1);
}
void
_acb_hypgeom_coulomb_series(acb_ptr F, acb_ptr G,
acb_ptr Hpos, acb_ptr Hneg, const acb_t l, const acb_t eta,
acb_srcptr z, slong zlen, slong len, slong prec)
{
acb_ptr t, v;
if (len == 0)
return;
zlen = FLINT_MIN(zlen, len);
if (zlen == 1)
{
acb_hypgeom_coulomb(F, G, Hpos, Hneg, l, eta, z, prec);
if (F != NULL) _acb_vec_zero(F + 1, len - 1);
if (G != NULL) _acb_vec_zero(G + 1, len - 1);
if (Hpos != NULL) _acb_vec_zero(Hpos + 1, len - 1);
if (Hneg != NULL) _acb_vec_zero(Hneg + 1, len - 1);
return;
}
t = _acb_vec_init(len);
v = _acb_vec_init(zlen);
/* copy nonconstant part first to allow aliasing */
acb_zero(v);
_acb_vec_set(v + 1, z + 1, zlen - 1);
acb_hypgeom_coulomb_jet(F, G, Hpos, Hneg, l, eta, z, len, prec);
if (F != NULL)
{
_acb_vec_set(t, F, len);
_acb_poly_compose_series(F, t, len, v, zlen, len, prec);
}
if (G != NULL)
{
_acb_vec_set(t, G, len);
_acb_poly_compose_series(G, t, len, v, zlen, len, prec);
}
if (Hpos != NULL)
{
_acb_vec_set(t, Hpos, len);
_acb_poly_compose_series(Hpos, t, len, v, zlen, len, prec);
}
if (Hneg != NULL)
{
_acb_vec_set(t, Hneg, len);
_acb_poly_compose_series(Hneg, t, len, v, zlen, len, prec);
}
_acb_vec_clear(t, len);
_acb_vec_clear(v, zlen);
}
void
_acb_poly_sin_series(acb_ptr g, acb_srcptr h, slong hlen, slong n, slong prec)
{
hlen = FLINT_MIN(hlen, n);
if (hlen == 1)
{
acb_sin(g, h, prec);
_acb_vec_zero(g + 1, n - 1);
}
else if (n == 2)
{
acb_t t;
acb_init(t);
acb_sin_cos(g, t, h, prec);
acb_mul(g + 1, h + 1, t, prec); /* safe since hlen >= 2 */
acb_clear(t);
}
else
{
acb_ptr t = _acb_vec_init(n);
_acb_poly_sin_cos_series(g, t, h, hlen, n, prec);
_acb_vec_clear(t, n);
}
}
void
_acb_dirichlet_hardy_z_series(acb_ptr res, acb_srcptr s, slong slen,
const dirichlet_group_t G, const dirichlet_char_t chi,
slong len, slong prec)
{
slen = FLINT_MIN(slen, len);
if (len == 0)
return;
if (slen == 1)
{
acb_dirichlet_hardy_z(res, s, G, chi, 1, prec);
_acb_vec_zero(res + 1, len - 1);
}
else
{
acb_ptr t, u;
t = _acb_vec_init(len);
u = _acb_vec_init(slen);
acb_dirichlet_hardy_z(t, s, G, chi, len, prec);
/* compose with nonconstant part */
acb_zero(u);
_acb_vec_set(u + 1, s + 1, slen - 1);
_acb_poly_compose_series(res, t, len, u, slen, len, prec);
_acb_vec_clear(t, len);
_acb_vec_clear(u, slen);
}
}
void
acb_poly_set_coeff_si(acb_poly_t poly, slong n, slong x)
{
acb_poly_fit_length(poly, n + 1);
if (n + 1 > poly->length)
{
_acb_vec_zero(poly->coeffs + poly->length, n - poly->length);
poly->length = n + 1;
}
acb_set_si(poly->coeffs + n, x);
_acb_poly_normalise(poly);
}
/* compose by poly2 = a*x^n + c, no aliasing; n >= 1 */
void
_acb_poly_compose_axnc(acb_ptr res, acb_srcptr poly1, slong len1,
const acb_t c, const acb_t a, slong n, slong prec)
{
slong i;
_acb_vec_set_round(res, poly1, len1, prec);
/* shift by c (c = 0 case will be fast) */
_acb_poly_taylor_shift(res, c, len1, prec);
/* multiply by powers of a */
if (!acb_is_one(a))
{
if (acb_equal_si(a, -1))
{
for (i = 1; i < len1; i += 2)
acb_neg(res + i, res + i);
}
else if (len1 == 2)
{
acb_mul(res + 1, res + 1, a, prec);
}
else
{
acb_t t;
acb_init(t);
acb_set(t, a);
for (i = 1; i < len1; i++)
{
acb_mul(res + i, res + i, t, prec);
if (i + 1 < len1)
acb_mul(t, t, a, prec);
}
acb_clear(t);
}
}
/* stretch */
for (i = len1 - 1; i >= 1 && n > 1; i--)
{
acb_swap(res + i * n, res + i);
_acb_vec_zero(res + (i - 1) * n + 1, n - 1);
}
}
void
_acb_poly_compose_series(acb_ptr res, acb_srcptr poly1, slong len1,
acb_srcptr poly2, slong len2, slong n, slong prec)
{
if (len2 == 1)
{
acb_set_round(res, poly1, prec);
_acb_vec_zero(res + 1, n - 1);
}
else if (_acb_vec_is_zero(poly2 + 1, len2 - 2)) /* poly2 is a monomial */
{
slong i, j;
acb_t t;
acb_init(t);
acb_set(t, poly2 + len2 - 1);
acb_set_round(res, poly1, prec);
for (i = 1, j = len2 - 1; i < len1 && j < n; i++, j += len2 - 1)
{
acb_mul(res + j, poly1 + i, t, prec);
if (i + 1 < len1 && j + len2 - 1 < n)
acb_mul(t, t, poly2 + len2 - 1, prec);
}
if (len2 != 2)
for (i = 1; i < n; i++)
if (i % (len2 - 1) != 0)
acb_zero(res + i);
acb_clear(t);
}
else if (len1 < 6 || n < 6)
{
_acb_poly_compose_series_horner(res, poly1, len1, poly2, len2, n, prec);
}
else
{
_acb_poly_compose_series_brent_kung(res, poly1, len1, poly2, len2, n, prec);
}
}
void
_acb_poly_compose_series_horner(acb_ptr res, acb_srcptr poly1, slong len1,
acb_srcptr poly2, slong len2, slong n, slong prec)
{
if (n == 1)
{
acb_set(res, poly1);
}
else
{
slong i = len1 - 1;
slong lenr;
acb_ptr t = _acb_vec_init(n);
lenr = len2;
_acb_vec_scalar_mul(res, poly2, len2, poly1 + i, prec);
i--;
acb_add(res, res, poly1 + i, prec);
while (i > 0)
{
i--;
if (lenr + len2 - 1 < n)
{
_acb_poly_mul(t, res, lenr, poly2, len2, prec);
lenr = lenr + len2 - 1;
}
else
{
_acb_poly_mullow(t, res, lenr, poly2, len2, n, prec);
lenr = n;
}
_acb_poly_add(res, t, lenr, poly1 + i, 1, prec);
}
_acb_vec_zero(res + lenr, n - lenr);
_acb_vec_clear(t, n);
}
}
void
_acb_poly_sqrt_series(acb_ptr g,
acb_srcptr h, slong hlen, slong len, slong prec)
{
hlen = FLINT_MIN(hlen, len);
while (hlen > 0 && acb_is_zero(h + hlen - 1))
hlen--;
if (hlen <= 1)
{
acb_sqrt(g, h, prec);
_acb_vec_zero(g + 1, len - 1);
}
else if (len == 2)
{
acb_sqrt(g, h, prec);
acb_div(g + 1, h + 1, h, prec);
acb_mul(g + 1, g + 1, g, prec);
acb_mul_2exp_si(g + 1, g + 1, -1);
}
else if (_acb_vec_is_zero(h + 1, hlen - 2))
{
acb_t t;
acb_init(t);
arf_set_si_2exp_si(arb_midref(acb_realref(t)), 1, -1);
_acb_poly_binomial_pow_acb_series(g, h, hlen, t, len, prec);
acb_clear(t);
}
else
{
acb_ptr t;
t = _acb_vec_init(len);
_acb_poly_rsqrt_series(t, h, hlen, len, prec);
_acb_poly_mullow(g, t, len, h, hlen, len, prec);
_acb_vec_clear(t, len);
}
}
void
_acb_poly_atan_series(acb_ptr g, acb_srcptr h, slong hlen, slong n, slong prec)
{
acb_t c;
acb_init(c);
acb_atan(c, h, prec);
hlen = FLINT_MIN(hlen, n);
if (hlen == 1)
{
_acb_vec_zero(g + 1, n - 1);
}
else
{
acb_ptr t, u;
slong ulen;
t = _acb_vec_init(n);
u = _acb_vec_init(n);
/* atan(h(x)) = integral(h'(x)/(1+h(x)^2)) */
ulen = FLINT_MIN(n, 2 * hlen - 1);
_acb_poly_mullow(u, h, hlen, h, hlen, ulen, prec);
acb_add_ui(u, u, 1, prec);
_acb_poly_derivative(t, h, hlen, prec);
_acb_poly_div_series(g, t, hlen - 1, u, ulen, n, prec);
_acb_poly_integral(g, g, n, prec);
_acb_vec_clear(t, n);
_acb_vec_clear(u, n);
}
acb_swap(g, c);
acb_clear(c);
}
void
_acb_poly_pow_ui_trunc_binexp(acb_ptr res,
acb_srcptr f, long flen, ulong exp, long len, long prec)
{
acb_ptr v, R, S, T;
long rlen;
ulong bit;
if (exp <= 1)
{
if (exp == 0)
acb_one(res);
else if (exp == 1)
_acb_vec_set_round(res, f, len, prec);
return;
}
/* (f * x^r)^m = x^(rm) * f^m */
while (flen > 1 && acb_is_zero(f))
{
if (((ulong) len) > exp)
{
_acb_vec_zero(res, exp);
len -= exp;
res += exp;
}
else
{
_acb_vec_zero(res, len);
return;
}
f++;
flen--;
}
if (exp == 2)
{
_acb_poly_mullow(res, f, flen, f, flen, len, prec);
return;
}
if (flen == 1)
{
acb_pow_ui(res, f, exp, prec);
return;
}
v = _acb_vec_init(len);
bit = 1UL << (FLINT_BIT_COUNT(exp) - 2);
if (n_zerobits(exp) % 2)
{
R = res;
S = v;
}
else
{
R = v;
S = res;
}
MUL(R, rlen, f, flen, f, flen, len, prec);
if (bit & exp)
{
MUL(S, rlen, R, rlen, f, flen, len, prec);
T = R;
R = S;
S = T;
}
while (bit >>= 1)
{
if (bit & exp)
{
MUL(S, rlen, R, rlen, R, rlen, len, prec);
MUL(R, rlen, S, rlen, f, flen, len, prec);
}
else
{
MUL(S, rlen, R, rlen, R, rlen, len, prec);
T = R;
R = S;
S = T;
}
}
_acb_vec_clear(v, len);
}
void
_acb_poly_inv_series(acb_ptr Qinv,
acb_srcptr Q, slong Qlen, slong len, slong prec)
{
Qlen = FLINT_MIN(Qlen, len);
acb_inv(Qinv, Q, prec);
if (Qlen == 1)
{
_acb_vec_zero(Qinv + 1, len - 1);
}
else if (len == 2)
{
acb_mul(Qinv + 1, Qinv, Qinv, prec);
acb_mul(Qinv + 1, Qinv + 1, Q + 1, prec);
acb_neg(Qinv + 1, Qinv + 1);
}
else
{
slong i, blen;
/* The basecase algorithm is faster for much larger Qlen or len than
this, but unfortunately also much less numerically stable. */
if (Qlen == 2 || len <= 8)
blen = len;
else
blen = FLINT_MIN(len, 4);
for (i = 1; i < blen; i++)
{
acb_dot(Qinv + i, NULL, 1,
Q + 1, 1, Qinv + i - 1, -1, FLINT_MIN(i, Qlen - 1), prec);
if (!acb_is_one(Qinv))
acb_mul(Qinv + i, Qinv + i, Qinv, prec);
}
if (len > blen)
{
slong Qnlen, Wlen, W2len;
acb_ptr W;
W = _acb_vec_init(len);
NEWTON_INIT(blen, len)
NEWTON_LOOP(m, n)
Qnlen = FLINT_MIN(Qlen, n);
Wlen = FLINT_MIN(Qnlen + m - 1, n);
W2len = Wlen - m;
MULLOW(W, Q, Qnlen, Qinv, m, Wlen, prec);
MULLOW(Qinv + m, Qinv, m, W + m, W2len, n - m, prec);
_acb_vec_neg(Qinv + m, Qinv + m, n - m);
NEWTON_END_LOOP
NEWTON_END
_acb_vec_clear(W, len);
}
}
}
void
_acb_poly_powsum_one_series_sieved(acb_ptr z, const acb_t s, slong n, slong len, slong prec)
{
slong * divisors;
slong powers_alloc;
slong i, j, k, ibound, kprev, power_of_two, horner_point;
int critical_line, integer;
acb_ptr powers;
acb_ptr t, u, x;
acb_ptr p1, p2;
arb_t logk, v, w;
critical_line = arb_is_exact(acb_realref(s)) &&
(arf_cmp_2exp_si(arb_midref(acb_realref(s)), -1) == 0);
integer = arb_is_zero(acb_imagref(s)) && arb_is_int(acb_realref(s));
divisors = flint_calloc(n / 2 + 1, sizeof(slong));
powers_alloc = (n / 6 + 1) * len;
powers = _acb_vec_init(powers_alloc);
ibound = n_sqrt(n);
for (i = 3; i <= ibound; i += 2)
if (DIVISOR(i) == 0)
for (j = i * i; j <= n; j += 2 * i)
DIVISOR(j) = i;
t = _acb_vec_init(len);
u = _acb_vec_init(len);
x = _acb_vec_init(len);
arb_init(logk);
arb_init(v);
arb_init(w);
power_of_two = 1;
while (power_of_two * 2 <= n)
power_of_two *= 2;
horner_point = n / power_of_two;
_acb_vec_zero(z, len);
kprev = 0;
COMPUTE_POWER(x, 2, kprev);
for (k = 1; k <= n; k += 2)
{
/* t = k^(-s) */
if (DIVISOR(k) == 0)
{
COMPUTE_POWER(t, k, kprev);
}
else
{
p1 = POWER(DIVISOR(k));
p2 = POWER(k / DIVISOR(k));
if (len == 1)
acb_mul(t, p1, p2, prec);
else
_acb_poly_mullow(t, p1, len, p2, len, len, prec);
}
if (k * 3 <= n)
_acb_vec_set(POWER(k), t, len);
_acb_vec_add(u, u, t, len, prec);
while (k == horner_point && power_of_two != 1)
{
_acb_poly_mullow(t, z, len, x, len, len, prec);
_acb_vec_add(z, t, u, len, prec);
power_of_two /= 2;
horner_point = n / power_of_two;
horner_point -= (horner_point % 2 == 0);
}
}
_acb_poly_mullow(t, z, len, x, len, len, prec);
_acb_vec_add(z, t, u, len, prec);
flint_free(divisors);
_acb_vec_clear(powers, powers_alloc);
_acb_vec_clear(t, len);
_acb_vec_clear(u, len);
_acb_vec_clear(x, len);
arb_clear(logk);
arb_clear(v);
arb_clear(w);
}
void
_acb_poly_digamma_series(acb_ptr res, acb_srcptr h, slong hlen, slong len, slong prec)
{
int reflect;
slong i, r, n, rflen, wp;
acb_t zr;
acb_ptr t, u, v;
hlen = FLINT_MIN(hlen, len);
if (hlen == 1)
{
acb_digamma(res, h, prec);
if (acb_is_finite(res))
_acb_vec_zero(res + 1, len - 1);
else
_acb_vec_indeterminate(res + 1, len - 1);
return;
}
/* use real code for real input */
if (_acb_vec_is_real(h, hlen))
{
arb_ptr tmp = _arb_vec_init(len);
for (i = 0; i < hlen; i++)
arb_set(tmp + i, acb_realref(h + i));
_arb_poly_digamma_series(tmp, tmp, hlen, len, prec);
for (i = 0; i < len; i++)
acb_set_arb(res + i, tmp + i);
_arb_vec_clear(tmp, len);
return;
}
wp = prec + FLINT_BIT_COUNT(prec);
t = _acb_vec_init(len + 1);
u = _acb_vec_init(len + 1);
v = _acb_vec_init(len + 1);
acb_init(zr);
/* use Stirling series */
acb_gamma_stirling_choose_param(&reflect, &r, &n, h, 1, 1, wp);
/* psi(x) = psi((1-x)+r) - h(1-x,r) - pi*cot(pi*x) */
if (reflect)
{
if (r != 0) /* otherwise t = 0 */
{
acb_sub_ui(v, h, 1, wp);
acb_neg(v, v);
acb_one(v + 1);
rflen = FLINT_MIN(len + 1, r + 1);
_acb_poly_rising_ui_series(u, v, 2, r, rflen, wp);
_acb_poly_derivative(v, u, rflen, wp);
_acb_poly_div_series(t, v, rflen - 1, u, rflen, len, wp);
for (i = 1; i < len; i += 2)
acb_neg(t + i, t + i);
}
acb_sub_ui(zr, h, r + 1, wp);
acb_neg(zr, zr);
_acb_poly_gamma_stirling_eval2(u, zr, n, len + 1, 1, wp);
for (i = 1; i < len; i += 2)
acb_neg(u + i, u + i);
_acb_vec_sub(u, u, t, len, wp);
acb_set(t, h);
acb_one(t + 1);
_acb_poly_cot_pi_series(t, t, 2, len, wp);
acb_const_pi(v, wp);
_acb_vec_scalar_mul(t, t, len, v, wp);
_acb_vec_sub(u, u, t, len, wp);
}
else
{
if (r == 0)
{
acb_add_ui(zr, h, r, wp);
_acb_poly_gamma_stirling_eval2(u, zr, n, len + 1, 1, wp);
}
else
{
acb_set(v, h);
acb_one(v + 1);
rflen = FLINT_MIN(len + 1, r + 1);
_acb_poly_rising_ui_series(u, v, 2, r, rflen, wp);
_acb_poly_derivative(v, u, rflen, wp);
_acb_poly_div_series(t, v, rflen - 1, u, rflen, len, wp);
acb_add_ui(zr, h, r, wp);
_acb_poly_gamma_stirling_eval2(u, zr, n, len + 1, 1, wp);
_acb_vec_sub(u, u, t, len, wp);
}
}
/* compose with nonconstant part */
acb_zero(t);
_acb_vec_set(t + 1, h + 1, hlen - 1);
_acb_poly_compose_series(res, u, len, t, hlen, len, prec);
acb_clear(zr);
_acb_vec_clear(t, len + 1);
_acb_vec_clear(u, len + 1);
_acb_vec_clear(v, len + 1);
}
void
_acb_poly_rgamma_series(acb_ptr res, acb_srcptr h, slong hlen, slong len, slong prec)
{
int reflect;
slong i, rflen, r, n, wp;
acb_ptr t, u, v;
acb_struct f[2];
hlen = FLINT_MIN(hlen, len);
if (hlen == 1)
{
acb_rgamma(res, h, prec);
_acb_vec_zero(res + 1, len - 1);
return;
}
/* use real code for real input */
if (_acb_vec_is_real(h, hlen))
{
arb_ptr tmp = _arb_vec_init(len);
for (i = 0; i < hlen; i++)
arb_set(tmp + i, acb_realref(h + i));
_arb_poly_rgamma_series(tmp, tmp, hlen, len, prec);
for (i = 0; i < len; i++)
acb_set_arb(res + i, tmp + i);
_arb_vec_clear(tmp, len);
return;
}
wp = prec + FLINT_BIT_COUNT(prec);
t = _acb_vec_init(len);
u = _acb_vec_init(len);
v = _acb_vec_init(len);
acb_init(f);
acb_init(f + 1);
/* otherwise use Stirling series */
acb_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) */
acb_sub_ui(f, h, r + 1, wp);
acb_neg(f, f);
_acb_poly_gamma_stirling_eval(t, f, n, len, wp);
_acb_poly_exp_series(u, t, len, len, wp);
for (i = 1; i < len; i += 2)
acb_neg(u + i, u + i);
/* v = sin(pi x) */
acb_set(f, h);
acb_one(f + 1);
_acb_poly_sin_pi_series(v, f, 2, len, wp);
_acb_poly_mullow(t, u, len, v, len, len, wp);
/* rf(1-h,r) * pi */
if (r == 0)
{
acb_const_pi(u, wp);
_acb_vec_scalar_div(v, t, len, u, wp);
}
else
{
acb_sub_ui(f, h, 1, wp);
acb_neg(f, f);
acb_set_si(f + 1, -1);
rflen = FLINT_MIN(len, r + 1);
_acb_poly_rising_ui_series(v, f, FLINT_MIN(2, len), r, rflen, wp);
acb_const_pi(u, wp);
_acb_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 */
_acb_poly_inv_series(u, v, rflen, len, wp);
_acb_poly_mullow(v, t, len, u, len, len, wp);
}
}
else
{
/* rgamma(h) = rgamma(h+r) rf(h,r) */
if (r == 0)
{
acb_add_ui(f, h, r, wp);
_acb_poly_gamma_stirling_eval(t, f, n, len, wp);
_acb_vec_neg(t, t, len);
_acb_poly_exp_series(v, t, len, len, wp);
}
else
{
acb_set(f, h);
acb_one(f + 1);
rflen = FLINT_MIN(len, r + 1);
_acb_poly_rising_ui_series(t, f, FLINT_MIN(2, len), r, rflen, wp);
acb_add_ui(f, h, r, wp);
_acb_poly_gamma_stirling_eval(v, f, n, len, wp);
_acb_vec_neg(v, v, len);
_acb_poly_exp_series(u, v, len, len, wp);
_acb_poly_mullow(v, u, len, t, rflen, len, wp);
}
}
/* compose with nonconstant part */
acb_zero(t);
_acb_vec_set(t + 1, h + 1, hlen - 1);
_acb_poly_compose_series(res, v, len, t, hlen, len, prec);
acb_clear(f);
acb_clear(f + 1);
_acb_vec_clear(t, len);
_acb_vec_clear(u, len);
_acb_vec_clear(v, len);
}
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);
}
void
_acb_poly_zeta_em_tail_naive(acb_ptr sum, const acb_t s, const acb_t Na, acb_srcptr Nasx, slong M, slong d, slong prec)
{
acb_ptr u, term;
acb_t Na2, splus, rec;
arb_t x;
fmpz_t c;
int aint;
slong r;
BERNOULLI_ENSURE_CACHED(2 * M);
u = _acb_vec_init(d);
term = _acb_vec_init(d);
acb_init(splus);
acb_init(rec);
acb_init(Na2);
arb_init(x);
fmpz_init(c);
_acb_vec_zero(sum, d);
/* u = 1/2 * Nasx */
_acb_vec_scalar_mul_2exp_si(u, Nasx, d, -WORD(1));
/* term = u * (s+x) / (N+a) */
_acb_poly_mullow_cpx(u, u, d, s, d, prec);
_acb_vec_scalar_div(term, u, d, Na, prec);
/* (N+a)^2 or 1/(N+a)^2 */
acb_mul(Na2, Na, Na, prec);
aint = acb_is_int(Na2);
if (!aint)
acb_inv(Na2, Na2, prec);
for (r = 1; r <= M; r++)
{
/* flint_printf("sum 2: %wd %wd\n", r, M); */
/* sum += bernoulli number * term */
arb_set_round_fmpz(x, fmpq_numref(bernoulli_cache + 2 * r), prec);
arb_div_fmpz(x, x, fmpq_denref(bernoulli_cache + 2 * r), prec);
_acb_vec_scalar_mul_arb(u, term, d, x, prec);
_acb_vec_add(sum, sum, u, d, prec);
/* multiply term by ((s+x)+2r-1)((s+x)+2r) / ((N+a)^2 * (2*r+1)*(2*r+2)) */
acb_set(splus, s);
arb_add_ui(acb_realref(splus), acb_realref(splus), 2*r-1, prec);
_acb_poly_mullow_cpx(term, term, d, splus, d, prec);
arb_add_ui(acb_realref(splus), acb_realref(splus), 1, prec);
_acb_poly_mullow_cpx(term, term, d, splus, d, prec);
/* TODO: combine with previous multiplication? */
if (aint)
{
arb_mul_ui(x, acb_realref(Na2), 2*r+1, prec);
arb_mul_ui(x, x, 2*r+2, prec);
_acb_vec_scalar_div_arb(term, term, d, x, prec);
}
else
{
fmpz_set_ui(c, 2*r+1);
fmpz_mul_ui(c, c, 2*r+2);
acb_div_fmpz(rec, Na2, c, prec);
_acb_vec_scalar_mul(term, term, d, rec, prec);
}
}
_acb_vec_clear(u, d);
_acb_vec_clear(term, d);
acb_clear(splus);
acb_clear(rec);
acb_clear(Na2);
arb_clear(x);
fmpz_clear(c);
}
void
_acb_poly_lgamma_series(acb_ptr res, acb_srcptr h, slong hlen, slong len, slong prec)
{
int reflect;
slong i, r, n, wp;
acb_t zr;
acb_ptr t, u;
hlen = FLINT_MIN(hlen, len);
if (hlen == 1)
{
acb_lgamma(res, h, prec);
if (acb_is_finite(res))
_acb_vec_zero(res + 1, len - 1);
else
_acb_vec_indeterminate(res + 1, len - 1);
return;
}
if (len == 2)
{
acb_t v;
acb_init(v);
acb_set(v, h + 1);
acb_digamma(res + 1, h, prec);
acb_lgamma(res, h, prec);
acb_mul(res + 1, res + 1, v, prec);
acb_clear(v);
return;
}
/* use real code for real input and output */
if (_acb_vec_is_real(h, hlen) && arb_is_positive(acb_realref(h)))
{
arb_ptr tmp = _arb_vec_init(len);
for (i = 0; i < hlen; i++)
arb_set(tmp + i, acb_realref(h + i));
_arb_poly_lgamma_series(tmp, tmp, hlen, len, prec);
for (i = 0; i < len; i++)
acb_set_arb(res + i, tmp + i);
_arb_vec_clear(tmp, len);
return;
}
wp = prec + FLINT_BIT_COUNT(prec);
t = _acb_vec_init(len);
u = _acb_vec_init(len);
acb_init(zr);
/* use Stirling series */
acb_gamma_stirling_choose_param(&reflect, &r, &n, h, 1, 0, wp);
if (reflect)
{
/* log gamma(h+x) = log rf(1-(h+x), r) - log gamma(1-(h+x)+r) - log sin(pi (h+x)) + log(pi) */
if (r != 0) /* otherwise t = 0 */
{
acb_sub_ui(u, h, 1, wp);
acb_neg(u, u);
_log_rising_ui_series(t, u, r, len, wp);
for (i = 1; i < len; i += 2)
acb_neg(t + i, t + i);
}
acb_sub_ui(u, h, 1, wp);
acb_neg(u, u);
acb_add_ui(zr, u, r, wp);
_acb_poly_gamma_stirling_eval(u, zr, n, len, wp);
for (i = 1; i < len; i += 2)
acb_neg(u + i, u + i);
_acb_vec_sub(t, t, u, len, wp);
/* log(sin) is unstable with large imaginary parts;
cot_pi is implemented in a numerically stable way */
acb_set(u, h);
acb_one(u + 1);
_acb_poly_cot_pi_series(u, u, 2, len - 1, wp);
_acb_poly_integral(u, u, len, wp);
acb_const_pi(u, wp);
_acb_vec_scalar_mul(u + 1, u + 1, len - 1, u, wp);
acb_log_sin_pi(u, h, wp);
_acb_vec_sub(u, t, u, len, wp);
acb_const_pi(t, wp); /* todo: constant for log pi */
acb_log(t, t, wp);
acb_add(u, u, t, wp);
}
else
{
/* log gamma(x) = log gamma(x+r) - log rf(x,r) */
acb_add_ui(zr, h, r, wp);
_acb_poly_gamma_stirling_eval(u, zr, n, len, wp);
if (r != 0)
{
_log_rising_ui_series(t, h, r, len, wp);
_acb_vec_sub(u, u, t, len, wp);
}
}
/* compose with nonconstant part */
acb_zero(t);
_acb_vec_set(t + 1, h + 1, hlen - 1);
_acb_poly_compose_series(res, u, len, t, hlen, len, prec);
acb_clear(zr);
_acb_vec_clear(t, len);
_acb_vec_clear(u, len);
}
void
_acb_poly_sin_cos_series_tangent(acb_ptr s, acb_ptr c,
const acb_srcptr h, slong hlen, slong len, slong prec, int times_pi)
{
acb_ptr t, u, v;
acb_t s0, c0;
hlen = FLINT_MIN(hlen, len);
if (hlen == 1)
{
if (times_pi)
acb_sin_cos_pi(s, c, h, prec);
else
acb_sin_cos(s, c, h, prec);
_acb_vec_zero(s + 1, len - 1);
_acb_vec_zero(c + 1, len - 1);
return;
}
/*
sin(x) = 2*tan(x/2)/(1+tan(x/2)^2)
cos(x) = (1-tan(x/2)^2)/(1+tan(x/2)^2)
*/
acb_init(s0);
acb_init(c0);
t = _acb_vec_init(3 * len);
u = t + len;
v = u + len;
/* sin, cos of h0 */
if (times_pi)
acb_sin_cos_pi(s0, c0, h, prec);
else
acb_sin_cos(s0, c0, h, prec);
/* t = tan((h-h0)/2) */
acb_zero(u);
_acb_vec_scalar_mul_2exp_si(u + 1, h + 1, hlen - 1, -1);
if (times_pi)
{
acb_const_pi(t, prec);
_acb_vec_scalar_mul(u + 1, u + 1, hlen - 1, t, prec);
}
_acb_poly_tan_series(t, u, hlen, len, prec);
/* v = 1 + t^2 */
_acb_poly_mullow(v, t, len, t, len, len, prec);
acb_add_ui(v, v, 1, prec);
/* u = 1/(1+t^2) */
_acb_poly_inv_series(u, v, len, len, prec);
/* sine */
_acb_poly_mullow(s, t, len, u, len, len, prec);
_acb_vec_scalar_mul_2exp_si(s, s, len, 1);
/* cosine */
acb_sub_ui(v, v, 2, prec);
_acb_vec_neg(v, v, len);
_acb_poly_mullow(c, v, len, u, len, len, prec);
/* sin(h0 + h1) = cos(h0) sin(h1) + sin(h0) cos(h1)
cos(h0 + h1) = cos(h0) cos(h1) - sin(h0) sin(h1) */
if (!acb_is_zero(s0))
{
_acb_vec_scalar_mul(t, s, len, c0, prec);
_acb_vec_scalar_mul(u, c, len, s0, prec);
_acb_vec_scalar_mul(v, s, len, s0, prec);
_acb_vec_add(s, t, u, len, prec);
_acb_vec_scalar_mul(t, c, len, c0, prec);
_acb_vec_sub(c, t, v, len, prec);
}
_acb_vec_clear(t, 3 * len);
acb_clear(s0);
acb_clear(c0);
}
