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_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_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_fresnel(arb_t res1, arb_t res2, const arb_t z, int normalized, slong prec)
{
if (!arb_is_finite(z))
{
if (res1 != NULL) arb_indeterminate(res1);
if (res2 != NULL) arb_indeterminate(res2);
}
else
{
acb_t t, u;
acb_init(t);
acb_init(u);
arb_set(acb_realref(t), z);
acb_hypgeom_fresnel(res1 ? t : NULL, res2 ? u : NULL, t, normalized, prec);
if (res1 != NULL) arb_swap(res1, acb_realref(t));
if (res2 != NULL) arb_swap(res2, acb_realref(u));
acb_clear(t);
acb_clear(u);
}
}
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_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;
}
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);
}
void
arb_hypgeom_ei(arb_t res, const arb_t z, slong prec)
{
if (!arb_is_finite(z))
{
arb_indeterminate(res);
}
else
{
acb_t t;
acb_init(t);
arb_set(acb_realref(t), z);
acb_hypgeom_ei(t, t, prec);
arb_swap(res, acb_realref(t));
acb_clear(t);
}
}
/* compose by poly2 = a*x^n + c, no aliasing; n >= 1 */
void
_arb_poly_compose_axnc(arb_ptr res, arb_srcptr poly1, slong len1,
const arb_t c, const arb_t a, slong n, slong prec)
{
slong i;
_arb_vec_set_round(res, poly1, len1, prec);
/* shift by c (c = 0 case will be fast) */
_arb_poly_taylor_shift(res, c, len1, prec);
/* multiply by powers of a */
if (!arb_is_one(a))
{
if (arb_equal_si(a, -1))
{
for (i = 1; i < len1; i += 2)
arb_neg(res + i, res + i);
}
else if (len1 == 2)
{
arb_mul(res + 1, res + 1, a, prec);
}
else
{
arb_t t;
arb_init(t);
arb_set(t, a);
for (i = 1; i < len1; i++)
{
arb_mul(res + i, res + i, t, prec);
if (i + 1 < len1)
arb_mul(t, t, a, prec);
}
arb_clear(t);
}
}
/* stretch */
for (i = len1 - 1; i >= 1 && n > 1; i--)
{
arb_swap(res + i * n, res + i);
_arb_vec_zero(res + (i - 1) * n + 1, n - 1);
}
}
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
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);
}
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);
}
}
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);
}
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);
}
void
_arb_poly_evaluate_horner(arb_t y, arb_srcptr f, slong len,
const arb_t x, slong prec)
{
if (len == 0)
{
arb_zero(y);
}
else if (len == 1 || arb_is_zero(x))
{
arb_set_round(y, f, prec);
}
else if (len == 2)
{
arb_mul(y, x, f + 1, prec);
arb_add(y, y, f + 0, prec);
}
else
{
slong i = len - 1;
arb_t t, u;
arb_init(t);
arb_init(u);
arb_set(u, f + i);
for (i = len - 2; i >= 0; i--)
{
arb_mul(t, u, x, prec);
arb_add(u, f + i, t, prec);
}
arb_swap(y, u);
arb_clear(t);
arb_clear(u);
}
}
void
arb_mat_approx_solve_triu_classical(arb_mat_t X, const arb_mat_t U,
const arb_mat_t B, int unit, slong prec)
{
slong i, j, n, m;
arb_ptr tmp;
arb_t s;
n = U->r;
m = B->c;
arb_init(s);
tmp = flint_malloc(sizeof(arb_struct) * n);
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
tmp[j] = *arb_mat_entry(X, j, i);
for (j = n - 1; j >= 0; j--)
{
arb_approx_dot(s, arb_mat_entry(B, j, i), 1, U->rows[j] + j + 1, 1, tmp + j + 1, 1, n - j - 1, prec);
if (!unit)
arb_approx_div(tmp + j, s, arb_mat_entry(U, j, j), prec);
else
arb_swap(tmp + j, s);
}
for (j = 0; j < n; j++)
*arb_mat_entry(X, j, i) = tmp[j];
}
flint_free(tmp);
arb_clear(s);
}
void
acb_calc_cauchy_bound(arb_t bound, acb_calc_func_t func, void * param,
const acb_t x, const arb_t radius, slong maxdepth, slong prec)
{
slong i, n, depth, wp;
arb_t pi, theta, v, s1, c1, s2, c2, st, ct;
acb_t t, u;
arb_t b;
arb_init(pi);
arb_init(theta);
arb_init(v);
arb_init(s1);
arb_init(c1);
arb_init(s2);
arb_init(c2);
arb_init(st);
arb_init(ct);
acb_init(t);
acb_init(u);
arb_init(b);
wp = prec + 20;
arb_const_pi(pi, wp);
arb_zero_pm_inf(b);
for (depth = 0, n = 16; depth < maxdepth; n *= 2, depth++)
{
arb_zero(b);
/* theta = 2 pi / n */
arb_div_ui(theta, pi, n, wp);
arb_mul_2exp_si(theta, theta, 1);
/* sine and cosine of i*theta and (i+1)*theta */
arb_zero(s1);
arb_one(c1);
arb_sin_cos(st, ct, theta, wp);
arb_set(s2, st);
arb_set(c2, ct);
for (i = 0; i < n; i++)
{
/* sine and cosine of 2 pi ([i,i+1]/n) */
/* since we use power of two subdivision points, the
sine and cosine are monotone on each subinterval */
arb_union(acb_realref(t), c1, c2, wp);
arb_union(acb_imagref(t), s1, s2, wp);
acb_mul_arb(t, t, radius, wp);
acb_add(t, t, x, prec);
/* next angle */
arb_mul(v, c2, ct, wp);
arb_mul(c1, s2, st, wp);
arb_sub(c1, v, c1, wp);
arb_mul(v, c2, st, wp);
arb_mul(s1, s2, ct, wp);
arb_add(s1, v, s1, wp);
arb_swap(c1, c2);
arb_swap(s1, s2);
func(u, t, param, 1, prec);
acb_abs(v, u, prec);
arb_add(b, b, v, prec);
}
arb_div_ui(b, b, n, prec);
if (arb_is_positive(b))
break;
}
arb_set(bound, b);
arb_clear(pi);
arb_clear(theta);
arb_clear(v);
acb_clear(t);
acb_clear(u);
arb_clear(b);
arb_clear(s1);
arb_clear(c1);
arb_clear(s2);
arb_clear(c2);
arb_clear(st);
arb_clear(ct);
}
