void
acb_hypgeom_laguerre_l(acb_t res, const acb_t n, const acb_t m, const acb_t z, slong prec)
{
acb_t t, u, v;
if (use_recurrence(n, m, prec))
{
acb_hypgeom_laguerre_l_ui_recurrence(res,
arf_get_si(arb_midref(acb_realref(n)), ARF_RND_DOWN), m, z, prec);
return;
}
/* todo: should be a test of whether n contains any negative integer */
if (acb_contains_int(n) && !arb_is_nonnegative(acb_realref(n)))
{
acb_indeterminate(res);
return;
}
acb_init(t);
acb_init(u);
acb_init(v);
acb_neg(t, n);
acb_add_ui(u, m, 1, prec);
acb_hypgeom_m(t, t, u, z, 1, prec);
acb_add_ui(u, n, 1, prec);
acb_rising(u, u, m, prec);
acb_mul(res, t, u, prec);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
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_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 void
acb_approx_mul(acb_t res, const acb_t x, const acb_t y, slong prec)
{
arf_complex_mul(arb_midref(acb_realref(res)), arb_midref(acb_imagref(res)),
arb_midref(acb_realref(x)), arb_midref(acb_imagref(x)),
arb_midref(acb_realref(y)), arb_midref(acb_imagref(y)), prec, ARB_RND);
}
/* REAL: erf(x) = 2x/sqrt(pi) * exp(-x^2) 1F1(1, 3/2, x^2) */
void
acb_hypgeom_erf_1f1b(acb_t res, const acb_t z, slong prec)
{
acb_t a, b, t, w;
acb_init(a);
acb_init(b);
acb_init(t);
acb_init(w);
acb_set_ui(b, 3);
acb_mul_2exp_si(b, b, -1);
acb_mul(w, z, z, prec);
acb_hypgeom_pfq_direct(t, a, 0, b, 1, w, -1, prec);
acb_neg(w, w);
acb_exp(w, w, prec);
acb_mul(t, t, w, prec);
acb_mul(t, t, z, prec);
arb_const_sqrt_pi(acb_realref(w), prec);
acb_div_arb(t, t, acb_realref(w), prec);
acb_mul_2exp_si(res, t, 1);
acb_clear(a);
acb_clear(b);
acb_clear(t);
acb_clear(w);
}
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);
}
}
void
acb_get_mag(mag_t u, const acb_t z)
{
if (arb_is_zero(acb_imagref(z)))
{
arb_get_mag(u, acb_realref(z));
}
else if (arb_is_zero(acb_realref(z)))
{
arb_get_mag(u, acb_imagref(z));
}
else
{
mag_t v;
mag_init(v);
arb_get_mag(u, acb_realref(z));
arb_get_mag(v, acb_imagref(z));
mag_mul(u, u, u);
mag_addmul(u, v, v);
mag_sqrt(u, u);
mag_clear(v);
}
}
void
acb_hypgeom_u(acb_t res, const acb_t a, const acb_t b, const acb_t z, long prec)
{
acb_t t;
acb_init(t);
acb_sub(t, a, b, prec);
acb_add_ui(t, t, 1, prec);
if ((acb_is_int(a) && arf_sgn(arb_midref(acb_realref(a))) <= 0) ||
(acb_is_int(t) && arf_sgn(arb_midref(acb_realref(t))) <= 0) ||
acb_hypgeom_u_use_asymp(z, prec))
{
acb_neg(t, a);
acb_pow(t, z, t, prec);
acb_hypgeom_u_asymp(res, a, b, z, -1, prec);
acb_mul(res, res, t, prec);
}
else
{
acb_hypgeom_u_1f1(res, a, b, z, prec);
}
acb_clear(t);
}
static void
acb_set_dddd(acb_t z, double a, double ar, double b, double br)
{
arf_set_d(arb_midref(acb_realref(z)), a);
mag_set_d(arb_radref(acb_realref(z)), ar);
arf_set_d(arb_midref(acb_imagref(z)), b);
mag_set_d(arb_radref(acb_imagref(z)), br);
}
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_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_hypgeom_erf_propagated_error(mag_t re, mag_t im, const acb_t z)
{
mag_t x, y;
mag_init(x);
mag_init(y);
/* |exp(-(x+y)^2)| = exp(y^2-x^2) */
arb_get_mag(y, acb_imagref(z));
mag_mul(y, y, y);
arb_get_mag_lower(x, acb_realref(z));
mag_mul_lower(x, x, x);
if (mag_cmp(y, x) >= 0)
{
mag_sub(re, y, x);
mag_exp(re, re);
}
else
{
mag_sub_lower(re, x, y);
mag_expinv(re, re);
}
/* Radius. */
mag_hypot(x, arb_radref(acb_realref(z)), arb_radref(acb_imagref(z)));
mag_mul(re, re, x);
/* 2/sqrt(pi) < 289/256 */
mag_mul_ui(re, re, 289);
mag_mul_2exp_si(re, re, -8);
if (arb_is_zero(acb_imagref(z)))
{
/* todo: could bound magnitude even for complex numbers */
mag_set_ui(y, 2);
mag_min(re, re, y);
mag_zero(im);
}
else if (arb_is_zero(acb_realref(z)))
{
mag_swap(im, re);
mag_zero(re);
}
else
{
mag_set(im, re);
}
mag_clear(x);
mag_clear(y);
}
int main()
{
flint_printf("spherical_y....");
fflush(stdout);
{
slong i, n, m;
acb_t z, w, x, y;
acb_init(z);
acb_init(w);
acb_init(x);
acb_init(y);
i = 0;
arb_set_str(acb_realref(x), "0.2", 64);
arb_set_str(acb_imagref(x), "0.3", 64);
arb_set_str(acb_realref(y), "0.3", 64);
arb_set_str(acb_imagref(y), "0.4", 64);
for (n = -4; n <= 4; n++)
{
for (m = -4; m <= 4; m++)
{
acb_hypgeom_spherical_y(z, n, m, x, y, 64);
acb_set_d_d(w, testdata[2 * i], testdata[2 * i + 1]);
mag_set_d(arb_radref(acb_realref(w)), 1e-13);
mag_set_d(arb_radref(acb_imagref(w)), 1e-13);
if (!acb_overlaps(z, w))
{
flint_printf("FAIL: value\n\n");
flint_printf("n = %wd, m = %wd\n", n, m);
flint_printf("z = "); acb_printd(z, 20); flint_printf("\n\n");
flint_printf("w = "); acb_printd(w, 20); flint_printf("\n\n");
abort();
}
i++;
}
}
acb_clear(z);
acb_clear(w);
acb_clear(x);
acb_clear(y);
}
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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_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_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
acb_hurwitz_zeta(acb_t z, const acb_t s, const acb_t a, slong prec)
{
if (acb_is_one(a) && acb_is_int(s) &&
arf_cmpabs_2exp_si(arb_midref(acb_realref(s)), FLINT_BITS - 1) < 0)
{
acb_zeta_si(z, arf_get_si(arb_midref(acb_realref(s)), ARF_RND_DOWN), prec);
return;
}
_acb_poly_zeta_cpx_series(z, s, a, 0, 1, prec);
}
/* note: the tmp variable t should have zero radius */
static void
acb_approx_div(acb_t z, const acb_t x, const acb_t y, acb_t t, slong prec)
{
arf_set(arb_midref(acb_realref(t)), arb_midref(acb_realref(y)));
arf_set(arb_midref(acb_imagref(t)), arb_midref(acb_imagref(y)));
acb_inv(t, t, prec);
mag_zero(arb_radref(acb_realref(t)));
mag_zero(arb_radref(acb_imagref(t)));
acb_approx_mul(z, x, t, prec);
}
void
acb_hypgeom_m_1f1(acb_t res, const acb_t a, const acb_t b, const acb_t z, int regularized, slong prec)
{
if (arf_sgn(arb_midref(acb_realref(z))) >= 0
|| (acb_is_int(a) && arb_is_nonpositive(acb_realref(a))))
{
_acb_hypgeom_m_1f1(res, a, b, z, regularized, prec, prec, 0);
}
else
{
_acb_hypgeom_m_1f1(res, a, b, z, regularized, prec, prec, 1);
}
}
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);
}
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);
}
}
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);
}
}
/* this can be improved */
static int
use_recurrence(const acb_t n, const acb_t m, slong prec)
{
if (!acb_is_int(n) || !arb_is_nonnegative(acb_realref(n)))
return 0;
if (arf_cmpabs_ui(arb_midref(acb_realref(n)), prec) > 0)
return 0;
if (arf_cmpabs(arb_midref(acb_realref(n)), arb_midref(acb_realref(m))) >= 0)
return 0;
return 1;
}
/* this can be improved */
static int
use_recurrence(const acb_t n, const acb_t a, const acb_t b, slong prec)
{
if (!acb_is_int(n) || !arb_is_nonnegative(acb_realref(n)))
return 0;
if (arf_cmpabs_ui(arb_midref(acb_realref(n)), prec) > 0)
return 0;
if (arb_is_nonnegative(acb_realref(a)) ||
arf_get_d(arb_midref(acb_realref(a)), ARF_RND_DOWN) > -0.9)
return 0;
return 1;
}
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
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
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);
}
}
static void
acb_log1p_tiny(acb_t r, const acb_t z, slong prec)
{
mag_t b, c;
acb_t t;
int real;
mag_init(b);
mag_init(c);
acb_init(t);
real = acb_is_real(z);
/* if |z| < 1, then |log(1+z) - [z - z^2/2]| <= |z|^3/(1-|z|) */
acb_get_mag(b, z);
mag_one(c);
mag_sub_lower(c, c, b);
mag_pow_ui(b, b, 3);
mag_div(b, b, c);
acb_mul(t, z, z, prec);
acb_mul_2exp_si(t, t, -1);
acb_sub(r, z, t, prec);
if (real && mag_is_finite(b))
arb_add_error_mag(acb_realref(r), b);
else
acb_add_error_mag(r, b);
mag_clear(b);
mag_clear(c);
acb_clear(t);
}
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);
}