void arb_rising_fmpq_ui(arb_t y, const fmpq_t x, ulong n, long prec) { if (n == 0) { arb_one(y); } else if (n == 1) { arb_set_fmpq(y, x, prec); } else { long wp; wp = ARF_PREC_ADD(prec, FLINT_BIT_COUNT(n)); bsplit(y, fmpq_numref(x), fmpq_denref(x), 0, n, wp); if (fmpz_is_one(fmpq_denref(x))) { arb_set_round(y, y, prec); } else { arb_t t; arb_init(t); arb_set_fmpz(t, fmpq_denref(x)); arb_pow_ui(t, t, n, wp); arb_div(y, y, t, prec); arb_clear(t); } } }
void custom_rate_mixture_get_prob(arb_t prob, const custom_rate_mixture_t x, slong idx, slong prec) { if (x->mode == RATE_MIXTURE_UNDEFINED) { flint_fprintf(stderr, "internal error: undefined rate mixture\n"); abort(); } else if (x->mode == RATE_MIXTURE_NONE) { arb_one(prob); } else if (x->mode == RATE_MIXTURE_UNIFORM) { /* * This code branch involves a division that could * unnecessarily lose exactness in some situations. */ arb_set_si(prob, x->n); arb_inv(prob, prob, prec); } else if (x->mode == RATE_MIXTURE_CUSTOM) { arb_set_d(prob, x->prior[idx]); } else { flint_fprintf(stderr, "internal error: " "unrecognized rate mixture mode\n"); abort(); } }
int f_pol(arb_t max, const arb_t t, params_t * p, slong prec) { slong k; acb_t z; arb_t tmp; acb_init(z); arb_init(tmp); arb_one(max); for (k = 0; k < p->len; k++) { acb_sub_arb(z, p->z + k, t, prec); acb_abs(tmp, z, prec); if (arb_contains_zero(tmp)) return 0; arb_mul(max, max, tmp, prec); } arb_inv(max, max, prec); arb_clear(tmp); acb_clear(z); return 1; }
void arb_pow(arb_t z, const arb_t x, const arb_t y, slong prec) { if (arb_is_zero(y)) { arb_one(z); return; } if (arb_is_zero(x)) { if (arb_is_positive(y)) arb_zero(z); else arb_indeterminate(z); return; } if (arb_is_exact(y) && !arf_is_special(arb_midref(x))) { const arf_struct * ymid = arb_midref(y); /* small half-integer or integer */ if (arf_cmpabs_2exp_si(ymid, BINEXP_LIMIT) < 0 && arf_is_int_2exp_si(ymid, -1)) { fmpz_t e; fmpz_init(e); if (arf_is_int(ymid)) { arf_get_fmpz_fixed_si(e, ymid, 0); arb_pow_fmpz_binexp(z, x, e, prec); } else { arf_get_fmpz_fixed_si(e, ymid, -1); arb_sqrt(z, x, prec + fmpz_bits(e)); arb_pow_fmpz_binexp(z, z, e, prec); } fmpz_clear(e); return; } else if (arf_is_int(ymid) && arf_sgn(arb_midref(x)) < 0) { /* use (-x)^n = (-1)^n * x^n to avoid NaNs at least at high enough precision */ int odd = !arf_is_int_2exp_si(ymid, 1); _arb_pow_exp(z, x, 1, y, prec); if (odd) arb_neg(z, z); return; } } _arb_pow_exp(z, x, 0, y, prec); }
void acb_dirichlet_vec_mellin_arb(acb_ptr res, const dirichlet_group_t G, const dirichlet_char_t chi, slong len, const arb_t t, slong n, slong prec) { slong k; arb_t tk, xt, stk, st; acb_ptr a; mag_t e; a = _acb_vec_init(len); acb_dirichlet_chi_vec(a, G, chi, len, prec); if (dirichlet_parity_char(G, chi)) { for (k = 2; k < len; k++) acb_mul_si(a + k, a + k, k, prec); } arb_init(tk); arb_init(xt); arb_init(st); arb_init(stk); mag_init(e); arb_sqrt(st, t, prec); arb_one(tk); arb_one(stk); for (k = 0; k < n; k++) { _acb_dirichlet_theta_argument_at_arb(xt, G->q, tk, prec); mag_tail_kexpk2_arb(e, xt, len); arb_neg(xt, xt); arb_exp(xt, xt, prec); /* TODO: reduce len */ acb_dirichlet_qseries_arb(res + k, a, xt, len, prec); acb_add_error_mag(res + k, e); acb_mul_arb(res + k, res + k, stk, prec); arb_mul(tk, tk, t, prec); arb_mul(stk, stk, st, prec); } mag_clear(e); arb_clear(xt); arb_clear(tk); arb_clear(stk); arb_clear(st); _acb_vec_clear(a, len); }
static void bound_K(arb_t C, const arb_t AN, const arb_t B, const arb_t T, slong wp) { if (arb_is_zero(B) || arb_is_zero(T)) { arb_one(C); } else { arb_div(C, B, AN, wp); /* TODO: atan is dumb, should also bound by pi/2 */ arb_atan(C, C, wp); arb_mul(C, C, T, wp); if (arb_is_nonpositive(C)) arb_one(C); else arb_exp(C, C, wp); } }
void arb_div_2expm1_ui(arb_t y, const arb_t x, ulong n, long prec) { if (n < FLINT_BITS) { arb_div_ui(y, x, (1UL << n) - 1, prec); } else if (n < 1024 + prec / 32 || n > LONG_MAX / 4) { arb_t t; fmpz_t e; arb_init(t); fmpz_init_set_ui(e, n); arb_one(t); arb_mul_2exp_fmpz(t, t, e); arb_sub_ui(t, t, 1, prec); arb_div(y, x, t, prec); arb_clear(t); fmpz_clear(e); } else { arb_t s, t; long i, b; arb_init(s); arb_init(t); /* x / (2^n - 1) = sum_{k>=1} x * 2^(-k*n)*/ arb_mul_2exp_si(s, x, -n); arb_set(t, s); b = 1; for (i = 2; i <= prec / n + 1; i++) { arb_mul_2exp_si(t, t, -n); arb_add(s, s, t, prec); b = i; } /* error bound: sum_{k>b} x * 2^(-k*n) <= x * 2^(-b*n - (n-1)) */ arb_mul_2exp_si(t, x, -b*n - (n-1)); arb_abs(t, t); arb_add_error(s, t); arb_set(y, s); arb_clear(s); arb_clear(t); } }
void arb_mat_ones(arb_mat_t mat) { slong R, C, i, j; R = arb_mat_nrows(mat); C = arb_mat_ncols(mat); for (i = 0; i < R; i++) for (j = 0; j < C; j++) arb_one(arb_mat_entry(mat, i, j)); }
void scaled_bessel_select_N(arb_t N, ulong k, slong prec) { slong e; double f = log(k/3.14159265358979)/log(2); e = 1; while ((k / 2.0) * (e - f) - e < prec + 5) e++; arb_one(N); arb_mul_2exp_si(N, N, e); }
void arb_sinc(arb_t z, const arb_t x, slong prec) { mag_t c, r; mag_init(c); mag_init(r); mag_set_ui_2exp_si(c, 5, -1); arb_get_mag_lower(r, x); if (mag_cmp(c, r) < 0) { /* x is not near the origin */ _arb_sinc_direct(z, x, prec); } else if (mag_cmp_2exp_si(arb_radref(x), 1) < 0) { /* determine error magnitude using the derivative bound */ if (arb_is_exact(x)) { mag_zero(c); } else { _arb_sinc_derivative_bound(r, x); mag_mul(c, arb_radref(x), r); } /* evaluate sinc at the midpoint of x */ if (arf_is_zero(arb_midref(x))) { arb_one(z); } else { arb_get_mid_arb(z, x); _arb_sinc_direct(z, z, prec); } /* add the error */ mag_add(arb_radref(z), arb_radref(z), c); } else { /* x has a large radius and includes points near the origin */ arf_zero(arb_midref(z)); mag_one(arb_radref(z)); } mag_clear(c); mag_clear(r); }
int sin_x(arb_ptr out, const arb_t inp, void * params, long order, long prec) { int xlen = FLINT_MIN(2, order); arb_set(out, inp); if (xlen > 1) arb_one(out + 1); _arb_poly_sin_series(out, out, xlen, order, prec); eval_count++; return 0; }
static void bound_I(arb_ptr I, const arb_t A, const arb_t B, const arb_t C, slong len, slong wp) { slong k; arb_t D, Dk, L, T, Bm1; arb_init(D); arb_init(Dk); arb_init(Bm1); arb_init(T); arb_init(L); arb_sub_ui(Bm1, B, 1, wp); arb_one(L); /* T = 1 / (A^Bm1 * Bm1) */ arb_inv(T, A, wp); arb_pow(T, T, Bm1, wp); arb_div(T, T, Bm1, wp); if (len > 1) { arb_log(D, A, wp); arb_add(D, D, C, wp); arb_mul(D, D, Bm1, wp); arb_set(Dk, D); } for (k = 0; k < len; k++) { if (k > 0) { arb_mul_ui(L, L, k, wp); arb_add(L, L, Dk, wp); arb_mul(Dk, Dk, D, wp); } arb_mul(I + k, L, T, wp); arb_div(T, T, Bm1, wp); } arb_clear(D); arb_clear(Dk); arb_clear(Bm1); arb_clear(T); arb_clear(L); }
void custom_rate_mixture_expectation(arb_t rate, const custom_rate_mixture_t x, slong prec) { if (x->mode == RATE_MIXTURE_UNDEFINED) { flint_fprintf(stderr, "internal error: undefined rate mixture\n"); abort(); } else if (x->mode == RATE_MIXTURE_NONE) { arb_one(rate); } else if (x->mode == RATE_MIXTURE_UNIFORM || x->mode == RATE_MIXTURE_CUSTOM) { slong i; arb_t tmp, tmpb; arb_init(tmp); arb_init(tmpb); arb_zero(rate); if (x->mode == RATE_MIXTURE_UNIFORM) { for (i = 0; i < x->n; i++) { arb_set_d(tmp, x->rates[i]); arb_add(rate, rate, tmp, prec); } arb_div_si(rate, rate, x->n, prec); } else if (x->mode == RATE_MIXTURE_CUSTOM) { for (i = 0; i < x->n; i++) { arb_set_d(tmp, x->rates[i]); arb_set_d(tmpb, x->prior[i]); arb_addmul(rate, tmp, tmpb, prec); } } arb_clear(tmp); arb_clear(tmpb); } else { flint_fprintf(stderr, "internal error: " "unrecognized rate mixture mode\n"); abort(); } }
static void _stirling_number_2_vec_next(arb_ptr row, arb_srcptr prev, slong n, slong klen, slong prec) { slong k; if (klen > n) arb_one(row + n); if (n != 0 && klen != 0) arb_zero(row); for (k = FLINT_MIN(n, klen) - 1; k >= 1; k--) { arb_mul_ui(row + k, prev + k, k, prec); arb_add(row + k, prev + k - 1, row + k, prec); } for (k = n + 1; k < klen; k++) arb_zero(row + k); }
static __inline__ void _log_rising_ui_series(arb_ptr t, const arb_t x, slong r, slong len, slong prec) { arb_struct f[2]; slong rflen; arb_init(f); arb_init(f + 1); arb_set(f, x); arb_one(f + 1); rflen = FLINT_MIN(len, r + 1); _arb_poly_rising_ui_series(t, f, FLINT_MIN(2, len), r, rflen, prec); _arb_poly_log_series(t, t, rflen, len, prec); arb_clear(f); arb_clear(f + 1); }
int f_aj(arb_t m, const arb_t t, params_t * p, slong prec) { slong k; acb_t z, zu; arb_t abs; arb_init(abs); acb_init(z); acb_init(zu); arb_const_pi(abs, prec); arb_mul_2exp_si(abs, abs, -2); /* Pi/4 */ arb_set(acb_realref(z), t); arb_set(acb_imagref(z), abs); acb_sinh(z, z, prec); arb_mul_2exp_si(abs, abs, 1); /* Pi/2 */ acb_mul_arb(z, z, abs, prec); acb_tanh(z, z, prec); arb_one(m); for (k = 0; k < p->len; k++) { acb_sub(zu, z, p->z + k, prec); if (acb_contains_zero(zu)) { arb_clear(abs); acb_clear(zu); acb_clear(z); return 0; } acb_abs(abs, zu, prec); arb_mul(m, m, abs, prec); } arb_inv(m, m, prec); arb_clear(abs); acb_clear(zu); acb_clear(z); return 1; }
/* invalid in (-1,0) */ int _acb_hypgeom_legendre_q_single_valid(const acb_t z) { arb_t t; int ok; if (!arb_contains_zero(acb_imagref(z))) return 1; if (arb_is_positive(acb_imagref(z))) return 1; arb_init(t); arb_one(t); arb_neg(t, t); ok = arb_lt(acb_realref(z), t); arb_clear(t); return ok; }
int z_function(arb_ptr out, const arb_t inp, void * params, long order, long prec) { arb_struct x[2]; arb_init(x); arb_init(x + 1); arb_set(x, inp); arb_one(x + 1); _arb_poly_riemann_siegel_z_series(out, x, FLINT_MIN(2, order), order, prec); arb_clear(x); arb_clear(x + 1); eval_count++; return 0; }
/* sin((pi/2)x) */ static int sin_pi2_x(arb_ptr out, const arb_t inp, void * params, slong order, slong prec) { arb_ptr x; x = _arb_vec_init(2); arb_set(x, inp); arb_one(x + 1); arb_const_pi(out, prec); arb_mul_2exp_si(out, out, -1); _arb_vec_scalar_mul(x, x, 2, out, prec); _arb_poly_sin_series(out, x, order, order, prec); _arb_vec_clear(x, 2); return 0; }
int sin_1x(arb_ptr out, const arb_t inp, void * params, long order, long prec) { arb_ptr x; int xlen = FLINT_MIN(2, order); x = _arb_vec_init(xlen); arb_set(x, inp); if (xlen > 1) arb_one(x + 1); _arb_poly_inv_series(out, x, xlen, order, prec); _arb_poly_sin_series(out, out, order, order, prec); _arb_vec_clear(x, xlen); eval_count++; return 0; }
void _arb_poly_inv_borel_transform(arb_ptr res, arb_srcptr poly, slong len, slong prec) { slong i; arb_t t; arb_init(t); arb_one(t); for (i = 0; i < len; i++) { if (i > 1) arb_mul_ui(t, t, i, prec); arb_mul(res + i, poly + i, t, prec); } arb_clear(t); }
void arb_hypgeom_sum(arb_t P, arb_t Q, const hypgeom_t hyp, long n, long prec) { if (n < 1) { arb_zero(P); arb_one(Q); } else { arb_t B, T; arb_init(B); arb_init(T); bsplit_recursive_arb(P, Q, B, T, hyp, 0, n, 0, prec); if (!arb_is_one(B)) arb_mul(Q, Q, B, prec); arb_swap(P, T); arb_clear(B); arb_clear(T); } }
static void bound_rfac(arb_ptr F, const acb_t s, ulong n, slong len, slong wp) { if (len == 1) { acb_rising_ui_get_mag(arb_radref(F), s, n); arf_set_mag(arb_midref(F), arb_radref(F)); mag_zero(arb_radref(F + 0)); } else { arb_struct sx[2]; arb_init(sx + 0); arb_init(sx + 1); acb_abs(sx + 0, s, wp); arb_one(sx + 1); _arb_vec_zero(F, len); _arb_poly_rising_ui_series(F, sx, 2, n, len, wp); arb_clear(sx + 0); arb_clear(sx + 1); } }
void acb_acosh(acb_t res, const acb_t z, slong prec) { if (acb_is_one(z)) { acb_zero(res); } else { acb_t t, u; acb_init(t); acb_init(u); acb_add_ui(t, z, 1, prec); acb_sub_ui(u, z, 1, prec); acb_sqrt(t, t, prec); acb_sqrt(u, u, prec); acb_mul(t, t, u, prec); acb_add(t, t, z, prec); if (!arb_is_zero(acb_imagref(z))) { acb_log(res, t, prec); } else { /* pure imaginary on (-1,1) */ arb_abs(acb_realref(u), acb_realref(z)); arb_one(acb_imagref(u)); acb_log(res, t, prec); if (arb_lt(acb_realref(u), acb_imagref(u))) arb_zero(acb_realref(res)); } acb_clear(t); acb_clear(u); } }
void custom_rate_mixture_get_rate(arb_t rate, const custom_rate_mixture_t x, slong idx) { if (x->mode == RATE_MIXTURE_UNDEFINED) { flint_fprintf(stderr, "internal error: undefined rate mixture\n"); abort(); } else if (x->mode == RATE_MIXTURE_NONE) { arb_one(rate); } else if (x->mode == RATE_MIXTURE_UNIFORM || x->mode == RATE_MIXTURE_CUSTOM) { arb_set_d(rate, x->rates[idx]); } else { flint_fprintf(stderr, "internal error: " "unrecognized rate mixture mode\n"); abort(); } }
/* TODO: BSGS can reduce to nv mul */ void acb_dirichlet_arb_quadratic_powers(arb_ptr v, slong nv, const arb_t x, slong prec) { slong i; arb_t dx, x2; arb_init(dx); arb_init(x2); arb_set(dx, x); arb_mul(x2, x, x, prec); for (i = 0; i < nv; i++) { if (i == 0) arb_one(v + i); else if (i == 1) arb_set_round(v + i, x, prec); else { arb_mul(dx, dx, x2, prec); arb_mul(v + i, v + i - 1, dx, prec); } } arb_clear(dx); arb_clear(x2); }
static __inline__ void zeta_coeff_k(zeta_bsplit_t S, slong k, slong n, slong s) { arb_set_si(S->D, 2 * (n + k)); arb_mul_si(S->D, S->D, n - k, ARF_PREC_EXACT); arb_set_si(S->Q1, k + 1); arb_mul_si(S->Q1, S->Q1, 2*k + 1, ARF_PREC_EXACT); if (k == 0) { arb_zero(S->A); arb_one(S->Q2); } else { arb_set_si(S->A, k % 2 ? 1 : -1); arb_mul(S->A, S->A, S->Q1, ARF_PREC_EXACT); arb_ui_pow_ui(S->Q2, k, s, ARF_PREC_EXACT); } arb_mul(S->Q3, S->Q1, S->Q2, ARF_PREC_EXACT); arb_zero(S->B); arb_set(S->C, S->Q1); }
int main() { long iter; flint_rand_t state; printf("div_2expm1_ui...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { arb_t a, b, c; ulong n; long prec, acc1, acc2; fmpz_t t; arb_init(a); arb_init(b); arb_init(c); fmpz_init(t); prec = 2 + n_randint(state, 10000); arb_randtest(a, state, 1 + n_randint(state, 10000), 10); if (n_randint(state, 2)) n = 1 + (n_randtest(state) % (10 * prec)); else n = n_randtest(state); arb_div_2expm1_ui(b, a, n, prec); arb_one(c); if (n >= (1UL << (FLINT_BITS-1))) { arb_mul_2exp_si(c, c, (1UL << (FLINT_BITS-2))); arb_mul_2exp_si(c, c, (1UL << (FLINT_BITS-2))); arb_mul_2exp_si(c, c, n - (1UL << (FLINT_BITS-1))); } else { arb_mul_2exp_si(c, c, n); } arb_sub_ui(c, c, 1, prec); arb_div(c, a, c, prec); acc1 = arb_rel_accuracy_bits(a); acc2 = arb_rel_accuracy_bits(b); if (!arb_overlaps(b, c)) { printf("FAIL: containment\n\n"); printf("n = %lu\n", n); printf("a = "); arb_print(a); printf("\n\n"); printf("b = "); arb_print(b); printf("\n\n"); printf("c = "); arb_print(c); printf("\n\n"); abort(); } if (n > 0 && (acc2 < FLINT_MIN(prec, acc1) - 10) && !(acc1 == -ARF_PREC_EXACT && acc2 == -ARF_PREC_EXACT)) { printf("FAIL: poor accuracy\n\n"); printf("prec=%ld, acc1=%ld, acc2=%ld\n\n", prec, acc1, acc2); printf("n = %lu\n\n", n); printf("a = "); arb_print(a); printf("\n\n"); printf("b = "); arb_print(b); printf("\n\n"); printf("c = "); arb_print(c); printf("\n\n"); abort(); } arb_clear(a); arb_clear(b); arb_clear(c); fmpz_clear(t); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("zeta_series...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 500; iter++) { long m, n1, n2, bits1, bits2, bits3; int deflate; arb_poly_t S, A, B, C, D, E, F; arb_t a, a1; bits1 = 2 + n_randint(state, 300); bits2 = 2 + n_randint(state, 300); bits3 = 2 + n_randint(state, 300); m = 1 + n_randint(state, 30); n1 = 1 + n_randint(state, 30); n2 = 1 + n_randint(state, 30); arb_poly_init(S); arb_poly_init(A); arb_poly_init(B); arb_poly_init(C); arb_poly_init(D); arb_poly_init(E); arb_poly_init(F); arb_init(a); arb_init(a1); deflate = n_randint(state, 2); arb_poly_randtest(S, state, m, bits1, 3); arb_randtest_precise(a, state, bits1, 3); arb_poly_set_coeff_arb(S, 0, a); if (n_randint(state, 2)) arb_randtest(a, state, bits1, 3); else arb_one(a); arb_poly_zeta_series(A, S, a, deflate, n1, bits2); arb_poly_zeta_series(B, S, a, deflate, n2, bits3); arb_poly_set(C, A); arb_poly_truncate(C, FLINT_MIN(n1, n2)); arb_poly_truncate(B, FLINT_MIN(n1, n2)); if (!arb_poly_overlaps(B, C)) { printf("FAIL\n\n"); printf("S = "); arb_poly_printd(S, 15); printf("\n\n"); printf("a = "); arb_printd(a, 15); printf("\n\n"); printf("A = "); arb_poly_printd(A, 15); printf("\n\n"); printf("B = "); arb_poly_printd(B, 15); printf("\n\n"); abort(); } /* check zeta(s,a) = zeta(s,a+1) + a^(-s) */ arb_poly_set_arb(D, a); arb_poly_log_series(D, D, n1, bits2); arb_poly_mullow(D, D, S, n1, bits2); arb_poly_neg(D, D); arb_poly_exp_series(D, D, n1, bits2); arb_add_ui(a1, a, 1, bits2); arb_poly_zeta_series(E, S, a1, deflate, n1, bits2); arb_poly_add(E, E, D, bits2); if (!arb_poly_overlaps(A, E)) { printf("FAIL (functional equation)\n\n"); printf("S = "); arb_poly_printd(S, 15); printf("\n\n"); printf("a = "); arb_printd(a, 15); printf("\n\n"); printf("A = "); arb_poly_printd(A, 15); printf("\n\n"); printf("E = "); arb_poly_printd(A, 15); printf("\n\n"); abort(); } arb_poly_zeta_series(S, S, a, deflate, n1, bits2); if (!arb_poly_overlaps(A, S)) { printf("FAIL (aliasing)\n\n"); abort(); } arb_poly_clear(S); arb_poly_clear(A); arb_poly_clear(B); arb_poly_clear(C); arb_poly_clear(D); arb_poly_clear(E); arb_poly_clear(F); arb_clear(a); arb_clear(a1); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
void keiper_li_series(arb_ptr z, slong len, slong prec) { arb_ptr t, u, v; t = _arb_vec_init(len); u = _arb_vec_init(len); v = _arb_vec_init(len); /* -zeta(s) */ flint_printf("zeta: "); TIMEIT_ONCE_START arb_zero(t + 0); arb_one(t + 1); arb_one(u); _arb_poly_zeta_series(v, t, 2, u, 0, len, prec); _arb_vec_neg(v, v, len); TIMEIT_ONCE_STOP SHOW_MEMORY_USAGE /* logarithm */ flint_printf("log: "); TIMEIT_ONCE_START _arb_poly_log_series(t, v, len, len, prec); TIMEIT_ONCE_STOP /* add log(gamma(1+s/2)) */ flint_printf("gamma: "); TIMEIT_ONCE_START arb_one(u); arb_one(u + 1); arb_mul_2exp_si(u + 1, u + 1, -1); _arb_poly_lgamma_series(v, u, 2, len, prec); _arb_vec_add(t, t, v, len, prec); TIMEIT_ONCE_STOP /* subtract 0.5 s log(pi) */ arb_const_pi(u, prec); arb_log(u, u, prec); arb_mul_2exp_si(u, u, -1); arb_sub(t + 1, t + 1, u, prec); /* add log(1-s) */ arb_one(u); arb_set_si(u + 1, -1); _arb_poly_log_series(v, u, 2, len, prec); _arb_vec_add(t, t, v, len, prec); /* binomial transform */ flint_printf("binomial transform: "); TIMEIT_ONCE_START arb_set(z, t); _arb_vec_neg(t + 1, t + 1, len - 1); _arb_poly_binomial_transform(z + 1, t + 1, len - 1, len - 1, prec); TIMEIT_ONCE_STOP _arb_vec_clear(t, len); _arb_vec_clear(u, len); _arb_vec_clear(v, len); }