void
arb_poly_compose_series(arb_poly_t res,
const arb_poly_t poly1,
const arb_poly_t poly2, slong n, slong prec)
{
slong len1 = poly1->length;
slong len2 = poly2->length;
slong lenr;
if (len2 != 0 && !arb_is_zero(poly2->coeffs))
{
flint_printf("exception: compose_series: inner "
"polynomial must have zero constant term\n");
abort();
}
if (len1 == 0 || n == 0)
{
arb_poly_zero(res);
return;
}
if (len2 == 0 || len1 == 1)
{
arb_poly_set_arb(res, poly1->coeffs);
return;
}
lenr = FLINT_MIN((len1 - 1) * (len2 - 1) + 1, n);
len1 = FLINT_MIN(len1, lenr);
len2 = FLINT_MIN(len2, lenr);
if ((res != poly1) && (res != poly2))
{
arb_poly_fit_length(res, lenr);
_arb_poly_compose_series(res->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2, lenr, prec);
_arb_poly_set_length(res, lenr);
_arb_poly_normalise(res);
}
else
{
arb_poly_t t;
arb_poly_init2(t, lenr);
_arb_poly_compose_series(t->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2, lenr, prec);
_arb_poly_set_length(t, lenr);
_arb_poly_normalise(t);
arb_poly_swap(res, t);
arb_poly_clear(t);
}
}
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);
}
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
_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);
}
