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);
}
/* todo: remove radii */
void
acb_lambertw_halley_step(acb_t res, acb_t ew, const acb_t z, const acb_t w, slong prec)
{
acb_t t, u, v;
acb_init(t);
acb_init(u);
acb_init(v);
acb_exp(ew, w, prec);
acb_add_ui(u, w, 2, prec);
acb_add_ui(v, w, 1, prec);
acb_mul_2exp_si(v, v, 1);
acb_div(v, u, v, prec);
acb_mul(t, ew, w, prec);
acb_sub(u, t, z, prec);
acb_mul(v, v, u, prec);
acb_neg(v, v);
acb_add(v, v, t, prec);
acb_add(v, v, ew, prec);
acb_div(t, u, v, prec);
acb_sub(t, w, t, prec);
acb_swap(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
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_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
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_laguerre_l_ui_recurrence(acb_t res, ulong n, const acb_t m,
const acb_t z, slong prec)
{
acb_t t, u, v;
ulong k;
if (n == 0)
{
acb_one(res);
return;
}
if (n == 1)
{
acb_sub(res, m, z, prec);
acb_add_ui(res, res, 1, prec);
return;
}
acb_init(t);
acb_init(u);
acb_init(v);
acb_one(t);
acb_sub(u, m, z, prec);
acb_add_ui(u, u, 1, prec);
for (k = 2; k <= n; k++)
{
acb_add_ui(v, m, k - 1, prec);
acb_mul(t, t, v, prec);
acb_add_ui(v, m, 2 * k - 1, prec);
acb_sub(v, v, z, prec);
acb_mul(v, v, u, prec);
acb_sub(t, v, t, prec);
acb_div_ui(t, t, k, prec);
acb_swap(t, u);
}
acb_set(res, u);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
/* Differential equation for F(a,b,c,y+z):
(y+z)(y-1+z) F''(z) + ((y+z)(a+b+1) - c) F'(z) + a b F(z) = 0
Coefficients in the Taylor series are bounded by
A * binomial(N+k, k) * nu^k
using the Cauchy-Kovalevskaya majorant method.
See J. van der Hoeven, "Fast evaluation of holonomic functions near
and in regular singularities"
*/
static void
bound(mag_t A, mag_t nu, mag_t N,
const acb_t a, const acb_t b, const acb_t c, const acb_t y,
const acb_t f0, const acb_t f1)
{
mag_t M0, M1, t, u;
acb_t d;
acb_init(d);
mag_init(M0);
mag_init(M1);
mag_init(t);
mag_init(u);
/* nu = max(1/|y-1|, 1/|y|) = 1/min(|y-1|, |y|) */
acb_get_mag_lower(t, y);
acb_sub_ui(d, y, 1, MAG_BITS);
acb_get_mag_lower(u, d);
mag_min(t, t, u);
mag_one(u);
mag_div(nu, u, t);
/* M0 = 2 nu |ab| */
acb_get_mag(t, a);
acb_get_mag(u, b);
mag_mul(M0, t, u);
mag_mul(M0, M0, nu);
mag_mul_2exp_si(M0, M0, 1);
/* M1 = 2 nu |(a+b+1)y-c| + 2|a+b+1| */
acb_add(d, a, b, MAG_BITS);
acb_add_ui(d, d, 1, MAG_BITS);
acb_get_mag(t, d);
acb_mul(d, d, y, MAG_BITS);
acb_sub(d, d, c, MAG_BITS);
acb_get_mag(u, d);
mag_mul(u, u, nu);
mag_add(M1, t, u);
mag_mul_2exp_si(M1, M1, 1);
/* N = max(sqrt(2 M0), 2 M1) / nu */
mag_mul_2exp_si(M0, M0, 1);
mag_sqrt(M0, M0);
mag_mul_2exp_si(M1, M1, 1);
mag_max(N, M0, M1);
mag_div(N, N, nu);
/* A = max(|f0|, |f1| / (nu (N+1)) */
acb_get_mag(t, f0);
acb_get_mag(u, f1);
mag_div(u, u, nu);
mag_div(u, u, N); /* upper bound for dividing by N+1 */
mag_max(A, t, u);
acb_clear(d);
mag_clear(M0);
mag_clear(M1);
mag_clear(t);
mag_clear(u);
}
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_lgamma(acb_t y, const acb_t x, long prec)
{
int reflect;
long r, n, wp;
acb_t t, u;
wp = prec + FLINT_BIT_COUNT(prec);
acb_gamma_stirling_choose_param(&reflect, &r, &n, x, 0, 0, wp);
/* log(gamma(x)) = log(gamma(x+r)) - log(rf(x,r)) */
acb_init(t);
acb_init(u);
acb_add_ui(t, x, r, wp);
acb_gamma_stirling_eval(u, t, n, 0, wp);
acb_rising_ui_rec(t, x, r, prec);
acb_log(t, t, prec);
_acb_log_rising_correct_branch(t, t, x, r, wp);
acb_sub(y, u, t, prec);
acb_clear(t);
acb_clear(u);
}
void
acb_poly_add_si(acb_poly_t res, const acb_poly_t x, long y, long prec)
{
long len = x->length;
if (len == 0)
{
acb_poly_set_si(res, y);
}
else
{
acb_poly_fit_length(res, len);
if (y >= 0)
acb_add_ui(res->coeffs, x->coeffs, y, prec);
else
acb_sub_ui(res->coeffs, x->coeffs, -y, prec);
if (res != x)
_acb_vec_set(res->coeffs + 1, x->coeffs + 1, len - 1);
_acb_poly_set_length(res, len);
_acb_poly_normalise(res);
}
}
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_gamma(acb_t y, const acb_t x, long prec, int inverse)
{
int reflect;
long r, n, wp;
acb_t t, u, v;
wp = prec + FLINT_BIT_COUNT(prec);
acb_gamma_stirling_choose_param(&reflect, &r, &n, x, 1, 0, wp);
acb_init(t);
acb_init(u);
acb_init(v);
if (reflect)
{
/* gamma(x) = (rf(1-x, r) * pi) / (gamma(1-x+r) sin(pi x)) */
acb_sub_ui(t, x, 1, wp);
acb_neg(t, t);
acb_rising_ui_rec(u, t, r, wp);
arb_const_pi(acb_realref(v), wp);
acb_mul_arb(u, u, acb_realref(v), wp);
acb_add_ui(t, t, r, wp);
acb_gamma_stirling_eval(v, t, n, 0, wp);
acb_exp(v, v, wp);
acb_sin_pi(t, x, wp);
acb_mul(v, v, t, wp);
}
else
{
/* gamma(x) = gamma(x+r) / rf(x,r) */
acb_add_ui(t, x, r, wp);
acb_gamma_stirling_eval(u, t, n, 0, wp);
acb_exp(u, u, prec);
acb_rising_ui_rec(v, x, r, wp);
}
if (inverse)
acb_div(y, v, u, prec);
else
acb_div(y, u, v, prec);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
void
acb_hypgeom_jacobi_p_ui_direct(acb_t res, ulong n,
const acb_t a, const acb_t b, const acb_t z, slong prec)
{
acb_ptr terms;
acb_t t, u, v;
slong k;
terms = _acb_vec_init(n + 1);
acb_init(t);
acb_init(u);
acb_init(v);
acb_one(terms);
acb_add_ui(u, z, 1, prec);
for (k = 1; k <= n; k++)
{
acb_add_ui(t, a, n + 1 - k, prec);
acb_mul(t, t, u, prec);
acb_div_ui(t, t, 2 * k, prec);
acb_mul(terms + k, terms + k - 1, t, prec);
}
acb_sub_ui(u, z, 1, prec);
acb_one(v);
for (k = 1; k <= n; k++)
{
acb_add_ui(t, b, n + 1 - k, prec);
acb_mul(t, t, u, prec);
acb_div_ui(t, t, 2 * k, prec);
acb_mul(v, v, t, prec);
acb_mul(terms + n - k, terms + n - k, v, prec);
}
acb_set(res, terms);
for (k = 1; k <= n; k++)
acb_add(res, res, terms + k, prec);
_acb_vec_clear(terms, n + 1);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
static void
bsplit(acb_t p, acb_t q, const acb_t x, ulong a, ulong b, slong prec)
{
if (b - a < 8)
{
ulong k;
acb_t t;
acb_one(p);
acb_add_ui(q, x, a, prec);
acb_init(t);
for (k = a + 1; k < b; k++)
{
acb_add_ui(t, x, k, prec);
acb_mul(p, p, t, prec);
acb_add(p, p, q, prec);
acb_mul(q, q, t, prec);
}
acb_clear(t);
}
else
{
acb_t r, s;
ulong m;
acb_init(r);
acb_init(s);
m = a + (b - a) / 2;
bsplit(p, q, x, a, m, prec);
bsplit(r, s, x, m, b, prec);
acb_mul(p, p, s, prec);
acb_mul(r, r, q, prec);
acb_add(p, p, r, prec);
acb_mul(q, q, s, prec);
acb_clear(r);
acb_clear(s);
}
}
void
acb_digamma(acb_t y, const acb_t x, long prec)
{
int reflect;
long r, n, wp;
acb_t t, u, v;
wp = prec + FLINT_BIT_COUNT(prec);
acb_gamma_stirling_choose_param(&reflect, &r, &n, x, 1, 1, wp);
acb_init(t);
acb_init(u);
acb_init(v);
/* psi(x) = psi((1-x)+r) - h(1-x,r) - pi*cot(pi*x) */
if (reflect)
{
acb_sub_ui(t, x, 1, wp);
acb_neg(t, t);
acb_cot_pi(v, x, wp);
arb_const_pi(acb_realref(u), wp);
acb_mul_arb(v, v, acb_realref(u), wp);
acb_rising2_ui(y, u, t, r, wp);
acb_div(u, u, y, wp);
acb_add(v, v, u, wp);
acb_add_ui(t, t, r, wp);
acb_gamma_stirling_eval(u, t, n, 1, wp);
acb_sub(y, u, v, wp);
}
else
{
acb_add_ui(t, x, r, wp);
acb_gamma_stirling_eval(u, t, n, 1, wp);
acb_rising2_ui(y, t, x, r, wp);
acb_div(t, t, y, wp);
acb_sub(y, u, t, prec);
}
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
void
acb_hypgeom_jacobi_p(acb_t res, const acb_t n, const acb_t a, const acb_t b,
const acb_t z, slong prec)
{
acb_t t, u, v, w;
if (use_recurrence(n, a, b, prec))
{
acb_hypgeom_jacobi_p_ui_direct(res,
arf_get_si(arb_midref(acb_realref(n)), ARF_RND_DOWN), a, b, z, prec);
return;
}
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(w);
acb_neg(t, n);
acb_add_ui(v, a, 1, prec);
acb_add(u, n, v, prec);
acb_add(u, u, b, prec);
acb_sub_ui(w, z, 1, prec);
acb_mul_2exp_si(w, w, -1);
acb_neg(w, w);
acb_hypgeom_2f1(w, t, u, v, w, 0, prec);
acb_rising(t, v, n, prec);
acb_mul(w, w, t, prec);
acb_add_ui(t, n, 1, prec);
acb_rgamma(t, t, prec);
acb_mul(w, w, t, prec);
acb_set(res, w);
acb_clear(t);
acb_clear(u);
acb_clear(v);
acb_clear(w);
}
/* f(z) = 1/(1+z^2) */
int
f_atanderiv(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_mul(res, z, z, prec);
acb_add_ui(res, res, 1, prec);
acb_inv(res, res, prec);
return 0;
}
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_hypgeom_bessel_j_0f1(acb_t res, const acb_t nu, const acb_t z, long prec)
{
acb_struct b[2];
acb_t w, c, t;
if (acb_is_int(nu) && arb_is_negative(acb_realref(nu)))
{
acb_init(t);
acb_neg(t, nu);
acb_hypgeom_bessel_j_0f1(res, t, z, prec);
acb_mul_2exp_si(t, t, -1);
if (!acb_is_int(t))
acb_neg(res, res);
acb_clear(t);
return;
}
acb_init(b + 0);
acb_init(b + 1);
acb_init(w);
acb_init(c);
acb_init(t);
acb_add_ui(b + 0, nu, 1, prec);
acb_one(b + 1);
/* (z/2)^nu / gamma(nu+1) */
acb_mul_2exp_si(c, z, -1);
acb_pow(c, c, nu, prec);
acb_rgamma(t, b + 0, prec);
acb_mul(c, t, c, prec);
/* -z^2/4 */
acb_mul(w, z, z, prec);
acb_mul_2exp_si(w, w, -2);
acb_neg(w, w);
acb_hypgeom_pfq_direct(t, NULL, 0, b, 2, w, -1, prec);
acb_mul(res, t, c, prec);
acb_clear(b + 0);
acb_clear(b + 1);
acb_clear(w);
acb_clear(c);
acb_clear(t);
}
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);
}
/* f(z) = -log(z) / (1 + z) */
int
f_log_div1p(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
acb_t t;
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_init(t);
acb_add_ui(t, z, 1, prec);
acb_log(res, z, prec);
acb_div(res, res, t, prec);
acb_neg(res, res);
acb_clear(t);
return 0;
}
void
acb_rising_ui(acb_t y, const acb_t x, ulong n, long prec)
{
if (n < FLINT_MAX(prec, 100))
{
acb_rising_ui_rec(y, x, n, prec);
}
else
{
acb_t t;
acb_init(t);
acb_add_ui(t, x, n, prec);
acb_gamma(t, t, prec);
acb_rgamma(y, x, prec);
acb_mul(y, y, t, prec);
acb_clear(t);
}
}
/* f(z) = sin(z) + exp(-200-z^2) */
int
f_sin_plus_small(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
acb_t t;
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_init(t);
acb_mul(t, z, z, prec);
acb_add_ui(t, t, 200, prec);
acb_neg(t, t);
acb_exp(t, t, prec);
acb_sin(res, z, prec);
acb_add(res, res, t, prec);
acb_clear(t);
return 0;
}
void
acb_lambertw_cleared_cut(acb_t res, const acb_t z, const fmpz_t k, int flags, slong prec)
{
acb_t ez1;
acb_init(ez1);
/* compute e*z + 1 */
arb_const_e(acb_realref(ez1), prec);
acb_mul(ez1, ez1, z, prec);
acb_add_ui(ez1, ez1, 1, prec);
if (acb_is_exact(z))
{
acb_lambertw_main(res, z, ez1, k, flags, prec);
}
else
{
acb_t zz;
mag_t err, rad;
mag_init(err);
mag_init(rad);
acb_init(zz);
acb_lambertw_bound_deriv(err, z, ez1, k);
mag_hypot(rad, arb_radref(acb_realref(z)), arb_radref(acb_imagref(z)));
mag_mul(err, err, rad);
acb_set(zz, z);
mag_zero(arb_radref(acb_realref(zz)));
mag_zero(arb_radref(acb_imagref(zz))); /* todo: recompute ez1? */
acb_lambertw_main(res, zz, ez1, k, flags, prec);
acb_add_error_mag(res, err);
mag_clear(err);
mag_clear(rad);
acb_clear(zz);
}
acb_clear(ez1);
}
/* f(z) = z sin(z) / (1 + cos(z)^2) */
int
f_sin_cos_frac(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
acb_t s, c;
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_init(s);
acb_init(c);
acb_sin_cos(s, c, z, prec);
acb_mul(c, c, c, prec);
acb_add_ui(c, c, 1, prec);
acb_mul(s, s, z, prec);
acb_div(res, s, c, prec);
acb_clear(s);
acb_clear(c);
return 0;
}
void
_acb_poly_atan_series(acb_ptr g, acb_srcptr h, slong hlen, slong n, slong prec)
{
acb_t c;
acb_init(c);
acb_atan(c, h, prec);
hlen = FLINT_MIN(hlen, n);
if (hlen == 1)
{
_acb_vec_zero(g + 1, n - 1);
}
else
{
acb_ptr t, u;
slong ulen;
t = _acb_vec_init(n);
u = _acb_vec_init(n);
/* atan(h(x)) = integral(h'(x)/(1+h(x)^2)) */
ulen = FLINT_MIN(n, 2 * hlen - 1);
_acb_poly_mullow(u, h, hlen, h, hlen, ulen, prec);
acb_add_ui(u, u, 1, prec);
_acb_poly_derivative(t, h, hlen, prec);
_acb_poly_div_series(g, t, hlen - 1, u, ulen, n, prec);
_acb_poly_integral(g, g, n, prec);
_acb_vec_clear(t, n);
_acb_vec_clear(u, n);
}
acb_swap(g, c);
acb_clear(c);
}
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_hypgeom_bessel_k_asymp(acb_t res, const acb_t nu, const acb_t z, slong prec)
{
acb_t t, a, b, w;
acb_init(t);
acb_init(a);
acb_init(b);
acb_init(w);
acb_one(a);
acb_mul_2exp_si(a, a, -1);
acb_add(a, a, nu, prec);
acb_mul_2exp_si(b, nu, 1);
acb_add_ui(b, b, 1, prec);
acb_mul_2exp_si(w, z, 1);
acb_hypgeom_u_asymp(t, a, b, w, -1, prec);
acb_neg(w, z);
acb_exp(w, w, prec);
acb_mul(t, t, w, prec);
acb_mul_2exp_si(w, z, 1);
acb_rsqrt(w, w, prec);
acb_mul(res, t, w, prec);
arb_const_sqrt_pi(acb_realref(w), prec);
acb_mul_arb(res, res, acb_realref(w), prec);
acb_clear(t);
acb_clear(a);
acb_clear(b);
acb_clear(w);
}
int main()
{
long iter;
flint_rand_t state;
printf("u....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000; iter++)
{
acb_t a0, a1, a2, b, z, w0, w1, w2, t, u;
long prec0, prec1, prec2;
acb_init(a0);
acb_init(a1);
acb_init(a2);
acb_init(b);
acb_init(z);
acb_init(w0);
acb_init(w1);
acb_init(w2);
acb_init(t);
acb_init(u);
prec0 = 2 + n_randint(state, 700);
prec1 = 2 + n_randint(state, 700);
prec2 = 2 + n_randint(state, 700);
acb_randtest_maybe_half_int(a0, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest_maybe_half_int(b, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(z, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(w0, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(w1, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(w2, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_add_ui(a1, a0, 1, prec0);
acb_add_ui(a2, a0, 2, prec0);
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_u_asymp_proper(w0, a0, b, z, prec0);
break;
case 1:
acb_hypgeom_u_1f1(w0, a0, b, z, prec0);
break;
default:
acb_hypgeom_u(w0, a0, b, z, prec0);
}
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_u_asymp_proper(w1, a0, b, z, prec1);
break;
case 1:
acb_hypgeom_u_1f1(w1, a0, b, z, prec1);
break;
default:
acb_hypgeom_u(w1, a0, b, z, prec1);
}
if (!acb_overlaps(w0, w1))
{
printf("FAIL: consistency\n\n");
printf("a = "); acb_printd(a0, 30); printf("\n\n");
printf("b = "); acb_printd(b, 30); printf("\n\n");
printf("z = "); acb_printd(z, 30); printf("\n\n");
printf("w0 = "); acb_printd(w0, 30); printf("\n\n");
printf("w1 = "); acb_printd(w1, 30); printf("\n\n");
abort();
}
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_u_asymp_proper(w1, a1, b, z, prec1);
break;
case 1:
acb_hypgeom_u_1f1(w1, a1, b, z, prec1);
break;
default:
acb_hypgeom_u(w1, a1, b, z, prec1);
}
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_u_asymp_proper(w2, a2, b, z, prec2);
break;
case 1:
acb_hypgeom_u_1f1(w2, a2, b, z, prec2);
break;
default:
acb_hypgeom_u(w2, a2, b, z, prec2);
}
acb_set(t, w0);
acb_mul_2exp_si(u, a0, 1);
acb_sub(u, u, b, prec0);
acb_add(u, u, z, prec0);
acb_add_ui(u, u, 2, prec0);
acb_submul(t, w1, u, prec0);
acb_sub(u, a2, b, prec0);
acb_mul(u, u, a1, prec0);
acb_addmul(t, w2, u, prec0);
if (!acb_contains_zero(t))
{
printf("FAIL: contiguous relation\n\n");
printf("a = "); acb_printd(a0, 30); printf("\n\n");
printf("b = "); acb_printd(b, 30); printf("\n\n");
printf("z = "); acb_printd(z, 30); printf("\n\n");
printf("w0 = "); acb_printd(w0, 30); printf("\n\n");
printf("w1 = "); acb_printd(w1, 30); printf("\n\n");
printf("w2 = "); acb_printd(w2, 30); printf("\n\n");
printf("t = "); acb_printd(t, 30); printf("\n\n");
abort();
}
acb_clear(a0);
acb_clear(a1);
acb_clear(a2);
acb_clear(b);
acb_clear(z);
acb_clear(w0);
acb_clear(w1);
acb_clear(w2);
acb_clear(t);
acb_clear(u);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_bessel_k_0f1(acb_t res, const acb_t nu, const acb_t z, slong prec)
{
if (acb_is_int(nu))
{
acb_poly_t nux, zx, rx;
acb_poly_init(nux);
acb_poly_init(zx);
acb_poly_init(rx);
acb_poly_set_coeff_acb(nux, 0, nu);
acb_poly_set_coeff_si(nux, 1, 1);
acb_poly_set_acb(zx, z);
acb_hypgeom_bessel_k_0f1_series(rx, nux, zx, 1, prec);
acb_poly_get_coeff_acb(res, rx, 0);
acb_poly_clear(nux);
acb_poly_clear(zx);
acb_poly_clear(rx);
}
else
{
acb_t t, u, v, w;
acb_struct b[2];
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(w);
acb_init(b + 0);
acb_init(b + 1);
/* u = 0F1(1+nu), v = 0F1(1-nu) */
acb_mul(t, z, z, prec);
acb_mul_2exp_si(t, t, -2);
acb_add_ui(b, nu, 1, prec);
acb_one(b + 1);
acb_hypgeom_pfq_direct(u, NULL, 0, b, 2, t, -1, prec);
acb_sub_ui(b, nu, 1, prec);
acb_neg(b, b);
acb_hypgeom_pfq_direct(v, NULL, 0, b, 2, t, -1, prec);
/* v = v * gamma(nu) / (z/2)^nu */
acb_mul_2exp_si(t, z, -1);
acb_pow(t, t, nu, prec);
acb_gamma(w, nu, prec);
acb_mul(v, v, w, prec);
acb_div(v, v, t, prec);
/* u = u * t * pi / (gamma(nu) * nu * sin(pi nu)) */
acb_mul(u, u, t, prec);
acb_const_pi(t, prec);
acb_mul(u, u, t, prec);
acb_sin_pi(t, nu, prec);
acb_mul(t, t, w, prec);
acb_mul(t, t, nu, prec);
acb_div(u, u, t, prec);
acb_sub(res, v, u, prec);
acb_mul_2exp_si(res, res, -1);
acb_clear(t);
acb_clear(u);
acb_clear(v);
acb_clear(w);
acb_clear(b + 0);
acb_clear(b + 1);
}
}
