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_revert_series_lagrange_fast(arb_ptr Qinv, arb_srcptr Q, long Qlen, long n, long prec)
{
long i, j, k, m;
arb_ptr R, S, T, tmp;
arb_t t;
if (n <= 2)
{
if (n >= 1)
arb_zero(Qinv);
if (n == 2)
arb_inv(Qinv + 1, Q + 1, prec);
return;
}
m = n_sqrt(n);
arb_init(t);
R = _arb_vec_init((n - 1) * m);
S = _arb_vec_init(n - 1);
T = _arb_vec_init(n - 1);
arb_zero(Qinv);
arb_inv(Qinv + 1, Q + 1, prec);
_arb_poly_inv_series(Ri(1), Q + 1, FLINT_MIN(Qlen, n) - 1, n - 1, prec);
for (i = 2; i <= m; i++)
_arb_poly_mullow(Ri(i), Ri((i + 1) / 2), n - 1, Ri(i / 2), n - 1, n - 1, prec);
for (i = 2; i < m; i++)
arb_div_ui(Qinv + i, Ri(i) + i - 1, i, prec);
_arb_vec_set(S, Ri(m), n - 1);
for (i = m; i < n; i += m)
{
arb_div_ui(Qinv + i, S + i - 1, i, prec);
for (j = 1; j < m && i + j < n; j++)
{
arb_mul(t, S + 0, Ri(j) + i + j - 1, prec);
for (k = 1; k <= i + j - 1; k++)
arb_addmul(t, S + k, Ri(j) + i + j - 1 - k, prec);
arb_div_ui(Qinv + i + j, t, i + j, prec);
}
if (i + 1 < n)
{
_arb_poly_mullow(T, S, n - 1, Ri(m), n - 1, n - 1, prec);
tmp = S; S = T; T = tmp;
}
}
arb_clear(t);
_arb_vec_clear(R, (n - 1) * m);
_arb_vec_clear(S, n - 1);
_arb_vec_clear(T, n - 1);
}
void
acb_tan_pi(acb_t r, const acb_t z, slong prec)
{
if (arb_is_zero(acb_imagref(z)))
{
arb_tan_pi(acb_realref(r), acb_realref(z), prec);
arb_zero(acb_imagref(r));
}
else if (arb_is_zero(acb_realref(z)))
{
arb_t t;
arb_init(t);
arb_const_pi(t, prec + 4);
arb_mul(t, acb_imagref(z), t, prec + 4);
arb_tanh(acb_imagref(r), t, prec);
arb_zero(acb_realref(r));
arb_clear(t);
}
else
{
acb_t t;
acb_init(t);
if (arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), 0) < 0)
{
acb_sin_cos_pi(r, t, z, prec + 4);
acb_div(r, r, t, prec);
}
else
{
acb_mul_2exp_si(t, z, 1);
if (arf_sgn(arb_midref(acb_imagref(z))) > 0)
{
acb_exp_pi_i(t, t, prec + 4);
acb_add_ui(r, t, 1, prec + 4);
acb_div(r, t, r, prec + 4);
acb_mul_2exp_si(r, r, 1);
acb_sub_ui(r, r, 1, prec);
acb_div_onei(r, r);
}
else
{
acb_neg(t, t);
acb_exp_pi_i(t, t, prec + 4);
acb_add_ui(r, t, 1, prec + 4);
acb_div(r, t, r, prec + 4);
acb_mul_2exp_si(r, r, 1);
acb_sub_ui(r, r, 1, prec);
acb_mul_onei(r, r);
}
}
acb_clear(t);
}
}
void
acb_sin_cos_pi(acb_t s, acb_t c, const acb_t z, slong prec)
{
#define a acb_realref(z)
#define b acb_imagref(z)
if (arb_is_zero(b))
{
arb_sin_cos_pi(acb_realref(s), acb_realref(c), a, prec);
arb_zero(acb_imagref(s));
arb_zero(acb_imagref(c));
}
else if (arb_is_zero(a))
{
arb_t t;
arb_init(t);
arb_const_pi(t, prec);
arb_mul(t, t, b, prec);
arb_sinh_cosh(acb_imagref(s), acb_realref(c), t, prec);
arb_zero(acb_realref(s));
arb_zero(acb_imagref(c));
arb_clear(t);
}
else
{
arb_t sa, ca, sb, cb;
arb_init(sa);
arb_init(ca);
arb_init(sb);
arb_init(cb);
arb_const_pi(sb, prec);
arb_mul(sb, sb, b, prec);
arb_sin_cos_pi(sa, ca, a, prec);
arb_sinh_cosh(sb, cb, sb, prec);
arb_mul(acb_realref(s), sa, cb, prec);
arb_mul(acb_imagref(s), sb, ca, prec);
arb_mul(acb_realref(c), ca, cb, prec);
arb_mul(acb_imagref(c), sa, sb, prec);
arb_neg(acb_imagref(c), acb_imagref(c));
arb_clear(sa);
arb_clear(ca);
arb_clear(sb);
arb_clear(cb);
}
#undef a
#undef b
}
void
acb_hypgeom_erf_asymp(acb_t res, const acb_t z, slong prec, slong prec2)
{
acb_t a, t, u;
acb_init(a);
acb_init(t);
acb_init(u);
acb_one(a);
acb_mul_2exp_si(a, a, -1);
acb_mul(t, z, z, prec2);
acb_hypgeom_u_asymp(u, a, a, t, -1, prec2);
acb_neg(t, t);
acb_exp(t, t, prec2);
acb_mul(u, u, t, prec2);
acb_const_pi(t, prec2);
acb_sqrt(t, t, prec2);
acb_mul(t, t, z, prec2);
acb_div(u, u, t, prec2);
/* branch cut term: -1 or 1 */
if (arb_contains_zero(acb_realref(z)))
{
arb_zero(acb_imagref(t));
arf_zero(arb_midref(acb_realref(t)));
mag_one(arb_radref(acb_realref(t)));
}
else
{
acb_set_si(t, arf_sgn(arb_midref(acb_realref(z))));
}
acb_sub(t, t, u, prec);
if (arb_is_zero(acb_imagref(z)))
arb_zero(acb_imagref(t));
else if (arb_is_zero(acb_realref(z)))
arb_zero(acb_realref(t));
acb_set(res, t);
acb_clear(a);
acb_clear(t);
acb_clear(u);
}
void
acb_dirichlet_gauss_sum_order2(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi, slong prec)
{
if (dirichlet_parity_char(G, chi))
{
arb_zero(acb_realref(res));
arb_sqrt_ui(acb_imagref(res), G->q, prec);
}
else
{
arb_zero(acb_imagref(res));
arb_sqrt_ui(acb_realref(res), G->q, prec);
}
}
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;
}
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);
}
void
arb_log1p(arb_t r, const arb_t z, slong prec)
{
slong magz;
if (arb_is_zero(z))
{
arb_zero(r);
return;
}
magz = arf_abs_bound_lt_2exp_si(arb_midref(z));
if (magz < -prec)
{
arb_log1p_tiny(r, z, prec);
}
else
{
if (magz < 0)
arb_add_ui(r, z, 1, prec + (-magz) + 4);
else
arb_add_ui(r, z, 1, prec + 4);
arb_log(r, r, prec);
}
}
void
arb_sqrt1pm1(arb_t r, const arb_t z, slong prec)
{
slong magz, wp;
if (arb_is_zero(z))
{
arb_zero(r);
return;
}
magz = arf_abs_bound_lt_2exp_si(arb_midref(z));
if (magz < -prec)
{
arb_sqrt1pm1_tiny(r, z, prec);
}
else
{
if (magz < 0)
wp = prec + (-magz) + 4;
else
wp = prec + 4;
arb_add_ui(r, z, 1, wp);
arb_sqrt(r, r, wp);
arb_sub_ui(r, r, 1, wp);
}
}
void
acb_hypgeom_m_asymp(acb_t res, const acb_t a, const acb_t b, const acb_t z, int regularized, slong prec)
{
acb_t t, u, v, c;
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(c);
acb_sub(c, b, a, prec);
acb_neg(v, z);
acb_hypgeom_u_asymp(t, a, b, z, -1, prec);
acb_hypgeom_u_asymp(u, c, b, v, -1, prec);
/* gamma(b-a) */
acb_rgamma(v, c, prec);
acb_mul(t, t, v, prec);
/* z^(a-b) */
acb_neg(c, c);
acb_pow(v, z, c, prec);
acb_mul(u, u, v, prec);
/* gamma(a) */
acb_rgamma(v, a, prec);
acb_mul(u, u, v, prec);
/* exp(z) */
acb_exp(v, z, prec);
acb_mul(u, u, v, prec);
/* (-z)^(-a) */
acb_neg(c, a);
acb_neg(v, z);
acb_pow(v, v, c, prec);
acb_mul(t, t, v, prec);
acb_add(t, t, u, prec);
if (!regularized)
{
acb_gamma(v, b, prec);
acb_mul(t, t, v, prec);
}
if (acb_is_real(a) && acb_is_real(b) && acb_is_real(z))
{
arb_zero(acb_imagref(t));
}
acb_swap(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(v);
acb_clear(c);
}
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);
}
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
arb_bernoulli_fmpz(arb_t res, const fmpz_t n, slong prec)
{
if (fmpz_cmp_ui(n, UWORD_MAX) <= 0)
{
if (fmpz_sgn(n) >= 0)
arb_bernoulli_ui(res, fmpz_get_ui(n), prec);
else
arb_zero(res);
}
else if (fmpz_is_odd(n))
{
arb_zero(res);
}
else
{
arb_t t;
slong wp;
arb_init(t);
wp = prec + 2 * fmpz_bits(n);
/* zeta(n) ~= 1 */
arf_one(arb_midref(res));
mag_one(arb_radref(res));
mag_mul_2exp_si(arb_radref(res), arb_radref(res), WORD_MIN);
/* |B_n| = 2 * n! / (2*pi)^n * zeta(n) */
arb_gamma_fmpz(t, n, wp);
arb_mul_fmpz(t, t, n, wp);
arb_mul(res, res, t, wp);
arb_const_pi(t, wp);
arb_mul_2exp_si(t, t, 1);
arb_pow_fmpz(t, t, n, wp);
arb_div(res, res, t, prec);
arb_mul_2exp_si(res, res, 1);
if (fmpz_fdiv_ui(n, 4) == 0)
arb_neg(res, res);
arb_clear(t);
}
}
void
arb_mat_zero(arb_mat_t mat)
{
slong i, j;
for (i = 0; i < arb_mat_nrows(mat); i++)
for (j = 0; j < arb_mat_ncols(mat); j++)
arb_zero(arb_mat_entry(mat, i, j));
}
void
_arb_poly_integral(arb_ptr res, arb_srcptr poly, slong len, slong prec)
{
slong k = len - 1;
for (k = len - 1; k > 0; k--)
arb_div_ui(res + k, poly + k - 1, k, prec);
arb_zero(res);
}
void
_arb_poly_sinh_cosh_series_basecase(arb_ptr s, arb_ptr c, arb_srcptr h, slong hlen,
slong n, slong prec)
{
slong j, k, alen = FLINT_MIN(n, hlen);
arb_ptr a;
arb_t t, u;
arb_sinh_cosh(s, c, h, prec);
if (hlen == 1)
{
_arb_vec_zero(s + 1, n - 1);
_arb_vec_zero(c + 1, n - 1);
return;
}
arb_init(t);
arb_init(u);
a = _arb_vec_init(alen);
for (k = 1; k < alen; k++)
arb_mul_ui(a + k, h + k, k, prec);
for (k = 1; k < n; k++)
{
arb_zero(t);
arb_zero(u);
for (j = 1; j < FLINT_MIN(k + 1, hlen); j++)
{
arb_addmul(t, a + j, s + k - j, prec);
arb_addmul(u, a + j, c + k - j, prec);
}
arb_div_ui(c + k, t, k, prec);
arb_div_ui(s + k, u, k, prec);
}
arb_clear(t);
arb_clear(u);
_arb_vec_clear(a, alen);
}
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
acb_hypgeom_bessel_jy(acb_t res1, acb_t res2, const acb_t nu, const acb_t z, slong prec)
{
acb_t jnu, t, u, v;
acb_init(jnu);
acb_init(t);
acb_init(u);
acb_init(v);
acb_hypgeom_bessel_j(jnu, nu, z, prec);
if (acb_is_int(nu))
{
int is_real = acb_is_real(nu) && acb_is_real(z)
&& arb_is_positive(acb_realref(z));
acb_mul_onei(t, z);
acb_hypgeom_bessel_k(t, nu, t, prec);
acb_onei(u);
acb_pow(u, u, nu, prec);
acb_mul(t, t, u, prec);
acb_const_pi(u, prec);
acb_div(t, t, u, prec);
acb_mul_2exp_si(t, t, 1);
acb_neg(t, t);
phase(v, acb_realref(z), acb_imagref(z));
acb_mul(u, jnu, v, prec);
acb_mul_onei(u, u);
acb_sub(res2, t, u, prec);
if (is_real)
arb_zero(acb_imagref(res2));
}
else
{
acb_sin_cos_pi(t, u, nu, prec);
acb_mul(v, jnu, u, prec);
acb_neg(u, nu);
acb_hypgeom_bessel_j(u, u, z, prec);
acb_sub(v, v, u, prec);
acb_div(res2, v, t, prec);
}
if (res1 != NULL)
acb_set(res1, jnu);
acb_clear(jnu);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
void arb_mat_L2norm(arb_t out, const arb_mat_t in, slong prec) {
int nrows = arb_mat_nrows(in);
int ncols = arb_mat_ncols(in);
arb_zero(out);
for(int i = 0; i < nrows; i++) {
for(int j = 0; j < ncols; j++) {
arb_addmul(out, arb_mat_entry(in, i, j), arb_mat_entry(in, i, j), prec);
}
}
arb_sqrtpos(out, out, prec);
}
void
acb_lambertw(acb_t res, const acb_t z, const fmpz_t k, int flags, slong prec)
{
acb_t ez1;
if (!acb_is_finite(z))
{
acb_indeterminate(res);
return;
}
if (flags == ACB_LAMBERTW_LEFT)
{
acb_lambertw_left(res, z, k, prec);
return;
}
if (flags == ACB_LAMBERTW_MIDDLE)
{
acb_lambertw_middle(res, z, prec);
return;
}
if (acb_contains_zero(z) && !fmpz_is_zero(k))
{
acb_indeterminate(res);
return;
}
acb_init(ez1);
/* precompute z*e + 1 */
arb_const_e(acb_realref(ez1), prec);
acb_mul(ez1, ez1, z, prec);
acb_add_ui(ez1, ez1, 1, prec);
/* Compute standard branches */
/* use real code when possible */
if (acb_is_real(z) && arb_is_positive(acb_realref(ez1)) &&
(fmpz_is_zero(k) ||
(fmpz_equal_si(k, -1) && arb_is_negative(acb_realref(z)))))
{
arb_lambertw(acb_realref(res), acb_realref(z), !fmpz_is_zero(k), prec);
arb_zero(acb_imagref(res));
}
else
{
_acb_lambertw(res, z, ez1, k, flags, prec);
}
acb_clear(ez1);
}
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);
}
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);
}
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();
}
}
void
acb_zeta_si(acb_t z, slong s, slong prec)
{
if (s >= 0)
{
arb_zeta_ui(acb_realref(z), s, prec);
}
else
{
arb_bernoulli_ui(acb_realref(z), 1-s, prec);
arb_div_ui(acb_realref(z), acb_realref(z), 1-s, prec);
arb_neg(acb_realref(z), acb_realref(z));
}
arb_zero(acb_imagref(z));
return;
}
void
acb_randtest_maybe_half_int(acb_t x, flint_rand_t state, long prec, long size)
{
if (n_randint(state, 8) == 0)
{
fmpz_t t;
fmpz_init(t);
fmpz_randtest(t, state, 1 + n_randint(state, prec));
arb_set_fmpz(acb_realref(x), t);
arb_zero(acb_imagref(x));
acb_mul_2exp_si(x, x, -1);
fmpz_clear(t);
}
else
{
acb_randtest(x, state, prec, size);
}
}
void
_arb_poly_compose_series(arb_ptr res, arb_srcptr poly1, slong len1,
arb_srcptr poly2, slong len2, slong n, slong prec)
{
if (len2 == 1)
{
arb_set_round(res, poly1, prec);
_arb_vec_zero(res + 1, n - 1);
}
else if (_arb_vec_is_zero(poly2 + 1, len2 - 2)) /* poly2 is a monomial */
{
slong i, j;
arb_t t;
arb_init(t);
arb_set(t, poly2 + len2 - 1);
arb_set_round(res, poly1, prec);
for (i = 1, j = len2 - 1; i < len1 && j < n; i++, j += len2 - 1)
{
arb_mul(res + j, poly1 + i, t, prec);
if (i + 1 < len1 && j + len2 - 1 < n)
arb_mul(t, t, poly2 + len2 - 1, prec);
}
if (len2 != 2)
for (i = 1; i < n; i++)
if (i % (len2 - 1) != 0)
arb_zero(res + i);
arb_clear(t);
}
else if (len1 < 6 || n < 6)
{
_arb_poly_compose_series_horner(res, poly1, len1, poly2, len2, n, prec);
}
else
{
_arb_poly_compose_series_brent_kung(res, poly1, len1, poly2, len2, n, prec);
}
}
static void
phase(acb_t res, const arb_t re, const arb_t im)
{
if (arb_is_nonnegative(re) || arb_is_negative(im))
{
acb_one(res);
}
else if (arb_is_negative(re) && arb_is_nonnegative(im))
{
acb_set_si(res, -3);
}
else
{
arb_zero(acb_imagref(res));
/* -1 +/- 2 */
arf_set_si(arb_midref(acb_realref(res)), -1);
mag_one(arb_radref(acb_realref(res)));
mag_mul_2exp_si(arb_radref(acb_realref(res)), arb_radref(acb_realref(res)), 1);
}
}
void
arb_acosh(arb_t z, const arb_t x, slong prec)
{
if (arb_is_one(x))
{
arb_zero(z);
}
else
{
arb_t t;
arb_init(t);
arb_mul(t, x, x, prec + 4);
arb_sub_ui(t, t, 1, prec + 4);
arb_sqrt(t, t, prec + 4);
arb_add(t, t, x, prec + 4);
arb_log(z, 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);
}
}
