void
acb_dirichlet_chi_vec(acb_ptr v, const dirichlet_group_t G, const dirichlet_char_t chi, slong nv, slong prec)
{
slong k;
ulong * a, order;
acb_dirichlet_roots_t t;
a = flint_malloc(nv * sizeof(ulong));
order = dirichlet_order_char(G, chi);
dirichlet_chi_vec_order(a, G, chi, order, nv);
acb_dirichlet_roots_init(t, order, nv, prec);
acb_zero(v + 0);
for (k = 0; k < nv; k++)
{
if (a[k] != DIRICHLET_CHI_NULL)
acb_dirichlet_root(v + k, t, a[k], prec);
else
acb_zero(v + k);
}
acb_dirichlet_roots_clear(t);
flint_free(a);
}
void
_acb_poly_reverse(acb_ptr res, acb_srcptr poly, long len, long n)
{
if (res == poly)
{
long i;
for (i = 0; i < n / 2; i++)
{
acb_struct t = res[i];
res[i] = res[n - 1 - i];
res[n - 1 - i] = t;
}
for (i = 0; i < n - len; i++)
acb_zero(res + i);
}
else
{
long i;
for (i = 0; i < n - len; i++)
acb_zero(res + i);
for (i = 0; i < len; i++)
acb_set(res + (n - len) + i, poly + (len - 1) - i);
}
}
void
_acb_poly_revert_series_lagrange_fast(acb_ptr Qinv, acb_srcptr Q, slong Qlen, slong n, slong prec)
{
slong i, j, k, m;
acb_ptr R, S, T, tmp;
acb_t t;
if (n <= 2)
{
if (n >= 1)
acb_zero(Qinv);
if (n == 2)
acb_inv(Qinv + 1, Q + 1, prec);
return;
}
m = n_sqrt(n);
acb_init(t);
R = _acb_vec_init((n - 1) * m);
S = _acb_vec_init(n - 1);
T = _acb_vec_init(n - 1);
acb_zero(Qinv);
acb_inv(Qinv + 1, Q + 1, prec);
_acb_poly_inv_series(Ri(1), Q + 1, FLINT_MIN(Qlen, n) - 1, n - 1, prec);
for (i = 2; i <= m; i++)
_acb_poly_mullow(Ri(i), Ri((i + 1) / 2), n - 1, Ri(i / 2), n - 1, n - 1, prec);
for (i = 2; i < m; i++)
acb_div_ui(Qinv + i, Ri(i) + i - 1, i, prec);
_acb_vec_set(S, Ri(m), n - 1);
for (i = m; i < n; i += m)
{
acb_div_ui(Qinv + i, S + i - 1, i, prec);
for (j = 1; j < m && i + j < n; j++)
{
acb_mul(t, S + 0, Ri(j) + i + j - 1, prec);
for (k = 1; k <= i + j - 1; k++)
acb_addmul(t, S + k, Ri(j) + i + j - 1 - k, prec);
acb_div_ui(Qinv + i + j, t, i + j, prec);
}
if (i + 1 < n)
{
_acb_poly_mullow(T, S, n - 1, Ri(m), n - 1, n - 1, prec);
tmp = S; S = T; T = tmp;
}
}
acb_clear(t);
_acb_vec_clear(R, (n - 1) * m);
_acb_vec_clear(S, n - 1);
_acb_vec_clear(T, n - 1);
}
void
_acb_dirichlet_hardy_z_series(acb_ptr res, acb_srcptr s, slong slen,
const dirichlet_group_t G, const dirichlet_char_t chi,
slong len, slong prec)
{
slen = FLINT_MIN(slen, len);
if (len == 0)
return;
if (slen == 1)
{
acb_dirichlet_hardy_z(res, s, G, chi, 1, prec);
_acb_vec_zero(res + 1, len - 1);
}
else
{
acb_ptr t, u;
t = _acb_vec_init(len);
u = _acb_vec_init(slen);
acb_dirichlet_hardy_z(t, s, G, chi, len, prec);
/* compose with nonconstant part */
acb_zero(u);
_acb_vec_set(u + 1, s + 1, slen - 1);
_acb_poly_compose_series(res, t, len, u, slen, len, prec);
_acb_vec_clear(t, len);
_acb_vec_clear(u, slen);
}
}
/* assumes no aliasing of w and p */
void
acb_lambertw_branchpoint_series(acb_t w, const acb_t t, int bound, slong prec)
{
slong i;
static const int coeffs[] = {-130636800,130636800,-43545600,19958400,
-10402560,5813640,-3394560,2042589,-1256320};
acb_zero(w);
for (i = 8; i >= 0; i--)
{
acb_mul(w, w, t, prec);
acb_add_si(w, w, coeffs[i], prec);
}
acb_div_si(w, w, -coeffs[0], prec);
if (bound)
{
mag_t err;
mag_init(err);
acb_get_mag(err, t);
mag_geom_series(err, err, 9);
if (acb_is_real(t))
arb_add_error_mag(acb_realref(w), err);
else
acb_add_error_mag(w, err);
mag_clear(err);
}
}
void
_acb_poly_div_root(acb_ptr Q, acb_t R, acb_srcptr A,
slong len, const acb_t c, slong prec)
{
acb_t r, t;
slong i;
if (len < 2)
{
acb_zero(R);
return;
}
acb_init(r);
acb_init(t);
acb_set(t, A + len - 2);
acb_set(Q + len - 2, A + len - 1);
acb_set(r, Q + len - 2);
/* TODO: avoid the extra assignments (but still support aliasing) */
for (i = len - 2; i > 0; i--)
{
acb_mul(r, r, c, prec);
acb_add(r, r, t, prec);
acb_set(t, A + i - 1);
acb_set(Q + i - 1, r);
}
acb_mul(r, r, c, prec);
acb_add(R, r, t, prec);
acb_clear(r);
acb_clear(t);
}
void
acb_dot_simple(acb_t res, const acb_t initial, int subtract,
acb_srcptr x, slong xstep, acb_srcptr y, slong ystep, slong len, slong prec)
{
slong i;
if (len <= 0)
{
if (initial == NULL)
acb_zero(res);
else
acb_set_round(res, initial, prec);
return;
}
if (initial == NULL)
{
acb_mul(res, x, y, prec);
}
else
{
if (subtract)
acb_neg(res, initial);
else
acb_set(res, initial);
acb_addmul(res, x, y, prec);
}
for (i = 1; i < len; i++)
acb_addmul(res, x + i * xstep, y + i * ystep, prec);
if (subtract)
acb_neg(res, res);
}
void
_acb_poly_binomial_transform_basecase(acb_ptr b, acb_srcptr a, slong alen, slong len, slong prec)
{
slong n, k;
fmpz_t t;
fmpz_init(t);
for (n = 0; n < len; n++)
{
acb_zero(b + n);
for (k = 0; k < FLINT_MIN(n + 1, alen); k++)
{
if (k == 0)
{
fmpz_one(t);
}
else
{
fmpz_mul_si(t, t, -(n - k + 1));
fmpz_divexact_ui(t, t, k);
}
acb_addmul_fmpz(b + n, a + k, t, prec);
}
}
fmpz_clear(t);
}
int
acb_mat_lu(long * P, acb_mat_t LU, const acb_mat_t A, long prec)
{
acb_t d, e;
acb_ptr * a;
long i, j, m, n, r, row, col;
int result;
m = acb_mat_nrows(A);
n = acb_mat_ncols(A);
result = 1;
if (m == 0 || n == 0)
return result;
acb_mat_set(LU, A);
a = LU->rows;
row = col = 0;
for (i = 0; i < m; i++)
P[i] = i;
acb_init(d);
acb_init(e);
while (row < m && col < n)
{
r = acb_mat_find_pivot_partial(LU, row, m, col);
if (r == -1)
{
result = 0;
break;
}
else if (r != row)
acb_mat_swap_rows(LU, P, row, r);
acb_set(d, a[row] + col);
for (j = row + 1; j < m; j++)
{
acb_div(e, a[j] + col, d, prec);
acb_neg(e, e);
_acb_vec_scalar_addmul(a[j] + col,
a[row] + col, n - col, e, prec);
acb_zero(a[j] + col);
acb_neg(a[j] + row, e);
}
row++;
col++;
}
acb_clear(d);
acb_clear(e);
return result;
}
void
acb_log1p(acb_t r, const acb_t z, slong prec)
{
slong magz, magx, magy;
if (acb_is_zero(z))
{
acb_zero(r);
return;
}
magx = arf_abs_bound_lt_2exp_si(arb_midref(acb_realref(z)));
magy = arf_abs_bound_lt_2exp_si(arb_midref(acb_imagref(z)));
magz = FLINT_MAX(magx, magy);
if (magz < -prec)
{
acb_log1p_tiny(r, z, prec);
}
else
{
if (magz < 0)
acb_add_ui(r, z, 1, prec + (-magz) + 4);
else
acb_add_ui(r, z, 1, prec + 4);
acb_log(r, r, prec);
}
}
void
_acb_hypgeom_coulomb_series(acb_ptr F, acb_ptr G,
acb_ptr Hpos, acb_ptr Hneg, const acb_t l, const acb_t eta,
acb_srcptr z, slong zlen, slong len, slong prec)
{
acb_ptr t, v;
if (len == 0)
return;
zlen = FLINT_MIN(zlen, len);
if (zlen == 1)
{
acb_hypgeom_coulomb(F, G, Hpos, Hneg, l, eta, z, prec);
if (F != NULL) _acb_vec_zero(F + 1, len - 1);
if (G != NULL) _acb_vec_zero(G + 1, len - 1);
if (Hpos != NULL) _acb_vec_zero(Hpos + 1, len - 1);
if (Hneg != NULL) _acb_vec_zero(Hneg + 1, len - 1);
return;
}
t = _acb_vec_init(len);
v = _acb_vec_init(zlen);
/* copy nonconstant part first to allow aliasing */
acb_zero(v);
_acb_vec_set(v + 1, z + 1, zlen - 1);
acb_hypgeom_coulomb_jet(F, G, Hpos, Hneg, l, eta, z, len, prec);
if (F != NULL)
{
_acb_vec_set(t, F, len);
_acb_poly_compose_series(F, t, len, v, zlen, len, prec);
}
if (G != NULL)
{
_acb_vec_set(t, G, len);
_acb_poly_compose_series(G, t, len, v, zlen, len, prec);
}
if (Hpos != NULL)
{
_acb_vec_set(t, Hpos, len);
_acb_poly_compose_series(Hpos, t, len, v, zlen, len, prec);
}
if (Hneg != NULL)
{
_acb_vec_set(t, Hneg, len);
_acb_poly_compose_series(Hneg, t, len, v, zlen, len, prec);
}
_acb_vec_clear(t, len);
_acb_vec_clear(v, zlen);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("csgn....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_t x, y;
arb_t a;
slong prec;
acb_init(x);
acb_init(y);
arb_init(a);
acb_randtest_special(x, state, 1 + n_randint(state, 200), 2 + n_randint(state, 100));
arb_randtest_special(a, state, 1 + n_randint(state, 200), 2 + n_randint(state, 100));
prec = 2 + n_randint(state, 200);
acb_csgn(a, x);
if (acb_is_zero(x))
{
acb_zero(y);
}
else
{
acb_mul(y, x, x, prec);
acb_sqrt(y, y, prec);
acb_div(y, y, x, prec);
}
if (!arb_contains(acb_realref(y), a))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("x = "); acb_printd(x, 15); flint_printf("\n\n");
flint_printf("a = "); arb_printd(a, 15); flint_printf("\n\n");
flint_printf("y = "); acb_printd(y, 15); flint_printf("\n\n");
abort();
}
acb_clear(x);
acb_clear(y);
arb_clear(a);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_erf(acb_t res, const acb_t z, slong prec)
{
double x, y, absz2, logz;
slong prec2;
if (!acb_is_finite(z))
{
acb_indeterminate(res);
return;
}
if (acb_is_zero(z))
{
acb_zero(res);
return;
}
if ((arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), 0) < 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), 0) < 0))
{
acb_hypgeom_erf_1f1a(res, z, prec);
return;
}
if ((arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), 64) > 0 ||
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), 64) > 0))
{
acb_hypgeom_erf_asymp(res, z, prec, prec);
return;
}
x = arf_get_d(arb_midref(acb_realref(z)), ARF_RND_DOWN);
y = arf_get_d(arb_midref(acb_imagref(z)), ARF_RND_DOWN);
absz2 = x * x + y * y;
logz = 0.5 * log(absz2);
if (logz - absz2 < -(prec + 8) * 0.69314718055994530942)
{
/* If the asymptotic term is small, we can
compute with reduced precision */
prec2 = FLINT_MIN(prec + 4 + (y*y - x*x - logz) * 1.4426950408889634074, (double) prec);
prec2 = FLINT_MAX(8, prec2);
prec2 = FLINT_MIN(prec2, prec);
acb_hypgeom_erf_asymp(res, z, prec, prec2);
}
else if (arf_cmpabs(arb_midref(acb_imagref(z)), arb_midref(acb_realref(z))) > 0)
{
acb_hypgeom_erf_1f1a(res, z, prec);
}
else
{
acb_hypgeom_erf_1f1b(res, z, prec);
}
}
void
acb_modular_lambda(acb_t r, const acb_t tau, long prec)
{
psl2z_t g;
arf_t one_minus_eps;
acb_t tau_prime, q;
acb_struct thetas[4];
int R[4], S[4], C;
int Rsum, qpower;
psl2z_init(g);
arf_init(one_minus_eps);
acb_init(tau_prime);
acb_init(q);
acb_init(thetas + 0);
acb_init(thetas + 1);
acb_init(thetas + 2);
acb_init(thetas + 3);
arf_set_ui_2exp_si(one_minus_eps, 63, -6);
acb_modular_fundamental_domain_approx(tau_prime, g, tau,
one_minus_eps, prec);
acb_modular_theta_transform(R, S, &C, g);
acb_exp_pi_i(q, tau_prime, prec);
acb_modular_theta_const_sum(thetas + 1, thetas + 2, thetas + 3, q, prec);
acb_zero(thetas + 0);
/* divide the transformation factors */
Rsum = 4 * (R[1] - R[2]);
/* possible factor [q^(+/- 1/4)]^4 needed for theta_1^4 or theta_2^4 */
qpower = (S[1] == 0 || S[1] == 1) - (S[2] == 0 || S[2] == 1);
acb_div(r, thetas + S[1], thetas + S[2], prec);
acb_mul(r, r, r, prec);
acb_mul(r, r, r, prec);
if ((Rsum & 7) == 4)
acb_neg(r, r);
if (qpower == 1)
acb_mul(r, r, q, prec);
else if (qpower == -1)
acb_div(r, r, q, prec);
psl2z_clear(g);
arf_clear(one_minus_eps);
acb_clear(tau_prime);
acb_clear(q);
acb_clear(thetas + 0);
acb_clear(thetas + 1);
acb_clear(thetas + 2);
acb_clear(thetas + 3);
}
void
_acb_poly_evaluate_rectangular(acb_t y, acb_srcptr poly,
slong len, const acb_t x, slong prec)
{
slong i, j, m, r;
acb_ptr xs;
acb_t s, t, c;
if (len < 3)
{
if (len == 0)
{
acb_zero(y);
}
else if (len == 1)
{
acb_set_round(y, poly + 0, prec);
}
else if (len == 2)
{
acb_mul(y, x, poly + 1, prec);
acb_add(y, y, poly + 0, prec);
}
return;
}
m = n_sqrt(len) + 1;
r = (len + m - 1) / m;
xs = _acb_vec_init(m + 1);
acb_init(s);
acb_init(t);
acb_init(c);
_acb_vec_set_powers(xs, x, m + 1, prec);
acb_set(y, poly + (r - 1) * m);
for (j = 1; (r - 1) * m + j < len; j++)
acb_addmul(y, xs + j, poly + (r - 1) * m + j, prec);
for (i = r - 2; i >= 0; i--)
{
acb_set(s, poly + i * m);
for (j = 1; j < m; j++)
acb_addmul(s, xs + j, poly + i * m + j, prec);
acb_mul(y, y, xs + m, prec);
acb_add(y, y, s, prec);
}
_acb_vec_clear(xs, m + 1);
acb_clear(s);
acb_clear(t);
acb_clear(c);
}
void
acb_mat_one(acb_mat_t mat)
{
slong i, j;
for (i = 0; i < acb_mat_nrows(mat); i++)
for (j = 0; j < acb_mat_ncols(mat); j++)
if (i == j)
acb_one(acb_mat_entry(mat, i, j));
else
acb_zero(acb_mat_entry(mat, i, j));
}
static void
_acb_hypgeom_li(acb_t res, const acb_t z, long prec)
{
if (acb_is_zero(z))
{
acb_zero(res);
}
else
{
acb_log(res, z, prec);
acb_hypgeom_ei(res, res, prec);
}
}
void
_acb_poly_set_length(acb_poly_t poly, slong len)
{
slong i;
if (poly->length > len)
{
for (i = len; i < poly->length; i++)
acb_zero(poly->coeffs + i);
}
poly->length = len;
}
void acb_hypgeom_beta_lower(acb_t res,
const acb_t a, const acb_t b, const acb_t z, int regularized, slong prec)
{
acb_t t, u;
if (acb_is_zero(z) && arb_is_positive(acb_realref(a)))
{
acb_zero(res);
return;
}
if (acb_is_one(z) && arb_is_positive(acb_realref(b)))
{
if (regularized)
acb_one(res);
else
acb_beta(res, a, b, prec);
return;
}
acb_init(t);
acb_init(u);
acb_sub_ui(t, b, 1, prec);
acb_neg(t, t);
acb_add_ui(u, a, 1, prec);
if (regularized)
{
acb_hypgeom_2f1(t, a, t, u, z, 1, prec);
acb_add(u, a, b, prec);
acb_gamma(u, u, prec);
acb_mul(t, t, u, prec);
acb_rgamma(u, b, prec);
acb_mul(t, t, u, prec);
}
else
{
acb_hypgeom_2f1(t, a, t, u, z, 0, prec);
acb_div(t, t, a, prec);
}
acb_pow(u, z, a, prec);
acb_mul(t, t, u, prec);
acb_set(res, t);
acb_clear(t);
acb_clear(u);
}
void
acb_dirichlet_pairing(acb_t res, const dirichlet_group_t G, ulong m, ulong n, slong prec)
{
ulong expo;
expo = dirichlet_pairing(G, m, n);
if (expo == DIRICHLET_CHI_NULL)
acb_zero(res);
else
{
fmpq_t t;
fmpq_init(t);
fmpq_set_si(t, 2 * expo, G->expo);
arb_sin_cos_pi_fmpq(acb_imagref(res), acb_realref(res), t, prec);
fmpq_clear(t);
}
}
static void
_acb_hypgeom_li_offset(acb_t res, const acb_t z, long prec)
{
if (acb_is_int(z) && arf_cmp_2exp_si(arb_midref(acb_realref(z)), 1) == 0)
{
acb_zero(res);
}
else
{
arb_t t;
arb_init(t);
_acb_hypgeom_const_li2(t, prec);
_acb_hypgeom_li(res, z, prec);
arb_sub(acb_realref(res), acb_realref(res), t, prec);
arb_clear(t);
}
}
void
acb_acos(acb_t res, const acb_t z, slong prec)
{
if (acb_is_one(z))
{
acb_zero(res);
}
else
{
acb_t t;
acb_init(t);
acb_asin(res, z, prec);
acb_const_pi(t, prec);
acb_mul_2exp_si(t, t, -1);
acb_sub(res, t, res, prec);
acb_clear(t);
}
}
void
_acb_poly_zeta_series(acb_ptr res, acb_srcptr h, slong hlen, const acb_t a, int deflate, slong len, slong prec)
{
acb_ptr t, u;
hlen = FLINT_MIN(hlen, len);
t = _acb_vec_init(len);
u = _acb_vec_init(len);
_acb_poly_zeta_cpx_reflect(t, h, a, deflate, len, prec);
/* compose with nonconstant part */
acb_zero(u);
_acb_vec_set(u + 1, h + 1, hlen - 1);
_acb_poly_compose_series(res, t, len, u, hlen, len, prec);
_acb_vec_clear(t, len);
_acb_vec_clear(u, len);
}
void
_acb_poly_compose_series(acb_ptr res, acb_srcptr poly1, slong len1,
acb_srcptr poly2, slong len2, slong n, slong prec)
{
if (len2 == 1)
{
acb_set_round(res, poly1, prec);
_acb_vec_zero(res + 1, n - 1);
}
else if (_acb_vec_is_zero(poly2 + 1, len2 - 2)) /* poly2 is a monomial */
{
slong i, j;
acb_t t;
acb_init(t);
acb_set(t, poly2 + len2 - 1);
acb_set_round(res, poly1, prec);
for (i = 1, j = len2 - 1; i < len1 && j < n; i++, j += len2 - 1)
{
acb_mul(res + j, poly1 + i, t, prec);
if (i + 1 < len1 && j + len2 - 1 < n)
acb_mul(t, t, poly2 + len2 - 1, prec);
}
if (len2 != 2)
for (i = 1; i < n; i++)
if (i % (len2 - 1) != 0)
acb_zero(res + i);
acb_clear(t);
}
else if (len1 < 6 || n < 6)
{
_acb_poly_compose_series_horner(res, poly1, len1, poly2, len2, n, prec);
}
else
{
_acb_poly_compose_series_brent_kung(res, poly1, len1, poly2, len2, n, prec);
}
}
void
_acb_poly_agm1_series(acb_ptr res, acb_srcptr z, long zlen, long len, long prec)
{
acb_ptr t, u;
zlen = FLINT_MIN(zlen, len);
t = _acb_vec_init(len);
u = _acb_vec_init(len);
acb_agm1_cpx(t, z, len, prec);
/* compose with nonconstant part */
acb_zero(u);
_acb_vec_set(u + 1, z + 1, zlen - 1);
_acb_poly_compose_series(res, t, len, u, zlen, len, prec);
_acb_vec_clear(t, len);
_acb_vec_clear(u, len);
}
void
_acb_poly_shift_left(acb_ptr res, acb_srcptr poly, long len, long n)
{
long i;
/* Copy in reverse to avoid writing over unshifted coefficients */
if (res != poly)
{
for (i = len; i--; )
acb_set(res + n + i, poly + i);
}
else
{
for (i = len; i--; )
acb_swap(res + n + i, res + i);
}
for (i = 0; i < n; i++)
acb_zero(res + i);
}
/* f(z) = sin(1/z), assume on real interval */
int
f_essing(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
if ((order == 0) && acb_is_real(z) && arb_contains_zero(acb_realref(z)))
{
/* todo: arb_zero_pm_one, arb_unit_interval? */
acb_zero(res);
mag_one(arb_radref(acb_realref(res)));
}
else
{
acb_inv(res, z, prec);
acb_sin(res, res, prec);
}
return 0;
}
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
acb_quadratic_roots_fmpz(acb_t r1, acb_t r2,
const fmpz_t a, const fmpz_t b, const fmpz_t c, slong prec)
{
fmpz_t d;
fmpz_init(d);
/* d = b^2 - 4ac */
fmpz_mul(d, a, c);
fmpz_mul_2exp(d, d, 2);
fmpz_submul(d, b, b);
fmpz_neg(d, d);
/* +/- sqrt(d) */
acb_zero(r1);
if (fmpz_sgn(d) >= 0)
{
arb_sqrt_fmpz(acb_realref(r1), d, prec + fmpz_bits(d) + 4);
}
else
{
fmpz_neg(d, d);
arb_sqrt_fmpz(acb_imagref(r1), d, prec + fmpz_bits(d) + 4);
}
acb_neg(r2, r1);
/* -b */
acb_sub_fmpz(r1, r1, b, prec + 4);
acb_sub_fmpz(r2, r2, b, prec + 4);
/* divide by 2a */
fmpz_mul_2exp(d, a, 1);
acb_div_fmpz(r1, r1, d, prec);
acb_div_fmpz(r2, r2, d, prec);
fmpz_clear(d);
return;
}
void
_arb_poly_evaluate_acb_horner(acb_t y, arb_srcptr f, long len,
const acb_t x, long prec)
{
if (len == 0)
{
acb_zero(y);
}
else if (len == 1 || acb_is_zero(x))
{
acb_set_round_arb(y, f, prec);
}
else if (len == 2)
{
acb_mul_arb(y, x, f + 1, prec);
acb_add_arb(y, y, f + 0, prec);
}
else
{
long i = len - 1;
acb_t t, u;
acb_init(t);
acb_init(u);
acb_set_arb(u, f + i);
for (i = len - 2; i >= 0; i--)
{
acb_mul(t, u, x, prec);
acb_add_arb(u, t, f + i, prec);
}
acb_swap(y, u);
acb_clear(t);
acb_clear(u);
}
}
