void
acb_log_sin_pi(acb_t res, const acb_t z, slong prec)
{
if (!acb_is_finite(z))
{
acb_indeterminate(res);
return;
}
if (arb_is_positive(acb_imagref(z)) ||
(arb_is_zero(acb_imagref(z)) && arb_is_negative(acb_realref(z))))
{
acb_log_sin_pi_half(res, z, prec, 1);
}
else if (arb_is_negative(acb_imagref(z)) ||
(arb_is_zero(acb_imagref(z)) && arb_is_positive(acb_realref(z))))
{
acb_log_sin_pi_half(res, z, prec, 0);
}
else
{
acb_t t;
acb_init(t);
acb_log_sin_pi_half(t, z, prec, 1);
acb_log_sin_pi_half(res, z, prec, 0);
arb_union(acb_realref(res), acb_realref(res), acb_realref(t), prec);
arb_union(acb_imagref(res), acb_imagref(res), acb_imagref(t), prec);
acb_clear(t);
}
}
int acb_cmp_pretty(const acb_t a, const acb_t b)
{
arb_t t, u, v;
int res;
arb_init(t);
arb_init(u);
arb_init(v);
arb_abs(u, acb_imagref(a));
arb_abs(v, acb_imagref(b));
arb_sub(t, u, v, MAG_BITS);
res = 0;
if (arb_contains_zero(t))
{
arb_sub(t, acb_realref(a), acb_realref(b), MAG_BITS);
res = arb_is_positive(t) ? 1 : -1;
}
else
{
res = arb_is_positive(t) ? 1 : -1;
}
arb_clear(t);
arb_clear(u);
arb_clear(v);
return res;
}
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_hypgeom_bessel_i_asymp_prefactors(acb_t A, acb_t B, acb_t C,
const acb_t nu, const acb_t z, long prec)
{
acb_t t, u;
acb_init(t);
acb_init(u);
/* C = (2 pi z)^(-1/2) */
acb_const_pi(C, prec);
acb_mul_2exp_si(C, C, 1);
acb_mul(C, C, z, prec);
acb_rsqrt(C, C, prec);
if (arb_is_positive(acb_imagref(z)) ||
(arb_is_zero(acb_imagref(z)) && arb_is_negative(acb_realref(z))))
{
acb_exp_pi_i(t, nu, prec);
acb_mul_onei(t, t);
}
else if (arb_is_negative(acb_imagref(z)) ||
(arb_is_zero(acb_imagref(z)) && arb_is_positive(acb_realref(z))))
{
acb_neg(t, nu);
acb_exp_pi_i(t, t, prec);
acb_mul_onei(t, t);
acb_neg(t, t);
}
else
{
acb_exp_pi_i(t, nu, prec);
acb_mul_onei(t, t);
acb_neg(u, nu);
acb_exp_pi_i(u, u, prec);
acb_mul_onei(u, u);
acb_neg(u, u);
arb_union(acb_realref(t), acb_realref(t), acb_realref(u), prec);
arb_union(acb_imagref(t), acb_imagref(t), acb_imagref(u), prec);
}
acb_exp_invexp(B, A, z, prec);
acb_mul(A, A, t, prec);
acb_clear(t);
acb_clear(u);
}
void
acb_real_min(acb_t res, const acb_t x, const acb_t y, int analytic, slong prec)
{
arb_t t;
if (!acb_is_finite(x) || !acb_is_finite(y))
{
acb_indeterminate(res);
return;
}
arb_init(t);
arb_sub(t, acb_realref(x), acb_realref(y), prec);
if (arb_is_positive(t))
acb_set_round(res, y, prec);
else if (arb_is_negative(t))
acb_set_round(res, x, prec);
else if (!analytic)
acb_union(res, x, y, prec);
else
acb_indeterminate(res);
arb_clear(t);
}
static __inline__ int
arb_sgn2(arb_t a)
{
if (arb_is_positive(a)) return 1;
else if (arb_is_negative(a)) return -1;
return 0;
}
void
acb_hypgeom_bessel_j_asymp_prefactors(acb_t Ap, acb_t Am, acb_t C,
const acb_t nu, const acb_t z, long prec)
{
if (arb_is_positive(acb_realref(z)))
{
acb_t t, u;
acb_init(t);
acb_init(u);
/* -(2nu+1)/4 * pi + z */
acb_mul_2exp_si(t, nu, 1);
acb_add_ui(t, t, 1, prec);
acb_mul_2exp_si(t, t, -2);
acb_neg(t, t);
acb_const_pi(u, prec);
acb_mul(t, t, u, prec);
acb_add(t, t, z, prec);
acb_mul_onei(t, t);
acb_exp_invexp(Ap, Am, t, prec);
/* (2 pi z)^(-1/2) */
acb_const_pi(C, prec);
acb_mul_2exp_si(C, C, 1);
acb_mul(C, C, z, prec);
acb_rsqrt(C, C, prec);
acb_clear(t);
acb_clear(u);
return;
}
acb_hypgeom_bessel_j_asymp_prefactors_fallback(Ap, Am, C, nu, z, prec);
}
void
acb_polygamma(acb_t res, const acb_t s, const acb_t z, long prec)
{
if (acb_is_zero(s))
{
acb_digamma(res, z, prec);
}
else if (acb_is_int(s) && arb_is_positive(acb_realref(s)))
{
acb_t t, u;
acb_init(t);
acb_init(u);
acb_add_ui(t, s, 1, prec);
acb_gamma(u, t, prec);
acb_hurwitz_zeta(t, t, z, prec);
if (arf_is_int_2exp_si(arb_midref(acb_realref(s)), 1))
acb_neg(t, t);
acb_mul(res, t, u, prec);
acb_clear(t);
acb_clear(u);
}
else
{
acb_t t, u;
acb_struct v[2];
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(v + 1);
/* u = psi(-s) + gamma */
acb_neg(t, s);
acb_digamma(u, t, prec);
arb_const_euler(acb_realref(v), prec);
arb_add(acb_realref(u), acb_realref(u), acb_realref(v), prec);
acb_add_ui(t, s, 1, prec);
_acb_poly_zeta_cpx_series(v, t, z, 0, 2, prec);
acb_addmul(v + 1, v, u, prec);
acb_neg(t, s);
acb_rgamma(u, t, prec);
acb_mul(res, v + 1, u, prec);
acb_clear(v);
acb_clear(v + 1);
acb_clear(t);
acb_clear(u);
}
}
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);
}
/* 0 means that it *could* be zero; otherwise +/- 1 */
static __inline__ int
_arb_sign(const arb_t t)
{
if (arb_is_positive(t))
return 1;
else if (arb_is_negative(t))
return -1;
else
return 0;
}
void
acb_lambertw_left(acb_t res, const acb_t z, const fmpz_t k, slong prec)
{
if (acb_contains_zero(z) && !(fmpz_equal_si(k, -1) && acb_is_real(z)))
{
acb_indeterminate(res);
return;
}
if (arb_is_positive(acb_imagref(z)))
{
acb_lambertw(res, z, k, 0, prec);
}
else if (arb_is_nonpositive(acb_imagref(z)))
{
fmpz_t kk;
fmpz_init(kk);
fmpz_add_ui(kk, k, 1);
fmpz_neg(kk, kk);
acb_conj(res, z);
acb_lambertw(res, res, kk, 0, prec);
acb_conj(res, res);
fmpz_clear(kk);
}
else
{
acb_t za, zb;
fmpz_t kk;
acb_init(za);
acb_init(zb);
fmpz_init(kk);
acb_set(za, z);
acb_conj(zb, z);
arb_nonnegative_part(acb_imagref(za), acb_imagref(za));
arb_nonnegative_part(acb_imagref(zb), acb_imagref(zb));
fmpz_add_ui(kk, k, 1);
fmpz_neg(kk, kk);
acb_lambertw(za, za, k, 0, prec);
acb_lambertw(zb, zb, kk, 0, prec);
acb_conj(zb, zb);
acb_union(res, za, zb, prec);
acb_clear(za);
acb_clear(zb);
fmpz_clear(kk);
}
}
/* Check if z crosses a branch cut. */
int
acb_lambertw_branch_crossing(const acb_t z, const acb_t ez1, const fmpz_t k)
{
if (arb_contains_zero(acb_imagref(z)) && !arb_is_nonnegative(acb_imagref(z)))
{
if (fmpz_is_zero(k))
{
if (!arb_is_positive(acb_realref(ez1)))
{
return 1;
}
}
else if (!arb_is_positive(acb_realref(z)))
{
return 1;
}
}
return 0;
}
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
_acb_poly_zeta_cpx_series(acb_ptr z, const acb_t s, const acb_t a, int deflate, slong d, slong prec)
{
ulong M, N;
slong i;
mag_t bound;
arb_ptr vb;
int is_real, const_is_real;
if (d < 1)
return;
if (!acb_is_finite(s) || !acb_is_finite(a))
{
_acb_vec_indeterminate(z, d);
return;
}
is_real = const_is_real = 0;
if (acb_is_real(s) && acb_is_real(a))
{
if (arb_is_positive(acb_realref(a)))
{
is_real = const_is_real = 1;
}
else if (arb_is_int(acb_realref(a)) &&
arb_is_int(acb_realref(s)) &&
arb_is_nonpositive(acb_realref(s)))
{
const_is_real = 1;
}
}
mag_init(bound);
vb = _arb_vec_init(d);
_acb_poly_zeta_em_choose_param(bound, &N, &M, s, a, FLINT_MIN(d, 2), prec, MAG_BITS);
_acb_poly_zeta_em_bound(vb, s, a, N, M, d, MAG_BITS);
_acb_poly_zeta_em_sum(z, s, a, deflate, N, M, d, prec);
for (i = 0; i < d; i++)
{
arb_get_mag(bound, vb + i);
arb_add_error_mag(acb_realref(z + i), bound);
if (!is_real && !(i == 0 && const_is_real))
arb_add_error_mag(acb_imagref(z + i), bound);
}
mag_clear(bound);
_arb_vec_clear(vb, d);
}
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);
}
int main()
{
int iter;
FLINT_TEST_INIT(state);
test_field1(state);
test_field2(state);
for (iter = 0; iter < 100; iter++)
{
renf_t nf;
renf_elem_t a;
fmpz_t f;
arb_t e;
fmpz_init(f);
arb_init(e);
renf_randtest(nf, state,
2 + n_randint(state, 20), /* length */
8 + n_randint(state, 2408), /* prec */
10 + n_randint(state, 10) /* bits */
);
renf_elem_init(a, nf);
renf_elem_randtest(a, state, 30 + n_randint(state, 10), nf);
renf_elem_ceil(f, a, nf);
arb_sub_fmpz(e, a->emb, f, 1024);
if (arb_is_positive(e))
{
printf("FAIL:\n");
abort();
}
arb_add_ui(e, e, 1, 1024);
if (arb_is_negative(e))
{
printf("FAIL:\n");
abort();
}
renf_elem_clear(a, nf);
renf_clear(nf);
fmpz_clear(f);
arb_clear(e);
}
FLINT_TEST_CLEANUP(state);
return 0;
}
void
arb_hypgeom_chi(arb_t res, const arb_t z, slong prec)
{
if (!arb_is_finite(z) || !arb_is_positive(z))
{
arb_indeterminate(res);
}
else
{
acb_t t;
acb_init(t);
arb_set(acb_realref(t), z);
acb_hypgeom_chi(t, t, prec);
arb_swap(res, acb_realref(t));
acb_clear(t);
}
}
/* 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;
}
static int
check_block(arb_calc_func_t func, void * param, const arf_interval_t block,
int asign, int bsign, slong prec)
{
arb_struct t[2];
arb_t x;
int result;
arb_init(t + 0);
arb_init(t + 1);
arb_init(x);
arf_interval_get_arb(x, block, prec);
func(t, x, param, 1, prec);
result = BLOCK_UNKNOWN;
if (arb_is_positive(t) || arb_is_negative(t))
{
result = BLOCK_NO_ZERO;
}
else
{
if ((asign < 0 && bsign > 0) || (asign > 0 && bsign < 0))
{
func(t, x, param, 2, prec);
if (arb_is_finite(t + 1) && !arb_contains_zero(t + 1))
{
result = BLOCK_ISOLATED_ZERO;
}
}
}
arb_clear(t + 0);
arb_clear(t + 1);
arb_clear(x);
return result;
}
/* u[0..l1[ contains roots re(ui)<=0
u[l1..d-2[ roots with re(ui) > 0
the last two components are set to
(b-a)/2 and (a+b)/(b-a)
returns l1
*/
slong
ab_points(acb_ptr u, acb_srcptr x, edge_t e, slong d, slong prec)
{
slong k, l;
acb_t ab, ba; /* a + b and b - a */
acb_init(ab);
acb_init(ba);
acb_set(ba, x + e.b);
acb_sub(ba, ba, x + e.a, prec);
acb_set(ab, x + e.a);
acb_add(ab, ba, x + e.b, prec);
for (k = 0, l = 0; k < d; k++)
{
if (k == e.a || k == e.b)
continue;
acb_mul_2exp_si(u + l, x + k, 1);
acb_sub(u + l, u + l, ab, prec);
acb_div(u + l, u + l, ba, prec);
l++;
}
/* now l = d - 2, set last two */
acb_mul_2exp_si(u + l, ba, -1);
acb_div(u + l + 1, ab, ba, prec);
/* reorder */
for (k = 0; k < l; k++)
if (arb_is_positive(acb_realref(u + k)))
acb_swap(u + k--, u + l--);
acb_clear(ab);
acb_clear(ba);
return l;
}
/* F = 1 + U + U^2 + ... = 1/(1-U) assuming that U[0] is positive;
indeterminate if not convergent */
static void
arb_poly_geometric_sum(arb_poly_t F, const arb_poly_t U, long len, long prec)
{
if (U->length == 0)
{
arb_poly_one(F);
return;
}
arb_poly_add_si(F, U, -1, prec);
arb_poly_neg(F, F);
if (F->length > 0 && arb_is_positive(F->coeffs))
{
arb_poly_inv_series(F, F, len, prec);
}
else
{
arb_poly_fit_length(F, len);
_arb_vec_indeterminate(F->coeffs, len);
_arb_poly_set_length(F, len);
}
}
/* F = 1 + U + U^2 + U^3 + ... = 1/(1-U)
U = product of (1 + |A-B|/(|B[0] - |B[1:]|)
product of (1 / (|B[0] - |B[1:]|))
* |Z|
*/
void
acb_hypgeom_pfq_series_bound_factor(arb_poly_t F,
const acb_poly_struct * a, long p,
const acb_poly_struct * b, long q,
const acb_poly_t z,
long n, long len, long prec)
{
long i;
arb_poly_t T, U, V;
acb_poly_t BN, AB;
/* not convergent */
if (p > q)
{
arb_poly_fit_length(F, len);
_arb_vec_indeterminate(F->coeffs, len);
_arb_poly_set_length(F, len);
return;
}
arb_poly_init(T);
arb_poly_init(U);
arb_poly_init(V);
acb_poly_init(BN);
acb_poly_init(AB);
acb_poly_majorant(U, z, prec);
for (i = 0; i < q; i++)
{
acb_poly_add_si(BN, b + i, n, prec);
if (acb_poly_length(BN) != 0 &&
arb_is_positive(acb_realref(BN->coeffs)))
{
if (i < p)
{
/* 1 + |a-b|/reciprocal_majorant(b + n) */
acb_poly_sub(AB, a + i, b + i, prec);
acb_poly_majorant(T, AB, prec);
acb_poly_reciprocal_majorant(V, BN, prec);
arb_poly_div_series(T, T, V, len, prec);
arb_poly_add_si(T, T, 1, prec);
arb_poly_mullow(U, U, T, len, prec);
}
else
{
acb_poly_reciprocal_majorant(T, BN, prec);
arb_poly_div_series(U, U, T, len, prec);
}
}
else
{
arb_poly_fit_length(U, len);
_arb_vec_indeterminate(U->coeffs, len);
_arb_poly_set_length(U, len);
break;
}
}
/* F = 1/(1-U) */
arb_poly_geometric_sum(F, U, len, prec);
arb_poly_clear(T);
arb_poly_clear(U);
arb_poly_clear(V);
acb_poly_clear(BN);
acb_poly_clear(AB);
}
void
acb_hypgeom_ci_asymp(acb_t res, const acb_t z, slong prec)
{
acb_t t, u, w, v, one;
acb_init(t);
acb_init(u);
acb_init(w);
acb_init(v);
acb_init(one);
acb_one(one);
acb_mul_onei(w, z);
/* u = U(1,1,iz) */
acb_hypgeom_u_asymp(u, one, one, w, -1, prec);
/* v = e^(-iz) */
acb_neg(v, w);
acb_exp(v, v, prec);
acb_mul(t, u, v, prec);
if (acb_is_real(z))
{
arb_div(acb_realref(t), acb_imagref(t), acb_realref(z), prec);
arb_zero(acb_imagref(t));
acb_neg(t, t);
}
else
{
/* u = U(1,1,-iz) */
acb_neg(w, w);
acb_hypgeom_u_asymp(u, one, one, w, -1, prec);
acb_inv(v, v, prec);
acb_submul(t, u, v, prec);
acb_div(t, t, w, prec);
acb_mul_2exp_si(t, t, -1);
}
if (arb_is_zero(acb_realref(z)))
{
if (arb_is_positive(acb_imagref(z)))
{
arb_const_pi(acb_imagref(t), prec);
arb_mul_2exp_si(acb_imagref(t), acb_imagref(t), -1);
}
else if (arb_is_negative(acb_imagref(z)))
{
arb_const_pi(acb_imagref(t), prec);
arb_mul_2exp_si(acb_imagref(t), acb_imagref(t), -1);
arb_neg(acb_imagref(t), acb_imagref(t));
}
else
{
acb_const_pi(u, prec);
acb_mul_2exp_si(u, u, -1);
arb_zero(acb_imagref(t));
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
else
{
/* 0 if positive or positive imaginary
pi if upper left quadrant (including negative real axis)
-pi if lower left quadrant (including negative imaginary axis) */
if (arb_is_positive(acb_realref(z)))
{
/* do nothing */
}
else if (arb_is_negative(acb_realref(z)) && arb_is_nonnegative(acb_imagref(z)))
{
acb_const_pi(u, prec);
arb_add(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else if (arb_is_nonpositive(acb_realref(z)) && arb_is_negative(acb_imagref(z)))
{
acb_const_pi(u, prec);
arb_sub(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else
{
/* add [-pi,pi] */
acb_const_pi(u, prec);
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
acb_swap(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(w);
acb_clear(v);
acb_clear(one);
}
void
_arb_poly_lgamma_series(arb_ptr res, arb_srcptr h, slong hlen, slong len, slong prec)
{
int reflect;
slong r, n, wp;
arb_t zr;
arb_ptr t, u;
if (!arb_is_positive(h))
{
_arb_vec_indeterminate(res, len);
return;
}
hlen = FLINT_MIN(hlen, len);
wp = prec + FLINT_BIT_COUNT(prec);
t = _arb_vec_init(len);
u = _arb_vec_init(len);
arb_init(zr);
/* use zeta values at small integers */
if (arb_is_int(h) && (arf_cmpabs_ui(arb_midref(h), prec / 2) < 0))
{
r = arf_get_si(arb_midref(h), ARF_RND_DOWN);
if (r <= 0)
{
_arb_vec_indeterminate(res, len);
goto cleanup;
}
else
{
_arb_poly_lgamma_series_at_one(u, len, wp);
if (r != 1)
{
arb_one(zr);
_log_rising_ui_series(t, zr, r - 1, len, wp);
_arb_vec_add(u, u, t, len, wp);
}
}
}
else if (len <= 2)
{
arb_lgamma(u, h, wp);
if (len == 2)
arb_digamma(u + 1, h, wp);
}
else
{
/* otherwise use Stirling series */
arb_gamma_stirling_choose_param(&reflect, &r, &n, h, 0, 0, wp);
arb_add_ui(zr, h, r, wp);
_arb_poly_gamma_stirling_eval(u, zr, n, len, wp);
if (r != 0)
{
_log_rising_ui_series(t, h, r, len, wp);
_arb_vec_sub(u, u, t, len, wp);
}
}
/* compose with nonconstant part */
arb_zero(t);
_arb_vec_set(t + 1, h + 1, hlen - 1);
_arb_poly_compose_series(res, u, len, t, hlen, len, prec);
cleanup:
arb_clear(zr);
_arb_vec_clear(t, len);
_arb_vec_clear(u, len);
}
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);
}
void
acb_hypgeom_chi_asymp(acb_t res, const acb_t z, slong prec)
{
acb_t t, u, v, one;
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(one);
acb_one(one);
/* u = U(1,1,z) */
acb_hypgeom_u_asymp(u, one, one, z, -1, prec);
/* v = e^(-z) */
acb_neg(v, z);
acb_exp(v, v, prec);
acb_mul(t, u, v, prec);
if (arb_is_zero(acb_realref(z)))
{
arb_div(acb_realref(t), acb_imagref(t), acb_imagref(z), prec);
arb_zero(acb_imagref(t));
acb_neg(t, t);
}
else
{
/* u = U(1,1,-z) */
acb_neg(u, z);
acb_hypgeom_u_asymp(u, one, one, u, -1, prec);
acb_inv(v, v, prec);
acb_submul(t, u, v, prec);
acb_div(t, t, z, prec);
acb_mul_2exp_si(t, t, -1);
acb_neg(t, t);
}
if (acb_is_real(z))
{
if (arb_is_positive(acb_realref(z)))
{
arb_zero(acb_imagref(t));
}
else if (arb_is_negative(acb_realref(z)))
{
arb_const_pi(acb_imagref(t), prec);
}
else
{
/* add [-pi,pi]/2 i */
acb_const_pi(u, prec);
arb_zero(acb_imagref(t));
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
else
{
/* -pi/2 if positive real or in lower half plane
pi/2 if negative real or in upper half plane */
if (arb_is_negative(acb_imagref(z)))
{
acb_const_pi(u, prec);
acb_mul_2exp_si(u, u, -1);
arb_sub(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else if (arb_is_positive(acb_imagref(z)))
{
acb_const_pi(u, prec);
acb_mul_2exp_si(u, u, -1);
arb_add(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else
{
/* add [-pi,pi]/2 i */
acb_const_pi(u, prec);
acb_mul_2exp_si(u, u, -1);
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
acb_swap(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(v);
acb_clear(one);
}
void
_acb_poly_lgamma_series(acb_ptr res, acb_srcptr h, slong hlen, slong len, slong prec)
{
int reflect;
slong i, r, n, wp;
acb_t zr;
acb_ptr t, u;
hlen = FLINT_MIN(hlen, len);
if (hlen == 1)
{
acb_lgamma(res, h, prec);
if (acb_is_finite(res))
_acb_vec_zero(res + 1, len - 1);
else
_acb_vec_indeterminate(res + 1, len - 1);
return;
}
if (len == 2)
{
acb_t v;
acb_init(v);
acb_set(v, h + 1);
acb_digamma(res + 1, h, prec);
acb_lgamma(res, h, prec);
acb_mul(res + 1, res + 1, v, prec);
acb_clear(v);
return;
}
/* use real code for real input and output */
if (_acb_vec_is_real(h, hlen) && arb_is_positive(acb_realref(h)))
{
arb_ptr tmp = _arb_vec_init(len);
for (i = 0; i < hlen; i++)
arb_set(tmp + i, acb_realref(h + i));
_arb_poly_lgamma_series(tmp, tmp, hlen, len, prec);
for (i = 0; i < len; i++)
acb_set_arb(res + i, tmp + i);
_arb_vec_clear(tmp, len);
return;
}
wp = prec + FLINT_BIT_COUNT(prec);
t = _acb_vec_init(len);
u = _acb_vec_init(len);
acb_init(zr);
/* use Stirling series */
acb_gamma_stirling_choose_param(&reflect, &r, &n, h, 1, 0, wp);
if (reflect)
{
/* log gamma(h+x) = log rf(1-(h+x), r) - log gamma(1-(h+x)+r) - log sin(pi (h+x)) + log(pi) */
if (r != 0) /* otherwise t = 0 */
{
acb_sub_ui(u, h, 1, wp);
acb_neg(u, u);
_log_rising_ui_series(t, u, r, len, wp);
for (i = 1; i < len; i += 2)
acb_neg(t + i, t + i);
}
acb_sub_ui(u, h, 1, wp);
acb_neg(u, u);
acb_add_ui(zr, u, r, wp);
_acb_poly_gamma_stirling_eval(u, zr, n, len, wp);
for (i = 1; i < len; i += 2)
acb_neg(u + i, u + i);
_acb_vec_sub(t, t, u, len, wp);
/* log(sin) is unstable with large imaginary parts;
cot_pi is implemented in a numerically stable way */
acb_set(u, h);
acb_one(u + 1);
_acb_poly_cot_pi_series(u, u, 2, len - 1, wp);
_acb_poly_integral(u, u, len, wp);
acb_const_pi(u, wp);
_acb_vec_scalar_mul(u + 1, u + 1, len - 1, u, wp);
acb_log_sin_pi(u, h, wp);
_acb_vec_sub(u, t, u, len, wp);
acb_const_pi(t, wp); /* todo: constant for log pi */
acb_log(t, t, wp);
acb_add(u, u, t, wp);
}
else
{
/* log gamma(x) = log gamma(x+r) - log rf(x,r) */
acb_add_ui(zr, h, r, wp);
_acb_poly_gamma_stirling_eval(u, zr, n, len, wp);
if (r != 0)
{
_log_rising_ui_series(t, h, r, len, wp);
_acb_vec_sub(u, u, t, len, wp);
}
}
/* compose with nonconstant part */
acb_zero(t);
_acb_vec_set(t + 1, h + 1, hlen - 1);
_acb_poly_compose_series(res, u, len, t, hlen, len, prec);
acb_clear(zr);
_acb_vec_clear(t, len);
_acb_vec_clear(u, len);
}
int
_acb_poly_validate_real_roots(acb_srcptr roots, acb_srcptr poly, long len, long prec)
{
long i, deg, num_real;
arb_ptr real;
int result;
deg = len - 1;
num_real = 0;
result = 1;
if (deg <= 1)
return 1;
real = _arb_vec_init(deg);
/* pick out the candidate real roots */
for (i = 0; i < deg; i++)
{
if (arb_contains_zero(acb_imagref(roots + i)))
{
arb_set(real + num_real, acb_realref(roots + i));
num_real++;
}
}
/* number of real roots must be even if the polynomial is even,
and odd if the polynomial is odd (unless there are repeated roots...
in which case the input is invalid) */
if ((num_real % 2) != (deg % 2))
{
result = 0;
}
else if (num_real > 0)
{
int sign_neg_inf, sign_pos_inf, prev_sign;
acb_t t;
acb_init(t);
/* by assumption that the roots are real and isolated, the lead
coefficient really must be known to be either positive or negative */
sign_pos_inf = arb_is_positive(acb_realref(poly + deg)) ? 1 : -1;
sign_neg_inf = (deg % 2) ? -sign_pos_inf : sign_pos_inf;
/* now we check that there's a sign change between each root */
_arb_vec_sort_mid(real, num_real);
prev_sign = sign_neg_inf;
for (i = 0; i < num_real - 1; i++)
{
/* set t to the midpoint between the midpoints */
arb_zero(acb_imagref(t));
arf_add(arb_midref(acb_realref(t)),
arb_midref(real + i), arb_midref(real + i + 1), prec, ARF_RND_DOWN);
arf_mul_2exp_si(arb_midref(acb_realref(t)), arb_midref(acb_realref(t)), -1);
mag_zero(arb_radref(acb_realref(t)));
/* check that this point really is between both intervals (one interval
could be much wider than the other */
if (arb_lt(real + i, acb_realref(t)) && arb_lt(acb_realref(t), real + i + 1))
{
/* check sign change */
_acb_poly_evaluate(t, poly, len, t, prec);
if (prev_sign == 1)
result = arb_is_negative(acb_realref(t));
else
result = arb_is_positive(acb_realref(t));
if (!result)
break;
prev_sign = -prev_sign;
}
else
{
result = 0;
break;
}
}
acb_clear(t);
}
_arb_vec_clear(real, deg);
return result;
}
void
acb_hypgeom_2f1(acb_t res, const acb_t a, const acb_t b,
const acb_t c, const acb_t z, int flags, slong prec)
{
int algorithm, regularized;
regularized = flags & ACB_HYPGEOM_2F1_REGULARIZED;
if (!acb_is_finite(a) || !acb_is_finite(b) || !acb_is_finite(c) || !acb_is_finite(z))
{
acb_indeterminate(res);
return;
}
if (acb_is_zero(z))
{
if (regularized)
acb_rgamma(res, c, prec);
else
acb_one(res);
return;
}
if (regularized && acb_is_int(c) && arb_is_nonpositive(acb_realref(c)))
{
if ((acb_is_int(a) && arb_is_nonpositive(acb_realref(a)) &&
arf_cmp(arb_midref(acb_realref(a)), arb_midref(acb_realref(c))) >= 0) ||
(acb_is_int(b) && arb_is_nonpositive(acb_realref(b)) &&
arf_cmp(arb_midref(acb_realref(b)), arb_midref(acb_realref(c))) >= 0))
{
acb_zero(res);
return;
}
}
if (regularized && acb_eq(a, c))
{
_acb_hypgeom_2f1r_reduced(res, b, c, z, prec);
return;
}
if (regularized && acb_eq(b, c))
{
_acb_hypgeom_2f1r_reduced(res, a, c, z, prec);
return;
}
/* polynomial */
if (acb_is_int(a) && arf_sgn(arb_midref(acb_realref(a))) <= 0 &&
arf_cmpabs_ui(arb_midref(acb_realref(a)), prec) < 0)
{
acb_hypgeom_2f1_direct(res, a, b, c, z, regularized, prec);
return;
}
/* polynomial */
if (acb_is_int(b) && arf_sgn(arb_midref(acb_realref(b))) <= 0 &&
arf_cmpabs_ui(arb_midref(acb_realref(b)), prec) < 0)
{
acb_hypgeom_2f1_direct(res, a, b, c, z, regularized, prec);
return;
}
/* Try to reduce to a polynomial case using the Pfaff transformation */
/* TODO: look at flags for integer c-b, c-a here, even when c is nonexact */
if (acb_is_exact(c))
{
acb_t t;
acb_init(t);
acb_sub(t, c, b, prec);
if (acb_is_int(t) && arb_is_nonpositive(acb_realref(t)))
{
acb_hypgeom_2f1_transform(res, a, b, c, z, flags, 1, prec);
acb_clear(t);
return;
}
acb_sub(t, c, a, prec);
if (acb_is_int(t) && arb_is_nonpositive(acb_realref(t)))
{
int f1, f2;
/* When swapping a, b, also swap the flags. */
f1 = flags & ACB_HYPGEOM_2F1_AC;
f2 = flags & ACB_HYPGEOM_2F1_BC;
flags &= ~ACB_HYPGEOM_2F1_AC;
flags &= ~ACB_HYPGEOM_2F1_BC;
if (f1) flags |= ACB_HYPGEOM_2F1_BC;
if (f2) flags |= ACB_HYPGEOM_2F1_AC;
acb_hypgeom_2f1_transform(res, b, a, c, z, flags, 1, prec);
acb_clear(t);
return;
}
acb_clear(t);
}
/* special value at z = 1 */
if (acb_is_one(z))
{
acb_t t, u, v;
acb_init(t);
acb_init(u);
acb_init(v);
acb_sub(t, c, a, prec);
acb_sub(u, c, b, prec);
acb_sub(v, t, b, prec);
if (arb_is_positive(acb_realref(v)))
{
acb_rgamma(t, t, prec);
acb_rgamma(u, u, prec);
acb_mul(t, t, u, prec);
acb_gamma(v, v, prec);
acb_mul(t, t, v, prec);
if (!regularized)
{
acb_gamma(v, c, prec);
acb_mul(t, t, v, prec);
}
acb_set(res, t);
}
else
{
acb_indeterminate(res);
}
acb_clear(t);
acb_clear(u);
acb_clear(v);
return;
}
algorithm = acb_hypgeom_2f1_choose(z);
if (algorithm == 0)
{
acb_hypgeom_2f1_direct(res, a, b, c, z, regularized, prec);
}
else if (algorithm >= 1 && algorithm <= 5)
{
acb_hypgeom_2f1_transform(res, a, b, c, z, flags, algorithm, prec);
}
else
{
acb_hypgeom_2f1_corner(res, a, b, c, z, regularized, prec);
}
}
void
acb_hypgeom_bessel_i_asymp(acb_t res, const acb_t nu, const acb_t z, long prec)
{
acb_t A1, A2, C, U1, U2, s, t, u;
int is_real, is_imag;
acb_init(A1);
acb_init(A2);
acb_init(C);
acb_init(U1);
acb_init(U2);
acb_init(s);
acb_init(t);
acb_init(u);
is_imag = 0;
is_real = acb_is_real(nu) && acb_is_real(z)
&& (acb_is_int(nu) || arb_is_positive(acb_realref(z)));
if (!is_real && arb_is_zero(acb_realref(z)) && acb_is_int(nu))
{
acb_mul_2exp_si(t, nu, -1);
if (acb_is_int(t))
is_real = 1;
else
is_imag = 1;
}
acb_hypgeom_bessel_i_asymp_prefactors(A1, A2, C, nu, z, prec);
/* todo: if Ap ~ 2^a and Am = 2^b and U1 ~ U2 ~ 1, change precision? */
if (!acb_is_finite(A1) || !acb_is_finite(A2) || !acb_is_finite(C))
{
acb_indeterminate(res);
}
else
{
/* s = 1/2 + nu */
acb_one(s);
acb_mul_2exp_si(s, s, -1);
acb_add(s, s, nu, prec);
/* t = 1 + 2 nu */
acb_mul_2exp_si(t, nu, 1);
acb_add_ui(t, t, 1, prec);
acb_mul_2exp_si(u, z, 1);
acb_hypgeom_u_asymp(U1, s, t, u, -1, prec);
acb_neg(u, u);
acb_hypgeom_u_asymp(U2, s, t, u, -1, prec);
acb_mul(res, A1, U1, prec);
acb_addmul(res, A2, U2, prec);
acb_mul(res, res, C, prec);
if (is_real)
arb_zero(acb_imagref(res));
if (is_imag)
arb_zero(acb_realref(res));
}
acb_clear(A1);
acb_clear(A2);
acb_clear(C);
acb_clear(U1);
acb_clear(U2);
acb_clear(s);
acb_clear(t);
acb_clear(u);
}