void
_nmod_poly_revert_series_lagrange(mp_ptr Qinv, mp_srcptr Q, long n, nmod_t mod)
{
long i;
mp_ptr R, S, T, tmp;
if (n >= 1) Qinv[0] = 0UL;
if (n >= 2) Qinv[1] = n_invmod(Q[1], mod.n);
if (n <= 2)
return;
R = _nmod_vec_init(n - 1);
S = _nmod_vec_init(n - 1);
T = _nmod_vec_init(n - 1);
_nmod_poly_inv_series(R, Q + 1, n - 1, mod);
_nmod_vec_set(S, R, n - 1);
for (i = 2; i < n; i++)
{
_nmod_poly_mullow(T, S, n - 1, R, n - 1, n - 1, mod);
Qinv[i] = nmod_div(T[i - 1], i, mod);
tmp = S; S = T; T = tmp;
}
_nmod_vec_clear(R);
_nmod_vec_clear(S);
_nmod_vec_clear(T);
}
void _nmod_poly_divrem_newton(mp_ptr Q, mp_ptr R, mp_srcptr A, long lenA,
mp_srcptr B, long lenB, nmod_t mod)
{
const long lenQ = lenA - lenB + 1;
_nmod_poly_div_newton(Q, A, lenA, B, lenB, mod);
if (lenB > 1)
{
if (lenQ >= lenB - 1)
_nmod_poly_mullow(R, Q, lenQ, B, lenB - 1, lenB - 1, mod);
else
_nmod_poly_mullow(R, B, lenB - 1, Q, lenQ, lenB - 1, mod);
_nmod_vec_sub(R, A, R, lenB - 1, mod);
}
}
void
_nmod_poly_asinh_series(mp_ptr g, mp_srcptr h, slong n, nmod_t mod)
{
mp_ptr t, u;
t = _nmod_vec_init(n);
u = _nmod_vec_init(n);
/* asinh(h(x)) = integral(h'(x)/sqrt(1+h(x)^2)) */
_nmod_poly_mullow(u, h, n, h, n, n, mod); u[0] = UWORD(1);
_nmod_poly_invsqrt_series(t, u, n, mod);
_nmod_poly_derivative(u, h, n, mod); u[n-1] = UWORD(0);
_nmod_poly_mullow(g, t, n, u, n, n, mod);
_nmod_poly_integral(g, g, n, mod);
_nmod_vec_clear(t);
_nmod_vec_clear(u);
}
void
_nmod_poly_taylor_shift_convolution(mp_ptr p, mp_limb_t c, slong len, nmod_t mod)
{
slong i, n = len - 1;
mp_limb_t f, d;
mp_ptr t, u;
if (c == 0 || len <= 1)
return;
t = _nmod_vec_init(len);
u = _nmod_vec_init(len);
f = 1;
for (i = 2; i <= n; i++)
{
f = n_mulmod2_preinv(f, i, mod.n, mod.ninv);
p[i] = n_mulmod2_preinv(p[i], f, mod.n, mod.ninv);
}
_nmod_poly_reverse(p, p, len, len);
t[n] = 1;
for (i = n; i > 0; i--)
t[i - 1] = n_mulmod2_preinv(t[i], i, mod.n, mod.ninv);
if (c == mod.n - 1)
{
for (i = 1; i <= n; i += 2)
t[i] = nmod_neg(t[i], mod);
}
else if (c != 1)
{
d = c;
for (i = 1; i <= n; i++)
{
t[i] = n_mulmod2_preinv(t[i], d, mod.n, mod.ninv);
d = n_mulmod2_preinv(d, c, mod.n, mod.ninv);
}
}
_nmod_poly_mullow(u, p, len, t, len, len, mod);
f = n_mulmod2_preinv(f, f, mod.n, mod.ninv);
f = n_invmod(f, mod.n);
for (i = n; i >= 0; i--)
{
p[i] = n_mulmod2_preinv(u[n - i], f, mod.n, mod.ninv);
f = n_mulmod2_preinv(f, (i == 0) ? 1 : i, mod.n, mod.ninv);
}
_nmod_vec_clear(t);
_nmod_vec_clear(u);
}
void
_nmod_poly_atan_series(mp_ptr g, mp_srcptr h, long n, nmod_t mod)
{
mp_ptr t, u;
t = _nmod_vec_init(n);
u = _nmod_vec_init(n);
/* atan(h(x)) = integral(h'(x)/(1+h(x)^2)) */
_nmod_poly_mullow(u, h, n, h, n, n, mod); u[0] = 1UL;
_nmod_poly_derivative(t, h, n, mod); t[n-1] = 0UL;
_nmod_poly_div_series(g, t, u, n, mod);
_nmod_poly_integral(g, g, n, mod);
_nmod_vec_free(t);
_nmod_vec_free(u);
}
void
__nmod_poly_exp_series_prealloc(mp_ptr f, mp_ptr g, mp_srcptr h,
mp_srcptr hprime, mp_ptr T, mp_ptr U, long n, nmod_t mod, int extend)
{
long m, m2, l;
if (n < NMOD_NEWTON_EXP_CUTOFF)
{
_nmod_poly_exp_series_basecase(f, h, n, n, mod);
_nmod_poly_inv_series_basecase(g, f, extend ? n : (n + 1) / 2, mod);
return;
}
m = (n + 1) / 2;
m2 = (m + 1) / 2;
l = m - 1; /* shifted for derivative */
/* f := exp(h) + O(x^m), g := exp(-h) + O(x^m2) */
__nmod_poly_exp_series_prealloc(f, g, h, hprime, T, U, m, mod, 0);
/* g := exp(-h) + O(x^m) */
_nmod_poly_mullow(T, f, m, g, m2, m, mod);
_nmod_poly_mullow(g + m2, g, m2, T + m2, m - m2, m - m2, mod);
_nmod_vec_neg(g + m2, g + m2, m - m2, mod);
/* U := h' + g (f' - f h') + O(x^(n-1))
Note: should replace h' by h' mod x^(m-1) */
_nmod_vec_zero(f + m, n - m);
_nmod_poly_mullow(T, f, n, hprime, n, n, mod); /* should be mulmid */
_nmod_poly_derivative(U, f, n, mod); /* should skip low terms */
_nmod_vec_sub(U + l, U + l, T + l, n - l, mod);
_nmod_poly_mullow(T + l, g, n - m, U + l, n - m, n - m, mod);
_nmod_vec_add(U + l, hprime + l, T + l, n - m, mod);
/* f := f + f * (h - int U) + O(x^n) = exp(h) + O(x^n) */
_nmod_poly_integral(U, U, n, mod); /* should skip low terms */
_nmod_vec_sub(U + m, h + m, U + m, n - m, mod);
_nmod_poly_mullow(f + m, f, n - m, U + m, n - m, n - m, mod);
/* g := exp(-h) + O(x^n) */
if (extend)
{
_nmod_poly_mullow(T, f, n, g, m, n, mod);
_nmod_poly_mullow(g + m, g, m, T + m, n - m, n - m, mod);
_nmod_vec_neg(g + m, g + m, n - m, mod);
}
}
void
_nmod_poly_compose_series_horner(mp_ptr res, mp_srcptr poly1, long len1,
mp_srcptr poly2, long len2, long n, nmod_t mod)
{
if (n == 1)
{
res[0] = poly1[0];
}
else
{
long i = len1 - 1;
long lenr;
mp_ptr t = _nmod_vec_init(n);
lenr = len2;
_nmod_vec_scalar_mul_nmod(res, poly2, len2, poly1[i], mod);
i--;
res[0] = nmod_add(res[0], poly1[i], mod);
while (i > 0)
{
i--;
if (lenr + len2 - 1 < n)
{
_nmod_poly_mul(t, res, lenr, poly2, len2, mod);
lenr = lenr + len2 - 1;
}
else
{
_nmod_poly_mullow(t, res, lenr, poly2, len2, n, mod);
lenr = n;
}
_nmod_poly_add(res, t, lenr, poly1 + i, 1, mod);
}
_nmod_vec_zero(res + lenr, n - lenr);
_nmod_vec_clear(t);
}
}
void
_nmod_poly_divrem_divconquer_recursive(mp_ptr Q, mp_ptr BQ, mp_ptr W, mp_ptr V,
mp_srcptr A, mp_srcptr B, slong lenB, nmod_t mod)
{
if (lenB <= NMOD_DIVREM_DIVCONQUER_CUTOFF)
{
mp_ptr t = V;
mp_ptr w = t + 2*lenB - 1;
flint_mpn_copyi(t + lenB - 1, A + lenB - 1, lenB);
flint_mpn_zero(t, lenB - 1);
_nmod_poly_divrem_basecase(Q, BQ, w, t, 2 * lenB - 1, B, lenB, mod);
/* BQ = A - R */
_nmod_vec_neg(BQ, BQ, lenB - 1, mod);
}
else
{
const slong n2 = lenB / 2;
const slong n1 = lenB - n2;
mp_ptr W1 = W;
mp_ptr W2 = W + n2;
mp_srcptr p1 = A + 2 * n2;
mp_srcptr p2;
mp_srcptr d1 = B + n2;
mp_srcptr d2 = B;
mp_srcptr d3 = B + n1;
mp_srcptr d4 = B;
mp_ptr q1 = Q + n2;
mp_ptr q2 = Q;
mp_ptr dq1 = BQ + n2;
mp_ptr d1q1 = BQ + n2 - (n1 - 1);
mp_ptr d2q1, d3q2, d4q2, t;
/*
Set q1 to p1 div d1, a 2 n1 - 1 by n1 division so q1 ends up
being of length n1; low(d1q1) = d1 q1 is of length n1 - 1
*/
_nmod_poly_divrem_divconquer_recursive(q1, d1q1, W1, V, p1, d1, n1, mod);
/*
Compute bottom n1 + n2 - 1 coeffs of d2q1 = d2 q1
*/
d2q1 = W1;
_nmod_poly_mullow(d2q1, q1, n1, d2, n2, n1 + n2 - 1, mod);
/*
Compute dq1 = d1 q1 x^n2 + d2 q1, of length n1 + n2 - 1
Split it into a segment of length n1 - 1 at dq1 and a piece
of length n2 at BQ.
*/
flint_mpn_copyi(dq1, d2q1, n1 - 1);
if (n2 > n1 - 1)
BQ[0] = d2q1[n1 - 1];
_nmod_vec_add(d1q1, d1q1, d2q1 + n2, n1 - 1, mod);
/*
Compute t = A/x^n2 - dq1, which has length 2 n1 + n2 - 1, but we
are not interested in the top n1 coeffs as they will be zero, so
this has effective length n1 + n2 - 1
For the following division, we want to set {p2, 2 n2 - 1} to the
top 2 n2 - 1 coeffs of this
Since the bottom n2 - 1 coeffs of p2 are irrelevant for the
division, we in fact set {t, n2} to the relevant coeffs
*/
t = W1;
_nmod_vec_sub(t, A + n2 + (n1 - 1), BQ, n2, mod);
p2 = t - (n2 - 1);
/*
Compute q2 = t div d3, a 2 n2 - 1 by n2 division, so q2 will have
length n2; let low(d3q2) = d3 q2, of length n2 - 1
*/
d3q2 = BQ;
_nmod_poly_divrem_divconquer_recursive(q2, d3q2, W2, V, p2, d3, n2, mod);
/*
Compute d4q2 = d4 q2, of length n1 + n2 - 1
*/
d4q2 = W1;
_nmod_poly_mullow(d4q2, d4, n1, q2, n2, n1 + n2 - 1, mod);
/*
Compute dq2 = d3q2 x^n1 + d4q2, of length n1 + n2 - 1
*/
_nmod_vec_add(BQ + n1, BQ + n1, d3q2, n2 - 1, mod);
flint_mpn_copyi(BQ, d4q2, n2);
_nmod_vec_add(BQ + n2, BQ + n2, d4q2 + n2, n1 - 1, mod);
/*
Note Q = q1 x^n2 + q2, and BQ = dq1 x^n2 + dq2
*/
}
}
void
_nmod_poly_div_divconquer_recursive(mp_ptr Q, mp_ptr W, mp_ptr V,
mp_srcptr A, mp_srcptr B, long lenB, nmod_t mod)
{
if (lenB <= NMOD_DIV_DIVCONQUER_CUTOFF)
{
_nmod_poly_div_basecase(Q, V, A, 2 * lenB - 1, B, lenB, mod);
}
else
{
const long n2 = lenB / 2;
const long n1 = lenB - n2;
mp_ptr W1 = W;
mp_ptr W2 = W + n2;
mp_srcptr p1 = A + 2 * n2;
mp_srcptr p2;
mp_srcptr d1 = B + n2;
mp_srcptr d2 = B;
mp_srcptr d3 = B + n1;
mp_ptr q1 = Q + n2;
mp_ptr q2 = Q;
mp_ptr d1q1 = q2 + n2 - (n1 - 1);
mp_ptr d2q1, t;
/*
Set q1 to p1 div d1, a 2 n1 - 1 by n1 division so q1 ends up
being of length n1; low(d1q1) = d1 q1 is of length n1 - 1
*/
_nmod_poly_divrem_divconquer_recursive(q1, d1q1, W1, V, p1, d1, n1, mod);
/*
Compute bottom n1 + n2 - 1 coeffs of d2q1 = d2 q1
*/
d2q1 = W1;
_nmod_poly_mullow(d2q1, q1, n1, d2, n2, n1 + n2 - 1, mod);
/*
Compute dq1 = d1 q1 x^n2 + d2 q1, of length n1 + n2 - 1
Split it into a segment of length n1 - 1 at which is ignored
and a piece of length n2 at BQ.
*/
if (n2 > n1 - 1)
W1[0] = d2q1[n1 - 1];
_nmod_vec_add(W1 + n2 - (n1 - 1), d1q1, d2q1 + n2, n1 - 1, mod);
/*
Compute t = A/x^n2 - dq1, which has length 2 n1 + n2 - 1, but we
are not interested in the top n1 coeffs as they will be zero, so
this has effective length n1 + n2 - 1
For the following division, we want to set {p2, 2 n2 - 1} to the
top 2 n2 - 1 coeffs of this
Since the bottom n2 - 1 coeffs of p2 are irrelevant for the
division, we in fact set {t, n2} to the relevant coeffs
*/
t = W1;
_nmod_vec_sub(t, A + n2 + (n1 - 1), t, n2, mod);
p2 = t - (n2 - 1);
/*
Compute q2 = t div d3, a 2 n2 - 1 by n2 division, so q2 will have
length n2;
*/
_nmod_poly_div_divconquer_recursive(q2, W2, V, p2, d3, n2, mod);
/*
Note Q = q1 x^n2 + q2
*/
}
}
