int main()
{
slong iter;
flint_rand_t state;
flint_printf("sin_pi....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
acb_t x, y, a, b, c;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
acb_init(x);
acb_init(y);
acb_init(a);
acb_init(b);
acb_init(c);
acb_randtest(x, state, 1 + n_randint(state, 1000), 2 + n_randint(state, 100));
acb_sin_pi(a, x, prec1);
acb_sin_pi(b, x, prec2);
/* check consistency */
if (!acb_overlaps(a, b))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("x = "); acb_print(x); flint_printf("\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("b = "); acb_print(b); flint_printf("\n\n");
abort();
}
/* compare with cos */
arb_const_pi(acb_realref(c), prec1);
acb_mul_arb(y, x, acb_realref(c), prec1);
acb_sin(c, y, prec1);
if (!acb_overlaps(a, c))
{
flint_printf("FAIL: functional equation\n\n");
flint_printf("x = "); acb_print(x); flint_printf("\n\n");
flint_printf("y = "); acb_print(y); flint_printf("\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("c = "); acb_print(c); flint_printf("\n\n");
abort();
}
acb_sin_pi(x, x, prec1);
if (!acb_overlaps(a, x))
{
flint_printf("FAIL: aliasing\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("x = "); acb_print(x); flint_printf("\n\n");
abort();
}
acb_clear(x);
acb_clear(y);
acb_clear(a);
acb_clear(b);
acb_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("erfc....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t a, b, c;
slong prec1, prec2, prec3, prec4;
prec1 = 2 + n_randint(state, 1000);
prec2 = 2 + n_randint(state, 1000);
prec3 = 2 + n_randint(state, 1000);
prec4 = 2 + n_randint(state, 1000);
acb_init(a);
acb_init(b);
acb_init(c);
acb_randtest_special(a, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest_special(b, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest_special(c, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
switch (n_randint(state, 4))
{
case 0:
acb_hypgeom_erf_asymp(b, a, 1, prec1, prec3);
break;
case 1:
acb_hypgeom_erf(b, a, prec1);
acb_sub_ui(b, b, 1, prec1);
acb_neg(b, b);
break;
default:
acb_hypgeom_erfc(b, a, prec1);
}
switch (n_randint(state, 4))
{
case 0:
acb_hypgeom_erf_asymp(c, a, 1, prec2, prec4);
break;
case 1:
acb_hypgeom_erf(c, a, prec2);
acb_sub_ui(c, c, 1, prec2);
acb_neg(c, c);
break;
default:
acb_hypgeom_erfc(c, a, prec2);
}
if (!acb_overlaps(b, c))
{
flint_printf("FAIL: overlap\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("c = "); acb_printd(c, 30); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_rising_ui_rs(acb_t y, const acb_t x, ulong n, ulong m, slong prec)
{
acb_ptr xs;
acb_t t, u, v;
ulong i, k, rem;
fmpz_t c, h;
fmpz *s, *d;
slong wp;
if (n == 0)
{
acb_one(y);
return;
}
if (n == 1)
{
acb_set_round(y, x, prec);
return;
}
wp = ARF_PREC_ADD(prec, FLINT_BIT_COUNT(n));
acb_init(t);
acb_init(u);
acb_init(v);
fmpz_init(c);
fmpz_init(h);
if (m == 0)
{
ulong m1, m2;
m1 = 0.2 * pow(2.0 * wp, 0.4);
m2 = n_sqrt(n);
m = FLINT_MIN(m1, m2);
}
m = FLINT_MIN(m, n);
m = FLINT_MAX(m, 1);
xs = _acb_vec_init(m + 1);
d = _fmpz_vec_init(m * m);
s = _fmpz_vec_init(m + 1);
_acb_vec_set_powers(xs, x, m + 1, wp);
rising_difference_polynomial(s, d, m);
/* tail */
rem = m;
while (rem + m <= n)
rem += m;
acb_one(y);
for (k = rem; k < n; k++)
{
acb_add_ui(t, xs + 1, k, wp);
acb_mul(y, y, t, wp);
}
/* initial rising factorial */
acb_zero(t);
for (i = 1; i <= m; i++)
acb_addmul_fmpz(t, xs + i, s + i, wp);
acb_mul(y, y, t, wp);
/* the leading coefficient is always the same */
acb_mul_fmpz(xs + m - 1, xs + m - 1, d + m - 1 + 0, wp);
for (k = 0; k + 2 * m <= n; k += m)
{
for (i = 0; i < m - 1; i++)
{
fmpz_set_ui(h, k);
_fmpz_poly_evaluate_horner_fmpz(c, d + i * m, m - i, h);
if (i == 0)
acb_add_fmpz(t, t, c, wp);
else
acb_addmul_fmpz(t, xs + i, c, wp);
}
acb_add(t, t, xs + m - 1, wp);
acb_mul(y, y, t, wp);
}
acb_set_round(y, y, prec);
acb_clear(t);
acb_clear(u);
acb_clear(v);
_acb_vec_clear(xs, m + 1);
_fmpz_vec_clear(d, m * m);
_fmpz_vec_clear(s, m + 1);
fmpz_clear(c);
fmpz_clear(h);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("exp_pi_i_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
slong m, n, prec;
acb_poly_t a, b, c;
acb_t t;
acb_poly_init(a);
acb_poly_init(b);
acb_poly_init(c);
acb_init(t);
prec = 2 + n_randint(state, 100);
acb_poly_randtest(a, state, 1 + n_randint(state, 20), prec, 5);
acb_poly_randtest(b, state, 1 + n_randint(state, 20), prec, 5);
acb_poly_randtest(c, state, 1 + n_randint(state, 20), prec, 5);
m = n_randint(state, 20);
n = n_randint(state, 20);
if (n_randint(state, 2) == 0)
acb_poly_exp_pi_i_series(b, a, m, prec);
else
{
acb_poly_set(b, a);
acb_poly_exp_pi_i_series(b, b, m, prec);
}
acb_const_pi(t, prec);
acb_mul_onei(t, t);
acb_poly_scalar_mul(c, a, t, prec);
acb_poly_exp_series(c, c, n, prec);
acb_poly_truncate(b, FLINT_MIN(m, n));
acb_poly_truncate(c, FLINT_MIN(m, n));
if (!acb_poly_overlaps(b, c))
{
flint_printf("FAIL\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_abort();
}
acb_poly_clear(a);
acb_poly_clear(b);
acb_poly_clear(c);
acb_clear(t);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("0f1....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000 * arb_test_multiplier(); iter++)
{
acb_t a, z, w1, w2;
slong prec1, prec2;
int regularized, ebits;
acb_init(a);
acb_init(z);
acb_init(w1);
acb_init(w2);
prec1 = 2 + n_randint(state, 700);
prec2 = 2 + n_randint(state, 700);
if (n_randint(state, 5) == 0)
ebits = 100;
else
ebits = 10;
acb_randtest_param(a, state, 1 + n_randint(state, 1000), 1 + n_randint(state, ebits));
acb_randtest_param(z, state, 1 + n_randint(state, 1000), 1 + n_randint(state, ebits));
acb_randtest(w1, state, 1 + n_randint(state, 1000), 1 + n_randint(state, ebits));
acb_randtest(w2, state, 1 + n_randint(state, 1000), 1 + n_randint(state, ebits));
regularized = n_randint(state, 2);
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_0f1_asymp(w1, a, z, regularized, prec1);
break;
case 1:
acb_hypgeom_0f1_direct(w1, a, z, regularized, prec1);
break;
default:
acb_hypgeom_0f1(w1, a, z, regularized, prec1);
}
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_0f1_asymp(w2, a, z, regularized, prec2);
break;
case 1:
acb_hypgeom_0f1_direct(w2, a, z, regularized, prec2);
break;
default:
acb_hypgeom_0f1(w2, a, z, regularized, prec2);
}
if (!acb_overlaps(w1, w2))
{
flint_printf("FAIL: consistency\n\n");
flint_printf("regularized = %d\n\n", regularized);
flint_printf("a = "); acb_printd(a, 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");
flint_abort();
}
acb_clear(a);
acb_clear(z);
acb_clear(w1);
acb_clear(w2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
acb_calc_integrate_taylor(acb_t res,
acb_calc_func_t func, void * param,
const acb_t a, const acb_t b,
const arf_t inner_radius,
const arf_t outer_radius,
long accuracy_goal, long prec)
{
long num_steps, step, N, bp;
int result;
acb_t delta, m, x, y1, y2, sum;
acb_ptr taylor_poly;
arf_t err;
acb_init(delta);
acb_init(m);
acb_init(x);
acb_init(y1);
acb_init(y2);
acb_init(sum);
arf_init(err);
acb_sub(delta, b, a, prec);
/* precision used for bounds calculations */
bp = MAG_BITS;
/* compute the number of steps */
{
arf_t t;
arf_init(t);
acb_get_abs_ubound_arf(t, delta, bp);
arf_div(t, t, inner_radius, bp, ARF_RND_UP);
arf_mul_2exp_si(t, t, -1);
num_steps = (long) (arf_get_d(t, ARF_RND_UP) + 1.0);
/* make sure it's not something absurd */
num_steps = FLINT_MIN(num_steps, 10 * prec);
num_steps = FLINT_MAX(num_steps, 1);
arf_clear(t);
}
result = ARB_CALC_SUCCESS;
acb_zero(sum);
for (step = 0; step < num_steps; step++)
{
/* midpoint of subinterval */
acb_mul_ui(m, delta, 2 * step + 1, prec);
acb_div_ui(m, m, 2 * num_steps, prec);
acb_add(m, m, a, prec);
if (arb_calc_verbose)
{
printf("integration point %ld/%ld: ", 2 * step + 1, 2 * num_steps);
acb_printd(m, 15); printf("\n");
}
/* evaluate at +/- x */
/* TODO: exactify m, and include error in x? */
acb_div_ui(x, delta, 2 * num_steps, prec);
/* compute bounds and number of terms to use */
{
arb_t cbound, xbound, rbound;
arf_t C, D, R, X, T;
double DD, TT, NN;
arb_init(cbound);
arb_init(xbound);
arb_init(rbound);
arf_init(C);
arf_init(D);
arf_init(R);
arf_init(X);
arf_init(T);
/* R is the outer radius */
arf_set(R, outer_radius);
/* X = upper bound for |x| */
acb_get_abs_ubound_arf(X, x, bp);
arb_set_arf(xbound, X);
/* Compute C(m,R). Important subtlety: due to rounding when
computing m, we will in general be farther than R away from
the integration path. But since acb_calc_cauchy_bound
actually integrates over the area traced by a complex
interval, it will catch any extra singularities (giving
an infinite bound). */
arb_set_arf(rbound, outer_radius);
acb_calc_cauchy_bound(cbound, func, param, m, rbound, 8, bp);
arf_set_mag(C, arb_radref(cbound));
arf_add(C, arb_midref(cbound), C, bp, ARF_RND_UP);
/* Sanity check: we need C < inf and R > X */
if (arf_is_finite(C) && arf_cmp(R, X) > 0)
{
/* Compute upper bound for D = C * R * X / (R - X) */
arf_mul(D, C, R, bp, ARF_RND_UP);
arf_mul(D, D, X, bp, ARF_RND_UP);
arf_sub(T, R, X, bp, ARF_RND_DOWN);
arf_div(D, D, T, bp, ARF_RND_UP);
/* Compute upper bound for T = (X / R) */
arf_div(T, X, R, bp, ARF_RND_UP);
/* Choose N */
/* TODO: use arf arithmetic to avoid overflow */
/* TODO: use relative accuracy (look at |f(m)|?) */
DD = arf_get_d(D, ARF_RND_UP);
TT = arf_get_d(T, ARF_RND_UP);
NN = -(accuracy_goal * 0.69314718055994530942 + log(DD)) / log(TT);
N = NN + 0.5;
N = FLINT_MIN(N, 100 * prec);
N = FLINT_MAX(N, 1);
/* Tail bound: D / (N + 1) * T^N */
{
mag_t TT;
mag_init(TT);
arf_get_mag(TT, T);
mag_pow_ui(TT, TT, N);
arf_set_mag(T, TT);
mag_clear(TT);
}
arf_mul(D, D, T, bp, ARF_RND_UP);
arf_div_ui(err, D, N + 1, bp, ARF_RND_UP);
}
else
{
N = 1;
arf_pos_inf(err);
result = ARB_CALC_NO_CONVERGENCE;
}
if (arb_calc_verbose)
{
printf("N = %ld; bound: ", N); arf_printd(err, 15); printf("\n");
printf("R: "); arf_printd(R, 15); printf("\n");
printf("C: "); arf_printd(C, 15); printf("\n");
printf("X: "); arf_printd(X, 15); printf("\n");
}
arb_clear(cbound);
arb_clear(xbound);
arb_clear(rbound);
arf_clear(C);
arf_clear(D);
arf_clear(R);
arf_clear(X);
arf_clear(T);
}
/* evaluate Taylor polynomial */
taylor_poly = _acb_vec_init(N + 1);
func(taylor_poly, m, param, N, prec);
_acb_poly_integral(taylor_poly, taylor_poly, N + 1, prec);
_acb_poly_evaluate(y2, taylor_poly, N + 1, x, prec);
acb_neg(x, x);
_acb_poly_evaluate(y1, taylor_poly, N + 1, x, prec);
acb_neg(x, x);
/* add truncation error */
arb_add_error_arf(acb_realref(y1), err);
arb_add_error_arf(acb_imagref(y1), err);
arb_add_error_arf(acb_realref(y2), err);
arb_add_error_arf(acb_imagref(y2), err);
acb_add(sum, sum, y2, prec);
acb_sub(sum, sum, y1, prec);
if (arb_calc_verbose)
{
printf("values: ");
acb_printd(y1, 15); printf(" ");
acb_printd(y2, 15); printf("\n");
}
_acb_vec_clear(taylor_poly, N + 1);
if (result == ARB_CALC_NO_CONVERGENCE)
break;
}
acb_set(res, sum);
acb_clear(delta);
acb_clear(m);
acb_clear(x);
acb_clear(y1);
acb_clear(y2);
acb_clear(sum);
arf_clear(err);
return result;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("chebyshev_t....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000; iter++)
{
acb_t n, z, a, b, c, t, res1, res2;
slong prec;
acb_init(n);
acb_init(z);
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(t);
acb_init(res1);
acb_init(res2);
prec = 2 + n_randint(state, 300);
acb_randtest_param(n, state, 1 + n_randint(state, 400), 1 + n_randint(state, 10));
acb_randtest_param(z, state, 1 + n_randint(state, 400), 1 + n_randint(state, 10));
acb_randtest_param(res1, state, 1 + n_randint(state, 400), 1 + n_randint(state, 10));
acb_randtest_param(res2, state, 1 + n_randint(state, 400), 1 + n_randint(state, 10));
acb_hypgeom_chebyshev_t(res1, n, z, prec);
acb_neg(a, n);
acb_set(b, n);
acb_one(c);
acb_mul_2exp_si(c, c, -1);
acb_sub_ui(t, z, 1, prec);
acb_neg(t, t);
acb_mul_2exp_si(t, t, -1);
acb_hypgeom_2f1(res2, a, b, c, t, 0, 2 + n_randint(state, 300));
if (!acb_overlaps(res1, res2))
{
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("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");
abort();
}
acb_clear(n);
acb_clear(z);
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(t);
acb_clear(res1);
acb_clear(res2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("rel_accuracy_bits....");
fflush(stdout);
flint_randinit(state);
/* test aliasing of c and a */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t x;
acb_t z;
slong a1, a2;
arb_init(x);
acb_init(z);
arb_randtest_special(x, state, 1 + n_randint(state, 200), 1 + n_randint(state, 200));
acb_set_arb(z, x);
a1 = arb_rel_accuracy_bits(x);
a2 = acb_rel_accuracy_bits(z);
if (a1 != a2)
{
flint_printf("FAIL: acb != arb\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("z = "); acb_print(z); flint_printf("\n\n");
flint_printf("a1 = %wd, a2 = %wd\n\n", a1, a2);
flint_abort();
}
acb_randtest_special(z, state, 1 + n_randint(state, 200), 1 + n_randint(state, 200));
a1 = acb_rel_accuracy_bits(z);
if (n_randint(state, 2))
arf_swap(arb_midref(acb_realref(z)), arb_midref(acb_imagref(z)));
if (n_randint(state, 2))
mag_swap(arb_radref(acb_realref(z)), arb_radref(acb_imagref(z)));
a2 = acb_rel_accuracy_bits(z);
if (a1 != a2)
{
flint_printf("FAIL: swapping\n\n");
flint_printf("z = "); acb_print(z); flint_printf("\n\n");
flint_printf("a1 = %wd, a2 = %wd\n\n", a1, a2);
flint_abort();
}
acb_randtest_special(z, state, 1 + n_randint(state, 200), 1 + n_randint(state, 200));
if (arf_cmpabs(arb_midref(acb_realref(z)), arb_midref(acb_imagref(z))) >= 0)
arf_set(arb_midref(x), arb_midref(acb_realref(z)));
else
arf_set(arb_midref(x), arb_midref(acb_imagref(z)));
if (mag_cmp(arb_radref(acb_realref(z)), arb_radref(acb_imagref(z))) >= 0)
mag_set(arb_radref(x), arb_radref(acb_realref(z)));
else
mag_set(arb_radref(x), arb_radref(acb_imagref(z)));
a1 = acb_rel_accuracy_bits(z);
a2 = arb_rel_accuracy_bits(x);
if (a1 != a2)
{
flint_printf("FAIL: acb != arb (2)\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("z = "); acb_print(z); flint_printf("\n\n");
flint_printf("a1 = %wd, a2 = %wd\n\n", a1, a2);
flint_abort();
}
arb_clear(x);
acb_clear(z);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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; 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;
}
void
acb_rising2_ui_rs(acb_t u, acb_t v,
const acb_t x, ulong n, ulong m, slong prec)
{
if (n == 0)
{
acb_zero(v);
acb_one(u);
}
else if (n == 1)
{
acb_set(u, x);
acb_one(v);
}
else
{
slong wp;
ulong i, j, a, b;
acb_ptr xs;
acb_t S, T, U, V;
fmpz *A, *B;
wp = ARF_PREC_ADD(prec, FLINT_BIT_COUNT(n));
if (m == 0)
{
ulong m1, m2;
m1 = 0.6 * pow(wp, 0.4);
m2 = n_sqrt(n);
m = FLINT_MIN(m1, m2);
}
m = FLINT_MAX(m, 1);
xs = _acb_vec_init(m + 1);
A = _fmpz_vec_init(2 * m + 1);
B = A + (m + 1);
acb_init(S);
acb_init(T);
acb_init(U);
acb_init(V);
_acb_vec_set_powers(xs, x, m + 1, wp);
for (i = 0; i < n; i += m)
{
a = i;
b = FLINT_MIN(n, a + m);
if (a == 0 || b != a + m)
{
_gamma_rf_bsplit(A, a, b);
}
else
{
fmpz tt = m;
_fmpz_poly_taylor_shift(A, &tt, m + 1);
}
_fmpz_poly_derivative(B, A, b - a + 1);
acb_set_fmpz(S, A);
for (j = 1; j <= b - a; j++)
acb_addmul_fmpz(S, xs + j, A + j, wp);
acb_set_fmpz(T, B);
for (j = 1; j < b - a; j++)
acb_addmul_fmpz(T, xs + j, B + j, wp);
if (i == 0)
{
acb_set(U, S);
acb_set(V, T);
}
else
{
acb_mul(V, V, S, wp);
acb_addmul(V, U, T, wp);
acb_mul(U, U, S, wp);
}
}
acb_set(u, U);
acb_set(v, V);
_acb_vec_clear(xs, m + 1);
_fmpz_vec_clear(A, 2 * m + 1);
acb_clear(S);
acb_clear(T);
acb_clear(U);
acb_clear(V);
}
}
void
acb_hypgeom_u_1f1(acb_t res, const acb_t a, const acb_t b, const acb_t z, long prec)
{
if (acb_is_int(b))
{
acb_poly_t aa, bb, zz;
acb_poly_init(aa);
acb_poly_init(bb);
acb_poly_init(zz);
acb_poly_set_acb(aa, a);
acb_poly_set_coeff_acb(bb, 0, b);
acb_poly_set_coeff_si(bb, 1, 1);
acb_poly_set_acb(zz, z);
acb_hypgeom_u_1f1_series(zz, aa, bb, zz, 1, prec);
acb_poly_get_coeff_acb(res, zz, 0);
acb_poly_clear(aa);
acb_poly_clear(bb);
acb_poly_clear(zz);
}
else
{
acb_t t, u, v;
acb_struct aa[3];
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(aa + 0);
acb_init(aa + 1);
acb_init(aa + 2);
acb_set(aa, a);
acb_set(aa + 1, b);
acb_one(aa + 2);
acb_hypgeom_pfq_direct(u, aa, 1, aa + 1, 2, z, -1, prec);
acb_sub(aa, a, b, prec);
acb_add_ui(aa, aa, 1, prec);
acb_sub_ui(aa + 1, b, 2, prec);
acb_neg(aa + 1, aa + 1);
acb_hypgeom_pfq_direct(v, aa, 1, aa + 1, 2, z, -1, prec);
acb_sub_ui(aa + 1, b, 1, prec);
/* rgamma(a-b+1) * gamma(1-b) * u */
acb_rgamma(t, aa, prec);
acb_mul(u, u, t, prec);
acb_neg(t, aa + 1);
acb_gamma(t, t, prec);
acb_mul(u, u, t, prec);
/* rgamma(a) * gamma(b-1) * z^(1-b) * v */
acb_rgamma(t, a, prec);
acb_mul(v, v, t, prec);
acb_gamma(t, aa + 1, prec);
acb_mul(v, v, t, prec);
acb_neg(t, aa + 1);
acb_pow(t, z, t, prec);
acb_mul(v, v, t, prec);
acb_add(res, u, v, prec);
acb_clear(t);
acb_clear(u);
acb_clear(v);
acb_clear(aa + 0);
acb_clear(aa + 1);
acb_clear(aa + 2);
}
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("hermite_h....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_t n, n1, n2, z, res1, res2, res3, s;
slong prec1, prec2, prec3;
acb_init(n);
acb_init(n1);
acb_init(n2);
acb_init(z);
acb_init(res1);
acb_init(res2);
acb_init(res3);
acb_init(s);
prec1 = 2 + n_randint(state, 300);
prec2 = 2 + n_randint(state, 300);
prec3 = 2 + n_randint(state, 300);
acb_randtest_param(n, state, 1 + n_randint(state, 400), 10);
acb_sub_ui(n1, n, 1, prec1);
acb_sub_ui(n2, n, 2, prec1);
acb_randtest_param(z, state, 1 + n_randint(state, 400), 10);
acb_randtest_param(res1, state, 1 + n_randint(state, 400), 10);
acb_hypgeom_hermite_h(res1, n, z, prec1);
acb_hypgeom_hermite_h(res2, n1, z, prec2);
acb_hypgeom_hermite_h(res3, n2, z, prec3);
acb_mul(s, res2, z, prec1);
acb_submul(s, res3, n1, prec1);
acb_mul_2exp_si(s, s, 1);
if (!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("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(n1);
acb_clear(n2);
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("2f1....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 3000 * arb_test_multiplier(); 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;
}
void acb_modular_transform(acb_t w, const psl2z_t g, const acb_t z, slong prec)
{
#define a (&g->a)
#define b (&g->b)
#define c (&g->c)
#define d (&g->d)
#define x acb_realref(z)
#define y acb_imagref(z)
if (fmpz_is_zero(c))
{
/* (az+b)/d, where we must have a = d = 1 */
acb_add_fmpz(w, z, b, prec);
}
else if (fmpz_is_zero(a))
{
/* b/(cz+d), where -bc = 1, c = 1 => -1/(z+d) */
acb_add_fmpz(w, z, d, prec);
acb_inv(w, w, prec);
acb_neg(w, w);
}
else if (0)
{
acb_t t, u;
acb_init(t);
acb_init(u);
acb_set_fmpz(t, b);
acb_addmul_fmpz(t, z, a, prec);
acb_set_fmpz(u, d);
acb_addmul_fmpz(u, z, c, prec);
acb_div(w, t, u, prec);
acb_clear(t);
acb_clear(u);
}
else
{
/* (az+b)/(cz+d) = (re+im*i)/den where
re = bd + (bc+ad)x + ac(x^2+y^2)
im = (ad-bc)y
den = c^2(x^2+y^2) + 2cdx + d^2
*/
fmpz_t t;
arb_t re, im, den;
arb_init(re);
arb_init(im);
arb_init(den);
fmpz_init(t);
arb_mul(im, x, x, prec);
arb_addmul(im, y, y, prec);
fmpz_mul(t, b, d);
arb_set_fmpz(re, t);
fmpz_mul(t, b, c);
fmpz_addmul(t, a, d);
arb_addmul_fmpz(re, x, t, prec);
fmpz_mul(t, a, c);
arb_addmul_fmpz(re, im, t, prec);
fmpz_mul(t, d, d);
arb_set_fmpz(den, t);
fmpz_mul(t, c, d);
fmpz_mul_2exp(t, t, 1);
arb_addmul_fmpz(den, x, t, prec);
fmpz_mul(t, c, c);
arb_addmul_fmpz(den, im, t, prec);
fmpz_mul(t, a, d);
fmpz_submul(t, b, c);
arb_mul_fmpz(im, y, t, prec);
arb_div(acb_realref(w), re, den, prec);
arb_div(acb_imagref(w), im, den, prec);
arb_clear(re);
arb_clear(im);
arb_clear(den);
fmpz_clear(t);
}
#undef a
#undef b
#undef c
#undef d
#undef x
#undef y
}
int main(int argc, char *argv[])
{
acb_t r, s, a, b;
arf_t inr, outr;
slong digits, prec;
if (argc < 2)
{
flint_printf("integrals d\n");
flint_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;
flint_printf("Digits: %wd\n", digits);
flint_printf("----------------------------------------------------------------\n");
flint_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);
flint_printf("RESULT:\n");
acb_printd(r, digits); flint_printf("\n");
TIMEIT_ONCE_STOP
flint_printf("----------------------------------------------------------------\n");
flint_printf("Elliptic integral F(phi, m) = integral of 1/sqrt(1 - m*sin(t)^2)\n");
flint_printf("from 0 to phi, with phi = 6+6i, m = 1/2. Integration path\n");
flint_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);
flint_printf("RESULT:\n");
acb_printd(r, digits); flint_printf("\n");
TIMEIT_ONCE_STOP
flint_printf("----------------------------------------------------------------\n");
flint_printf("Bessel function J_n(z) = (1/pi) * integral of cos(t*n - z*sin(t))\n");
flint_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);
flint_printf("RESULT:\n");
acb_printd(r, digits); flint_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("trace....");
fflush(stdout);
flint_randinit(state);
/* check that the acb trace contains the fmpq trace */
for (iter = 0; iter < 10000; iter++)
{
fmpq_mat_t Q;
fmpq_t Qtrace;
acb_mat_t A;
acb_t Atrace;
slong n, qbits, prec;
n = n_randint(state, 8);
qbits = 1 + n_randint(state, 100);
prec = 2 + n_randint(state, 200);
fmpq_mat_init(Q, n, n);
fmpq_init(Qtrace);
acb_mat_init(A, n, n);
acb_init(Atrace);
fmpq_mat_randtest(Q, state, qbits);
fmpq_mat_trace(Qtrace, Q);
acb_mat_set_fmpq_mat(A, Q, prec);
acb_mat_trace(Atrace, A, prec);
if (!acb_contains_fmpq(Atrace, Qtrace))
{
flint_printf("FAIL (containment, iter = %wd)\n", iter);
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("\n");
flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n");
flint_printf("Qtrace = \n"); fmpq_print(Qtrace); flint_printf("\n\n");
flint_printf("A = \n"); acb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("Atrace = \n"); acb_printd(Atrace, 15); flint_printf("\n\n");
flint_printf("Atrace = \n"); acb_print(Atrace); flint_printf("\n\n");
abort();
}
fmpq_mat_clear(Q);
fmpq_clear(Qtrace);
acb_mat_clear(A);
acb_clear(Atrace);
}
/* check trace(A*B) = trace(B*A) */
for (iter = 0; iter < 10000; iter++)
{
slong m, n, prec;
acb_mat_t a, b, ab, ba;
acb_t trab, trba;
prec = 2 + n_randint(state, 200);
m = n_randint(state, 10);
n = n_randint(state, 10);
acb_mat_init(a, m, n);
acb_mat_init(b, n, m);
acb_mat_init(ab, m, m);
acb_mat_init(ba, n, n);
acb_init(trab);
acb_init(trba);
acb_mat_randtest(a, state, 2 + n_randint(state, 100), 10);
acb_mat_randtest(b, state, 2 + n_randint(state, 100), 10);
acb_mat_mul(ab, a, b, prec);
acb_mat_mul(ba, b, a, prec);
acb_mat_trace(trab, ab, prec);
acb_mat_trace(trba, ba, prec);
if (!acb_overlaps(trab, trba))
{
flint_printf("FAIL (overlap, iter = %wd)\n", iter);
flint_printf("m = %wd, n = %wd, prec = %wd\n", m, n, prec);
flint_printf("\n");
flint_printf("a = \n"); acb_mat_printd(a, 15); flint_printf("\n\n");
flint_printf("b = \n"); acb_mat_printd(b, 15); flint_printf("\n\n");
flint_printf("ab = \n"); acb_mat_printd(ab, 15); flint_printf("\n\n");
flint_printf("ba = \n"); acb_mat_printd(ba, 15); flint_printf("\n\n");
flint_printf("trace(ab) = \n"); acb_printd(trab, 15); flint_printf("\n\n");
flint_printf("trace(ba) = \n"); acb_printd(trba, 15); flint_printf("\n\n");
}
acb_clear(trab);
acb_clear(trba);
acb_mat_clear(a);
acb_mat_clear(b);
acb_mat_clear(ab);
acb_mat_clear(ba);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_ci_asymp(acb_t res, const acb_t z, long prec)
{
acb_t t, u, w, v, one;
acb_init(t);
acb_init(u);
acb_init(w);
acb_init(v);
acb_init(one);
acb_one(one);
acb_mul_onei(w, z);
/* u = U(1,1,iz) */
acb_hypgeom_u_asymp(u, one, one, w, -1, prec);
/* v = e^(-iz) */
acb_neg(v, w);
acb_exp(v, v, prec);
acb_mul(t, u, v, prec);
if (acb_is_real(z))
{
arb_div(acb_realref(t), acb_imagref(t), acb_realref(z), prec);
arb_zero(acb_imagref(t));
acb_neg(t, t);
}
else
{
/* u = U(1,1,-iz) */
acb_neg(w, w);
acb_hypgeom_u_asymp(u, one, one, w, -1, prec);
acb_inv(v, v, prec);
acb_submul(t, u, v, prec);
acb_div(t, t, w, prec);
acb_mul_2exp_si(t, t, -1);
}
if (arb_is_zero(acb_realref(z)))
{
if (arb_is_positive(acb_imagref(z)))
{
arb_const_pi(acb_imagref(t), prec);
arb_mul_2exp_si(acb_imagref(t), acb_imagref(t), -1);
}
else if (arb_is_negative(acb_imagref(z)))
{
arb_const_pi(acb_imagref(t), prec);
arb_mul_2exp_si(acb_imagref(t), acb_imagref(t), -1);
arb_neg(acb_imagref(t), acb_imagref(t));
}
else
{
acb_const_pi(u, prec);
acb_mul_2exp_si(u, u, -1);
arb_zero(acb_imagref(t));
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
else
{
/* 0 if positive or positive imaginary
pi if upper left quadrant (including negative real axis)
-pi if lower left quadrant (including negative imaginary axis) */
if (arb_is_positive(acb_realref(z)))
{
/* do nothing */
}
else if (arb_is_negative(acb_realref(z)) && arb_is_nonnegative(acb_imagref(z)))
{
acb_const_pi(u, prec);
arb_add(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else if (arb_is_nonpositive(acb_realref(z)) && arb_is_negative(acb_imagref(z)))
{
acb_const_pi(u, prec);
arb_sub(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else
{
/* add [-pi,pi] */
acb_const_pi(u, prec);
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
acb_swap(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(w);
acb_clear(v);
acb_clear(one);
}
int main()
{
long iter;
flint_rand_t state;
printf("find_roots....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
acb_poly_t A;
acb_poly_t B;
acb_poly_t C;
acb_t t;
acb_ptr roots;
long i, deg, isolated;
long 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))
{
printf("FAIL: product does not equal polynomial\n");
acb_poly_printd(A, 15); printf("\n\n");
acb_poly_printd(B, 15); printf("\n\n");
abort();
}
}
for (i = 0; i < isolated; i++)
{
acb_poly_evaluate(t, A, roots + i, prec);
if (!acb_contains_zero(t))
{
printf("FAIL: poly(root) does not contain zero\n");
acb_poly_printd(A, 15); printf("\n\n");
acb_printd(roots + i, 15); printf("\n\n");
acb_printd(t, 15); printf("\n\n");
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();
printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_bessel_j_asymp(acb_t res, const acb_t nu, const acb_t z, long prec)
{
acb_t A1, A2, C, U1, U2, s, t, u;
int is_real, is_imag;
acb_init(A1);
acb_init(A2);
acb_init(C);
acb_init(U1);
acb_init(U2);
acb_init(s);
acb_init(t);
acb_init(u);
is_imag = 0;
is_real = acb_is_real(nu) && acb_is_real(z)
&& (acb_is_int(nu) || arb_is_positive(acb_realref(z)));
if (!is_real && arb_is_zero(acb_realref(z)) && acb_is_int(nu))
{
acb_mul_2exp_si(t, nu, -1);
if (acb_is_int(t))
is_real = 1;
else
is_imag = 1;
}
acb_hypgeom_bessel_j_asymp_prefactors(A1, A2, C, nu, z, prec);
/* todo: if Ap ~ 2^a and Am = 2^b and U1 ~ U2 ~ 1, change precision? */
if (!acb_is_finite(A1) || !acb_is_finite(A2) || !acb_is_finite(C))
{
acb_indeterminate(res);
}
else
{
/* s = 1/2 + nu */
acb_one(s);
acb_mul_2exp_si(s, s, -1);
acb_add(s, s, nu, prec);
/* t = 1 + 2 nu */
acb_mul_2exp_si(t, nu, 1);
acb_add_ui(t, t, 1, prec);
acb_mul_onei(u, z);
acb_mul_2exp_si(u, u, 1);
acb_hypgeom_u_asymp(U2, s, t, u, -1, prec);
acb_neg(u, u);
acb_hypgeom_u_asymp(U1, s, t, u, -1, prec);
acb_mul(res, A1, U1, prec);
acb_addmul(res, A2, U2, prec);
acb_mul(res, res, C, prec);
if (is_real)
arb_zero(acb_imagref(res));
if (is_imag)
arb_zero(acb_realref(res));
}
acb_clear(A1);
acb_clear(A2);
acb_clear(C);
acb_clear(U1);
acb_clear(U2);
acb_clear(s);
acb_clear(t);
acb_clear(u);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("theta....");
fflush(stdout);
flint_randinit(state);
/* Test consistency with/without transform */
for (iter = 0; iter < 10000; iter++)
{
acb_t t1, t2, t3, t4, t1b, t2b, t3b, t4b, z, tau;
slong prec0, prec1, prec2, e0;
acb_init(t1); acb_init(t2); acb_init(t3); acb_init(t4);
acb_init(t1b); acb_init(t2b); acb_init(t3b); acb_init(t4b);
acb_init(z);
acb_init(tau);
prec0 = 2 + n_randint(state, 2000);
prec1 = 2 + n_randint(state, 2000);
prec2 = 2 + n_randint(state, 2000);
e0 = 1 + n_randint(state, 100);
acb_randtest(tau, state, prec0, e0);
acb_randtest(z, state, prec0, e0);
acb_modular_theta(t1, t2, t3, t4, z, tau, prec1);
acb_modular_theta_notransform(t1b, t2b, t3b, t4b, z, tau, prec2);
if (!acb_overlaps(t1, t1b) || !acb_overlaps(t2, t2b) ||
!acb_overlaps(t3, t3b) || !acb_overlaps(t4, t4b))
{
flint_printf("FAIL (overlap)\n");
flint_printf("z = "); acb_printd(z, 25); flint_printf("\n\n");
flint_printf("tau = "); acb_printd(tau, 25); flint_printf("\n\n");
flint_printf("t1 = "); acb_printd(t1, 15); flint_printf("\n\n");
flint_printf("t1b = "); acb_printd(t1b, 15); flint_printf("\n\n");
flint_printf("t2 = "); acb_printd(t2, 15); flint_printf("\n\n");
flint_printf("t2b = "); acb_printd(t2b, 15); flint_printf("\n\n");
flint_printf("t3 = "); acb_printd(t3, 15); flint_printf("\n\n");
flint_printf("t3b = "); acb_printd(t3b, 15); flint_printf("\n\n");
flint_printf("t4 = "); acb_printd(t4, 15); flint_printf("\n\n");
flint_printf("t4b = "); acb_printd(t4b, 15); flint_printf("\n\n");
abort();
}
acb_clear(t1); acb_clear(t2); acb_clear(t3); acb_clear(t4);
acb_clear(t1b); acb_clear(t2b); acb_clear(t3b); acb_clear(t4b);
acb_clear(z);
acb_clear(tau);
}
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;
}
