static void
_newton_to_monomial(arb_ptr ys, arb_srcptr xs, long n, long prec)
{
arb_t t, u;
long i, j;
arb_init(t);
arb_init(u);
for (i = n - 2; i >= 0; i--)
{
arb_set(t, ys + i);
arb_set(ys + i, ys + i + 1);
for (j = i + 1; j < n - 1; j++)
{
arb_mul(u, ys + j, xs + i, prec);
arb_sub(ys + j, ys + j + 1, u, prec);
}
arb_mul(u, ys + n - 1, xs + i, prec);
arb_sub(ys + n - 1, t, u, prec);
}
_arb_poly_reverse(ys, ys, n, n);
arb_clear(t);
arb_clear(u);
}
void
_arb_poly_div_root(arb_ptr Q, arb_t R, arb_srcptr A,
slong len, const arb_t c, slong prec)
{
arb_t r, t;
slong i;
if (len < 2)
{
arb_zero(R);
return;
}
arb_init(r);
arb_init(t);
arb_set(t, A + len - 2);
arb_set(Q + len - 2, A + len - 1);
arb_set(r, Q + len - 2);
/* TODO: avoid the extra assignments (but still support aliasing) */
for (i = len - 2; i > 0; i--)
{
arb_mul(r, r, c, prec);
arb_add(r, r, t, prec);
arb_set(t, A + i - 1);
arb_set(Q + i - 1, r);
}
arb_mul(r, r, c, prec);
arb_add(R, r, t, prec);
}
static void
_interpolate_newton(arb_ptr ys, arb_srcptr xs, long n, long prec)
{
arb_t p, q, t;
long i, j;
arb_init(p);
arb_init(q);
arb_init(t);
for (i = 1; i < n; i++)
{
arb_set(t, ys + i - 1);
for (j = i; j < n; j++)
{
arb_sub(p, ys + j, t, prec);
arb_sub(q, xs + j, xs + j - i, prec);
arb_set(t, ys + j);
arb_div(ys + j, p, q, prec);
}
}
arb_clear(p);
arb_clear(q);
arb_clear(t);
}
void
_arb_poly_evaluate_rectangular(arb_t y, arb_srcptr poly,
long len, const arb_t x, long prec)
{
long i, j, m, r;
arb_ptr xs;
arb_t s, t, c;
if (len < 3)
{
if (len == 0)
{
arb_zero(y);
}
else if (len == 1)
{
arb_set_round(y, poly + 0, prec);
}
else if (len == 2)
{
arb_mul(y, x, poly + 1, prec);
arb_add(y, y, poly + 0, prec);
}
return;
}
m = n_sqrt(len) + 1;
r = (len + m - 1) / m;
xs = _arb_vec_init(m + 1);
arb_init(s);
arb_init(t);
arb_init(c);
_arb_vec_set_powers(xs, x, m + 1, prec);
arb_set(y, poly + (r - 1) * m);
for (j = 1; (r - 1) * m + j < len; j++)
arb_addmul(y, xs + j, poly + (r - 1) * m + j, prec);
for (i = r - 2; i >= 0; i--)
{
arb_set(s, poly + i * m);
for (j = 1; j < m; j++)
arb_addmul(s, xs + j, poly + i * m + j, prec);
arb_mul(y, y, xs + m, prec);
arb_add(y, y, s, prec);
}
_arb_vec_clear(xs, m + 1);
arb_clear(s);
arb_clear(t);
arb_clear(c);
}
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_agm(arb_t z, const arb_t x, const arb_t y, long prec)
{
arb_t t, u, v, w;
if (arb_contains_negative(x) || arb_contains_negative(y))
{
arb_indeterminate(z);
return;
}
if (arb_is_zero(x) || arb_is_zero(y))
{
arb_zero(z);
return;
}
arb_init(t);
arb_init(u);
arb_init(v);
arb_init(w);
arb_set(t, x);
arb_set(u, y);
while (!arb_overlaps(t, u) &&
!arb_contains_nonpositive(t) &&
!arb_contains_nonpositive(u))
{
arb_add(v, t, u, prec);
arb_mul_2exp_si(v, v, -1);
arb_mul(w, t, u, prec);
arb_sqrt(w, w, prec);
arb_swap(v, t);
arb_swap(w, u);
}
if (!arb_is_finite(t) || !arb_is_finite(u))
{
arb_indeterminate(z);
}
else
{
arb_union(z, t, u, prec);
}
arb_clear(t);
arb_clear(u);
arb_clear(v);
arb_clear(w);
}
void
arb_hypgeom_coulomb_jet(arb_ptr F, arb_ptr G, const arb_t l, const arb_t eta, const arb_t z, slong len, slong prec)
{
acb_ptr tmp, tmpF, tmpG;
slong k;
if (len <= 0)
return;
if (len == 1)
{
arb_hypgeom_coulomb(F, G, l, eta, z, prec);
return;
}
tmp = _acb_vec_init(3);
tmpF = _acb_vec_init(len);
tmpG = _acb_vec_init(len);
acb_set_arb(tmp, l);
acb_set_arb(tmp + 1, eta);
acb_set_arb(tmp + 2, z);
acb_hypgeom_coulomb_jet(F ? tmpF : NULL, G ? tmpG : NULL,
NULL, NULL, tmp, tmp + 1, tmp + 2, len, prec);
if (F != NULL)
{
if (acb_is_real(tmpF))
for (k = 0; k < len; k++)
arb_set(F + k, acb_realref(tmpF + k));
else
_arb_vec_indeterminate(F, len);
}
if (G != NULL)
{
if (acb_is_real(tmpG))
for (k = 0; k < len; k++)
arb_set(G + k, acb_realref(tmpG + k));
else
_arb_vec_indeterminate(G, len);
}
_acb_vec_clear(tmpF, len);
_acb_vec_clear(tmpG, len);
_acb_vec_clear(tmp, 3);
}
void
_arb_poly_reverse(arb_ptr res, arb_srcptr poly, slong len, slong n)
{
if (res == poly)
{
slong i;
for (i = 0; i < n / 2; i++)
{
arb_struct t = res[i];
res[i] = res[n - 1 - i];
res[n - 1 - i] = t;
}
for (i = 0; i < n - len; i++)
arb_zero(res + i);
}
else
{
slong i;
for (i = 0; i < n - len; i++)
arb_zero(res + i);
for (i = 0; i < len; i++)
arb_set(res + (n - len) + i, poly + (len - 1) - i);
}
}
void
_arb_poly_sinh_cosh_series(arb_ptr s, arb_ptr c, const arb_srcptr h, slong hlen, slong n, slong prec)
{
hlen = FLINT_MIN(hlen, n);
if (hlen == 1)
{
arb_sinh_cosh(s, c, h, prec);
_arb_vec_zero(s + 1, n - 1);
_arb_vec_zero(c + 1, n - 1);
}
else if (n == 2)
{
arb_t t;
arb_init(t);
arb_set(t, h + 1);
arb_sinh_cosh(s, c, h, prec);
arb_mul(s + 1, c, t, prec);
arb_mul(c + 1, s, t, prec);
arb_clear(t);
}
else if (hlen < 60 || n < 120)
_arb_poly_sinh_cosh_series_basecase(s, c, h, hlen, n, prec);
else
_arb_poly_sinh_cosh_series_exponential(s, c, h, hlen, n, prec);
}
void
arb_hypgeom_hermite_h(arb_t res, const arb_t nu, const arb_t z, slong prec)
{
acb_t t, u;
acb_init(t);
acb_init(u);
arb_set(acb_realref(t), nu);
arb_set(acb_realref(u), z);
acb_hypgeom_hermite_h(t, t, u, prec);
if (acb_is_finite(t) && acb_is_real(t))
arb_swap(res, acb_realref(t));
else
arb_indeterminate(res);
acb_clear(t);
acb_clear(u);
}
void
arb_hypgeom_gamma_upper(arb_t res, const arb_t s, const arb_t z, int regularized, slong prec)
{
acb_t t, u;
acb_init(t);
acb_init(u);
arb_set(acb_realref(t), s);
arb_set(acb_realref(u), z);
acb_hypgeom_gamma_upper(t, t, u, regularized, prec);
if (acb_is_finite(t) && acb_is_real(t))
arb_swap(res, acb_realref(t));
else
arb_indeterminate(res);
acb_clear(t);
acb_clear(u);
}
int
arb_mat_lu(long * P, arb_mat_t LU, const arb_mat_t A, long prec)
{
arb_t d, e;
arb_ptr * a;
long i, j, m, n, r, row, col;
int result;
m = arb_mat_nrows(A);
n = arb_mat_ncols(A);
result = 1;
if (m == 0 || n == 0)
return result;
arb_mat_set(LU, A);
a = LU->rows;
row = col = 0;
for (i = 0; i < m; i++)
P[i] = i;
arb_init(d);
arb_init(e);
while (row < m && col < n)
{
r = arb_mat_find_pivot_partial(LU, row, m, col);
if (r == -1)
{
result = 0;
break;
}
else if (r != row)
arb_mat_swap_rows(LU, P, row, r);
arb_set(d, a[row] + col);
for (j = row + 1; j < m; j++)
{
arb_div(e, a[j] + col, d, prec);
arb_neg(e, e);
_arb_vec_scalar_addmul(a[j] + col,
a[row] + col, n - col, e, prec);
arb_zero(a[j] + col);
arb_neg(a[j] + row, e);
}
row++;
col++;
}
arb_clear(d);
arb_clear(e);
return result;
}
static __inline__ void
arb_nonnegative_part(arb_t z, const arb_t x, long prec)
{
if (arb_contains_negative(x))
{
arf_t t;
arf_init(t);
arf_set_mag(t, arb_radref(x));
arf_add(arb_midref(z), arb_midref(x), t, MAG_BITS, ARF_RND_CEIL);
if (arf_sgn(arb_midref(z)) <= 0)
{
mag_zero(arb_radref(z));
}
else
{
arf_mul_2exp_si(arb_midref(z), arb_midref(z), -1);
arf_get_mag(arb_radref(z), arb_midref(z));
/* XXX: needed since arf_get_mag is inexact */
arf_set_mag(arb_midref(z), arb_radref(z));
}
arf_clear(t);
}
else
{
arb_set(z, x);
}
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("csch....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
arb_t x, a, b;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 200);
prec2 = prec1 + 30;
arb_init(x);
arb_init(a);
arb_init(b);
arb_randtest_special(x, state, 1 + n_randint(state, 300), 100);
arb_randtest_special(a, state, 1 + n_randint(state, 300), 100);
arb_randtest_special(b, state, 1 + n_randint(state, 300), 100);
if (n_randint(state, 2))
{
arb_csch(a, x, prec1);
}
else
{
arb_set(a, x);
arb_csch(a, a, prec1);
}
arb_sinh(b, x, prec2);
arb_inv(b, b, prec2);
/* check consistency */
if (!arb_overlaps(a, b))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("x = "); arb_printn(x, 20, 0); flint_printf("\n\n");
flint_printf("a = "); arb_printn(a, 20, 0); flint_printf("\n\n");
flint_printf("b = "); arb_printn(b, 20, 0); flint_printf("\n\n");
flint_abort();
}
arb_clear(x);
arb_clear(a);
arb_clear(b);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
nd_accum_accumulate(nd_accum_t a, int *coords, arb_struct *value, slong prec)
{
int axis_idx;
int offset, coord, stride;
nd_axis_struct *axis;
arb_struct *p;
arb_t x;
arb_init(x);
arb_set(x, value);
offset = 0;
for (axis_idx = 0; axis_idx < a->ndim; axis_idx++)
{
axis = a->axes + axis_idx;
coord = coords[axis_idx];
stride = a->strides[axis_idx];
/*
flint_printf("debug:\n");
flint_printf("ndim=%wd axis=%d coord=%d\n", a->ndim, axis_idx, coord);
flint_printf("strides:\n");
{
int j;
for (j = 0; j < a->ndim; j++)
{
flint_printf("%d : %d\n", j, a->strides[j]);
}
}
*/
if (axis->agg_weights)
{
arb_mul(x, x, axis->agg_weights + coord, prec);
/* todo: delay this division */
arb_div(x, x, axis->agg_weight_divisor, prec);
}
else
{
offset += coord * stride;
}
}
if (offset < 0)
{
fprintf(stderr, "internal error: negative offset\n");
abort();
}
if (offset >= a->size)
{
fprintf(stderr, "internal error: offset=%d >= size=%d\n",
offset, a->size);
abort();
}
p = a->data + offset;
arb_add(p, p, x, prec);
arb_clear(x);
}
void
arb_hypgeom_pfq(arb_t res, arb_srcptr a, slong p, arb_srcptr b, slong q, const arb_t z, int regularized, slong prec)
{
acb_ptr t;
slong i;
t = _acb_vec_init(p + q + 1);
for (i = 0; i < p; i++)
arb_set(acb_realref(t + i), a + i);
for (i = 0; i < q; i++)
arb_set(acb_realref(t + p + i), b + i);
arb_set(acb_realref(t + p + q), z);
acb_hypgeom_pfq(t, t, p, t + p, q, t + p + q, regularized, prec);
if (acb_is_finite(t) && acb_is_real(t))
arb_swap(res, acb_realref(t));
else
arb_indeterminate(res);
_acb_vec_clear(t, p + q + 1);
}
void
arb_hypgeom_legendre_q(arb_t res, const arb_t n, const arb_t m, const arb_t z, int type, slong prec)
{
acb_t t, u, v;
acb_init(t);
acb_init(u);
acb_init(v);
arb_set(acb_realref(t), n);
arb_set(acb_realref(u), m);
arb_set(acb_realref(v), z);
acb_hypgeom_legendre_q(t, t, u, v, type, prec);
if (acb_is_finite(t) && acb_is_real(t))
arb_swap(res, acb_realref(t));
else
arb_indeterminate(res);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
void
_acb_hypgeom_const_li2_eval(arb_t s, long prec)
{
acb_t t;
acb_init(t);
acb_set_ui(t, 2);
_acb_hypgeom_li(t, t, prec);
arb_set(s, acb_realref(t));
acb_clear(t);
}
void
arb_hypgeom_beta_lower(arb_t res, const arb_t a, const arb_t b, const arb_t z, int regularized, slong prec)
{
acb_t t, u, v;
acb_init(t);
acb_init(u);
acb_init(v);
arb_set(acb_realref(t), a);
arb_set(acb_realref(u), b);
arb_set(acb_realref(v), z);
acb_hypgeom_beta_lower(t, t, u, v, regularized, prec);
if (acb_is_finite(t) && acb_is_real(t))
arb_swap(res, acb_realref(t));
else
arb_indeterminate(res);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
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;
}
void
arb_hypgeom_bessel_jy(arb_t res1, arb_t res2, const arb_t nu, const arb_t z, slong prec)
{
acb_t t, u;
acb_init(t);
acb_init(u);
arb_set(acb_realref(t), nu);
arb_set(acb_realref(u), z);
acb_hypgeom_bessel_jy(t, u, t, u, prec);
if (acb_is_finite(t) && acb_is_real(t))
arb_swap(res1, acb_realref(t));
else
arb_indeterminate(res1);
if (acb_is_finite(u) && acb_is_real(u))
arb_swap(res2, acb_realref(u));
else
arb_indeterminate(res2);
acb_clear(t);
acb_clear(u);
}
void
arb_hypgeom_jacobi_p(arb_t res, const arb_t n, const arb_t a, const arb_t b, const arb_t z, slong prec)
{
acb_t t, u, v, w;
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(w);
arb_set(acb_realref(t), n);
arb_set(acb_realref(u), a);
arb_set(acb_realref(v), b);
arb_set(acb_realref(w), z);
acb_hypgeom_jacobi_p(t, t, u, v, w, prec);
if (acb_is_finite(t) && acb_is_real(t))
arb_swap(res, acb_realref(t));
else
arb_indeterminate(res);
acb_clear(t);
acb_clear(u);
acb_clear(v);
acb_clear(w);
}
static void
bsplit(arb_poly_t pol, const arb_t sqrtD,
const slong * qbf, slong a, slong b, slong prec)
{
if (b - a == 0)
{
arb_poly_one(pol);
}
else if (b - a == 1)
{
acb_t z;
acb_init(z);
/* j((-b+sqrt(-D))/(2a)) */
arb_set_si(acb_realref(z), -FLINT_ABS(qbf[3 * a + 1]));
arb_set(acb_imagref(z), sqrtD);
acb_div_si(z, z, 2 * qbf[3 * a], prec);
acb_modular_j(z, z, prec);
if (qbf[3 * a + 1] < 0)
{
/* (x^2 - 2re(j) x + |j|^2) */
arb_poly_fit_length(pol, 3);
arb_mul(pol->coeffs, acb_realref(z), acb_realref(z), prec);
arb_addmul(pol->coeffs, acb_imagref(z), acb_imagref(z), prec);
arb_mul_2exp_si(pol->coeffs + 1, acb_realref(z), 1);
arb_neg(pol->coeffs + 1, pol->coeffs + 1);
arb_one(pol->coeffs + 2);
_arb_poly_set_length(pol, 3);
}
else
{
/* (x-j) */
arb_poly_fit_length(pol, 2);
arb_neg(pol->coeffs, acb_realref(z));
arb_one(pol->coeffs + 1);
_arb_poly_set_length(pol, 2);
}
acb_clear(z);
}
else
{
arb_poly_t tmp;
arb_poly_init(tmp);
bsplit(pol, sqrtD, qbf, a, a + (b - a) / 2, prec);
bsplit(tmp, sqrtD, qbf, a + (b - a) / 2, b, prec);
arb_poly_mul(pol, pol, tmp, prec);
arb_poly_clear(tmp);
}
}
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;
}
void
arb_poly_set_coeff_arb(arb_poly_t poly, long n, const arb_t x)
{
arb_poly_fit_length(poly, n + 1);
if (n + 1 > poly->length)
{
_arb_vec_zero(poly->coeffs + poly->length, n - poly->length);
poly->length = n + 1;
}
arb_set(poly->coeffs + n, x);
_arb_poly_normalise(poly);
}
int arb_calc_newton_step(arb_t xnew, arb_calc_func_t func,
void * param, const arb_t x, const arb_t conv_region,
const arf_t conv_factor, slong prec)
{
mag_t err, v;
arb_t t;
arb_struct u[2];
int result;
mag_init(err);
mag_init(v);
arb_init(t);
arb_init(u + 0);
arb_init(u + 1);
mag_mul(err, arb_radref(x), arb_radref(x));
arf_get_mag(v, conv_factor);
mag_mul(err, err, v);
arf_set(arb_midref(t), arb_midref(x));
mag_zero(arb_radref(t));
func(u, t, param, 2, prec);
arb_div(u, u, u + 1, prec);
arb_sub(u, t, u, prec);
mag_add(arb_radref(u), arb_radref(u), err);
if (arb_contains(conv_region, u) &&
(mag_cmp(arb_radref(u), arb_radref(x)) < 0))
{
arb_swap(xnew, u);
result = ARB_CALC_SUCCESS;
}
else
{
arb_set(xnew, x);
result = ARB_CALC_NO_CONVERGENCE;
}
arb_clear(t);
arb_clear(u);
arb_clear(u + 1);
mag_clear(err);
mag_clear(v);
return result;
}
int arb_calc_refine_root_newton(arb_t r, arb_calc_func_t func,
void * param, const arb_t start, const arb_t conv_region,
const arf_t conv_factor, slong eval_extra_prec, slong prec)
{
slong precs[FLINT_BITS];
slong i, iters, wp, padding, start_prec;
int result;
start_prec = arb_rel_accuracy_bits(start);
if (arb_calc_verbose)
flint_printf("newton initial accuracy: %wd\n", start_prec);
padding = arf_abs_bound_lt_2exp_si(conv_factor);
padding = FLINT_MIN(padding, prec) + 5;
padding = FLINT_MAX(0, padding);
precs[0] = prec + padding;
iters = 1;
while ((iters < FLINT_BITS) && (precs[iters-1] + padding > 2*start_prec))
{
precs[iters] = (precs[iters-1] / 2) + padding;
iters++;
if (iters == FLINT_BITS)
{
return ARB_CALC_IMPRECISE_INPUT;
}
}
arb_set(r, start);
for (i = iters - 1; i >= 0; i--)
{
wp = precs[i] + eval_extra_prec;
if (arb_calc_verbose)
flint_printf("newton step: wp = %wd + %wd = %wd\n",
precs[i], eval_extra_prec, wp);
if ((result = arb_calc_newton_step(r, func, param,
r, conv_region, conv_factor, wp)) != ARB_CALC_SUCCESS)
{
return result;
}
}
return ARB_CALC_SUCCESS;
}
int
f_thsh_shift(arb_t max, const arb_t t, params_t * p, slong prec)
{
acb_t z;
acb_init(z);
arb_set(acb_realref(z), t);
arb_set_d(acb_imagref(z), .7);
acb_sinh(z, z, prec);
acb_tanh(z, z, prec);
acb_abs(max, z, prec);
acb_clear(z);
return 1;
}
int
_arb_poly_newton_step(arb_t xnew, arb_srcptr poly, long len,
const arb_t x,
const arb_t convergence_interval,
const arf_t convergence_factor, long prec)
{
arf_t err;
arb_t t, u, v;
int result;
arf_init(err);
arb_init(t);
arb_init(u);
arb_init(v);
arf_set_mag(err, arb_radref(x));
arf_mul(err, err, err, MAG_BITS, ARF_RND_UP);
arf_mul(err, err, convergence_factor, MAG_BITS, ARF_RND_UP);
arf_set(arb_midref(t), arb_midref(x));
mag_zero(arb_radref(t));
_arb_poly_evaluate2(u, v, poly, len, t, prec);
arb_div(u, u, v, prec);
arb_sub(u, t, u, prec);
arb_add_error_arf(u, err);
if (arb_contains(convergence_interval, u) &&
(mag_cmp(arb_radref(u), arb_radref(x)) < 0))
{
arb_swap(xnew, u);
result = 1;
}
else
{
arb_set(xnew, x);
result = 0;
}
arb_clear(t);
arb_clear(u);
arb_clear(v);
arf_clear(err);
return result;
}
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);
}
