void
acb_poly_sqrt_series(acb_poly_t g, const acb_poly_t h, slong n, slong prec)
{
if (n == 0)
{
acb_poly_zero(g);
return;
}
if (g == h)
{
acb_poly_t t;
acb_poly_init(t);
acb_poly_sqrt_series(t, h, n, prec);
acb_poly_swap(g, t);
acb_poly_clear(t);
return;
}
acb_poly_fit_length(g, n);
if (h->length == 0)
_acb_vec_indeterminate(g->coeffs, n);
else
_acb_poly_sqrt_series(g->coeffs, h->coeffs, h->length, n, prec);
_acb_poly_set_length(g, n);
_acb_poly_normalise(g);
}
void
acb_poly_revert_series_lagrange_fast(acb_poly_t Qinv,
const acb_poly_t Q, slong n, slong prec)
{
slong Qlen = Q->length;
if (Qlen < 2 || !acb_is_zero(Q->coeffs)
|| acb_contains_zero(Q->coeffs + 1))
{
flint_printf("Exception (acb_poly_revert_series_lagrange_fast). Input \n"
"must have zero constant term and nonzero coefficient of x^1.\n");
abort();
}
if (Qinv != Q)
{
acb_poly_fit_length(Qinv, n);
_acb_poly_revert_series_lagrange_fast(Qinv->coeffs, Q->coeffs, Qlen, n, prec);
}
else
{
acb_poly_t t;
acb_poly_init2(t, n);
_acb_poly_revert_series_lagrange_fast(t->coeffs, Q->coeffs, Qlen, n, prec);
acb_poly_swap(Qinv, t);
acb_poly_clear(t);
}
_acb_poly_set_length(Qinv, n);
_acb_poly_normalise(Qinv);
}
void
acb_poly_mul(acb_poly_t res, const acb_poly_t poly1,
const acb_poly_t poly2, slong prec)
{
slong len_out;
if ((poly1->length == 0) || (poly2->length == 0))
{
acb_poly_zero(res);
return;
}
len_out = poly1->length + poly2->length - 1;
if (res == poly1 || res == poly2)
{
acb_poly_t temp;
acb_poly_init2(temp, len_out);
_acb_poly_mul(temp->coeffs, poly1->coeffs, poly1->length,
poly2->coeffs, poly2->length, prec);
acb_poly_swap(res, temp);
acb_poly_clear(temp);
}
else
{
acb_poly_fit_length(res, len_out);
_acb_poly_mul(res->coeffs, poly1->coeffs, poly1->length,
poly2->coeffs, poly2->length, prec);
}
_acb_poly_set_length(res, len_out);
_acb_poly_normalise(res);
}
void
acb_poly_binomial_transform(acb_poly_t b, const acb_poly_t a, slong len, slong prec)
{
if (len == 0 || a->length == 0)
{
acb_poly_zero(b);
return;
}
if (b == a)
{
acb_poly_t c;
acb_poly_init2(c, len);
_acb_poly_binomial_transform(c->coeffs, a->coeffs, a->length, len, prec);
acb_poly_swap(b, c);
acb_poly_clear(c);
}
else
{
acb_poly_fit_length(b, len);
_acb_poly_binomial_transform(b->coeffs, a->coeffs, a->length, len, prec);
}
_acb_poly_set_length(b, len);
_acb_poly_normalise(b);
}
void
acb_poly_inv_series(acb_poly_t Qinv, const acb_poly_t Q, slong n, slong prec)
{
if (n == 0)
{
acb_poly_zero(Qinv);
return;
}
if (Q->length == 0)
{
acb_poly_fit_length(Qinv, n);
_acb_vec_indeterminate(Qinv->coeffs, n);
_acb_poly_set_length(Qinv, n);
return;
}
if (Qinv == Q)
{
acb_poly_t t;
acb_poly_init(t);
acb_poly_inv_series(t, Q, n, prec);
acb_poly_swap(Qinv, t);
acb_poly_clear(t);
return;
}
acb_poly_fit_length(Qinv, n);
_acb_poly_inv_series(Qinv->coeffs, Q->coeffs, Q->length, n, prec);
_acb_poly_set_length(Qinv, n);
_acb_poly_normalise(Qinv);
}
void
acb_poly_compose_series(acb_poly_t res,
const acb_poly_t poly1,
const acb_poly_t poly2, slong n, slong prec)
{
slong len1 = poly1->length;
slong len2 = poly2->length;
slong lenr;
if (len2 != 0 && !acb_is_zero(poly2->coeffs))
{
flint_printf("exception: compose_series: inner "
"polynomial must have zero constant term\n");
abort();
}
if (len1 == 0 || n == 0)
{
acb_poly_zero(res);
return;
}
if (len2 == 0 || len1 == 1)
{
acb_poly_set_acb(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))
{
acb_poly_fit_length(res, lenr);
_acb_poly_compose_series(res->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2, lenr, prec);
_acb_poly_set_length(res, lenr);
_acb_poly_normalise(res);
}
else
{
acb_poly_t t;
acb_poly_init2(t, lenr);
_acb_poly_compose_series(t->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2, lenr, prec);
_acb_poly_set_length(t, lenr);
_acb_poly_normalise(t);
acb_poly_swap(res, t);
acb_poly_clear(t);
}
}
void
acb_poly_pow_ui(acb_poly_t res,
const acb_poly_t poly, ulong exp, slong prec)
{
slong flen, rlen;
flen = poly->length;
if (exp == 0)
{
acb_poly_one(res);
}
else if (flen == 0)
{
acb_poly_zero(res);
}
else
{
rlen = exp * (flen - 1) + 1;
if (res != poly)
{
acb_poly_fit_length(res, rlen);
_acb_poly_pow_ui(res->coeffs,
poly->coeffs, flen, exp, prec);
_acb_poly_set_length(res, rlen);
_acb_poly_normalise(res);
}
else
{
acb_poly_t t;
acb_poly_init2(t, rlen);
_acb_poly_pow_ui(t->coeffs,
poly->coeffs, flen, exp, prec);
_acb_poly_set_length(t, rlen);
_acb_poly_normalise(t);
acb_poly_swap(res, t);
acb_poly_clear(t);
}
}
}
void
acb_poly_pow_ui_trunc_binexp(acb_poly_t res,
const acb_poly_t poly, ulong exp, long len, long prec)
{
long flen, rlen;
flen = poly->length;
if (exp == 0 && len != 0)
{
acb_poly_one(res);
}
else if (flen == 0 || len == 0)
{
acb_poly_zero(res);
}
else
{
rlen = poly_pow_length(flen, exp, len);
if (res != poly)
{
acb_poly_fit_length(res, rlen);
_acb_poly_pow_ui_trunc_binexp(res->coeffs,
poly->coeffs, flen, exp, rlen, prec);
_acb_poly_set_length(res, rlen);
_acb_poly_normalise(res);
}
else
{
acb_poly_t t;
acb_poly_init2(t, rlen);
_acb_poly_pow_ui_trunc_binexp(t->coeffs,
poly->coeffs, flen, exp, rlen, prec);
_acb_poly_set_length(t, rlen);
_acb_poly_normalise(t);
acb_poly_swap(res, t);
acb_poly_clear(t);
}
}
}
void
acb_poly_mullow(acb_poly_t res, const acb_poly_t poly1,
const acb_poly_t poly2,
slong n, slong prec)
{
slong len1, len2;
len1 = poly1->length;
len2 = poly2->length;
if (len1 == 0 || len2 == 0 || n == 0)
{
acb_poly_zero(res);
return;
}
n = FLINT_MIN((len1 + len2 - 1), n);
len1 = FLINT_MIN(len1, n);
len2 = FLINT_MIN(len2, n);
if (res == poly1 || res == poly2)
{
acb_poly_t t;
acb_poly_init2(t, n);
_acb_poly_mullow(t->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2, n, prec);
acb_poly_swap(res, t);
acb_poly_clear(t);
}
else
{
acb_poly_fit_length(res, n);
_acb_poly_mullow(res->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2, n, prec);
}
_acb_poly_set_length(res, n);
_acb_poly_normalise(res);
}
void acb_poly_compose(acb_poly_t res,
const acb_poly_t poly1, const acb_poly_t poly2, slong prec)
{
const slong len1 = poly1->length;
const slong len2 = poly2->length;
if (len1 == 0)
{
acb_poly_zero(res);
}
else if (len1 == 1 || len2 == 0)
{
acb_poly_set_acb(res, poly1->coeffs);
}
else
{
const slong lenr = (len1 - 1) * (len2 - 1) + 1;
if (res != poly1 && res != poly2)
{
acb_poly_fit_length(res, lenr);
_acb_poly_compose(res->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2, prec);
}
else
{
acb_poly_t t;
acb_poly_init2(t, lenr);
_acb_poly_compose(t->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2, prec);
acb_poly_swap(res, t);
acb_poly_clear(t);
}
_acb_poly_set_length(res, lenr);
_acb_poly_normalise(res);
}
}
void
acb_poly_mullow_classical(acb_poly_t res, const acb_poly_t poly1,
const acb_poly_t poly2,
slong n, slong prec)
{
slong len_out;
if (poly1->length == 0 || poly2->length == 0 || n == 0)
{
acb_poly_zero(res);
return;
}
len_out = poly1->length + poly2->length - 1;
if (n > len_out)
n = len_out;
if (res == poly1 || res == poly2)
{
acb_poly_t t;
acb_poly_init2(t, n);
_acb_poly_mullow_classical(t->coeffs, poly1->coeffs, poly1->length,
poly2->coeffs, poly2->length, n, prec);
acb_poly_swap(res, t);
acb_poly_clear(t);
}
else
{
acb_poly_fit_length(res, n);
_acb_poly_mullow_classical(res->coeffs, poly1->coeffs, poly1->length,
poly2->coeffs, poly2->length, n, prec);
}
_acb_poly_set_length(res, n);
_acb_poly_normalise(res);
}
void
acb_hypgeom_pfq_series_sum_forward(acb_poly_t s, acb_poly_t t,
const acb_poly_struct * a, long p,
const acb_poly_struct * b, long q,
const acb_poly_t z, int regularized,
long n, long len, long prec)
{
acb_poly_t u, v;
acb_poly_t tmp;
long k, i;
acb_poly_init(u);
acb_poly_init(v);
acb_poly_init(tmp);
if (!regularized)
{
acb_poly_zero(s);
acb_poly_one(t);
for (k = 0; k < n && acb_poly_length(t) != 0; k++)
{
acb_poly_add(s, s, t, prec);
if (p > 0)
{
acb_poly_add_si(u, a, k, prec);
for (i = 1; i < p; i++)
{
acb_poly_add_si(v, a + i, k, prec);
acb_poly_mullow(u, u, v, len, prec);
}
acb_poly_mullow(t, t, u, len, prec);
}
if (q > 0)
{
acb_poly_add_si(u, b, k, prec);
for (i = 1; i < q; i++)
{
acb_poly_add_si(v, b + i, k, prec);
acb_poly_mullow(u, u, v, len, prec);
}
acb_poly_div_series(t, t, u, len, prec);
}
acb_poly_mullow(t, t, z, len, prec);
}
}
else
{
acb_poly_zero(s);
for (i = 0; i < q; i++)
{
if (i == 0)
{
acb_poly_rgamma_series(t, b + i, len, prec);
}
else
{
acb_poly_rgamma_series(u, b + i, len, prec);
acb_poly_mullow(tmp, t, u, len, prec);
acb_poly_swap(tmp, t);
}
}
for (k = 0; k < n; k++)
{
acb_poly_add(s, s, t, prec);
if (p > 0)
{
acb_poly_add_si(u, a, k, prec);
for (i = 1; i < p; i++)
{
acb_poly_add_si(v, a + i, k, prec);
acb_poly_mullow(tmp, u, v, len, prec);
acb_poly_swap(tmp, u);
}
acb_poly_mullow(tmp, t, u, len, prec);
acb_poly_swap(tmp, t);
}
if (q > 0)
{
acb_poly_add_si(u, b, k, prec);
for (i = 1; i < q; i++)
{
acb_poly_add_si(v, b + i, k, prec);
acb_poly_mullow(tmp, u, v, len, prec);
acb_poly_swap(tmp, u);
}
if (acb_poly_length(u) > 0 && !acb_contains_zero(u->coeffs))
{
acb_poly_div_series(tmp, t, u, len, prec);
acb_poly_mullow(t, tmp, z, len, prec);
}
else
{
/* compute term from scratch */
acb_poly_one(t);
for (i = 0; i < p; i++)
{
acb_poly_rising_ui_series(v, a + i, k + 1, len, prec);
acb_poly_mullow(t, t, v, len, prec);
}
for (i = 0; i < q; i++)
{
acb_poly_add_si(v, b + i, k + 1, prec);
acb_poly_rgamma_series(v, v, len, prec);
acb_poly_mullow(t, t, v, len, prec);
}
acb_poly_pow_ui_trunc_binexp(v, z, k + 1, len, prec);
acb_poly_mullow(t, t, v, len, prec);
}
}
else
{
acb_poly_mullow(tmp, t, z, len, prec);
acb_poly_swap(tmp, t);
}
}
}
acb_poly_clear(u);
acb_poly_clear(v);
acb_poly_clear(tmp);
}
/* todo: do this using underscore methods */
static void
bsplit(acb_poly_t A, acb_poly_t B, acb_poly_t C,
acb_srcptr a, slong p, acb_srcptr b, slong q,
const acb_t z, slong an, slong bn, slong prec)
{
if (bn - an == 1)
{
evaluate(A, a, p, z, an, prec);
evaluate(B, b, q, NULL, an, prec);
acb_poly_set(C, B);
}
else if (bn - an == 2) /* inlined */
{
acb_poly_t A2, B2;
acb_poly_init(A2);
acb_poly_init(B2);
evaluate(A, a, p, z, an, prec);
evaluate(A2, a, p, z, an + 1, prec);
evaluate(B, b, q, NULL, an, prec);
evaluate(B2, b, q, NULL, an + 1, prec);
acb_poly_mul(C, B, B2, prec);
acb_poly_set(B, C);
acb_poly_mul(C, A, B2, prec);
acb_poly_add(C, C, B, prec);
acb_poly_mul(A2, A, A2, prec);
acb_poly_swap(A, A2);
acb_poly_clear(A2);
acb_poly_clear(B2);
}
else
{
slong m = an + (bn - an) / 2;
acb_poly_t A2, B2, C2, T;
acb_poly_init(A2);
acb_poly_init(B2);
acb_poly_init(C2);
acb_poly_init(T);
bsplit(A, B, C, a, p, b, q, z, an, m, prec);
bsplit(A2, B2, C2, a, p, b, q, z, m, bn, prec);
acb_poly_mul(T, B2, C, prec);
acb_poly_mul(C, A, C2, prec);
acb_poly_add(C, C, T, prec);
acb_poly_mul(C2, B, B2, prec);
acb_poly_swap(B, C2);
acb_poly_mul(B2, A, A2, prec);
acb_poly_swap(A, B2);
acb_poly_clear(A2);
acb_poly_clear(B2);
acb_poly_clear(C2);
acb_poly_clear(T);
}
}
