void
acb_hypgeom_m_asymp(acb_t res, const acb_t a, const acb_t b, const acb_t z, int regularized, slong prec)
{
acb_t t, u, v, c;
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(c);
acb_sub(c, b, a, prec);
acb_neg(v, z);
acb_hypgeom_u_asymp(t, a, b, z, -1, prec);
acb_hypgeom_u_asymp(u, c, b, v, -1, prec);
/* gamma(b-a) */
acb_rgamma(v, c, prec);
acb_mul(t, t, v, prec);
/* z^(a-b) */
acb_neg(c, c);
acb_pow(v, z, c, prec);
acb_mul(u, u, v, prec);
/* gamma(a) */
acb_rgamma(v, a, prec);
acb_mul(u, u, v, prec);
/* exp(z) */
acb_exp(v, z, prec);
acb_mul(u, u, v, prec);
/* (-z)^(-a) */
acb_neg(c, a);
acb_neg(v, z);
acb_pow(v, v, c, prec);
acb_mul(t, t, v, prec);
acb_add(t, t, u, prec);
if (!regularized)
{
acb_gamma(v, b, prec);
acb_mul(t, t, v, prec);
}
if (acb_is_real(a) && acb_is_real(b) && acb_is_real(z))
{
arb_zero(acb_imagref(t));
}
acb_swap(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(v);
acb_clear(c);
}
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_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);
}
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);
}
}
static void
_acb_hypgeom_2f1r_reduced(acb_t res,
const acb_t b, const acb_t c, const acb_t z, slong prec)
{
acb_t t, u;
acb_init(t);
acb_init(u);
acb_sub_ui(t, z, 1, prec);
acb_neg(t, t);
acb_neg(u, b);
acb_pow(t, t, u, prec);
acb_rgamma(u, c, prec);
acb_mul(t, t, u, prec);
acb_set(res, t);
acb_clear(t);
acb_clear(u);
return;
}
/* todo: move this to the acb module? */
static void
acb_beta(acb_t res, const acb_t a, const acb_t b, slong prec)
{
acb_t t, u;
acb_init(t);
acb_init(u);
acb_gamma(t, a, prec);
acb_gamma(u, b, prec);
acb_add(res, a, b, prec);
acb_rgamma(res, res, prec);
acb_mul(res, res, t, prec);
acb_mul(res, res, u, prec);
acb_clear(t);
acb_clear(u);
}
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);
}
void
acb_rising(acb_t y, const acb_t x, const acb_t n, long prec)
{
if (acb_is_int(n) && arf_sgn(arb_midref(acb_realref(n))) >= 0 &&
arf_cmpabs_ui(arb_midref(acb_realref(n)), FLINT_MAX(prec, 100)) < 0)
{
acb_rising_ui_rec(y, x,
arf_get_si(arb_midref(acb_realref(n)), ARF_RND_DOWN), prec);
}
else
{
acb_t t;
acb_init(t);
acb_add(t, x, n, prec);
acb_gamma(t, t, prec);
acb_rgamma(y, x, prec);
acb_mul(y, y, t, prec);
acb_clear(t);
}
}
void
acb_hypgeom_m_1f1(acb_t res, const acb_t a, const acb_t b, const acb_t z, int regularized, long prec)
{
acb_t t;
if (regularized)
{
acb_init(t);
acb_rgamma(t, b, 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, prec);
}
else
{
/* Kummer's transformation */
acb_t u, v;
acb_init(u);
acb_init(v);
acb_sub(u, b, a, prec);
acb_neg(v, z);
_acb_hypgeom_m_1f1(u, u, b, v, prec);
acb_exp(v, z, prec);
acb_mul(res, u, v, prec);
acb_clear(u);
acb_clear(v);
}
if (regularized)
{
acb_mul(res, res, t, prec);
acb_clear(t);
}
}
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_legendre_q(acb_t res, const acb_t n, const acb_t m,
const acb_t z, int type, slong prec)
{
if (type == 0)
{
/* http://functions.wolfram.com/07.11.26.0033.01 */
/* todo: simplify the gamma quotients and the sqrt pi factor... */
acb_t a, b, c, z2, mn, nm, t, u;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(z2);
acb_init(mn);
acb_init(nm);
acb_init(t);
acb_init(u);
acb_add(mn, m, n, prec); /* mn = m + n */
acb_sub(nm, n, m, prec); /* nm = n - m */
acb_mul(z2, z, z, prec); /* z2 = z^2 */
/* t = 2F1((1-m-n)/2, (n-m)/2+1, 3/2, z^2) */
acb_sub_ui(a, mn, 1, prec);
acb_neg(a, a);
acb_mul_2exp_si(a, a, -1);
acb_mul_2exp_si(b, nm, -1);
acb_add_ui(b, b, 1, prec);
acb_set_ui(c, 3);
acb_mul_2exp_si(c, c, -1);
acb_hypgeom_2f1(t, a, b, c, z2, 0, prec);
/* u = 2F1(-(m+n)/2, (n-m+1)/2, 1/2, z^2) */
acb_neg(a, mn);
acb_mul_2exp_si(a, a, -1);
acb_add_ui(b, nm, 1, prec);
acb_mul_2exp_si(b, b, -1);
acb_one(c);
acb_mul_2exp_si(c, c, -1);
acb_hypgeom_2f1(u, a, b, c, z2, 0, prec);
/* a = cospi((m+n)/2) gamma((m+n)/2+1) rgamma((n-m+1)/2) z */
/* b = sinpi((m+n)/2) gamma((m+n+1)/2) rgamma((n-m)/2+1) / 2 */
acb_mul_2exp_si(a, mn, -1);
acb_sin_cos_pi(b, a, a, prec);
acb_mul_2exp_si(c, mn, -1);
acb_add_ui(c, c, 1, prec);
acb_gamma(c, c, prec);
acb_mul(a, a, c, prec);
acb_add_ui(c, nm, 1, prec);
acb_mul_2exp_si(c, c, -1);
acb_rgamma(c, c, prec);
acb_mul(a, a, c, prec);
acb_mul(a, a, z, prec);
acb_add_ui(c, mn, 1, prec);
acb_mul_2exp_si(c, c, -1);
acb_gamma(c, c, prec);
acb_mul(b, b, c, prec);
acb_mul_2exp_si(c, nm, -1);
acb_add_ui(c, c, 1, prec);
acb_rgamma(c, c, prec);
acb_mul(b, b, c, prec);
acb_mul_2exp_si(b, b, -1);
/* at - bu */
acb_mul(t, t, a, prec);
acb_mul(u, u, b, prec);
acb_sub(t, t, u, prec);
/* prefactor sqrt(pi) 2^m (1-z^2)^(-m/2) */
if (!acb_is_zero(m))
{
acb_sub_ui(u, z2, 1, prec);
acb_neg(u, u);
acb_neg(c, m);
acb_mul_2exp_si(c, c, -1);
acb_pow(u, u, c, prec);
acb_set_ui(c, 2);
acb_pow(c, c, m, prec);
acb_mul(u, u, c, prec);
acb_mul(t, t, u, prec);
}
arb_const_sqrt_pi(acb_realref(u), prec);
acb_mul_arb(t, t, acb_realref(u), prec);
acb_set(res, t);
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(z2);
acb_clear(mn);
acb_clear(nm);
acb_clear(t);
acb_clear(u);
}
else if (type == 1)
{
if ((arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), -2) < 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), -2) < 0) ||
!_acb_hypgeom_legendre_q_single_valid(z))
{
_acb_hypgeom_legendre_q_double(res, n, m, z, prec);
}
else
{
_acb_hypgeom_legendre_q_single(res, n, m, z, prec);
}
}
else
{
flint_printf("unsupported 'type' %d for legendre q\n", type);
abort();
}
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("2f1....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 3000; iter++)
{
acb_t a, b, c, z, w1, w2, t;
slong prec1, prec2;
int reg1, reg2, ebits;
int alg1, alg2;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(z);
acb_init(w1);
acb_init(w2);
acb_init(t);
prec1 = 2 + n_randint(state, 300);
prec2 = 2 + n_randint(state, 300);
if (n_randint(state, 20) == 0)
ebits = 30;
else
ebits = 5;
switch (n_randint(state, 3))
{
case 0:
acb_set_si(a, n_randint(state, 500));
acb_set_si(b, n_randint(state, 500));
acb_set_si(c, n_randint(state, 10));
break;
case 1:
acb_set_si(a, n_randint(state, 200) - 100);
acb_set_si(b, n_randint(state, 200) - 100);
acb_set_si(c, n_randint(state, 200) - 100);
break;
default:
acb_randtest_param(a, state, 1 + n_randint(state, 400), 1 + n_randint(state, ebits));
acb_randtest_param(b, state, 1 + n_randint(state, 400), 1 + n_randint(state, ebits));
acb_randtest_param(c, state, 1 + n_randint(state, 400), 1 + n_randint(state, ebits));
}
acb_randtest_param(z, state, 1 + n_randint(state, 400), 1 + n_randint(state, ebits));
acb_randtest(w1, state, 1 + n_randint(state, 400), 1 + n_randint(state, ebits));
acb_randtest(w2, state, 1 + n_randint(state, 400), 1 + n_randint(state, ebits));
reg1 = n_randint(state, 2);
reg2 = n_randint(state, 2);
alg1 = n_randint(state, 10);
alg2 = n_randint(state, 10);
switch (alg1)
{
case 0:
acb_hypgeom_2f1_direct(w1, a, b, c, z, reg1, prec1);
break;
case 1:
case 2:
case 3:
case 4:
case 5:
acb_hypgeom_2f1_transform(w1, a, b, c, z, reg1, alg1, prec1);
break;
case 6:
acb_hypgeom_2f1_corner(w1, a, b, c, z, reg1, prec1);
break;
default:
acb_hypgeom_2f1(w1, a, b, c, z, reg1, prec1);
}
switch (alg2)
{
case 0:
acb_hypgeom_2f1_direct(w2, a, b, c, z, reg2, prec2);
break;
case 1:
case 2:
case 3:
case 4:
case 5:
acb_hypgeom_2f1_transform(w2, a, b, c, z, reg2, alg2, prec2);
break;
case 6:
acb_hypgeom_2f1_corner(w2, a, b, c, z, reg2, prec2);
break;
default:
acb_hypgeom_2f1(w2, a, b, c, z, reg2, prec2);
}
if (reg1 != reg2)
{
acb_rgamma(t, c, prec2);
if (reg1)
acb_mul(w2, w2, t, prec2);
else
acb_mul(w1, w1, t, prec2);
}
if (!acb_overlaps(w1, w2))
{
flint_printf("FAIL: consistency\n\n");
flint_printf("iter = %wd, prec1 = %wd, prec2 = %wd\n\n", iter, prec1, prec2);
flint_printf("alg1 = %d, alg2 = %d\n\n", alg1, alg2);
flint_printf("reg1 = %d, reg2 = %d\n\n", reg1, reg2);
flint_printf("a = "); acb_printd(a, 30); flint_printf("\n\n");
flint_printf("b = "); acb_printd(b, 30); flint_printf("\n\n");
flint_printf("c = "); acb_printd(c, 30); flint_printf("\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("w1 = "); acb_printd(w1, 30); flint_printf("\n\n");
flint_printf("w2 = "); acb_printd(w2, 30); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(z);
acb_clear(w1);
acb_clear(w2);
acb_clear(t);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("legendre_q....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
acb_t n, m, z, res1, res2;
long prec1, prec2, ebits;
acb_init(n);
acb_init(m);
acb_init(z);
acb_init(res1);
acb_init(res2);
prec1 = 2 + n_randint(state, 300);
prec2 = 2 + n_randint(state, 300);
ebits = 1 + n_randint(state, 10);
if (n_randint(state, 2))
{
acb_set_si(m, n_randint(state, 20) - 10);
acb_set_si(n, n_randint(state, 20) - 10);
}
else
{
acb_randtest_param(n, state, 1 + n_randint(state, 400), ebits);
acb_randtest_param(m, state, 1 + n_randint(state, 400), ebits);
}
acb_randtest_param(z, state, 1 + n_randint(state, 400), ebits);
_acb_hypgeom_legendre_q_single(res1, n, m, z, prec1);
_acb_hypgeom_legendre_q_double(res2, n, m, z, prec2);
if (!acb_overlaps(res1, res2))
{
printf("FAIL: consistency 1\n\n");
printf("iter = %ld, prec1 = %ld, prec2 = %ld\n\n", iter, prec1, prec2);
printf("m = "); acb_printd(m, 30); printf("\n\n");
printf("n = "); acb_printd(n, 30); printf("\n\n");
printf("z = "); acb_printd(z, 30); printf("\n\n");
printf("res1 = "); acb_printd(res1, 30); printf("\n\n");
printf("res2 = "); acb_printd(res2, 30); printf("\n\n");
abort();
}
acb_clear(n);
acb_clear(m);
acb_clear(z);
acb_clear(res1);
acb_clear(res2);
}
for (iter = 0; iter < 2000; iter++)
{
acb_t n, m, z, res1, res2, t, u;
long prec1, prec2, ebits;
int type;
acb_init(n);
acb_init(m);
acb_init(z);
acb_init(res1);
acb_init(res2);
acb_init(t);
acb_init(u);
prec1 = 2 + n_randint(state, 300);
prec2 = 2 + n_randint(state, 300);
ebits = 1 + n_randint(state, 10);
if (n_randint(state, 2))
{
acb_set_si(m, n_randint(state, 20) - 10);
acb_set_si(n, n_randint(state, 20) - 10);
}
else
{
acb_randtest_param(n, state, 1 + n_randint(state, 400), ebits);
acb_randtest_param(m, state, 1 + n_randint(state, 400), ebits);
}
acb_randtest_param(z, state, 1 + n_randint(state, 400), ebits);
type = n_randint(state, 2);
acb_hypgeom_legendre_q(res1, n, m, z, type, prec1);
acb_neg(t, m);
acb_hypgeom_legendre_p(res2, n, t, z, type, prec2);
acb_add(u, m, n, prec2);
acb_add_ui(u, u, 1, prec2);
acb_gamma(u, u, prec2);
acb_mul(res2, res2, u, prec2);
acb_sub(u, n, m, prec2);
acb_add_ui(u, u, 1, prec2);
acb_rgamma(u, u, prec2);
acb_mul(res2, res2, u, prec2);
acb_hypgeom_legendre_p(t, n, m, z, type, prec2);
if (type == 0)
{
acb_cos_pi(u, m, prec2);
acb_mul(t, t, u, prec2);
}
acb_sub(res2, t, res2, prec2);
if (type == 1)
{
acb_exp_pi_i(t, m, prec2);
acb_mul(res2, res2, t, prec2);
}
acb_sin_pi(t, m, prec2);
if (acb_contains_zero(t))
acb_indeterminate(res2);
else
acb_div(res2, res2, t, prec2);
acb_const_pi(t, prec2);
acb_mul(res2, res2, t, prec2);
acb_mul_2exp_si(res2, res2, -1);
if (!acb_overlaps(res1, res2))
{
printf("FAIL: consistency 2\n\n");
printf("iter = %ld, prec1 = %ld, prec2 = %ld\n\n", iter, prec1, prec2);
printf("type = %d\n\n", type);
printf("m = "); acb_printd(m, 30); printf("\n\n");
printf("n = "); acb_printd(n, 30); printf("\n\n");
printf("z = "); acb_printd(z, 30); printf("\n\n");
printf("res1 = "); acb_printd(res1, 30); printf("\n\n");
printf("res2 = "); acb_printd(res2, 30); printf("\n\n");
abort();
}
acb_clear(n);
acb_clear(m);
acb_clear(z);
acb_clear(res1);
acb_clear(res2);
acb_clear(t);
acb_clear(u);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
void
_acb_hypgeom_m_1f1(acb_t res, const acb_t a, const acb_t b, const acb_t z,
int regularized, slong prec, slong gamma_prec, int kummer)
{
if (regularized)
{
/* Remove singularity */
if (acb_is_int(b) && arb_is_nonpositive(acb_realref(b)) &&
arf_cmpabs_2exp_si(arb_midref(acb_realref(b)), 30) < 0)
{
acb_t c, d, t, u;
slong n;
n = arf_get_si(arb_midref(acb_realref(b)), ARF_RND_DOWN);
acb_init(c);
acb_init(d);
acb_init(t);
acb_init(u);
acb_sub(c, a, b, prec);
acb_add_ui(c, c, 1, prec);
acb_neg(d, b);
acb_add_ui(d, d, 2, prec);
_acb_hypgeom_m_1f1(t, c, d, z, 0, prec, gamma_prec, kummer);
acb_pow_ui(u, z, 1 - n, prec);
acb_mul(t, t, u, prec);
acb_rising_ui(u, a, 1 - n, prec);
acb_mul(t, t, u, prec);
arb_fac_ui(acb_realref(u), 1 - n, prec);
acb_div_arb(res, t, acb_realref(u), prec);
acb_clear(c);
acb_clear(d);
acb_clear(t);
acb_clear(u);
}
else
{
acb_t t;
acb_init(t);
acb_rgamma(t, b, gamma_prec);
_acb_hypgeom_m_1f1(res, a, b, z, 0, prec, gamma_prec, kummer);
acb_mul(res, res, t, prec);
acb_clear(t);
}
return;
}
/* Kummer's transformation */
if (kummer)
{
acb_t u, v;
acb_init(u);
acb_init(v);
acb_sub(u, b, a, prec);
acb_neg(v, z);
_acb_hypgeom_m_1f1(u, u, b, v, regularized, prec, gamma_prec, 0);
acb_exp(v, z, prec);
acb_mul(res, u, v, prec);
acb_clear(u);
acb_clear(v);
return;
}
if (acb_is_one(a))
{
acb_hypgeom_pfq_direct(res, NULL, 0, b, 1, z, -1, prec);
}
else
{
acb_struct c[3];
c[0] = *a;
c[1] = *b;
acb_init(c + 2);
acb_one(c + 2);
acb_hypgeom_pfq_direct(res, c, 1, c + 1, 2, z, -1, prec);
acb_clear(c + 2);
}
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("gamma_lower....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000 * arb_test_multiplier(); iter++)
{
acb_t a0, a1, b, z, w0, w1, t, u, enz;
slong prec0, prec1;
int regularized;
acb_init(a0);
acb_init(a1);
acb_init(b);
acb_init(z);
acb_init(w0);
acb_init(w1);
acb_init(t);
acb_init(u);
acb_init(enz);
regularized = n_randint(state, 3);
prec0 = 2 + n_randint(state, 1000);
prec1 = 2 + n_randint(state, 1000);
acb_randtest_param(a0, 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_add_ui(a1, a0, 1, prec0);
acb_hypgeom_gamma_lower(w0, a0, z, regularized, prec0);
acb_hypgeom_gamma_lower(w1, a1, z, regularized, prec1);
acb_neg(enz, z);
acb_exp(enz, enz, prec0);
/* recurrence relations */
if (regularized == 2)
{
/* gamma^{*}(a,z) - exp(-z)/Gamma(a+1) - z gamma^{*}(a+1,z) = 0 */
/* http://dlmf.nist.gov/8.8.E4 */
acb_set(t, w0);
acb_rgamma(u, a1, prec0);
acb_submul(t, enz, u, prec0);
acb_submul(t, z, w1, prec0);
}
else if (regularized == 1)
{
/* P(a,z) - exp(-z) z^a / Gamma(a+1) - P(a+1,z) = 0 */
/* http://dlmf.nist.gov/8.8.E5 */
acb_pow(u, z, a0, prec0);
acb_rgamma(b, a1, prec0);
acb_mul(u, u, b, prec0);
acb_sub(t, w0, w1, prec0);
acb_submul(t, enz, u, prec0);
}
else
{
/* a gamma(a,z) - exp(-z) z^a - gamma(a+1,z) = 0 */
/* http://dlmf.nist.gov/8.8.E1 */
acb_pow(u, z, a0, prec0);
acb_mul(t, a0, w0, prec0);
acb_submul(t, enz, u, prec0);
acb_sub(t, t, w1, prec0);
}
if (!acb_contains_zero(t))
{
flint_printf("FAIL: recurrence relation\n\n");
flint_printf("regularized = %d\n\n", regularized);
flint_printf("a0 = "); acb_printd(a0, 30); flint_printf("\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("w0 = "); acb_printd(w0, 30); flint_printf("\n\n");
flint_printf("w1 = "); acb_printd(w1, 30); flint_printf("\n\n");
flint_printf("t = "); acb_printd(t, 30); flint_printf("\n\n");
abort();
}
/* identities relating lower and upper incomplete gamma functions */
if (regularized == 0 || regularized == 1)
{
acb_t u0;
acb_init(u0);
acb_hypgeom_gamma_upper(u0, a0, z, regularized, prec0);
acb_zero(t);
if (regularized == 1)
{
/* P(s,z) + Q(s,z) - 1 = 0 */
/* http://dlmf.nist.gov/8.2.E5 */
acb_add(t, w0, u0, prec0);
acb_sub_ui(t, t, 1, prec0);
}
else
{
/* gamma(s,z) + Gamma(s,z) - Gamma(s) = 0 */
/* excludes non-positive integer values of s */
/* http://dlmf.nist.gov/8.2.E3 */
if (!acb_is_int(a0) || arb_is_positive(acb_realref(a0)))
{
acb_gamma(b, a0, prec0);
acb_add(t, w0, u0, prec0);
acb_sub(t, t, b, prec0);
}
}
if (!acb_contains_zero(t))
{
flint_printf("FAIL: lower plus upper\n\n");
flint_printf("regularized = %d\n\n", regularized);
flint_printf("a0 = "); acb_printd(a0, 30); flint_printf("\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("w0 = "); acb_printd(w0, 30); flint_printf("\n\n");
flint_printf("w1 = "); acb_printd(w1, 30); flint_printf("\n\n");
flint_printf("t = "); acb_printd(t, 30); flint_printf("\n\n");
abort();
}
acb_clear(u0);
}
acb_clear(a0);
acb_clear(a1);
acb_clear(b);
acb_clear(z);
acb_clear(w0);
acb_clear(w1);
acb_clear(t);
acb_clear(u);
acb_clear(enz);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("u_asymp....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t a, b, a2, b2, z, U1, U2, t, u, M1, M2, am;
acb_struct bm[2];
ulong n1, n2;
slong prec0, prec1, prec2;
acb_init(a);
acb_init(b);
acb_init(a2);
acb_init(b2);
acb_init(z);
acb_init(U1);
acb_init(U2);
acb_init(t);
acb_init(u);
acb_init(M1);
acb_init(M2);
acb_init(am);
acb_init(bm);
acb_init(bm + 1);
if (n_randint(state, 4) == 0)
{
n1 = n_randint(state, 200);
n2 = n_randint(state, 200);
prec0 = 2 + n_randint(state, 1000);
prec1 = 2 + n_randint(state, 1000);
prec2 = 2 + n_randint(state, 1000);
}
else
{
n1 = n_randint(state, 40);
n2 = n_randint(state, 40);
prec0 = 2 + n_randint(state, 300);
prec1 = 2 + n_randint(state, 300);
prec2 = 2 + n_randint(state, 300);
}
acb_randtest_param(a, state, prec0, 1 + n_randint(state, 20));
if (n_randint(state, 4) == 0)
acb_add_ui(b, a, n_randint(state, 10), prec0);
else
acb_randtest_param(b, state, prec0, 1 + n_randint(state, 20));
acb_randtest(z, state, prec0, 1 + n_randint(state, 20));
/* Test Kummer's transformation */
acb_sub(a2, a, b, prec0);
acb_add_ui(a2, a2, 1, prec0);
acb_sub_ui(b2, b, 2, prec0);
acb_neg(b2, b2);
acb_hypgeom_u_asymp(U1, a, b, z, n1, prec1);
acb_hypgeom_u_asymp(U2, a2, b2, z, n2, prec2);
if (!acb_overlaps(U1, U2))
{
flint_printf("FAIL (Kummer transformation)\n");
flint_printf("iter = %wd\n", iter);
flint_printf("a = "); acb_printd(a, 50); flint_printf("\n");
flint_printf("b = "); acb_printd(b, 50); flint_printf("\n");
flint_printf("z = "); acb_printd(z, 50); flint_printf("\n");
flint_printf("n1 = %wd, n2 = %wd, prec1 = %wd, prec2 = %wd\n", n1, n2, prec1, prec2);
flint_printf("U1 = "); acb_printd(U1, 100); flint_printf("\n");
flint_printf("U2 = "); acb_printd(U2, 100); flint_printf("\n");
abort();
}
/* Check contiguous relation
(b-a-1)U(a,b-1,z) + z U(a,b+1,z) + (1-b-z) U(a,b,z) = 0 */
acb_one(t);
acb_sub(t, t, b, prec0);
acb_sub(t, t, z, prec0);
acb_mul(u, U1, t, prec1);
acb_add_ui(b2, b, 1, prec0);
acb_hypgeom_u_asymp(U2, a, b2, z, n2, prec2);
acb_addmul(u, U2, z, prec1);
acb_sub_ui(b2, b, 1, prec0);
acb_hypgeom_u_asymp(U2, a, b2, z, n2, prec2);
acb_sub(t, b, a, prec0);
acb_sub_ui(t, t, 1, prec0);
acb_mul(t, t, U2, prec0);
acb_add(t, t, u, prec0);
if (!acb_contains_zero(t))
{
flint_printf("FAIL (contiguous relation)\n");
flint_printf("iter = %wd\n", iter);
flint_printf("a = "); acb_printd(a, 50); flint_printf("\n");
flint_printf("b = "); acb_printd(b, 50); flint_printf("\n");
flint_printf("z = "); acb_printd(z, 50); flint_printf("\n");
flint_printf("n1 = %wd, n2 = %wd, prec1 = %wd, prec2 = %wd\n", n1, n2, prec1, prec2);
flint_printf("U1 = "); acb_printd(U1, 100); flint_printf("\n");
flint_printf("t = "); acb_printd(t, 100); flint_printf("\n");
abort();
}
/* Test U(a,b,z) = gamma(1-b)/gamma(a-b+1) M(a,b,z)
+ gamma(b-1)/gamma(a) z^(1-b) M(a-b+1,2-b,z) */
acb_set(am, a);
acb_set(bm, b);
acb_one(bm + 1);
acb_hypgeom_pfq_direct(M1, am, 1, bm, 2, z, n2, prec2);
acb_sub(am, a, b, prec2);
acb_add_ui(am, am, 1, prec2);
acb_sub_ui(bm, b, 2, prec2);
acb_neg(bm, bm);
acb_one(bm + 1);
acb_hypgeom_pfq_direct(M2, am, 1, bm, 2, z, n2, prec2);
acb_sub(am, a, b, prec2);
acb_add_ui(am, am, 1, prec2);
acb_rgamma(am, am, prec2);
acb_mul(M1, M1, am, prec2);
acb_sub_ui(am, b, 1, prec2);
acb_neg(am, am);
acb_gamma(am, am, prec2);
acb_mul(M1, M1, am, prec2);
acb_rgamma(am, a, prec2);
acb_mul(M2, M2, am, prec2);
acb_sub_ui(am, b, 1, prec2);
acb_gamma(am, am, prec2);
acb_mul(M2, M2, am, prec2);
acb_sub_ui(am, b, 1, prec2);
acb_neg(am, am);
acb_pow(am, z, am, prec2);
acb_mul(M2, M2, am, prec2);
acb_add(U2, M1, M2, prec2);
acb_pow(am, z, a, prec2);
acb_mul(U2, U2, am, prec2);
if (!acb_overlaps(U1, U2))
{
flint_printf("FAIL (U in terms of M)\n");
flint_printf("iter = %wd\n", iter);
flint_printf("a = "); acb_printd(a, 50); flint_printf("\n");
flint_printf("b = "); acb_printd(b, 50); flint_printf("\n");
flint_printf("z = "); acb_printd(z, 50); flint_printf("\n");
flint_printf("n1 = %wd, n2 = %wd, prec1 = %wd, prec2 = %wd\n", n1, n2, prec1, prec2);
flint_printf("U1 = "); acb_printd(U1, 100); flint_printf("\n");
flint_printf("U2 = "); acb_printd(U2, 100); flint_printf("\n");
abort();
}
/* Test special value: b = a+1 */
acb_add_ui(b, a, 1, prec0);
acb_hypgeom_u_asymp(U1, a, b, z, n1, prec1);
acb_one(U2);
if (!acb_overlaps(U1, U2))
{
flint_printf("FAIL (special value)\n");
flint_printf("iter = %wd\n", iter);
flint_printf("a = "); acb_printd(a, 50); flint_printf("\n");
flint_printf("b = "); acb_printd(b, 50); flint_printf("\n");
flint_printf("z = "); acb_printd(z, 50); flint_printf("\n");
flint_printf("n1 = %wd, n2 = %wd, prec1 = %wd, prec2 = %wd\n", n1, n2, prec1, prec2);
flint_printf("U1 = "); acb_printd(U1, 100); flint_printf("\n");
flint_printf("U2 = "); acb_printd(U2, 100); flint_printf("\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(a2);
acb_clear(b2);
acb_clear(z);
acb_clear(U1);
acb_clear(U2);
acb_clear(t);
acb_clear(u);
acb_clear(M1);
acb_clear(M2);
acb_clear(am);
acb_clear(bm);
acb_clear(bm + 1);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_2f1_transform_nolimit(acb_t res, const acb_t a, const acb_t b,
const acb_t c, const acb_t z, int regularized, int which, slong prec)
{
acb_t ba, ca, cb, cab, ac1, bc1, ab1, ba1, w, t, u, v, s;
if (acb_contains_zero(z) || !acb_is_finite(z))
{
acb_indeterminate(res);
return;
}
if (arb_contains_si(acb_realref(z), 1) && arb_contains_zero(acb_imagref(z)))
{
acb_indeterminate(res);
return;
}
if (!regularized)
{
acb_init(t);
acb_gamma(t, c, prec);
acb_hypgeom_2f1_transform_nolimit(res, a, b, c, z, 1, which, prec);
acb_mul(res, res, t, prec);
acb_clear(t);
return;
}
acb_init(ba);
acb_init(ca); acb_init(cb); acb_init(cab);
acb_init(ac1); acb_init(bc1);
acb_init(ab1); acb_init(ba1);
acb_init(w); acb_init(t);
acb_init(u); acb_init(v);
acb_init(s);
acb_add_si(s, z, -1, prec); /* s = 1 - z */
acb_neg(s, s);
acb_sub(ba, b, a, prec); /* ba = b - a */
acb_sub(ca, c, a, prec); /* ca = c - a */
acb_sub(cb, c, b, prec); /* cb = c - b */
acb_sub(cab, ca, b, prec); /* cab = c - a - b */
acb_add_si(ac1, ca, -1, prec); acb_neg(ac1, ac1); /* ac1 = a - c + 1 */
acb_add_si(bc1, cb, -1, prec); acb_neg(bc1, bc1); /* bc1 = b - c + 1 */
acb_add_si(ab1, ba, -1, prec); acb_neg(ab1, ab1); /* ab1 = a - b + 1 */
acb_add_si(ba1, ba, 1, prec); /* ba1 = b - a + 1 */
/* t = left term, u = right term (DLMF 15.8.1 - 15.8.5) */
if (which == 2)
{
acb_inv(w, z, prec); /* w = 1/z */
acb_hypgeom_2f1_direct(t, a, ac1, ab1, w, 1, prec);
acb_hypgeom_2f1_direct(u, b, bc1, ba1, w, 1, prec);
}
else if (which == 3)
{
acb_inv(w, s, prec); /* w = 1/(1-z) */
acb_hypgeom_2f1_direct(t, a, cb, ab1, w, 1, prec);
acb_hypgeom_2f1_direct(u, b, ca, ba1, w, 1, prec);
}
else if (which == 4)
{
acb_set(w, s); /* w = 1-z */
acb_add(v, ac1, b, prec); /* v = a+b-c+1 */
acb_hypgeom_2f1_direct(t, a, b, v, w, 1, prec);
acb_add_si(v, cab, 1, prec); /* v = c-a-b+1 */
acb_hypgeom_2f1_direct(u, ca, cb, v, w, 1, prec);
}
else if (which == 5)
{
acb_inv(w, z, prec); /* w = 1-1/z */
acb_neg(w, w);
acb_add_si(w, w, 1, prec);
acb_add(v, ac1, b, prec); /* v = a+b-c+1 */
acb_hypgeom_2f1_direct(t, a, ac1, v, w, 1, prec);
acb_add_si(v, cab, 1, prec); /* v = c-a-b+1 */
acb_add_si(u, a, -1, prec); /* u = 1-a */
acb_neg(u, u);
acb_hypgeom_2f1_direct(u, ca, u, v, w, 1, prec);
}
else
{
flint_printf("invalid transformation!\n");
flint_abort();
}
/* gamma factors */
acb_rgamma(v, a, prec);
acb_mul(u, u, v, prec);
acb_rgamma(v, ca, prec);
acb_mul(t, t, v, prec);
acb_rgamma(v, b, prec);
if (which == 2 || which == 3)
acb_mul(t, t, v, prec);
else
acb_mul(u, u, v, prec);
acb_rgamma(v, cb, prec);
if (which == 2 || which == 3)
acb_mul(u, u, v, prec);
else
acb_mul(t, t, v, prec);
if (which == 2 || which == 3)
{
if (which == 2)
acb_neg(s, z); /* -z, otherwise 1-z since before */
acb_neg(v, a);
acb_pow(v, s, v, prec);
acb_mul(t, t, v, prec);
acb_neg(v, b);
acb_pow(v, s, v, prec);
acb_mul(u, u, v, prec);
}
else
{
acb_pow(v, s, cab, prec);
acb_mul(u, u, v, prec);
if (which == 5)
{
acb_neg(v, a);
acb_pow(v, z, v, prec);
acb_mul(t, t, v, prec);
acb_neg(v, ca);
acb_pow(v, z, v, prec);
acb_mul(u, u, v, prec);
}
}
acb_sub(t, t, u, prec);
if (which == 2 || which == 3)
acb_sin_pi(v, ba, prec);
else
acb_sin_pi(v, cab, prec);
acb_div(t, t, v, prec);
acb_const_pi(v, prec);
acb_mul(t, t, v, prec);
acb_set(res, t);
acb_clear(ba);
acb_clear(ca); acb_clear(cb); acb_clear(cab);
acb_clear(ac1); acb_clear(bc1);
acb_clear(ab1); acb_clear(ba1);
acb_clear(w); acb_clear(t);
acb_clear(u); acb_clear(v);
acb_clear(s);
}
void
_acb_poly_rgamma_series(acb_ptr res, acb_srcptr h, slong hlen, slong len, slong prec)
{
int reflect;
slong i, rflen, r, n, wp;
acb_ptr t, u, v;
acb_struct f[2];
hlen = FLINT_MIN(hlen, len);
if (hlen == 1)
{
acb_rgamma(res, h, prec);
_acb_vec_zero(res + 1, len - 1);
return;
}
/* use real code for real input */
if (_acb_vec_is_real(h, hlen))
{
arb_ptr tmp = _arb_vec_init(len);
for (i = 0; i < hlen; i++)
arb_set(tmp + i, acb_realref(h + i));
_arb_poly_rgamma_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);
v = _acb_vec_init(len);
acb_init(f);
acb_init(f + 1);
/* otherwise use Stirling series */
acb_gamma_stirling_choose_param(&reflect, &r, &n, h, 1, 0, wp);
/* rgamma(h) = (gamma(1-h+r) sin(pi h)) / (rf(1-h, r) * pi), h = h0 + t*/
if (reflect)
{
/* u = gamma(r+1-h) */
acb_sub_ui(f, h, r + 1, wp);
acb_neg(f, f);
_acb_poly_gamma_stirling_eval(t, f, n, len, wp);
_acb_poly_exp_series(u, t, len, len, wp);
for (i = 1; i < len; i += 2)
acb_neg(u + i, u + i);
/* v = sin(pi x) */
acb_set(f, h);
acb_one(f + 1);
_acb_poly_sin_pi_series(v, f, 2, len, wp);
_acb_poly_mullow(t, u, len, v, len, len, wp);
/* rf(1-h,r) * pi */
if (r == 0)
{
acb_const_pi(u, wp);
_acb_vec_scalar_div(v, t, len, u, wp);
}
else
{
acb_sub_ui(f, h, 1, wp);
acb_neg(f, f);
acb_set_si(f + 1, -1);
rflen = FLINT_MIN(len, r + 1);
_acb_poly_rising_ui_series(v, f, FLINT_MIN(2, len), r, rflen, wp);
acb_const_pi(u, wp);
_acb_vec_scalar_mul(v, v, rflen, u, wp);
/* divide by rising factorial */
/* TODO: might better to use div_series, when it has a good basecase */
_acb_poly_inv_series(u, v, rflen, len, wp);
_acb_poly_mullow(v, t, len, u, len, len, wp);
}
}
else
{
/* rgamma(h) = rgamma(h+r) rf(h,r) */
if (r == 0)
{
acb_add_ui(f, h, r, wp);
_acb_poly_gamma_stirling_eval(t, f, n, len, wp);
_acb_vec_neg(t, t, len);
_acb_poly_exp_series(v, t, len, len, wp);
}
else
{
acb_set(f, h);
acb_one(f + 1);
rflen = FLINT_MIN(len, r + 1);
_acb_poly_rising_ui_series(t, f, FLINT_MIN(2, len), r, rflen, wp);
acb_add_ui(f, h, r, wp);
_acb_poly_gamma_stirling_eval(v, f, n, len, wp);
_acb_vec_neg(v, v, len);
_acb_poly_exp_series(u, v, len, len, wp);
_acb_poly_mullow(v, u, len, t, rflen, len, wp);
}
}
/* compose with nonconstant part */
acb_zero(t);
_acb_vec_set(t + 1, h + 1, hlen - 1);
_acb_poly_compose_series(res, v, len, t, hlen, len, prec);
acb_clear(f);
acb_clear(f + 1);
_acb_vec_clear(t, len);
_acb_vec_clear(u, len);
_acb_vec_clear(v, len);
}
void
acb_dirichlet_l(acb_t res, const acb_t s,
const dirichlet_group_t G, const dirichlet_char_t chi, slong prec)
{
if (!acb_is_finite(s))
{
acb_indeterminate(res);
}
else if (G == NULL || G->q == 1)
{
acb_dirichlet_zeta(res, s, prec);
}
else if (dirichlet_char_is_primitive(G, chi) &&
(arf_cmp_d(arb_midref(acb_realref(s)), -0.5) < 0 ||
(G->q != 1 && dirichlet_parity_char(G, chi) == 0 &&
arf_cmpabs_d(arb_midref(acb_imagref(s)), 0.125) < 0 &&
arf_cmp_d(arb_midref(acb_realref(s)), 0.125) < 0)))
{
/* use functional equation */
acb_t t, u, v;
int parity;
ulong q;
parity = dirichlet_parity_char(G, chi);
q = G->q;
acb_init(t);
acb_init(u);
acb_init(v);
/* gamma((1-s+p)/2) / gamma((s+p)/2) */
acb_add_ui(t, s, parity, prec);
acb_mul_2exp_si(t, t, -1);
acb_rgamma(t, t, prec);
if (!acb_is_zero(t)) /* assumes q != 1 when s = 0 */
{
acb_neg(u, s);
acb_add_ui(u, u, 1 + parity, prec);
acb_mul_2exp_si(u, u, -1);
acb_gamma(u, u, prec);
acb_mul(t, t, u, prec);
/* epsilon */
acb_dirichlet_root_number(u, G, chi, prec);
acb_mul(t, t, u, prec);
/* (pi/q)^(s-1/2) */
acb_const_pi(u, prec);
acb_div_ui(u, u, q, prec);
acb_set_d(v, -0.5);
acb_add(v, v, s, prec);
acb_pow(u, u, v, prec);
acb_mul(t, t, u, prec);
acb_sub_ui(u, s, 1, prec);
acb_neg(u, u);
acb_conj(u, u);
acb_dirichlet_l_general(u, u, G, chi, prec);
acb_conj(u, u);
acb_mul(t, t, u, prec);
if (dirichlet_char_is_real(G, chi) && acb_is_real(s))
arb_zero(acb_imagref(t));
}
acb_set(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
else
{
acb_dirichlet_l_general(res, s, G, chi, prec);
}
}
void
acb_dirichlet_zeta_rs_mid(acb_t res, const acb_t s, slong K, slong prec)
{
acb_t R1, R2, X, t;
slong wp;
if (arf_sgn(arb_midref(acb_imagref(s))) < 0)
{
acb_init(t);
acb_conj(t, s);
acb_dirichlet_zeta_rs(res, t, K, prec);
acb_conj(res, res);
acb_clear(t);
return;
}
acb_init(R1);
acb_init(R2);
acb_init(X);
acb_init(t);
/* rs_r increases the precision internally */
wp = prec;
acb_dirichlet_zeta_rs_r(R1, s, K, wp);
if (arb_is_exact(acb_realref(s)) &&
(arf_cmp_2exp_si(arb_midref(acb_realref(s)), -1) == 0))
{
acb_conj(R2, R1);
}
else
{
/* conj(R(conj(1-s))) */
arb_sub_ui(acb_realref(t), acb_realref(s), 1, 10 * wp);
arb_neg(acb_realref(t), acb_realref(t));
arb_set(acb_imagref(t), acb_imagref(s));
acb_dirichlet_zeta_rs_r(R2, t, K, wp);
acb_conj(R2, R2);
}
if (acb_is_finite(R1) && acb_is_finite(R2))
{
wp += 10 + arf_abs_bound_lt_2exp_si(arb_midref(acb_imagref(s)));
wp = FLINT_MAX(wp, 10);
/* X = pi^(s-1/2) gamma((1-s)/2) rgamma(s/2)
= (2 pi)^s rgamma(s) / (2 cos(pi s / 2)) */
acb_rgamma(X, s, wp);
acb_const_pi(t, wp);
acb_mul_2exp_si(t, t, 1);
acb_pow(t, t, s, wp);
acb_mul(X, X, t, wp);
acb_mul_2exp_si(t, s, -1);
acb_cos_pi(t, t, wp);
acb_mul_2exp_si(t, t, 1);
acb_div(X, X, t, wp);
acb_mul(R2, R2, X, wp);
}
/* R1 + X * R2 */
acb_add(res, R1, R2, prec);
acb_clear(R1);
acb_clear(R2);
acb_clear(X);
acb_clear(t);
}
void
acb_hypgeom_u_1f1(acb_t res, const acb_t a, const acb_t b, const acb_t z, long prec)
{
if (acb_is_int(b))
{
acb_poly_t aa, bb, zz;
acb_poly_init(aa);
acb_poly_init(bb);
acb_poly_init(zz);
acb_poly_set_acb(aa, a);
acb_poly_set_coeff_acb(bb, 0, b);
acb_poly_set_coeff_si(bb, 1, 1);
acb_poly_set_acb(zz, z);
acb_hypgeom_u_1f1_series(zz, aa, bb, zz, 1, prec);
acb_poly_get_coeff_acb(res, zz, 0);
acb_poly_clear(aa);
acb_poly_clear(bb);
acb_poly_clear(zz);
}
else
{
acb_t t, u, v;
acb_struct aa[3];
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(aa + 0);
acb_init(aa + 1);
acb_init(aa + 2);
acb_set(aa, a);
acb_set(aa + 1, b);
acb_one(aa + 2);
acb_hypgeom_pfq_direct(u, aa, 1, aa + 1, 2, z, -1, prec);
acb_sub(aa, a, b, prec);
acb_add_ui(aa, aa, 1, prec);
acb_sub_ui(aa + 1, b, 2, prec);
acb_neg(aa + 1, aa + 1);
acb_hypgeom_pfq_direct(v, aa, 1, aa + 1, 2, z, -1, prec);
acb_sub_ui(aa + 1, b, 1, prec);
/* rgamma(a-b+1) * gamma(1-b) * u */
acb_rgamma(t, aa, prec);
acb_mul(u, u, t, prec);
acb_neg(t, aa + 1);
acb_gamma(t, t, prec);
acb_mul(u, u, t, prec);
/* rgamma(a) * gamma(b-1) * z^(1-b) * v */
acb_rgamma(t, a, prec);
acb_mul(v, v, t, prec);
acb_gamma(t, aa + 1, prec);
acb_mul(v, v, t, prec);
acb_neg(t, aa + 1);
acb_pow(t, z, t, prec);
acb_mul(v, v, t, prec);
acb_add(res, u, v, prec);
acb_clear(t);
acb_clear(u);
acb_clear(v);
acb_clear(aa + 0);
acb_clear(aa + 1);
acb_clear(aa + 2);
}
}