/* Extremely close to the branch point at -1/e, use the series expansion directly. */
int
acb_lambertw_try_near_branch_point(acb_t res, const acb_t z,
const acb_t ez1, const fmpz_t k, int flags, slong prec)
{
if (fmpz_is_zero(k) || (fmpz_is_one(k) && arb_is_negative(acb_imagref(z)))
|| (fmpz_equal_si(k, -1) && arb_is_nonnegative(acb_imagref(z))))
{
if (acb_contains_zero(ez1) ||
(arf_cmpabs_2exp_si(arb_midref(acb_realref(ez1)), -prec / 4.5 - 6) < 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(ez1)), -prec / 4.5 - 6) < 0))
{
acb_t t;
acb_init(t);
acb_mul_2exp_si(t, ez1, 1);
acb_sqrt(t, t, prec);
if (!fmpz_is_zero(k))
acb_neg(t, t);
acb_lambertw_branchpoint_series(res, t, 1, prec);
acb_clear(t);
return 1;
}
}
return 0;
}
void
acb_poly_revert_series_lagrange_fast(acb_poly_t Qinv,
const acb_poly_t Q, slong n, slong prec)
{
slong Qlen = Q->length;
if (Qlen < 2 || !acb_is_zero(Q->coeffs)
|| acb_contains_zero(Q->coeffs + 1))
{
flint_printf("Exception (acb_poly_revert_series_lagrange_fast). Input \n"
"must have zero constant term and nonzero coefficient of x^1.\n");
abort();
}
if (Qinv != Q)
{
acb_poly_fit_length(Qinv, n);
_acb_poly_revert_series_lagrange_fast(Qinv->coeffs, Q->coeffs, Qlen, n, prec);
}
else
{
acb_poly_t t;
acb_poly_init2(t, n);
_acb_poly_revert_series_lagrange_fast(t->coeffs, Q->coeffs, Qlen, n, prec);
acb_poly_swap(Qinv, t);
acb_poly_clear(t);
}
_acb_poly_set_length(Qinv, n);
_acb_poly_normalise(Qinv);
}
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);
}
}
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
_acb_poly_overlaps(acb_srcptr poly1, slong len1,
acb_srcptr poly2, slong len2)
{
slong i;
for (i = 0; i < len2; i++)
if (!acb_overlaps(poly1 + i, poly2 + i))
return 0;
for (i = len2; i < len1; i++)
if (!acb_contains_zero(poly1 + i))
return 0;
return 1;
}
int
f_aj(arb_t m, const arb_t t, params_t * p, slong prec)
{
slong k;
acb_t z, zu;
arb_t abs;
arb_init(abs);
acb_init(z);
acb_init(zu);
arb_const_pi(abs, prec);
arb_mul_2exp_si(abs, abs, -2); /* Pi/4 */
arb_set(acb_realref(z), t);
arb_set(acb_imagref(z), abs);
acb_sinh(z, z, prec);
arb_mul_2exp_si(abs, abs, 1); /* Pi/2 */
acb_mul_arb(z, z, abs, prec);
acb_tanh(z, z, prec);
arb_one(m);
for (k = 0; k < p->len; k++)
{
acb_sub(zu, z, p->z + k, prec);
if (acb_contains_zero(zu))
{
arb_clear(abs);
acb_clear(zu);
acb_clear(z);
return 0;
}
acb_abs(abs, zu, prec);
arb_mul(m, m, abs, prec);
}
arb_inv(m, m, prec);
arb_clear(abs);
acb_clear(zu);
acb_clear(z);
return 1;
}
int main()
{
long iter;
flint_rand_t state;
printf("bessel_j....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000; iter++)
{
acb_t nu0, nu1, nu2, z, w0, w1, w2, t, u;
long prec0, prec1, prec2;
acb_init(nu0);
acb_init(nu1);
acb_init(nu2);
acb_init(z);
acb_init(w0);
acb_init(w1);
acb_init(w2);
acb_init(t);
acb_init(u);
prec0 = 2 + n_randint(state, 1000);
prec1 = 2 + n_randint(state, 1000);
prec2 = 2 + n_randint(state, 1000);
acb_randtest_param(nu0, 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_sub_ui(nu1, nu0, 1, prec0);
acb_sub_ui(nu2, nu0, 2, prec0);
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_bessel_j_asymp(w0, nu0, z, prec0);
break;
case 1:
acb_hypgeom_bessel_j_0f1(w0, nu0, z, prec0);
break;
default:
acb_hypgeom_bessel_j(w0, nu0, z, prec0);
}
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_bessel_j_asymp(w1, nu0, z, prec1);
break;
case 1:
acb_hypgeom_bessel_j_0f1(w1, nu0, z, prec1);
break;
default:
acb_hypgeom_bessel_j(w1, nu0, z, prec1);
}
if (!acb_overlaps(w0, w1))
{
printf("FAIL: consistency\n\n");
printf("nu = "); acb_printd(nu0, 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_bessel_j_asymp(w1, nu1, z, prec1);
break;
case 1:
acb_hypgeom_bessel_j_0f1(w1, nu1, z, prec1);
break;
default:
acb_hypgeom_bessel_j(w1, nu1, z, prec1);
}
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_bessel_j_asymp(w2, nu2, z, prec2);
break;
case 1:
acb_hypgeom_bessel_j_0f1(w2, nu2, z, prec2);
break;
default:
acb_hypgeom_bessel_j(w2, nu2, z, prec2);
}
acb_mul(t, w1, nu1, prec0);
acb_mul_2exp_si(t, t, 1);
acb_submul(t, w2, z, prec0);
acb_submul(t, w0, z, prec0);
if (!acb_contains_zero(t))
{
printf("FAIL: contiguous relation\n\n");
printf("nu = "); acb_printd(nu0, 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_neg(t, nu0);
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_bessel_j_asymp(w2, t, z, prec2);
break;
case 1:
acb_hypgeom_bessel_j_0f1(w2, t, z, prec2);
break;
default:
acb_hypgeom_bessel_j(w2, t, z, prec2);
}
acb_mul(w1, w1, w2, prec2);
acb_neg(t, nu1);
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_bessel_j_asymp(w2, t, z, prec2);
break;
case 1:
acb_hypgeom_bessel_j_0f1(w2, t, z, prec2);
break;
default:
acb_hypgeom_bessel_j(w2, t, z, prec2);
}
acb_mul(w0, w0, w2, prec2);
acb_add(w0, w0, w1, prec2);
acb_sin_pi(t, nu0, prec2);
acb_const_pi(u, prec2);
acb_mul(u, u, z, prec2);
acb_div(t, t, u, prec2);
acb_mul_2exp_si(t, t, 1);
if (!acb_overlaps(w0, t))
{
printf("FAIL: wronskian\n\n");
printf("nu = "); acb_printd(nu0, 30); printf("\n\n");
printf("z = "); acb_printd(z, 30); printf("\n\n");
printf("w0 = "); acb_printd(w0, 30); printf("\n\n");
printf("t = "); acb_printd(t, 30); printf("\n\n");
abort();
}
acb_clear(nu0);
acb_clear(nu1);
acb_clear(nu2);
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;
}
slong
_acb_poly_find_roots(acb_ptr roots,
acb_srcptr poly,
acb_srcptr initial, slong len, slong maxiter, slong prec)
{
slong iter, i, deg;
slong rootmag, max_rootmag, correction, max_correction;
deg = len - 1;
if (deg == 0)
{
return 0;
}
else if (acb_contains_zero(poly + len - 1))
{
/* if the leading coefficient contains zero, roots can be anywhere */
for (i = 0; i < deg; i++)
{
arb_zero_pm_inf(acb_realref(roots + i));
arb_zero_pm_inf(acb_imagref(roots + i));
}
return 0;
}
else if (deg == 1)
{
acb_inv(roots + 0, poly + 1, prec);
acb_mul(roots + 0, roots + 0, poly + 0, prec);
acb_neg(roots + 0, roots + 0);
return 1;
}
if (initial == NULL)
_acb_poly_roots_initial_values(roots, deg, prec);
else
_acb_vec_set(roots, initial, deg);
if (maxiter == 0)
maxiter = 2 * deg + n_sqrt(prec);
for (iter = 0; iter < maxiter; iter++)
{
max_rootmag = -ARF_PREC_EXACT;
for (i = 0; i < deg; i++)
{
rootmag = _acb_get_mid_mag(roots + i);
max_rootmag = FLINT_MAX(rootmag, max_rootmag);
}
_acb_poly_refine_roots_durand_kerner(roots, poly, len, prec);
max_correction = -ARF_PREC_EXACT;
for (i = 0; i < deg; i++)
{
correction = _acb_get_rad_mag(roots + i);
max_correction = FLINT_MAX(correction, max_correction);
}
/* estimate the correction relative to the whole set of roots */
max_correction -= max_rootmag;
/* flint_printf("ITER %wd MAX CORRECTION: %wd\n", iter, max_correction); */
if (max_correction < -prec / 2)
maxiter = FLINT_MIN(maxiter, iter + 2);
else if (max_correction < -prec / 3)
maxiter = FLINT_MIN(maxiter, iter + 3);
else if (max_correction < -prec / 4)
maxiter = FLINT_MIN(maxiter, iter + 4);
}
return _acb_poly_validate_roots(roots, poly, len, prec);
}
void
acb_hypgeom_pfq_series_sum_forward(acb_poly_t s, acb_poly_t t,
const acb_poly_struct * a, long p,
const acb_poly_struct * b, long q,
const acb_poly_t z, int regularized,
long n, long len, long prec)
{
acb_poly_t u, v;
acb_poly_t tmp;
long k, i;
acb_poly_init(u);
acb_poly_init(v);
acb_poly_init(tmp);
if (!regularized)
{
acb_poly_zero(s);
acb_poly_one(t);
for (k = 0; k < n && acb_poly_length(t) != 0; k++)
{
acb_poly_add(s, s, t, prec);
if (p > 0)
{
acb_poly_add_si(u, a, k, prec);
for (i = 1; i < p; i++)
{
acb_poly_add_si(v, a + i, k, prec);
acb_poly_mullow(u, u, v, len, prec);
}
acb_poly_mullow(t, t, u, len, prec);
}
if (q > 0)
{
acb_poly_add_si(u, b, k, prec);
for (i = 1; i < q; i++)
{
acb_poly_add_si(v, b + i, k, prec);
acb_poly_mullow(u, u, v, len, prec);
}
acb_poly_div_series(t, t, u, len, prec);
}
acb_poly_mullow(t, t, z, len, prec);
}
}
else
{
acb_poly_zero(s);
for (i = 0; i < q; i++)
{
if (i == 0)
{
acb_poly_rgamma_series(t, b + i, len, prec);
}
else
{
acb_poly_rgamma_series(u, b + i, len, prec);
acb_poly_mullow(tmp, t, u, len, prec);
acb_poly_swap(tmp, t);
}
}
for (k = 0; k < n; k++)
{
acb_poly_add(s, s, t, prec);
if (p > 0)
{
acb_poly_add_si(u, a, k, prec);
for (i = 1; i < p; i++)
{
acb_poly_add_si(v, a + i, k, prec);
acb_poly_mullow(tmp, u, v, len, prec);
acb_poly_swap(tmp, u);
}
acb_poly_mullow(tmp, t, u, len, prec);
acb_poly_swap(tmp, t);
}
if (q > 0)
{
acb_poly_add_si(u, b, k, prec);
for (i = 1; i < q; i++)
{
acb_poly_add_si(v, b + i, k, prec);
acb_poly_mullow(tmp, u, v, len, prec);
acb_poly_swap(tmp, u);
}
if (acb_poly_length(u) > 0 && !acb_contains_zero(u->coeffs))
{
acb_poly_div_series(tmp, t, u, len, prec);
acb_poly_mullow(t, tmp, z, len, prec);
}
else
{
/* compute term from scratch */
acb_poly_one(t);
for (i = 0; i < p; i++)
{
acb_poly_rising_ui_series(v, a + i, k + 1, len, prec);
acb_poly_mullow(t, t, v, len, prec);
}
for (i = 0; i < q; i++)
{
acb_poly_add_si(v, b + i, k + 1, prec);
acb_poly_rgamma_series(v, v, len, prec);
acb_poly_mullow(t, t, v, len, prec);
}
acb_poly_pow_ui_trunc_binexp(v, z, k + 1, len, prec);
acb_poly_mullow(t, t, v, len, prec);
}
}
else
{
acb_poly_mullow(tmp, t, z, len, prec);
acb_poly_swap(tmp, t);
}
}
}
acb_poly_clear(u);
acb_poly_clear(v);
acb_poly_clear(tmp);
}
int main()
{
long iter;
flint_rand_t state;
printf("gamma_upper....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000; iter++)
{
acb_t a0, a1, b, z, w0, w1, t, u;
long prec0, prec1;
int modified;
acb_init(a0);
acb_init(a1);
acb_init(b);
acb_init(z);
acb_init(w0);
acb_init(w1);
acb_init(t);
acb_init(u);
modified = n_randint(state, 2);
prec0 = 2 + n_randint(state, 1000);
prec1 = 2 + n_randint(state, 1000);
acb_randtest_maybe_half_int(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);
switch (n_randint(state, 4))
{
case 0:
acb_hypgeom_gamma_upper_asymp(w0, a0, z, modified, prec0);
break;
case 1:
acb_hypgeom_gamma_upper_1f1a(w0, a0, z, modified, prec0);
break;
case 2:
acb_hypgeom_gamma_upper_1f1b(w0, a0, z, modified, prec0);
break;
default:
acb_hypgeom_gamma_upper(w0, a0, z, modified, prec0);
}
switch (n_randint(state, 4))
{
case 0:
acb_hypgeom_gamma_upper_asymp(w1, a0, z, modified, prec1);
break;
case 1:
acb_hypgeom_gamma_upper_1f1a(w1, a0, z, modified, prec1);
break;
case 2:
acb_hypgeom_gamma_upper_1f1b(w1, a0, z, modified, prec1);
break;
default:
acb_hypgeom_gamma_upper(w1, a0, z, modified, prec1);
}
if (!acb_overlaps(w0, w1))
{
printf("FAIL: consistency\n\n");
printf("nu = "); acb_printd(a0, 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, 4))
{
case 0:
acb_hypgeom_gamma_upper_asymp(w1, a1, z, modified, prec1);
break;
case 1:
acb_hypgeom_gamma_upper_1f1a(w1, a1, z, modified, prec1);
break;
case 2:
acb_hypgeom_gamma_upper_1f1b(w1, a1, z, modified, prec1);
break;
default:
acb_hypgeom_gamma_upper(w1, a1, z, modified, prec1);
}
/* a Gamma(a,z) + exp(-z) z^a = Gamma(a+1,z) */
if (modified)
acb_one(t);
else
acb_pow(t, z, a0, prec0);
acb_neg(u, z);
acb_exp(u, u, prec0);
acb_mul(t, t, u, prec0);
if (modified)
{
acb_mul(b, w1, z, prec0);
acb_addmul(t, a0, w0, prec0);
acb_sub(t, t, b, prec0);
}
else
{
acb_addmul(t, a0, w0, prec0);
acb_sub(t, t, w1, prec0);
}
if (!acb_contains_zero(t))
{
printf("FAIL: contiguous relation\n\n");
printf("nu = "); acb_printd(a0, 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("t = "); acb_printd(t, 30); printf("\n\n");
abort();
}
acb_clear(a0);
acb_clear(a1);
acb_clear(b);
acb_clear(z);
acb_clear(w0);
acb_clear(w1);
acb_clear(t);
acb_clear(u);
}
flint_randclear(state);
flint_cleanup();
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_lambertw_middle(acb_t res, const acb_t z, slong prec)
{
fmpz_t k;
if (acb_contains_zero(z))
{
acb_indeterminate(res);
return;
}
fmpz_init(k);
fmpz_set_si(k, -1);
if (arb_is_positive(acb_imagref(z)))
{
acb_lambertw(res, z, k, 0, prec);
}
else if (arb_is_negative(acb_imagref(z)))
{
acb_conj(res, z);
acb_lambertw(res, res, k, 0, prec);
acb_conj(res, res);
}
else if (arb_is_negative(acb_realref(z)))
{
if (arb_is_nonnegative(acb_imagref(z)))
{
acb_lambertw(res, z, k, 0, prec);
}
else if (arb_is_negative(acb_imagref(z)))
{
acb_conj(res, z);
acb_lambertw(res, res, k, 0, prec);
acb_conj(res, res);
}
else
{
acb_t za, zb;
acb_init(za);
acb_init(zb);
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));
acb_lambertw(za, za, k, 0, prec);
acb_lambertw(zb, zb, k, 0, prec);
acb_conj(zb, zb);
acb_union(res, za, zb, prec);
acb_clear(za);
acb_clear(zb);
}
}
else /* re is positive */
{
if (arb_is_positive(acb_imagref(z)))
{
acb_lambertw(res, z, k, 0, prec);
}
else if (arb_is_nonpositive(acb_imagref(z)))
{
acb_conj(res, z);
acb_lambertw(res, res, k, 0, prec);
acb_conj(res, res);
}
else
{
acb_t za, zb;
acb_init(za);
acb_init(zb);
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));
acb_lambertw(za, za, k, 0, prec);
acb_lambertw(zb, zb, k, 0, prec);
acb_conj(zb, zb);
acb_union(res, za, zb, prec);
acb_clear(za);
acb_clear(zb);
}
}
fmpz_clear(k);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("chi....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t zn1, zn2, zn1n2, zn1zn2;
dirichlet_group_t G;
dirichlet_char_t chi;
ulong q, m, n1, n2, iter2;
int res;
q = 1 + n_randint(state, 1000);
dirichlet_group_init(G, q);
dirichlet_char_init(chi, G);
acb_init(zn1);
acb_init(zn2);
acb_init(zn1n2);
acb_init(zn1zn2);
/* check chi(n1) chi(n2) = chi(n1 n2) */
for (iter2 = 0; iter2 < 10; iter2++)
{
do {
m = 1 + n_randint(state, q);
} while (n_gcd(q, m) != 1);
dirichlet_char_log(chi, G, m);
n1 = n_randint(state, 1000);
n2 = n_randint(state, 1000);
acb_dirichlet_chi(zn1, G, chi, n1, 53);
acb_dirichlet_pairing(zn2, G, m, n1, 53);
if (!acb_overlaps(zn1, zn2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("q = %wu\n\n", q);
flint_printf("m = %wu\n\n", m);
flint_printf("n = %wu\n\n", n1);
flint_printf("char = "); acb_printd(zn1, 15); flint_printf("\n\n");
flint_printf("pairing = "); acb_printd(zn2, 15); flint_printf("\n\n");
dirichlet_char_print(G, chi);
dirichlet_char_log(chi, G, m);
flint_printf("log(m) = "); dirichlet_char_print(G, chi);
dirichlet_char_log(chi, G, n1);
flint_printf("log(n1) = "); dirichlet_char_print(G, chi);
flint_abort();
}
acb_dirichlet_pairing(zn2, G, m, n2, 53);
acb_dirichlet_pairing(zn1n2, G, m, n1 * n2, 53);
acb_mul(zn1zn2, zn1, zn2, 53);
if (!acb_overlaps(zn1n2, zn1zn2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("q = %wu\n\n", q);
flint_printf("m = %wu\n\n", m);
flint_printf("n1 = %wu\n\n", n1);
flint_printf("n2 = %wu\n\n", n2);
flint_printf("zn1 = "); acb_printd(zn1, 15); flint_printf("\n\n");
flint_printf("zn2 = "); acb_printd(zn2, 15); flint_printf("\n\n");
flint_printf("zn1n2 = "); acb_printd(zn1n2, 15); flint_printf("\n\n");
flint_printf("zn1zn2 = "); acb_printd(zn1zn2, 15); flint_printf("\n\n");
flint_abort();
}
}
if (iter % 10 == 0)
{
/* check orthogonality */
acb_zero(zn1);
n1 = n_randint(state, 1000);
for (m = 1; m <= q; m++)
{
if (n_gcd(q, m) == 1)
{
acb_dirichlet_pairing(zn2, G, m, n1, 53);
acb_add(zn1, zn1, zn2, 53);
}
}
if (n1 % q == 1 % q)
res = arb_contains_si(acb_realref(zn1), n_euler_phi(q)) &&
arb_contains_zero(acb_imagref(zn1));
else
res = acb_contains_zero(zn1);
if (!res)
{
flint_printf("FAIL: orthogonality\n\n");
flint_printf("q = %wu\n\n", q);
flint_printf("phi = %wu\n\n", n_euler_phi(q));
flint_printf("n1 = %wu\n\n", n1);
flint_printf("zn1 = "); acb_printd(zn1, 15); flint_printf("\n\n");
flint_abort();
}
}
dirichlet_group_clear(G);
dirichlet_char_clear(chi);
acb_clear(zn1);
acb_clear(zn2);
acb_clear(zn1n2);
acb_clear(zn1zn2);
}
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;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("find_roots....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_poly_t A;
acb_poly_t B;
acb_poly_t C;
acb_t t;
acb_ptr roots;
slong i, deg, isolated;
slong prec = 10 + n_randint(state, 400);
acb_init(t);
acb_poly_init(A);
acb_poly_init(B);
acb_poly_init(C);
do {
acb_poly_randtest(A, state, 2 + n_randint(state, 15), prec, 5);
} while (A->length == 0);
deg = A->length - 1;
roots = _acb_vec_init(deg);
isolated = acb_poly_find_roots(roots, A, NULL, 0, prec);
if (isolated == deg)
{
acb_poly_fit_length(B, 1);
acb_set(B->coeffs, A->coeffs + deg);
_acb_poly_set_length(B, 1);
for (i = 0; i < deg; i++)
{
acb_poly_fit_length(C, 2);
acb_one(C->coeffs + 1);
acb_neg(C->coeffs + 0, roots + i);
_acb_poly_set_length(C, 2);
acb_poly_mul(B, B, C, prec);
}
if (!acb_poly_contains(B, A))
{
flint_printf("FAIL: product does not equal polynomial\n");
acb_poly_printd(A, 15); flint_printf("\n\n");
acb_poly_printd(B, 15); flint_printf("\n\n");
flint_abort();
}
}
for (i = 0; i < isolated; i++)
{
acb_poly_evaluate(t, A, roots + i, prec);
if (!acb_contains_zero(t))
{
flint_printf("FAIL: poly(root) does not contain zero\n");
acb_poly_printd(A, 15); flint_printf("\n\n");
acb_printd(roots + i, 15); flint_printf("\n\n");
acb_printd(t, 15); flint_printf("\n\n");
flint_abort();
}
}
_acb_vec_clear(roots, deg);
acb_clear(t);
acb_poly_clear(A);
acb_poly_clear(B);
acb_poly_clear(C);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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_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_hypgeom_2f1_transform_limit(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_poly_t aa, bb, cc, zz;
acb_t t;
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_limit(res, a, b, c, z, 1, which, prec);
acb_mul(res, res, t, prec);
acb_clear(t);
return;
}
acb_poly_init(aa);
acb_poly_init(bb);
acb_poly_init(cc);
acb_poly_init(zz);
acb_init(t);
acb_poly_set_acb(aa, a);
acb_poly_set_acb(bb, b);
acb_poly_set_acb(cc, c);
acb_poly_set_acb(zz, z);
if (which == 2 || which == 3)
{
acb_sub(t, b, a, prec);
acb_poly_set_coeff_si(aa, 1, 1);
/* prefer b-a nonnegative (either is correct) to avoid
expensive operations in the hypergeometric series */
if (arb_is_nonnegative(acb_realref(t)))
_acb_hypgeom_2f1_transform_limit(res, aa, bb, cc, zz, which, prec);
else
_acb_hypgeom_2f1_transform_limit(res, bb, aa, cc, zz, which, prec);
}
else
{
acb_poly_set_coeff_si(aa, 1, 1);
_acb_hypgeom_2f1_transform_limit(res, aa, bb, cc, zz, which, prec);
}
acb_poly_clear(aa);
acb_poly_clear(bb);
acb_poly_clear(cc);
acb_poly_clear(zz);
acb_clear(t);
}
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("quadratic_roots_fmpz....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t r1, r2, x, y;
fmpz_t a, b, c;
slong prec;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
acb_init(r1);
acb_init(r2);
acb_init(x);
acb_init(y);
prec = 2 + n_randint(state, 1000);
fmpz_randtest_not_zero(a, state, 1 + n_randint(state, 1000));
fmpz_randtest(b, state, 1 + n_randint(state, 1000));
fmpz_randtest(c, state, 1 + n_randint(state, 1000));
acb_randtest(r1, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(r2, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_quadratic_roots_fmpz(r1, r2, a, b, c, prec);
acb_mul(x, r1, r1, prec);
acb_mul_fmpz(x, x, a, prec);
acb_addmul_fmpz(x, r1, b, prec);
acb_add_fmpz(x, x, c, prec);
acb_mul(y, r2, r2, prec);
acb_mul_fmpz(y, y, a, prec);
acb_addmul_fmpz(y, r2, b, prec);
acb_add_fmpz(y, y, c, prec);
if (!acb_contains_zero(x) || !acb_contains_zero(y) ||
acb_rel_accuracy_bits(r1) < prec - 4 ||
acb_rel_accuracy_bits(r2) < prec - 4)
{
flint_printf("FAIL: containment / accuracy\n\n");
flint_printf("prec = %wd\n", prec);
flint_printf("a = "); fmpz_print(a); flint_printf("\n\n");
flint_printf("b = "); fmpz_print(b); flint_printf("\n\n");
flint_printf("c = "); fmpz_print(c); flint_printf("\n\n");
flint_printf("r1 = "); acb_printd(r1, 30); flint_printf("\n\n");
flint_printf("r2 = "); acb_printd(r2, 30); flint_printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
acb_clear(r1);
acb_clear(r2);
acb_clear(x);
acb_clear(y);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("j....");
fflush(stdout);
flint_randinit(state);
/* Test SL2Z invariance */
for (iter = 0; iter < 10000; iter++)
{
acb_t tau1, tau2, z1, z2;
slong e0, prec0, prec1, prec2;
psl2z_t g;
psl2z_init(g);
acb_init(tau1);
acb_init(tau2);
acb_init(z1);
acb_init(z2);
e0 = 1 + n_randint(state, 100);
prec0 = 2 + n_randint(state, 2000);
prec1 = 2 + n_randint(state, 2000);
prec2 = 2 + n_randint(state, 2000);
acb_randtest(tau1, state, prec0, e0);
acb_randtest(tau2, state, prec0, e0);
acb_randtest(z1, state, prec0, e0);
acb_randtest(z2, state, prec0, e0);
psl2z_randtest(g, state, 1 + n_randint(state, 200));
acb_modular_transform(tau2, g, tau1, prec0);
acb_modular_j(z1, tau1, prec1);
acb_modular_j(z2, tau2, prec2);
if (!acb_overlaps(z1, z2))
{
flint_printf("FAIL (overlap)\n");
flint_printf("tau1 = "); acb_print(tau1); flint_printf("\n\n");
flint_printf("tau2 = "); acb_print(tau2); flint_printf("\n\n");
flint_printf("z1 = "); acb_print(z1); flint_printf("\n\n");
flint_printf("z2 = "); acb_print(z2); flint_printf("\n\n");
abort();
}
acb_modular_j(tau1, tau1, prec2);
if (!acb_overlaps(z1, tau1))
{
flint_printf("FAIL (aliasing)\n");
flint_printf("tau1 = "); acb_print(tau1); flint_printf("\n\n");
flint_printf("tau2 = "); acb_print(tau2); flint_printf("\n\n");
flint_printf("z1 = "); acb_print(z1); flint_printf("\n\n");
flint_printf("z2 = "); acb_print(z2); flint_printf("\n\n");
abort();
}
acb_clear(tau1);
acb_clear(tau2);
acb_clear(z1);
acb_clear(z2);
psl2z_clear(g);
}
/* Test special values */
for (iter = 0; iter < 100; iter++)
{
acb_t tau, z;
slong prec;
acb_init(tau);
acb_init(z);
prec = 2 + n_randint(state, 2000);
acb_randtest(z, state, prec, 10);
acb_onei(tau);
acb_modular_j(z, tau, prec);
acb_sub_ui(z, z, 1728, prec);
if (!acb_contains_zero(z))
{
flint_printf("FAIL (value 1)\n");
flint_printf("tau = "); acb_print(tau); flint_printf("\n\n");
flint_printf("z = "); acb_print(z); flint_printf("\n\n");
abort();
}
acb_set_ui(tau, 2);
acb_div_ui(tau, tau, 3, prec);
acb_exp_pi_i(tau, tau, prec);
acb_modular_j(z, tau, prec);
if (!acb_contains_zero(z))
{
flint_printf("FAIL (value 2)\n");
flint_printf("tau = "); acb_print(tau); flint_printf("\n\n");
flint_printf("z = "); acb_print(z); flint_printf("\n\n");
abort();
}
acb_clear(tau);
acb_clear(z);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}