void
_arb_poly_tan_series(arb_ptr g,
arb_srcptr h, slong hlen, slong len, slong prec)
{
hlen = FLINT_MIN(hlen, len);
if (hlen == 1)
{
arb_tan(g, h, prec);
_arb_vec_zero(g + 1, len - 1);
}
else if (len == 2)
{
arb_t t;
arb_init(t);
arb_tan(g, h, prec);
arb_mul(t, g, g, prec);
arb_add_ui(t, t, 1, prec);
arb_mul(g + 1, t, h + 1, prec); /* safe since hlen >= 2 */
arb_clear(t);
}
else
{
arb_ptr t, u;
t = _arb_vec_init(2 * len);
u = t + len;
NEWTON_INIT(TAN_NEWTON_CUTOFF, len)
NEWTON_BASECASE(n)
_arb_poly_sin_cos_series_basecase(t, u, h, hlen, n, prec, 0);
_arb_poly_div_series(g, t, n, u, n, n, prec);
NEWTON_END_BASECASE
NEWTON_LOOP(m, n)
_arb_poly_mullow(u, g, m, g, m, n, prec);
arb_add_ui(u, u, 1, prec);
_arb_poly_atan_series(t, g, m, n, prec);
_arb_poly_sub(t + m, h + m, FLINT_MAX(0, hlen - m), t + m, n - m, prec);
_arb_poly_mullow(g + m, u, n, t + m, n - m, n - m, prec);
NEWTON_END_LOOP
NEWTON_END
_arb_vec_clear(t, 2 * len);
}
}
/* with inverse=1 simultaneously computes g = exp(-x) to length n
with inverse=0 uses g as scratch space, computing
g = exp(-x) only to length (n+1)/2 */
static void
_arb_poly_exp_series_newton(arb_ptr f, arb_ptr g,
arb_srcptr h, slong len, slong prec, int inverse, slong cutoff)
{
slong alloc;
arb_ptr T, U, hprime;
alloc = 3 * len;
T = _arb_vec_init(alloc);
U = T + len;
hprime = U + len;
_arb_poly_derivative(hprime, h, len, prec);
arb_zero(hprime + len - 1);
NEWTON_INIT(cutoff, len)
/* f := exp(h) + O(x^m), g := exp(-h) + O(x^m2) */
NEWTON_BASECASE(n)
_arb_poly_exp_series_basecase(f, h, n, n, prec);
_arb_poly_inv_series(g, f, (n + 1) / 2, (n + 1) / 2, prec);
NEWTON_END_BASECASE
/* extend from length m to length n */
NEWTON_LOOP(m, n)
slong m2 = (m + 1) / 2;
slong l = m - 1; /* shifted for derivative */
/* g := exp(-h) + O(x^m) */
_arb_poly_mullow(T, f, m, g, m2, m, prec);
_arb_poly_mullow(g + m2, g, m2, T + m2, m - m2, m - m2, prec);
_arb_vec_neg(g + m2, g + m2, m - m2);
/* U := h' + g (f' - f h') + O(x^(n-1))
Note: should replace h' by h' mod x^(m-1) */
_arb_vec_zero(f + m, n - m);
_arb_poly_mullow(T, f, n, hprime, n, n, prec); /* should be mulmid */
_arb_poly_derivative(U, f, n, prec);
arb_zero(U + n - 1); /* should skip low terms */
_arb_vec_sub(U + l, U + l, T + l, n - l, prec);
_arb_poly_mullow(T + l, g, n - m, U + l, n - m, n - m, prec);
_arb_vec_add(U + l, hprime + l, T + l, n - m, prec);
/* f := f + f * (h - int U) + O(x^n) = exp(h) + O(x^n) */
_arb_poly_integral(U, U, n, prec); /* should skip low terms */
_arb_vec_sub(U + m, h + m, U + m, n - m, prec);
_arb_poly_mullow(f + m, f, n - m, U + m, n - m, n - m, prec);
/* g := exp(-h) + O(x^n) */
/* not needed if we only want exp(x) */
if (n == len && inverse)
{
_arb_poly_mullow(T, f, n, g, m, n, prec);
_arb_poly_mullow(g + m, g, m, T + m, n - m, n - m, prec);
_arb_vec_neg(g + m, g + m, n - m);
}
NEWTON_END_LOOP
NEWTON_END
_arb_vec_clear(T, alloc);
}
