int main()
{
flint_printf("spherical_y....");
fflush(stdout);
{
slong i, n, m;
acb_t z, w, x, y;
acb_init(z);
acb_init(w);
acb_init(x);
acb_init(y);
i = 0;
arb_set_str(acb_realref(x), "0.2", 64);
arb_set_str(acb_imagref(x), "0.3", 64);
arb_set_str(acb_realref(y), "0.3", 64);
arb_set_str(acb_imagref(y), "0.4", 64);
for (n = -4; n <= 4; n++)
{
for (m = -4; m <= 4; m++)
{
acb_hypgeom_spherical_y(z, n, m, x, y, 64);
acb_set_d_d(w, testdata[2 * i], testdata[2 * i + 1]);
mag_set_d(arb_radref(acb_realref(w)), 1e-13);
mag_set_d(arb_radref(acb_imagref(w)), 1e-13);
if (!acb_overlaps(z, w))
{
flint_printf("FAIL: value\n\n");
flint_printf("n = %wd, m = %wd\n", n, m);
flint_printf("z = "); acb_printd(z, 20); flint_printf("\n\n");
flint_printf("w = "); acb_printd(w, 20); flint_printf("\n\n");
abort();
}
i++;
}
}
acb_clear(z);
acb_clear(w);
acb_clear(x);
acb_clear(y);
}
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long p = 1000;
long d = 53;
arb_t a, b, x, t;
arb_init(a);
arb_init(b);
arb_init(x);
arb_init(t);
// a = 1 + 2 ^ -76
arb_set_str(a, "2", p);
arb_set_str(t, "-76", p);
arb_pow(a, a, t, p);
arb_set_str(t, "1", p);
arb_add(a, t, a, p);
printf("a = "); arb_printd(a, d); printf("\n");
// b = 4 ^ 38 + 0.5
arb_set_str(b, "0.5", p);
arb_ui_pow_ui(t, 4, 38, p);
arb_add(b, t, b, p);
printf("b = "); arb_printd(b, d); printf("\n");
// x = a ^ b
arb_pow(x, a, b, p);
printf("x = "); arb_printd(x, d); printf("\n");
arb_const_e(t, p);
printf("e = "); arb_printd(t, d); printf("\n");
arb_sub(t, x, t, p);
printf("x-e = "); arb_printd(t, d); printf("\n");
printf("Computed with arb-%s\n", arb_version);
arb_clear(a);
arb_clear(b);
arb_clear(x);
arb_clear(t);
}
int
acb_get_file(acb_t z, FILE * fp, slong prec)
{
int i;
char * line = NULL;
size_t len = 0;
ssize_t read;
arb_ptr x = acb_realref(z);
for (i = 0; i < 2; i++)
{
if ((read = getline(&line, &len, fp)) < 0 || arb_set_str(x, line, prec))
{
flint_printf("error while setting value ref <- %s\n", line);
abort();
}
x = acb_imagref(z);
}
free(line);
return 0;
}
int main()
{
flint_rand_t state;
slong iter;
flint_printf("get_str....");
fflush(stdout);
flint_randinit(state);
/* just test no crashing... */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t x;
char * s;
slong n;
arb_init(x);
arb_randtest_special(x, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
n = 1 + n_randint(state, 300);
s = arb_get_str(x, n, (n_randint(state, 2) * ARB_STR_MORE)
| (n_randint(state, 2) * ARB_STR_NO_RADIUS)
| (ARB_STR_CONDENSE * n_randint(state, 50)));
flint_free(s);
arb_clear(x);
}
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arb_t x, y;
char * s;
slong n, prec;
int conversion_error;
arb_init(x);
arb_init(y);
arb_randtest_special(x, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
arb_randtest_special(y, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
n = 1 + n_randint(state, 300);
prec = 2 + n_randint(state, 1000);
s = arb_get_str(x, n, n_randint(state, 2) * ARB_STR_MORE);
conversion_error = arb_set_str(y, s, prec);
if (conversion_error || !arb_contains(y, x))
{
flint_printf("FAIL (roundtrip) iter = %wd\n", iter);
flint_printf("x = "); arb_printd(x, 50); flint_printf("\n\n");
flint_printf("s = %s", s); flint_printf("\n\n");
flint_printf("y = "); arb_printd(y, 50); flint_printf("\n\n");
abort();
}
flint_free(s);
arb_clear(x);
arb_clear(y);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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;
}
int main()
{
flint_rand_t state;
flint_printf("wrappers....");
fflush(stdout);
flint_randinit(state);
{
arb_t a, b, c, d, z, r, u, v;
slong prec;
prec = 53;
arb_init(a);
arb_init(b);
arb_init(c);
arb_init(d);
arb_init(z);
arb_init(r);
arb_init(u);
arb_init(v);
arb_set_d(a, 0.5);
arb_set_d(b, 0.25);
arb_set_d(c, 0.125);
arb_set_d(z, 0.75);
arb_hypgeom_pfq(r, a, 1, b, 1, z, 0, prec);
arb_set_str(v, "[3.40725820729608 +/- 6.88e-15]", prec);
TEST(r, v, "pfq");
arb_hypgeom_pfq(r, a, 1, b, 1, z, 1, prec);
arb_set_str(v, "[0.93977518087904 +/- 3.26e-15]", prec);
TEST(r, v, "pfq regularized");
arb_hypgeom_0f1(r, a, z, 0, prec);
arb_set_str(v, "[2.91457744017593 +/- 4.17e-15]", prec);
TEST(r, v, "0f1");
arb_hypgeom_0f1(r, a, z, 1, prec);
arb_set_str(v, "[1.64437423219054 +/- 3.77e-15]", prec);
TEST(r, v, "0f1 regularized");
arb_hypgeom_1f1(r, a, b, z, 0, prec);
arb_set_str(v, "[3.40725820729608 +/- 6.88e-15]", prec);
TEST(r, v, "1f1");
arb_hypgeom_1f1(r, a, b, z, 1, prec);
arb_set_str(v, "[0.93977518087904 +/- 3.26e-15]", prec);
TEST(r, v, "1f1 regularized");
arb_hypgeom_u(r, a, b, z, prec);
arb_set_str(v, "[0.7761320390950 +/- 3.89e-14]", prec);
TEST(r, v, "u");
arb_hypgeom_2f1(r, a, b, c, z, 0, prec);
arb_set_str(v, "[3.2569394189980 +/- 8.18e-14]", prec);
TEST(r, v, "2f1");
arb_hypgeom_2f1(r, a, b, c, z, 1, prec);
arb_set_str(v, "[0.4323021855542 +/- 1.67e-14]", prec);
TEST(r, v, "2f1 regularized");
arb_hypgeom_erf(r, z, prec);
arb_set_str(v, "[0.711155633653515 +/- 2.35e-16]", prec);
TEST(r, v, "erf");
arb_hypgeom_erfc(r, z, prec);
arb_set_str(v, "[0.288844366346485 +/- 2.34e-16]", prec);
TEST(r, v, "erfc");
arb_hypgeom_erfi(r, z, prec);
arb_set_str(v, "[1.03575728441196 +/- 3.17e-15]", prec);
TEST(r, v, "erfi");
arb_hypgeom_fresnel(r, NULL, z, 0, prec);
arb_set_str(v, "[0.137478632382610 +/- 1.79e-16]", prec);
TEST(r, v, "fresnel_s");
arb_hypgeom_fresnel(r, NULL, z, 1, prec);
arb_set_str(v, "[0.208877111233384 +/- 4.63e-16]", prec);
TEST(r, v, "fresnel_s normalized");
arb_hypgeom_fresnel(NULL, r, z, 0, prec);
arb_set_str(v, "[0.726614618304550 +/- 2.11e-16]", prec);
TEST(r, v, "fresnel_c");
arb_hypgeom_fresnel(NULL, r, z, 1, prec);
arb_set_str(v, "[0.693525990787136 +/- 2.76e-16]", prec);
TEST(r, v, "fresnel_c normalized");
arb_hypgeom_gamma_lower(r, a, z, 0, prec);
arb_set_str(v, "[1.38132404568612 +/- 3.66e-15]", prec);
TEST(r, v, "gamma_lower");
arb_hypgeom_gamma_lower(r, a, z, 1, prec);
arb_set_str(v, "[0.77932863808015 +/- 4.17e-15]", prec);
TEST(r, v, "gamma_lower 1");
arb_hypgeom_gamma_lower(r, a, z, 2, prec);
arb_set_str(v, "[0.89989119796552 +/- 2.76e-15]", prec);
TEST(r, v, "gamma_lower 2");
arb_hypgeom_gamma_upper(r, a, z, 0, prec);
arb_set_str(v, "[0.39112980521940 +/- 4.21e-15]", prec);
TEST(r, v, "gamma_upper");
arb_hypgeom_gamma_upper(r, a, z, 1, prec);
arb_set_str(v, "[0.22067136191985 +/- 4.08e-15]", prec);
TEST(r, v, "gamma_upper 1");
arb_hypgeom_beta_lower(r, a, b, z, 0, prec);
arb_set_str(v, "[2.3363313667086 +/- 3.14e-14]", prec);
TEST(r, v, "beta_lower");
arb_hypgeom_beta_lower(r, a, b, z, 1, prec);
arb_set_str(v, "[0.44551489018313 +/- 6.22e-15]", prec);
TEST(r, v, "beta_lower 1");
arb_hypgeom_expint(r, a, z, prec);
arb_set_str(v, "[0.45163779666301 +/- 3.10e-15]", prec);
TEST(r, v, "expint");
arb_hypgeom_ei(r, z, prec);
arb_set_str(v, "[1.20733281600122 +/- 2.72e-15]", prec);
TEST(r, v, "ei");
arb_hypgeom_si(r, z, prec);
arb_set_str(v, "[0.72695424715009 +/- 3.99e-15]", prec);
TEST(r, v, "si");
arb_hypgeom_ci(r, z, prec);
arb_set_str(v, "[0.152163600980330 +/- 5.49e-16]", prec);
TEST(r, v, "ci");
arb_hypgeom_shi(r, z, prec);
arb_set_str(v, "[0.77383681445623 +/- 5.97e-15]", prec);
TEST(r, v, "shi");
arb_hypgeom_chi(r, z, prec);
arb_set_str(v, "[0.433496001544996 +/- 7.91e-16]", prec);
TEST(r, v, "chi");
arb_hypgeom_li(r, z, 0, prec);
arb_set_str(v, "[-0.93693001101265 +/- 5.67e-15]", prec);
TEST(r, v, "li");
arb_hypgeom_li(r, z, 1, prec);
arb_set_str(v, "[-1.98209379113014 +/- 3.56e-15]", prec);
TEST(r, v, "li offset");
arb_hypgeom_bessel_j(r, a, z, prec);
arb_set_str(v, "[0.62800587637589 +/- 4.06e-15]", prec);
TEST(r, v, "bessel_j");
arb_hypgeom_bessel_y(r, a, z, prec);
arb_set_str(v, "[-0.67411792914454 +/- 5.27e-15]", prec);
TEST(r, v, "bessel_y");
arb_hypgeom_bessel_jy(r, u, a, z, prec);
arb_set_str(v, "[0.62800587637589 +/- 4.06e-15]", prec);
TEST(r, v, "bessel_jy");
arb_set_str(v, "[-0.67411792914454 +/- 5.27e-15]", prec);
TEST(u, v, "bessel_jy");
arb_hypgeom_bessel_i(r, a, z, prec);
arb_set_str(v, "[0.75761498638991 +/- 4.63e-15]", prec);
TEST(r, v, "bessel_i");
arb_hypgeom_bessel_k(r, a, z, prec);
arb_set_str(v, "[0.68361006034952 +/- 7.89e-15]", prec);
TEST(r, v, "bessel_k");
arb_hypgeom_airy(r, NULL, NULL, NULL, z, prec);
arb_set_str(v, "[0.179336305478645 +/- 2.36e-16]", prec);
TEST(r, v, "airy ai");
arb_hypgeom_airy(NULL, r, NULL, NULL, z, prec);
arb_set_str(v, "[-0.193175208104376 +/- 4.67e-16]", prec);
TEST(r, v, "airy ai'");
arb_hypgeom_airy(NULL, NULL, r, NULL, z, prec);
arb_set_str(v, "[1.00693090863322 +/- 3.90e-15]", prec);
TEST(r, v, "airy bi");
arb_hypgeom_airy(NULL, NULL, NULL, r, z, prec);
arb_set_str(v, "[0.690299702736886 +/- 2.34e-16]", prec);
TEST(r, v, "airy bi'");
arb_hypgeom_chebyshev_t(r, a, z, prec);
arb_set_str(v, "[0.935414346693485 +/- 7.02e-16]", prec);
TEST(r, v, "chebyshev_t");
arb_hypgeom_chebyshev_u(r, a, z, prec);
arb_set_str(v, "[1.33630620956212 +/- 3.41e-15]", prec);
TEST(r, v, "chebyshev_u");
arb_hypgeom_jacobi_p(r, a, b, c, z, prec);
arb_set_str(v, "[1.03224258095454 +/- 6.54e-15]", prec);
TEST(r, v, "jacobi_p");
arb_hypgeom_gegenbauer_c(r, a, b, z, prec);
arb_set_str(v, "[0.58153237382485 +/- 3.74e-15]", prec);
TEST(r, v, "gegenbauer_c");
arb_hypgeom_laguerre_l(r, a, b, z, prec);
arb_set_str(v, "[0.76858987769621 +/- 3.19e-15]", prec);
TEST(r, v, "laguerre_l");
arb_hypgeom_hermite_h(r, a, z, prec);
arb_set_str(v, "[1.31600493243946 +/- 6.52e-15]", prec);
TEST(r, v, "hermite_h");
arb_hypgeom_legendre_p(r, a, b, z, 0, prec);
arb_set_str(v, "[0.90435295129350 +/- 5.79e-15]", prec);
TEST(r, v, "legendre_q");
arb_hypgeom_legendre_q(r, a, b, z, 0, prec);
arb_set_str(v, "[-0.3763617490859 +/- 3.83e-14]", prec);
TEST(r, v, "legendre_q");
arb_clear(a);
arb_clear(b);
arb_clear(c);
arb_clear(d);
arb_clear(z);
arb_clear(r);
arb_clear(u);
arb_clear(v);
}
flint_randclear(state);
flint_cleanup();
flint_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;
}
int32_t Lib_Arb_Set_Str(ArbPtr x, const char * str , int32_t prec)
{
return arb_set_str( (arb_ptr) x, str, prec);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("lgamma_series....");
fflush(stdout);
flint_randinit(state);
/* special accuracy test case */
{
acb_poly_t a;
acb_t c;
acb_init(c);
acb_poly_init(a);
arb_set_str(acb_realref(c), "-20.25", 53);
arb_set_str(acb_imagref(c), "1e1000", 53);
acb_poly_set_coeff_acb(a, 0, c);
acb_poly_set_coeff_si(a, 1, 1);
acb_poly_lgamma_series(a, a, 3, 53);
if (acb_rel_accuracy_bits(a->coeffs) < 40 ||
acb_rel_accuracy_bits(a->coeffs + 1) < 40 ||
acb_rel_accuracy_bits(a->coeffs + 2) < 40)
{
flint_printf("FAIL: accuracy (reflection formula)\n\n");
acb_poly_printd(a, 15); flint_printf("\n\n");
abort();
}
acb_poly_clear(a);
acb_clear(c);
}
for (iter = 0; iter < 500 * arb_test_multiplier(); iter++)
{
slong m, n1, n2, rbits1, rbits2, rbits3;
acb_poly_t a, b, c, d;
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
rbits3 = 2 + n_randint(state, 200);
m = 1 + n_randint(state, 30);
n1 = 1 + n_randint(state, 30);
n2 = 1 + n_randint(state, 30);
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
acb_poly_init(d);
acb_poly_randtest(a, state, m, rbits1, 10);
acb_poly_randtest(b, state, m, rbits1, 10);
acb_poly_randtest(c, state, m, rbits1, 10);
acb_poly_lgamma_series(b, a, n1, rbits2);
acb_poly_lgamma_series(c, a, n2, rbits3);
acb_poly_set(d, b);
acb_poly_truncate(d, FLINT_MIN(n1, n2));
acb_poly_truncate(c, FLINT_MIN(n1, n2));
if (!acb_poly_overlaps(c, d))
{
flint_printf("FAIL\n\n");
flint_printf("n1 = %wd, n2 = %wd, bits2 = %wd, bits3 = %wd\n", n1, n2, rbits2, rbits3);
flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n");
abort();
}
/* check loggamma(a) + log(a) = loggamma(a+1) */
acb_poly_log_series(c, a, n1, rbits2);
acb_poly_add(c, b, c, rbits2);
acb_poly_set(d, a);
acb_add_ui(d->coeffs, d->coeffs, 1, rbits2);
acb_poly_lgamma_series(d, d, n1, rbits2);
if (!acb_poly_overlaps(c, d))
{
flint_printf("FAIL (functional equation)\n\n");
flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n");
flint_printf("d = "); acb_poly_printd(d, 15); flint_printf("\n\n");
abort();
}
acb_poly_lgamma_series(a, a, n1, rbits2);
if (!acb_poly_overlaps(a, b))
{
flint_printf("FAIL (aliasing)\n\n");
abort();
}
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(c);
acb_poly_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
flint_rand_t state;
arb_t t, u, v;
double x;
int error, bracket;
char tmp[256];
long i, j;
printf("set_str....");
fflush(stdout);
flint_randinit(state);
arb_init(t);
arb_init(u);
arb_init(v);
flint_randinit(state);
for (i = 0; testdata_floats[i] != NULL; i++)
{
arb_const_pi(t, 53);
error = arb_set_str(t, testdata_floats[i], 53);
x = strtod(testdata_floats[i], NULL);
if (x != x)
{
arb_indeterminate(u);
}
else
{
arf_set_d(arb_midref(u), x);
mag_zero(arb_radref(u));
}
if (error != 0 || !arb_equal(t, u))
{
printf("FAIL (valid input): %s\n", testdata_floats[i]);
arb_printd(t, 15); printf("\n");
arb_printd(u, 15); printf("\n");
abort();
}
}
for (i = 0; testdata_floats[i] != NULL; i++)
{
for (j = 0; testdata_floats[j] != NULL; j++)
{
for (bracket = 0; bracket < 2; bracket++)
{
arb_const_pi(t, 53);
bracket = n_randint(state, 2);
strcpy(tmp, "");
if (bracket)
strcat(tmp, "[");
/* allow empty string for midpoint */
strcat(tmp, (i == 0) ? "" : testdata_floats[i]);
strcat(tmp, "+/-");
strcat(tmp, testdata_floats[j]);
if (bracket)
strcat(tmp, "]");
error = arb_set_str(t, tmp, 53);
x = strtod((i == 0) ? "0" : testdata_floats[i], NULL);
if (x != x)
{
arb_indeterminate(u);
}
else
{
arf_set_d(arb_midref(u), x);
mag_zero(arb_radref(u));
}
x = strtod(testdata_floats[j], NULL);
arf_set_d(arb_midref(v), x);
mag_zero(arb_radref(v));
arb_abs(v, v);
arb_add_error(u, v);
if (error != 0 || !arb_equal(t, u))
{
printf("FAIL (valid input): %s\n", tmp);
arb_printd(t, 15); printf("\n");
arb_printd(u, 15); printf("\n");
abort();
}
}
}
}
for (i = 0; testdata_invalid[i] != NULL; i++)
{
arb_const_pi(t, 53);
error = arb_set_str(t, testdata_invalid[i], 53);
if (error == 0)
{
printf("FAIL (invalid input): %s\n", testdata_invalid[i]);
arb_printd(t, 15); printf("\n");
abort();
}
}
for (i = 0; testdata_invalid[i] != NULL; i++)
{
for (j = 0; testdata_invalid[j] != NULL; j++)
{
for (bracket = 0; bracket < 2; bracket++)
{
arb_const_pi(t, 53);
bracket = n_randint(state, 2);
strcpy(tmp, "");
if (bracket)
strcat(tmp, "[");
strcat(tmp, testdata_invalid[i]);
strcat(tmp, "+/-");
strcat(tmp, testdata_invalid[j]);
if (bracket)
strcat(tmp, "]");
error = arb_set_str(t, tmp, 53);
if (error == 0)
{
printf("FAIL (invalid input): %s\n", tmp);
arb_printd(t, 15); printf("\n");
abort();
}
}
}
}
arb_clear(t);
arb_clear(u);
arb_clear(v);
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
