int main()
{
slong iter;
flint_rand_t state;
flint_printf("l....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_t s, t, u;
dirichlet_group_t G;
dirichlet_char_t chi;
ulong q, k;
slong prec;
acb_init(s);
acb_init(t);
acb_init(u);
q = 1 + n_randint(state, 50);
prec = 2 + n_randint(state, 100);
k = n_randint(state, n_euler_phi(q));
dirichlet_group_init(G, q);
dirichlet_char_init(chi, G);
dirichlet_char_index(chi, G, k);
if (n_randint(state, 2))
acb_set_si(s, n_randint(state, 50) - 25);
else
acb_randtest(s, state, 2 + n_randint(state, 200), 2);
acb_dirichlet_l_hurwitz(t, s, NULL, G, chi, prec);
acb_dirichlet_l(u, s, G, chi, prec);
if (!acb_overlaps(t, u))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("iter = %ld q = %lu k = %lu prec = %ld\n\n", iter, q, k, prec);
flint_printf("s = "); acb_printn(s, 100, 0); flint_printf("\n\n");
flint_printf("t = "); acb_printn(t, 100, 0); flint_printf("\n\n");
flint_printf("u = "); acb_printn(u, 100, 0); flint_printf("\n\n");
abort();
}
dirichlet_char_clear(chi);
dirichlet_group_clear(G);
acb_clear(s);
acb_clear(t);
acb_clear(u);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_poly_set_coeff_si(acb_poly_t poly, slong n, slong x)
{
acb_poly_fit_length(poly, n + 1);
if (n + 1 > poly->length)
{
_acb_vec_zero(poly->coeffs + poly->length, n - poly->length);
poly->length = n + 1;
}
acb_set_si(poly->coeffs + n, x);
_acb_poly_normalise(poly);
}
void
acb_hypgeom_erf_asymp(acb_t res, const acb_t z, slong prec, slong prec2)
{
acb_t a, t, u;
acb_init(a);
acb_init(t);
acb_init(u);
acb_one(a);
acb_mul_2exp_si(a, a, -1);
acb_mul(t, z, z, prec2);
acb_hypgeom_u_asymp(u, a, a, t, -1, prec2);
acb_neg(t, t);
acb_exp(t, t, prec2);
acb_mul(u, u, t, prec2);
acb_const_pi(t, prec2);
acb_sqrt(t, t, prec2);
acb_mul(t, t, z, prec2);
acb_div(u, u, t, prec2);
/* branch cut term: -1 or 1 */
if (arb_contains_zero(acb_realref(z)))
{
arb_zero(acb_imagref(t));
arf_zero(arb_midref(acb_realref(t)));
mag_one(arb_radref(acb_realref(t)));
}
else
{
acb_set_si(t, arf_sgn(arb_midref(acb_realref(z))));
}
acb_sub(t, t, u, prec);
if (arb_is_zero(acb_imagref(z)))
arb_zero(acb_imagref(t));
else if (arb_is_zero(acb_realref(z)))
arb_zero(acb_realref(t));
acb_set(res, t);
acb_clear(a);
acb_clear(t);
acb_clear(u);
}
void
acb_unit_root(acb_t res, ulong order, slong prec)
{
switch (order)
{
case 1:
acb_one(res);
break;
case 2:
acb_set_si(res, -1);
break;
case 4:
acb_onei(res);
break;
default:
_acb_unit_root(res, order, prec);
break;
}
}
static void
phase(acb_t res, const arb_t re, const arb_t im)
{
if (arb_is_nonnegative(re) || arb_is_negative(im))
{
acb_one(res);
}
else if (arb_is_negative(re) && arb_is_nonnegative(im))
{
acb_set_si(res, -3);
}
else
{
arb_zero(acb_imagref(res));
/* -1 +/- 2 */
arf_set_si(arb_midref(acb_realref(res)), -1);
mag_one(arb_radref(acb_realref(res)));
mag_mul_2exp_si(arb_radref(acb_realref(res)), arb_radref(acb_realref(res)), 1);
}
}
int main(int argc, char *argv[])
{
acb_t s, t, a, b;
mag_t tol;
slong prec, goal;
slong N;
ulong k;
int integral, ifrom, ito;
int i, twice, havegoal, havetol;
acb_calc_integrate_opt_t options;
ifrom = ito = -1;
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-i"))
{
if (!strcmp(argv[i+1], "all"))
{
ifrom = 0;
ito = NUM_INTEGRALS - 1;
}
else
{
ifrom = ito = atol(argv[i+1]);
if (ito < 0 || ito >= NUM_INTEGRALS)
flint_abort();
}
}
}
if (ifrom == -1)
{
flint_printf("Compute integrals using acb_calc_integrate.\n");
flint_printf("Usage: integrals -i n [-prec p] [-tol eps] [-twice] [...]\n\n");
flint_printf("-i n - compute integral n (0 <= n <= %d), or \"-i all\"\n", NUM_INTEGRALS - 1);
flint_printf("-prec p - precision in bits (default p = 64)\n");
flint_printf("-goal p - approximate relative accuracy goal (default p)\n");
flint_printf("-tol eps - approximate absolute error goal (default 2^-p)\n");
flint_printf("-twice - run twice (to see overhead of computing nodes)\n");
flint_printf("-heap - use heap for subinterval queue\n");
flint_printf("-verbose - show information\n");
flint_printf("-verbose2 - show more information\n");
flint_printf("-deg n - use quadrature degree up to n\n");
flint_printf("-eval n - limit number of function evaluations to n\n");
flint_printf("-depth n - limit subinterval queue size to n\n\n");
flint_printf("Implemented integrals:\n");
for (integral = 0; integral < NUM_INTEGRALS; integral++)
flint_printf("I%d = %s\n", integral, descr[integral]);
flint_printf("\n");
return 1;
}
acb_calc_integrate_opt_init(options);
prec = 64;
twice = 0;
goal = 0;
havetol = havegoal = 0;
acb_init(a);
acb_init(b);
acb_init(s);
acb_init(t);
mag_init(tol);
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-prec"))
{
prec = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-twice"))
{
twice = 1;
}
else if (!strcmp(argv[i], "-goal"))
{
goal = atol(argv[i+1]);
if (goal < 0)
{
flint_printf("expected goal >= 0\n");
return 1;
}
havegoal = 1;
}
else if (!strcmp(argv[i], "-tol"))
{
arb_t x;
arb_init(x);
arb_set_str(x, argv[i+1], 10);
arb_get_mag(tol, x);
arb_clear(x);
havetol = 1;
}
else if (!strcmp(argv[i], "-deg"))
{
options->deg_limit = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-eval"))
{
options->eval_limit = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-depth"))
{
options->depth_limit = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-verbose"))
{
options->verbose = 1;
}
else if (!strcmp(argv[i], "-verbose2"))
{
options->verbose = 2;
}
else if (!strcmp(argv[i], "-heap"))
{
options->use_heap = 1;
}
}
if (!havegoal)
goal = prec;
if (!havetol)
mag_set_ui_2exp_si(tol, 1, -prec);
for (integral = ifrom; integral <= ito; integral++)
{
flint_printf("I%d = %s ...\n", integral, descr[integral]);
for (i = 0; i < 1 + twice; i++)
{
TIMEIT_ONCE_START
switch (integral)
{
case 0:
acb_set_d(a, 0);
acb_set_d(b, 100);
acb_calc_integrate(s, f_sin, NULL, a, b, goal, tol, options, prec);
break;
case 1:
acb_set_d(a, 0);
acb_set_d(b, 1);
acb_calc_integrate(s, f_atanderiv, NULL, a, b, goal, tol, options, prec);
acb_mul_2exp_si(s, s, 2);
break;
case 2:
acb_set_d(a, 0);
acb_one(b);
acb_mul_2exp_si(b, b, goal);
acb_calc_integrate(s, f_atanderiv, NULL, a, b, goal, tol, options, prec);
arb_add_error_2exp_si(acb_realref(s), -goal);
acb_mul_2exp_si(s, s, 1);
break;
case 3:
acb_set_d(a, 0);
acb_set_d(b, 1);
acb_calc_integrate(s, f_circle, NULL, a, b, goal, tol, options, prec);
acb_mul_2exp_si(s, s, 2);
break;
case 4:
acb_set_d(a, 0);
acb_set_d(b, 8);
acb_calc_integrate(s, f_rump, NULL, a, b, goal, tol, options, prec);
break;
case 5:
acb_set_d(a, 1);
acb_set_d(b, 101);
acb_calc_integrate(s, f_floor, NULL, a, b, goal, tol, options, prec);
break;
case 6:
acb_set_d(a, 0);
acb_set_d(b, 1);
acb_calc_integrate(s, f_helfgott, NULL, a, b, goal, tol, options, prec);
break;
case 7:
acb_zero(s);
acb_set_d_d(a, -1.0, -1.0);
acb_set_d_d(b, 2.0, -1.0);
acb_calc_integrate(t, f_zeta, NULL, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_set_d_d(a, 2.0, -1.0);
acb_set_d_d(b, 2.0, 1.0);
acb_calc_integrate(t, f_zeta, NULL, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_set_d_d(a, 2.0, 1.0);
acb_set_d_d(b, -1.0, 1.0);
acb_calc_integrate(t, f_zeta, NULL, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_set_d_d(a, -1.0, 1.0);
acb_set_d_d(b, -1.0, -1.0);
acb_calc_integrate(t, f_zeta, NULL, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_const_pi(t, prec);
acb_div(s, s, t, prec);
acb_mul_2exp_si(s, s, -1);
acb_div_onei(s, s);
break;
case 8:
acb_set_d(a, 0);
acb_set_d(b, 1);
acb_calc_integrate(s, f_essing, NULL, a, b, goal, tol, options, prec);
break;
case 9:
acb_set_d(a, 0);
acb_set_d(b, 1);
acb_calc_integrate(s, f_essing2, NULL, a, b, goal, tol, options, prec);
break;
case 10:
acb_set_d(a, 0);
acb_set_d(b, 10000);
acb_calc_integrate(s, f_factorial1000, NULL, a, b, goal, tol, options, prec);
break;
case 11:
acb_set_d_d(a, 1.0, 0.0);
acb_set_d_d(b, 1.0, 1000.0);
acb_calc_integrate(s, f_gamma, NULL, a, b, goal, tol, options, prec);
break;
case 12:
acb_set_d(a, -10.0);
acb_set_d(b, 10.0);
acb_calc_integrate(s, f_sin_plus_small, NULL, a, b, goal, tol, options, prec);
break;
case 13:
acb_set_d(a, -1020.0);
acb_set_d(b, -1010.0);
acb_calc_integrate(s, f_exp, NULL, a, b, goal, tol, options, prec);
break;
case 14:
acb_set_d(a, 0);
acb_set_d(b, ceil(sqrt(goal * 0.693147181) + 1.0));
acb_calc_integrate(s, f_gaussian, NULL, a, b, goal, tol, options, prec);
acb_mul(b, b, b, prec);
acb_neg(b, b);
acb_exp(b, b, prec);
arb_add_error(acb_realref(s), acb_realref(b));
break;
case 15:
acb_set_d(a, 0.0);
acb_set_d(b, 1.0);
acb_calc_integrate(s, f_spike, NULL, a, b, goal, tol, options, prec);
break;
case 16:
acb_set_d(a, 0.0);
acb_set_d(b, 8.0);
acb_calc_integrate(s, f_monster, NULL, a, b, goal, tol, options, prec);
break;
case 17:
acb_set_d(a, 0);
acb_set_d(b, ceil(goal * 0.693147181 + 1.0));
acb_calc_integrate(s, f_sech, NULL, a, b, goal, tol, options, prec);
acb_neg(b, b);
acb_exp(b, b, prec);
acb_mul_2exp_si(b, b, 1);
arb_add_error(acb_realref(s), acb_realref(b));
break;
case 18:
acb_set_d(a, 0);
acb_set_d(b, ceil(goal * 0.693147181 / 3.0 + 2.0));
acb_calc_integrate(s, f_sech3, NULL, a, b, goal, tol, options, prec);
acb_neg(b, b);
acb_mul_ui(b, b, 3, prec);
acb_exp(b, b, prec);
acb_mul_2exp_si(b, b, 3);
acb_div_ui(b, b, 3, prec);
arb_add_error(acb_realref(s), acb_realref(b));
break;
case 19:
if (goal < 0)
abort();
/* error bound 2^-N (1+N) when truncated at 2^-N */
N = goal + FLINT_BIT_COUNT(goal);
acb_one(a);
acb_mul_2exp_si(a, a, -N);
acb_one(b);
acb_calc_integrate(s, f_log_div1p, NULL, a, b, goal, tol, options, prec);
acb_set_ui(b, N + 1);
acb_mul_2exp_si(b, b, -N);
arb_add_error(acb_realref(s), acb_realref(b));
break;
case 20:
if (goal < 0)
abort();
/* error bound (N+1) exp(-N) when truncated at N */
N = goal + FLINT_BIT_COUNT(goal);
acb_zero(a);
acb_set_ui(b, N);
acb_calc_integrate(s, f_log_div1p_transformed, NULL, a, b, goal, tol, options, prec);
acb_neg(b, b);
acb_exp(b, b, prec);
acb_mul_ui(b, b, N + 1, prec);
arb_add_error(acb_realref(s), acb_realref(b));
break;
case 21:
acb_zero(s);
N = 10;
acb_set_d_d(a, 0.5, -0.5);
acb_set_d_d(b, 0.5, 0.5);
acb_calc_integrate(t, f_elliptic_p_laurent_n, &N, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_set_d_d(a, 0.5, 0.5);
acb_set_d_d(b, -0.5, 0.5);
acb_calc_integrate(t, f_elliptic_p_laurent_n, &N, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_set_d_d(a, -0.5, 0.5);
acb_set_d_d(b, -0.5, -0.5);
acb_calc_integrate(t, f_elliptic_p_laurent_n, &N, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_set_d_d(a, -0.5, -0.5);
acb_set_d_d(b, 0.5, -0.5);
acb_calc_integrate(t, f_elliptic_p_laurent_n, &N, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_const_pi(t, prec);
acb_div(s, s, t, prec);
acb_mul_2exp_si(s, s, -1);
acb_div_onei(s, s);
break;
case 22:
acb_zero(s);
N = 1000;
acb_set_d_d(a, 100.0, 0.0);
acb_set_d_d(b, 100.0, N);
acb_calc_integrate(t, f_zeta_frac, NULL, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_set_d_d(a, 100, N);
acb_set_d_d(b, 0.5, N);
acb_calc_integrate(t, f_zeta_frac, NULL, a, b, goal, tol, options, prec);
acb_add(s, s, t, prec);
acb_div_onei(s, s);
arb_zero(acb_imagref(s));
acb_set_ui(t, N);
acb_dirichlet_hardy_theta(t, t, NULL, NULL, 1, prec);
acb_add(s, s, t, prec);
acb_const_pi(t, prec);
acb_div(s, s, t, prec);
acb_add_ui(s, s, 1, prec);
break;
case 23:
acb_set_d(a, 0.0);
acb_set_d(b, 1000.0);
acb_calc_integrate(s, f_lambertw, NULL, a, b, goal, tol, options, prec);
break;
case 24:
acb_set_d(a, 0.0);
acb_const_pi(b, prec);
acb_calc_integrate(s, f_max_sin_cos, NULL, a, b, goal, tol, options, prec);
break;
case 25:
acb_set_si(a, -1);
acb_set_si(b, 1);
acb_calc_integrate(s, f_erf_bent, NULL, a, b, goal, tol, options, prec);
break;
case 26:
acb_set_si(a, -10);
acb_set_si(b, 10);
acb_calc_integrate(s, f_airy_ai, NULL, a, b, goal, tol, options, prec);
break;
case 27:
acb_set_si(a, 0);
acb_set_si(b, 10);
acb_calc_integrate(s, f_horror, NULL, a, b, goal, tol, options, prec);
break;
case 28:
acb_set_d_d(a, -1, -1);
acb_set_d_d(b, -1, 1);
acb_calc_integrate(s, f_sqrt, NULL, a, b, goal, tol, options, prec);
break;
case 29:
acb_set_d(a, 0);
acb_set_d(b, ceil(sqrt(goal * 0.693147181) + 1.0));
acb_calc_integrate(s, f_gaussian_twist, NULL, a, b, goal, tol, options, prec);
acb_mul(b, b, b, prec);
acb_neg(b, b);
acb_exp(b, b, prec);
arb_add_error(acb_realref(s), acb_realref(b));
arb_add_error(acb_imagref(s), acb_realref(b));
break;
case 30:
acb_set_d(a, 0);
acb_set_d(b, ceil(goal * 0.693147181 + 1.0));
acb_calc_integrate(s, f_exp_airy, NULL, a, b, goal, tol, options, prec);
acb_neg(b, b);
acb_exp(b, b, prec);
acb_mul_2exp_si(b, b, 1);
arb_add_error(acb_realref(s), acb_realref(b));
break;
case 31:
acb_zero(a);
acb_const_pi(b, prec);
acb_calc_integrate(s, f_sin_cos_frac, NULL, a, b, goal, tol, options, prec);
break;
case 32:
acb_zero(a);
acb_set_ui(b, 3);
acb_calc_integrate(s, f_sin_near_essing, NULL, a, b, goal, tol, options, prec);
break;
case 33:
acb_zero(a);
acb_zero(b);
k = 3;
scaled_bessel_select_N(acb_realref(b), k, prec);
acb_calc_integrate(s, f_scaled_bessel, &k, a, b, goal, tol, options, prec);
scaled_bessel_tail_bound(acb_realref(a), k, acb_realref(b), prec);
arb_add_error(acb_realref(s), acb_realref(a));
break;
case 34:
acb_zero(a);
acb_zero(b);
k = 15;
scaled_bessel_select_N(acb_realref(b), k, prec);
acb_calc_integrate(s, f_scaled_bessel, &k, a, b, goal, tol, options, prec);
scaled_bessel_tail_bound(acb_realref(a), k, acb_realref(b), prec);
arb_add_error(acb_realref(s), acb_realref(a));
break;
case 35:
acb_set_d_d(a, -1, -1);
acb_set_d_d(b, -1, 1);
acb_calc_integrate(s, f_rsqrt, NULL, a, b, goal, tol, options, prec);
break;
default:
abort();
}
TIMEIT_ONCE_STOP
}
flint_printf("I%d = ", integral);
acb_printn(s, 3.333 * prec, 0);
flint_printf("\n\n");
}
acb_clear(a);
acb_clear(b);
acb_clear(s);
acb_clear(t);
mag_clear(tol);
flint_cleanup();
return 0;
}
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);
}
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(int argc, char *argv[])
{
acb_t r, s, a, b;
arf_t inr, outr;
long digits, prec;
if (argc < 2)
{
printf("integrals d\n");
printf("compute integrals using d decimal digits of precision\n");
return 1;
}
acb_init(r);
acb_init(s);
acb_init(a);
acb_init(b);
arf_init(inr);
arf_init(outr);
arb_calc_verbose = 0;
digits = atol(argv[1]);
prec = digits * 3.32193;
printf("Digits: %ld\n", digits);
printf("----------------------------------------------------------------\n");
printf("Integral of sin(t) from 0 to 100.\n");
arf_set_d(inr, 0.125);
arf_set_d(outr, 1.0);
TIMEIT_ONCE_START
acb_set_si(a, 0);
acb_set_si(b, 100);
acb_calc_integrate_taylor(r, sinx, NULL, a, b, inr, outr, prec, 1.1 * prec);
printf("RESULT:\n");
acb_printd(r, digits); printf("\n");
TIMEIT_ONCE_STOP
printf("----------------------------------------------------------------\n");
printf("Elliptic integral F(phi, m) = integral of 1/sqrt(1 - m*sin(t)^2)\n");
printf("from 0 to phi, with phi = 6+6i, m = 1/2. Integration path\n");
printf("0 -> 6 -> 6+6i.\n");
arf_set_d(inr, 0.2);
arf_set_d(outr, 0.5);
TIMEIT_ONCE_START
acb_set_si(a, 0);
acb_set_si(b, 6);
acb_calc_integrate_taylor(r, elliptic, NULL, a, b, inr, outr, prec, 1.1 * prec);
acb_set_si(a, 6);
arb_set_si(acb_realref(b), 6);
arb_set_si(acb_imagref(b), 6);
acb_calc_integrate_taylor(s, elliptic, NULL, a, b, inr, outr, prec, 1.1 * prec);
acb_add(r, r, s, prec);
printf("RESULT:\n");
acb_printd(r, digits); printf("\n");
TIMEIT_ONCE_STOP
printf("----------------------------------------------------------------\n");
printf("Bessel function J_n(z) = (1/pi) * integral of cos(t*n - z*sin(t))\n");
printf("from 0 to pi. With n = 10, z = 20 + 10i.\n");
arf_set_d(inr, 0.1);
arf_set_d(outr, 0.5);
TIMEIT_ONCE_START
acb_set_si(a, 0);
acb_const_pi(b, 3 * prec);
acb_calc_integrate_taylor(r, bessel, NULL, a, b, inr, outr, prec, 3 * prec);
acb_div(r, r, b, prec);
printf("RESULT:\n");
acb_printd(r, digits); printf("\n");
TIMEIT_ONCE_STOP
acb_clear(r);
acb_clear(s);
acb_clear(a);
acb_clear(b);
arf_clear(inr);
arf_clear(outr);
flint_cleanup();
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("jacobi_p....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
acb_t n, a, b, n1, a1, b1, z, res1, res2, res3, s;
slong prec;
acb_init(n);
acb_init(a);
acb_init(b);
acb_init(n1);
acb_init(a1);
acb_init(b1);
acb_init(z);
acb_init(res1);
acb_init(res2);
acb_init(res3);
acb_init(s);
prec = 2 + n_randint(state, 300);
if (n_randint(state, 2))
{
acb_set_si(n, n_randint(state, 20) - 10);
acb_set_si(a, n_randint(state, 20) - 10);
acb_set_si(b, n_randint(state, 20) - 10);
}
else
{
acb_randtest_param(n, state, 1 + n_randint(state, 400), 10);
acb_randtest_param(a, state, 1 + n_randint(state, 400), 10);
acb_randtest_param(b, state, 1 + n_randint(state, 400), 10);
}
acb_randtest_param(z, state, 1 + n_randint(state, 400), 10);
acb_sub_ui(n1, n, 1, prec);
acb_sub_ui(a1, a, 1, prec);
acb_sub_ui(b1, b, 1, prec);
acb_hypgeom_jacobi_p(res1, n, a, b1, z, prec);
acb_hypgeom_jacobi_p(res2, n, a1, b, z, 2 + n_randint(state, 300));
acb_hypgeom_jacobi_p(res3, n1, a, b, z, 2 + n_randint(state, 300));
acb_sub(s, res1, res2, prec);
if (!acb_overlaps(s, res3))
{
flint_printf("FAIL: consistency\n\n");
flint_printf("iter = %wd\n\n", iter);
flint_printf("n = "); acb_printd(n, 30); flint_printf("\n\n");
flint_printf("a = "); acb_printd(a, 30); flint_printf("\n\n");
flint_printf("b = "); acb_printd(b, 30); flint_printf("\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("res1 = "); acb_printd(res1, 30); flint_printf("\n\n");
flint_printf("res2 = "); acb_printd(res2, 30); flint_printf("\n\n");
flint_printf("res3 = "); acb_printd(res3, 30); flint_printf("\n\n");
flint_printf("s = "); acb_printd(s, 30); flint_printf("\n\n");
abort();
}
acb_clear(n);
acb_clear(a);
acb_clear(b);
acb_clear(n1);
acb_clear(a1);
acb_clear(b1);
acb_clear(z);
acb_clear(res1);
acb_clear(res2);
acb_clear(res3);
acb_clear(s);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("laguerre_l....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000 * arb_test_multiplier(); iter++)
{
acb_t n, m, n1, m1, z, res1, res2, res3, s;
slong prec;
acb_init(n);
acb_init(m);
acb_init(n1);
acb_init(m1);
acb_init(z);
acb_init(res1);
acb_init(res2);
acb_init(res3);
acb_init(s);
prec = 2 + n_randint(state, 200);
if (n_randint(state, 2))
{
acb_set_si(n, n_randint(state, 20) - 10);
acb_set_si(m, n_randint(state, 20) - 10);
}
else
{
acb_randtest_param(n, state, 1 + n_randint(state, 400), 10);
acb_randtest_param(m, state, 1 + n_randint(state, 400), 10);
}
acb_randtest_param(z, state, 1 + n_randint(state, 400), 10);
acb_sub_ui(n1, n, 1, prec);
acb_sub_ui(m1, m, 1, prec);
acb_hypgeom_laguerre_l(res1, n, m, z, prec);
acb_hypgeom_laguerre_l(res2, n1, m, z, 2 + n_randint(state, 200));
acb_hypgeom_laguerre_l(res3, n, m1, z, 2 + n_randint(state, 200));
acb_add(s, res2, res3, prec);
if (acb_is_finite(res1) && acb_is_finite(s) && !acb_overlaps(res1, s))
{
flint_printf("FAIL: consistency\n\n");
flint_printf("iter = %wd\n\n", iter);
flint_printf("n = "); acb_printd(n, 30); flint_printf("\n\n");
flint_printf("m = "); acb_printd(m, 30); flint_printf("\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("res1 = "); acb_printd(res1, 30); flint_printf("\n\n");
flint_printf("res2 = "); acb_printd(res2, 30); flint_printf("\n\n");
flint_printf("res3 = "); acb_printd(res3, 30); flint_printf("\n\n");
flint_printf("s = "); acb_printd(s, 30); flint_printf("\n\n");
abort();
}
acb_clear(n);
acb_clear(m);
acb_clear(n1);
acb_clear(m1);
acb_clear(z);
acb_clear(res1);
acb_clear(res2);
acb_clear(res3);
acb_clear(s);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
_acb_poly_zeta_cpx_reflect(acb_ptr t, const acb_t h, const acb_t a, int deflate, slong len, slong prec)
{
/* use reflection formula */
if (arf_sgn(arb_midref(acb_realref(h))) < 0 && acb_is_one(a))
{
/* zeta(s) = (2*pi)**s * sin(pi*s/2) / pi * gamma(1-s) * zeta(1-s) */
acb_t pi, hcopy;
acb_ptr f, s1, s2, s3, s4, u;
slong i;
acb_init(pi);
acb_init(hcopy);
f = _acb_vec_init(2);
s1 = _acb_vec_init(len);
s2 = _acb_vec_init(len);
s3 = _acb_vec_init(len);
s4 = _acb_vec_init(len);
u = _acb_vec_init(len);
acb_set(hcopy, h);
acb_const_pi(pi, prec);
/* s1 = (2*pi)**s */
acb_mul_2exp_si(pi, pi, 1);
_acb_poly_pow_cpx(s1, pi, h, len, prec);
acb_mul_2exp_si(pi, pi, -1);
/* s2 = sin(pi*s/2) / pi */
acb_set(f, h);
acb_one(f + 1);
acb_mul_2exp_si(f, f, -1);
acb_mul_2exp_si(f + 1, f + 1, -1);
_acb_poly_sin_pi_series(s2, f, 2, len, prec);
_acb_vec_scalar_div(s2, s2, len, pi, prec);
/* s3 = gamma(1-s) */
acb_sub_ui(f, hcopy, 1, prec);
acb_neg(f, f);
acb_set_si(f + 1, -1);
_acb_poly_gamma_series(s3, f, 2, len, prec);
/* s4 = zeta(1-s) */
acb_sub_ui(f, hcopy, 1, prec);
acb_neg(f, f);
_acb_poly_zeta_cpx_series(s4, f, a, 0, len, prec);
for (i = 1; i < len; i += 2)
acb_neg(s4 + i, s4 + i);
_acb_poly_mullow(u, s1, len, s2, len, len, prec);
_acb_poly_mullow(s1, s3, len, s4, len, len, prec);
_acb_poly_mullow(t, u, len, s1, len, len, prec);
/* add 1/(1-(s+t)) = 1/(1-s) + t/(1-s)^2 + ... */
if (deflate)
{
acb_sub_ui(u, hcopy, 1, prec);
acb_neg(u, u);
acb_inv(u, u, prec);
for (i = 1; i < len; i++)
acb_mul(u + i, u + i - 1, u, prec);
_acb_vec_add(t, t, u, len, prec);
}
acb_clear(pi);
acb_clear(hcopy);
_acb_vec_clear(f, 2);
_acb_vec_clear(s1, len);
_acb_vec_clear(s2, len);
_acb_vec_clear(s3, len);
_acb_vec_clear(s4, len);
_acb_vec_clear(u, len);
}
else
{
_acb_poly_zeta_cpx_series(t, h, a, deflate, len, prec);
}
}
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;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("polygamma....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_t a, s, b, c;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 500);
prec2 = prec1 + 30;
acb_init(a);
acb_init(s);
acb_init(b);
acb_init(c);
if (iter < 200)
{
slong i = n_randint(state, 5);
acb_set_si(s, -2 + i);
acb_one(a);
acb_randtest(c, state, 1 + n_randint(state, 500), 3);
acb_add(s, s, c, prec2);
acb_sub(s, s, c, prec2);
acb_polygamma(b, s, a, prec1);
acb_zero(c);
arb_set_str(acb_realref(c), testdata[i], prec2);
}
else
{
acb_randtest(a, state, 1 + n_randint(state, 500), 3);
acb_randtest(s, state, 1 + n_randint(state, 500), 3);
acb_polygamma(b, s, a, prec1);
acb_randtest(c, state, 1 + n_randint(state, 500), 3);
acb_add(s, s, c, prec2);
acb_sub(s, s, c, prec2);
acb_polygamma(c, s, a, prec2);
}
if (!acb_overlaps(b, c))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("s = "); acb_print(s); flint_printf("\n\n");
flint_printf("b = "); acb_print(b); flint_printf("\n\n");
flint_printf("c = "); acb_print(c); flint_printf("\n\n");
flint_abort();
}
acb_clear(a);
acb_clear(s);
acb_clear(b);
acb_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_chebyshev_t(acb_t res, const acb_t n, const acb_t z, slong prec)
{
acb_t t;
if (acb_is_int(n) &&
arf_cmpabs_2exp_si(arb_midref(acb_realref(n)), FLINT_BITS - 1) < 0)
{
slong k = arf_get_si(arb_midref(acb_realref(n)), ARF_RND_DOWN);
acb_chebyshev_t_ui(res, FLINT_ABS(k), z, prec);
return;
}
if (acb_is_zero(z))
{
acb_mul_2exp_si(res, n, -1);
acb_cos_pi(res, res, prec);
return;
}
if (acb_is_one(z))
{
acb_one(res);
return;
}
acb_init(t);
acb_set_si(t, -1);
if (acb_equal(t, z))
{
acb_cos_pi(res, n, prec);
}
else
{
acb_sub_ui(t, z, 1, prec);
if (arf_cmpabs_2exp_si(arb_midref(acb_realref(t)), -2 - prec / 10) < 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(t)), -2 - prec / 10) < 0)
{
acb_t a, c;
acb_init(a);
acb_init(c);
acb_neg(a, n);
acb_one(c);
acb_mul_2exp_si(c, c, -1);
acb_neg(t, t);
acb_mul_2exp_si(t, t, -1);
acb_hypgeom_2f1(res, a, n, c, t, 0, prec);
acb_clear(a);
acb_clear(c);
}
else if (arb_is_nonnegative(acb_realref(t)))
{
acb_acosh(t, z, prec);
acb_mul(t, t, n, prec);
acb_cosh(res, t, prec);
}
else
{
acb_acos(t, z, prec);
acb_mul(t, t, n, prec);
acb_cos(res, t, prec);
}
}
acb_clear(t);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("taylor_shift_convolution....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000; iter++)
{
slong prec1, prec2;
acb_poly_t f, g;
acb_t c, d, e;
prec1 = 2 + n_randint(state, 500);
prec2 = 2 + n_randint(state, 500);
acb_poly_init(f);
acb_poly_init(g);
acb_init(c);
acb_init(d);
acb_init(e);
acb_poly_randtest(f, state, 1 + n_randint(state, 40), 1 + n_randint(state, 500), 10);
acb_poly_randtest(g, state, 1 + n_randint(state, 20), 1 + n_randint(state, 500), 10);
if (n_randint(state, 2))
acb_set_si(c, n_randint(state, 5) - 2);
else
acb_randtest(c, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
if (n_randint(state, 2))
acb_set_si(d, n_randint(state, 5) - 2);
else
acb_randtest(d, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
acb_add(e, c, d, prec1);
/* check f(x+c)(x+d) = f(x+c+d) */
acb_poly_taylor_shift_convolution(g, f, e, prec2);
acb_poly_taylor_shift_convolution(f, f, c, prec1);
acb_poly_taylor_shift_convolution(f, f, d, prec1);
if (!acb_poly_overlaps(f, g))
{
flint_printf("FAIL\n\n");
flint_printf("c = "); acb_printd(c, 15); flint_printf("\n\n");
flint_printf("d = "); acb_printd(d, 15); flint_printf("\n\n");
flint_printf("f = "); acb_poly_printd(f, 15); flint_printf("\n\n");
flint_printf("g = "); acb_poly_printd(g, 15); flint_printf("\n\n");
abort();
}
acb_poly_clear(f);
acb_poly_clear(g);
acb_clear(c);
acb_clear(d);
acb_clear(e);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("legendre_p....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000 * arb_test_multiplier(); iter++)
{
acb_t n, na, nb, m, z, res1, res2, res3, t, u;
slong prec1, prec2, ebits;
int type;
acb_init(n);
acb_init(na);
acb_init(nb);
acb_init(m);
acb_init(z);
acb_init(res1);
acb_init(res2);
acb_init(res3);
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);
acb_sub_ui(na, n, 1, prec2);
acb_add_ui(nb, n, 1, prec2);
type = n_randint(state, 2);
acb_hypgeom_legendre_p(res1, n, m, z, type, prec1);
acb_hypgeom_legendre_p(res2, na, m, z, type, prec2);
acb_hypgeom_legendre_p(res3, nb, m, z, type, prec2);
acb_add(t, n, m, prec2);
acb_mul(t, t, res2, prec2);
acb_sub(u, n, m, prec2);
acb_add_ui(u, u, 1, prec2);
acb_mul(u, u, res3, prec2);
acb_add(t, t, u, prec2);
acb_mul_2exp_si(u, n, 1);
acb_add_ui(u, u, 1, prec2);
acb_mul(u, u, z, prec2);
acb_mul(u, u, res1, prec2);
if (!acb_overlaps(t, u))
{
flint_printf("FAIL: consistency\n\n");
flint_printf("iter = %wd, prec1 = %wd, prec2 = %wd\n\n", iter, prec1, prec2);
flint_printf("type = %d\n\n", type);
flint_printf("n = "); acb_printd(n, 30); flint_printf("\n\n");
flint_printf("m = "); acb_printd(m, 30); flint_printf("\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("res1 = "); acb_printd(res1, 30); flint_printf("\n\n");
flint_printf("res2 = "); acb_printd(res2, 30); flint_printf("\n\n");
flint_printf("res3 = "); acb_printd(res3, 30); flint_printf("\n\n");
flint_printf("t = "); acb_printd(t, 30); flint_printf("\n\n");
flint_printf("u = "); acb_printd(u, 30); flint_printf("\n\n");
abort();
}
acb_clear(n);
acb_clear(na);
acb_clear(nb);
acb_clear(m);
acb_clear(z);
acb_clear(res1);
acb_clear(res2);
acb_clear(res3);
acb_clear(t);
acb_clear(u);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}