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_tanh_series(mp_ptr f, mp_srcptr h, long n, nmod_t mod) { mp_ptr t, u; t = _nmod_vec_init(n); u = _nmod_vec_init(n); _nmod_vec_add(t, h, h, n, mod); _nmod_poly_exp_series(u, t, n, mod); _nmod_vec_set(t, u, n); t[0] = 0UL; u[0] = 2UL; _nmod_poly_div_series(f, t, u, n, mod); _nmod_vec_free(t); _nmod_vec_free(u); }
void _nmod_poly_cosh_series(mp_ptr f, mp_srcptr h, long n, nmod_t mod) { mp_ptr g, T, U, hprime; g = _nmod_vec_init(n); T = _nmod_vec_init(n); U = _nmod_vec_init(n); hprime = _nmod_vec_init(n); _nmod_poly_derivative(hprime, h, n, mod); hprime[n-1] = 0UL; __nmod_poly_exp_series_prealloc(f, g, h, hprime, T, U, n, mod, 1); _nmod_vec_add(f, f, g, n, mod); _nmod_vec_scalar_mul_nmod(f, f, n, n_invmod(2UL, mod.n), mod); _nmod_vec_free(hprime); _nmod_vec_free(g); _nmod_vec_free(T); _nmod_vec_free(U); }
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 */ } }
void _nmod_poly_compose_divconquer(mp_ptr res, mp_srcptr poly1, long len1, mp_srcptr poly2, long len2, nmod_t mod) { long i, j, k, n; long * hlen, alloc, powlen; mp_ptr v, * h, pow, temp; if (len1 == 1) { res[0] = poly1[0]; return; } if (len2 == 1) { res[0] = _nmod_poly_evaluate_nmod(poly1, len1, poly2[0], mod); return; } if (len1 == 2) { _nmod_poly_compose_horner(res, poly1, len1, poly2, len2, mod); return; } /* Initialisation */ hlen = (long *) flint_malloc(((len1 + 1) / 2) * sizeof(long)); for (k = 1; (2 << k) < len1; k++) ; hlen[0] = hlen[1] = ((1 << k) - 1) * (len2 - 1) + 1; for (i = k - 1; i > 0; i--) { long hi = (len1 + (1 << i) - 1) / (1 << i); for (n = (hi + 1) / 2; n < hi; n++) hlen[n] = ((1 << i) - 1) * (len2 - 1) + 1; } powlen = (1 << k) * (len2 - 1) + 1; alloc = 0; for (i = 0; i < (len1 + 1) / 2; i++) alloc += hlen[i]; v = _nmod_vec_init(alloc + 2 * powlen); h = (mp_ptr *) flint_malloc(((len1 + 1) / 2) * sizeof(mp_ptr)); h[0] = v; for (i = 0; i < (len1 - 1) / 2; i++) { h[i + 1] = h[i] + hlen[i]; hlen[i] = 0; } hlen[(len1 - 1) / 2] = 0; pow = v + alloc; temp = pow + powlen; /* Let's start the actual work */ for (i = 0, j = 0; i < len1 / 2; i++, j += 2) { if (poly1[j + 1] != 0L) { _nmod_vec_scalar_mul_nmod(h[i], poly2, len2, poly1[j + 1], mod); h[i][0] = n_addmod(h[i][0], poly1[j], mod.n); hlen[i] = len2; } else if (poly1[j] != 0L) { h[i][0] = poly1[j]; hlen[i] = 1; } } if ((len1 & 1L)) { if (poly1[j] != 0L) { h[i][0] = poly1[j]; hlen[i] = 1; } } _nmod_poly_mul(pow, poly2, len2, poly2, len2, mod); powlen = 2 * len2 - 1; for (n = (len1 + 1) / 2; n > 2; n = (n + 1) / 2) { if (hlen[1] > 0) { long templen = powlen + hlen[1] - 1; _nmod_poly_mul(temp, pow, powlen, h[1], hlen[1], mod); _nmod_poly_add(h[0], temp, templen, h[0], hlen[0], mod); hlen[0] = FLINT_MAX(hlen[0], templen); } for (i = 1; i < n / 2; i++) { if (hlen[2*i + 1] > 0) { _nmod_poly_mul(h[i], pow, powlen, h[2*i + 1], hlen[2*i + 1], mod); hlen[i] = hlen[2*i + 1] + powlen - 1; } else hlen[i] = 0; _nmod_poly_add(h[i], h[i], hlen[i], h[2*i], hlen[2*i], mod); hlen[i] = FLINT_MAX(hlen[i], hlen[2*i]); } if ((n & 1L)) { mpn_copyi(h[i], h[2*i], hlen[2*i]); hlen[i] = hlen[2*i]; } _nmod_poly_mul(temp, pow, powlen, pow, powlen, mod); powlen += powlen - 1; { mp_ptr t = pow; pow = temp; temp = t; } } _nmod_poly_mul(res, pow, powlen, h[1], hlen[1], mod); _nmod_vec_add(res, res, h[0], hlen[0], mod); _nmod_vec_clear(v); flint_free(h); flint_free(hlen); }