void
_arb_poly_log1p_series(arb_ptr res, arb_srcptr f, slong flen, slong n, slong prec)
{
arb_t a;
flen = FLINT_MIN(flen, n);
arb_init(a);
arb_log1p(a, f, prec);
if (flen == 1)
{
_arb_vec_zero(res + 1, n - 1);
}
else if (n == 2)
{
arb_add_ui(res, f + 0, 1, prec);
arb_div(res + 1, f + 1, res + 0, prec);
}
else if (_arb_vec_is_zero(f + 1, flen - 2)) /* f = a + bx^d */
{
slong i, j, d = flen - 1;
arb_add_ui(res, f + 0, 1, prec);
for (i = 1, j = d; j < n; j += d, i++)
{
if (i == 1)
arb_div(res + j, f + d, res, prec);
else
arb_mul(res + j, res + j - d, res + d, prec);
_arb_vec_zero(res + j - d + 1, flen - 2);
}
_arb_vec_zero(res + j - d + 1, n - (j - d + 1));
for (i = 2, j = 2 * d; j < n; j += d, i++)
arb_div_si(res + j, res + j, i % 2 ? i : -i, prec);
}
else
{
arb_ptr f_diff, f_inv;
slong alloc;
alloc = n + flen;
f_inv = _arb_vec_init(alloc);
f_diff = f_inv + n;
arb_add_ui(f_diff, f, 1, prec);
_arb_vec_set(f_diff + 1, f + 1, flen - 1);
_arb_poly_inv_series(f_inv, f_diff, flen, n, prec);
_arb_poly_derivative(f_diff, f, flen, prec);
_arb_poly_mullow(res, f_inv, n - 1, f_diff, flen - 1, n - 1, prec);
_arb_poly_integral(res, res, n, prec);
_arb_vec_clear(f_inv, alloc);
}
arb_swap(res, a);
arb_clear(a);
}
void
_arb_poly_asin_series(arb_ptr g, arb_srcptr h, slong hlen, slong n, slong prec)
{
arb_t c;
arb_init(c);
arb_asin(c, h, prec);
hlen = FLINT_MIN(hlen, n);
if (hlen == 1)
{
_arb_vec_zero(g + 1, n - 1);
}
else
{
arb_ptr t, u;
slong ulen;
t = _arb_vec_init(n);
u = _arb_vec_init(n);
/* asin(h(x)) = integral(h'(x)/sqrt(1-h(x)^2)) */
ulen = FLINT_MIN(n, 2 * hlen - 1);
_arb_poly_mullow(u, h, hlen, h, hlen, ulen, prec);
arb_sub_ui(u, u, 1, prec);
_arb_vec_neg(u, u, ulen);
_arb_poly_rsqrt_series(t, u, ulen, n, prec);
_arb_poly_derivative(u, h, hlen, prec);
_arb_poly_mullow(g, t, n, u, hlen - 1, n, prec);
_arb_poly_integral(g, g, n, prec);
_arb_vec_clear(t, n);
_arb_vec_clear(u, n);
}
arb_swap(g, c);
arb_clear(c);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("rising2_ui....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
arb_t a, u, v, u2, v2;
fmpz *f;
arb_ptr g;
ulong n;
slong i, prec;
arb_init(a);
arb_init(u);
arb_init(v);
arb_init(u2);
arb_init(v2);
arb_randtest(a, state, 1 + n_randint(state, 4000), 10);
arb_randtest(u, state, 1 + n_randint(state, 4000), 10);
arb_randtest(v, state, 1 + n_randint(state, 4000), 10);
n = n_randint(state, 120);
f = _fmpz_vec_init(n + 1);
g = _arb_vec_init(n + 1);
prec = 2 + n_randint(state, 4000);
arb_rising2_ui(u, v, a, n, prec);
arith_stirling_number_1u_vec(f, n, n + 1);
for (i = 0; i <= n; i++)
arb_set_fmpz(g + i, f + i);
_arb_poly_evaluate(u2, g, n + 1, a, prec);
_arb_poly_derivative(g, g, n + 1, prec);
_arb_poly_evaluate(v2, g, n, a, prec);
if (!arb_overlaps(u, u2) || !arb_overlaps(v, v2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("n = %wu\n", n);
flint_printf("a = "); arb_printd(a, 15); flint_printf("\n\n");
flint_printf("u = "); arb_printd(u, 15); flint_printf("\n\n");
flint_printf("u2 = "); arb_printd(u2, 15); flint_printf("\n\n");
flint_printf("v = "); arb_printd(v, 15); flint_printf("\n\n");
flint_printf("v2 = "); arb_printd(v2, 15); flint_printf("\n\n");
abort();
}
arb_set(u2, a);
arb_rising2_ui(u2, v, u2, n, prec);
if (!arb_equal(u2, u))
{
flint_printf("FAIL: aliasing 1\n\n");
flint_printf("a = "); arb_printd(a, 15); flint_printf("\n\n");
flint_printf("u = "); arb_printd(u, 15); flint_printf("\n\n");
flint_printf("u2 = "); arb_printd(u2, 15); flint_printf("\n\n");
flint_printf("n = %wu\n", n);
abort();
}
arb_set(v2, a);
arb_rising2_ui(u, v2, v2, n, prec);
if (!arb_equal(v2, v))
{
flint_printf("FAIL: aliasing 2\n\n");
flint_printf("a = "); arb_printd(a, 15); flint_printf("\n\n");
flint_printf("v = "); arb_printd(v, 15); flint_printf("\n\n");
flint_printf("v2 = "); arb_printd(v2, 15); flint_printf("\n\n");
flint_printf("n = %wu\n", n);
abort();
}
arb_clear(a);
arb_clear(u);
arb_clear(v);
arb_clear(u2);
arb_clear(v2);
_fmpz_vec_clear(f, n + 1);
_arb_vec_clear(g, n + 1);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
/* 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);
}
