int main()
{
slong iter;
flint_rand_t state;
flint_printf("root_ui....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_t a, b, c;
ulong k;
slong prec;
prec = 2 + n_randint(state, 1000);
k = n_randtest_not_zero(state);
acb_init(a);
acb_init(b);
acb_init(c);
acb_randtest(a, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(b, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_root_ui(b, a, k, prec);
acb_pow_ui(c, b, k, prec);
if (!acb_contains(c, a))
{
flint_printf("FAIL: containment\n\n");
flint_printf("k = %wu\n", k);
flint_printf("a = "); acb_print(a); 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_root_ui(a, a, k, prec);
if (!acb_equal(a, b))
{
flint_printf("FAIL: aliasing\n\n");
flint_abort();
}
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("rsqrt....");
fflush(stdout);
flint_randinit(state);
/* check (a^(-1/2))^(-2) = a */
for (iter = 0; iter < 10000; iter++)
{
acb_t a, b, c;
slong prec;
acb_init(a);
acb_init(b);
acb_init(c);
acb_randtest(a, state, 1 + n_randint(state, 2000), 10);
acb_randtest(b, state, 1 + n_randint(state, 2000), 10);
prec = 2 + n_randint(state, 2000);
acb_rsqrt(b, a, prec);
acb_inv(c, b, prec);
acb_mul(c, c, c, prec);
if (!acb_contains(c, a))
{
flint_printf("FAIL: containment\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("b = "); acb_print(b); flint_printf("\n\n");
flint_printf("c = "); acb_print(c); flint_printf("\n\n");
abort();
}
acb_rsqrt(a, a, prec);
if (!acb_equal(a, b))
{
flint_printf("FAIL: aliasing\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("b = "); acb_print(b); 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;
}
int main()
{
long iter;
flint_rand_t state;
printf("exp....");
fflush(stdout);
flint_randinit(state);
/* check exp(a+b) = exp(a)*exp(b) */
for (iter = 0; iter < 10000; iter++)
{
acb_t a, b, c, d, e;
long prec;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(d);
acb_init(e);
acb_randtest(a, state, 1 + n_randint(state, 200), 3);
acb_randtest(b, state, 1 + n_randint(state, 200), 3);
acb_randtest(c, state, 1 + n_randint(state, 200), 3);
prec = 2 + n_randint(state, 200);
acb_add(c, a, b, prec);
acb_exp(c, c, prec);
acb_exp(d, a, prec);
acb_exp(e, b, prec);
acb_mul(d, d, e, prec);
if (!acb_overlaps(c, d))
{
printf("FAIL: overlap\n\n");
printf("a = "); acb_print(a); printf("\n\n");
printf("b = "); acb_print(b); printf("\n\n");
printf("c = "); acb_print(c); printf("\n\n");
printf("d = "); acb_print(d); printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(d);
acb_clear(e);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("exp_invexp....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
acb_t a, b, c, d, e;
long prec;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(d);
acb_init(e);
acb_randtest(a, state, 1 + n_randint(state, 200), 3);
acb_randtest(b, state, 1 + n_randint(state, 200), 3);
acb_randtest(c, state, 1 + n_randint(state, 200), 3);
prec = 2 + n_randint(state, 200);
acb_exp_invexp(b, c, a, prec);
acb_mul(b, b, c, prec);
acb_one(c);
if (!acb_contains(b, c))
{
printf("FAIL: overlap\n\n");
printf("a = "); acb_print(a); printf("\n\n");
printf("b = "); acb_print(b); printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(d);
acb_clear(e);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, j, result;
flint_rand_t state;
flint_printf("get/set_coeff_acb....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 100; i++)
{
acb_poly_t a;
acb_t x1, x2;
slong coeff, len;
acb_poly_init(a);
acb_init(x1);
acb_init(x2);
len = n_randint(state, 100) + 1;
for (j = 0; j < 100; j++)
{
acb_randtest(x1, state, 2 + n_randint(state, 200), 10);
coeff = n_randint(state, len);
acb_poly_set_coeff_acb(a, coeff, x1);
acb_poly_get_coeff_acb(x2, a, coeff);
result = (acb_equal(x1, x2));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("x1 = "), acb_print(x1), flint_printf("\n");
flint_printf("x2 = "), acb_print(x2), flint_printf("\n");
flint_printf("coeff = %wd, length = %wd\n", coeff, len);
flint_abort();
}
}
acb_clear(x1);
acb_clear(x2);
acb_poly_clear(a);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("get_mag....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t a;
arf_t m2, x, y, s;
mag_t m;
acb_init(a);
mag_init(m);
arf_init(m2);
arf_init(x);
arf_init(y);
arf_init(s);
acb_randtest_special(a, state, 200, 10);
acb_get_mag(m, a);
MAG_CHECK_BITS(m)
/* check m^2 >= x^2 + y^2 */
arf_set_mag(m2, m);
arf_mul(m2, m2, m2, ARF_PREC_EXACT, ARF_RND_DOWN);
arb_get_abs_ubound_arf(x, acb_realref(a), ARF_PREC_EXACT);
arb_get_abs_ubound_arf(y, acb_imagref(a), ARF_PREC_EXACT);
arf_sosq(s, x, y, ARF_PREC_EXACT, ARF_RND_DOWN);
if (arf_cmp(m2, s) < 0)
{
flint_printf("FAIL:\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("m = "); mag_print(m); flint_printf("\n\n");
flint_abort();
}
acb_clear(a);
mag_clear(m);
arf_clear(m2);
arf_clear(x);
arf_clear(y);
arf_clear(s);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("get_coeff_ptr....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 1000; i++)
{
acb_poly_t A;
acb_t a;
long n = n_randint(state, 100);
acb_poly_init(A);
acb_poly_randtest(A, state, n_randint(state, 100), 100, 10);
acb_init(a);
acb_poly_get_coeff_acb(a, A, n);
result = n < acb_poly_length(A) ?
acb_equal(a, acb_poly_get_coeff_ptr(A, n)) :
acb_poly_get_coeff_ptr(A, n) == NULL;
if (!result)
{
printf("FAIL:\n");
printf("A = "), acb_poly_printd(A, 10), printf("\n\n");
printf("a = "), acb_print(a), printf("\n\n");
printf("n = %ld\n\n", n);
abort();
}
acb_poly_clear(A);
acb_clear(a);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("div....");
fflush(stdout);
flint_randinit(state);
/* test aliasing of c and a */
for (iter = 0; iter < 100000; iter++)
{
acb_t a, b, c;
slong prec;
acb_init(a);
acb_init(b);
acb_init(c);
acb_randtest(a, state, 1 + n_randint(state, 200), 10);
acb_randtest(b, state, 1 + n_randint(state, 200), 10);
acb_randtest(c, state, 1 + n_randint(state, 200), 10);
prec = 2 + n_randint(state, 200);
acb_div(c, a, b, prec);
acb_div(a, a, b, prec);
if (!acb_equal(a, c))
{
flint_printf("FAIL: aliasing c, a\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("b = "); acb_print(b); flint_printf("\n\n");
flint_printf("c = "); acb_print(c); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
}
/* test aliasing of c and b */
for (iter = 0; iter < 100000; iter++)
{
acb_t a, b, c;
slong prec;
acb_init(a);
acb_init(b);
acb_init(c);
acb_randtest(a, state, 1 + n_randint(state, 200), 10);
acb_randtest(b, state, 1 + n_randint(state, 200), 10);
acb_randtest(c, state, 1 + n_randint(state, 200), 10);
prec = 2 + n_randint(state, 200);
acb_div(c, a, b, prec);
acb_div(b, a, b, prec);
if (!acb_equal(b, c))
{
flint_printf("FAIL: aliasing c, b\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("b = "); acb_print(b); flint_printf("\n\n");
flint_printf("c = "); acb_print(c); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
}
/* test aliasing a, a */
for (iter = 0; iter < 100000; iter++)
{
acb_t a, b, c, d;
slong prec;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(d);
acb_randtest(a, state, 1 + n_randint(state, 200), 10);
acb_randtest(b, state, 1 + n_randint(state, 200), 10);
acb_randtest(c, state, 1 + n_randint(state, 200), 10);
prec = 2 + n_randint(state, 200);
acb_set(b, a);
acb_div(c, a, a, prec);
acb_div(d, a, b, prec);
if (!acb_overlaps(c, d))
{
flint_printf("FAIL: aliasing a, a\n\n");
flint_printf("a = "); acb_print(a); 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_printf("d = "); acb_print(d); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(d);
}
/* test aliasing a, a, a */
for (iter = 0; iter < 100000; iter++)
{
acb_t a, b, c;
slong prec;
acb_init(a);
acb_init(b);
acb_init(c);
acb_randtest(a, state, 1 + n_randint(state, 200), 10);
acb_randtest(b, state, 1 + n_randint(state, 200), 10);
acb_randtest(c, state, 1 + n_randint(state, 200), 10);
prec = 2 + n_randint(state, 200);
acb_set(b, a);
acb_div(c, a, b, prec);
acb_div(a, a, a, prec);
if (!acb_overlaps(a, c))
{
flint_printf("FAIL: aliasing a, a, a\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("b = "); acb_print(b); flint_printf("\n\n");
flint_printf("c = "); acb_print(c); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
}
/* test (a+b)/c = a/c + b/c */
for (iter = 0; iter < 100000; iter++)
{
acb_t a, b, c, d, e, f;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(d);
acb_init(e);
acb_init(f);
acb_randtest(a, state, 1 + n_randint(state, 200), 10);
acb_randtest(b, state, 1 + n_randint(state, 200), 10);
acb_randtest(c, state, 1 + n_randint(state, 200), 10);
acb_add(d, a, b, 2 + n_randint(state, 200));
acb_div(e, d, c, 2 + n_randint(state, 200));
acb_div(d, a, c, 2 + n_randint(state, 200));
acb_div(f, b, c, 2 + n_randint(state, 200));
acb_add(f, d, f, 2 + n_randint(state, 200));
if (!acb_overlaps(e, f))
{
flint_printf("FAIL: (a+b)/c = a/c + b/c\n\n");
flint_printf("a = "); acb_print(a); 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_printf("e = "); acb_print(e); flint_printf("\n\n");
flint_printf("f = "); acb_print(f); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(d);
acb_clear(e);
acb_clear(f);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("rising_ui_rs....");
fflush(stdout);
flint_randinit(state);
/* check functional equation */
for (iter = 0; iter < 1000; iter++)
{
acb_t x, xn, y, z;
ulong n, m, step1, step2, step3;
acb_init(x);
acb_init(xn);
acb_init(y);
acb_init(z);
acb_randtest(x, state, 1 + n_randint(state, 4000), 10);
n = n_randint(state, 80);
m = n_randint(state, 40);
acb_add_ui(xn, x, n, 1 + n_randint(state, 4000));
step1 = n_randint(state, 20);
step2 = n_randint(state, 20);
step3 = n_randint(state, 20);
acb_rising_ui_rs(y, x, n, step1, 2 + n_randint(state, 4000));
acb_rising_ui_rs(z, xn, m, step2, 2 + n_randint(state, 4000));
acb_mul(y, y, z, 2 + n_randint(state, 4000));
acb_rising_ui_rs(z, x, n + m, step3, 2 + n_randint(state, 4000));
if (!acb_overlaps(y, z))
{
printf("FAIL: overlap\n\n");
printf("n = %lu\n", n);
printf("m = %lu\n", m);
printf("x = "); acb_print(x); printf("\n\n");
printf("xn = "); acb_print(xn); printf("\n\n");
printf("y = "); acb_print(y); printf("\n\n");
printf("z = "); acb_print(z); printf("\n\n");
abort();
}
acb_clear(x);
acb_clear(xn);
acb_clear(y);
acb_clear(z);
}
/* aliasing of y and x */
for (iter = 0; iter < 1000; iter++)
{
acb_t x, y;
ulong n;
long prec;
ulong step;
acb_init(x);
acb_init(y);
acb_randtest(x, state, 1 + n_randint(state, 200), 10);
acb_randtest(y, state, 1 + n_randint(state, 200), 10);
n = n_randint(state, 100);
step = n_randint(state, 20);
prec = 2 + n_randint(state, 4000);
acb_rising_ui_rs(y, x, n, step, prec);
acb_rising_ui_rs(x, x, n, step, prec);
if (!acb_equal(x, y))
{
printf("FAIL: aliasing\n\n");
printf("x = "); acb_print(x); printf("\n\n");
printf("y = "); acb_print(y); printf("\n\n");
printf("n = %lu\n", n);
abort();
}
acb_clear(x);
acb_clear(y);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("eta....");
fflush(stdout);
flint_randinit(state);
/* Test functional equation */
for (iter = 0; iter < 10000; iter++)
{
acb_t tau1, tau2, z1, z2, z3, t;
fmpq_t arg;
long e0, prec0, prec1, prec2;
psl2z_t g;
psl2z_init(g);
fmpq_init(arg);
acb_init(tau1);
acb_init(tau2);
acb_init(z1);
acb_init(z2);
acb_init(z3);
acb_init(t);
e0 = 1 + n_randint(state, 200);
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_eta(z1, tau1, prec1);
acb_modular_eta(z2, tau2, prec2);
/* apply transformation */
fmpq_set_si(arg, acb_modular_epsilon_arg(g), 12);
arb_sin_cos_pi_fmpq(acb_imagref(t), acb_realref(t), arg, prec1);
acb_mul(z3, z1, t, prec1);
acb_mul_fmpz(t, tau1, &g->c, prec1);
acb_add_fmpz(t, t, &g->d, prec1);
acb_sqrt(t, t, prec1);
acb_mul(z3, z3, t, prec1);
if (!acb_overlaps(z3, z2))
{
printf("FAIL (overlap)\n");
printf("tau1 = "); acb_printd(tau1, 15); printf("\n\n");
printf("tau2 = "); acb_printd(tau2, 15); printf("\n\n");
printf("g = "); psl2z_print(g); printf("\n\n");
printf("z1 = "); acb_printd(z1, 15); printf("\n\n");
printf("z2 = "); acb_printd(z2, 15); printf("\n\n");
printf("z3 = "); acb_printd(z3, 15); printf("\n\n");
abort();
}
acb_modular_eta(tau1, tau1, prec2);
if (!acb_overlaps(z1, tau1))
{
printf("FAIL (aliasing)\n");
printf("tau1 = "); acb_print(tau1); printf("\n\n");
printf("tau2 = "); acb_print(tau2); printf("\n\n");
printf("z1 = "); acb_print(z1); printf("\n\n");
printf("z2 = "); acb_print(z2); printf("\n\n");
abort();
}
acb_clear(tau1);
acb_clear(tau2);
acb_clear(z1);
acb_clear(z2);
acb_clear(z3);
acb_clear(t);
psl2z_clear(g);
fmpq_clear(arg);
}
/* Test special values */
for (iter = 0; iter < 100; iter++)
{
acb_t tau, z;
arb_t t, u;
long prec;
acb_init(tau);
acb_init(z);
arb_init(t);
arb_init(u);
prec = 2 + n_randint(state, 2000);
acb_randtest(z, state, prec, 10);
acb_onei(tau);
acb_modular_eta(z, tau, prec);
arb_one(t);
arb_mul_2exp_si(t, t, -2);
arb_gamma(t, t, prec);
arb_const_pi(u, prec);
arb_root(u, u, 4, prec);
arb_pow_ui(u, u, 3, prec);
arb_div(t, t, u, prec);
arb_mul_2exp_si(t, t, -1);
if (!arb_overlaps(acb_realref(z), t) ||
!arb_contains_zero(acb_imagref(z)))
{
printf("FAIL (value 1)\n");
printf("tau = "); acb_print(tau); printf("\n\n");
printf("z = "); acb_print(z); printf("\n\n");
abort();
}
acb_clear(tau);
acb_clear(z);
arb_clear(t);
arb_clear(u);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
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;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sin_pi....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); 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("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);
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);
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);
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("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;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("xi....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 500 * arb_test_multiplier(); iter++)
{
acb_t a, b, c;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 100);
prec2 = 2 + n_randint(state, 100);
acb_init(a);
acb_init(b);
acb_init(c);
acb_randtest_precise(a, state, 1 + n_randint(state, 1000), 3);
acb_dirichlet_xi(b, a, prec1);
if (n_randint(state, 2))
{
acb_dirichlet_xi(c, a, prec2);
}
else /* test aliasing */
{
acb_set(c, a);
acb_dirichlet_xi(c, c, prec2);
}
if (!acb_overlaps(b, c))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("a = "); acb_print(a); 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();
}
/* check xi(s) = xi(1-s) */
acb_sub_ui(c, a, 1, prec1);
acb_neg(c, c);
acb_dirichlet_xi(c, c, prec1);
if (!acb_overlaps(b, c))
{
flint_printf("FAIL: functional equation\n\n");
flint_printf("a = "); acb_print(a); 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(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("pow_fmpz....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 5000; iter++)
{
acb_t a, b, c, d;
fmpz_t e1, e2, e3;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(d);
fmpz_init(e1);
fmpz_init(e2);
fmpz_init(e3);
acb_randtest(a, state, 1 + n_randint(state, 1000), 200);
acb_randtest(b, state, 1 + n_randint(state, 1000), 200);
fmpz_randtest(e1, state, 200);
fmpz_randtest(e2, state, 200);
acb_pow_fmpz(b, a, e1, prec1);
acb_pow_fmpz(c, a, e1, prec2);
if (!acb_overlaps(b, c))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("a = "); acb_print(a); 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_printf("e1 = "); fmpz_print(e1); flint_printf("\n\n");
abort();
}
/* check a^(e1+e2) = a^e1*a^e2 */
acb_pow_fmpz(c, a, e2, prec1);
acb_mul(d, b, c, prec1);
fmpz_add(e3, e1, e2);
acb_pow_fmpz(c, a, e3, prec1);
if (!acb_overlaps(c, d))
{
flint_printf("FAIL: functional equation\n\n");
flint_printf("a = "); acb_print(a); 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_printf("d = "); acb_print(d); flint_printf("\n\n");
flint_printf("e1 = "); fmpz_print(e1); flint_printf("\n\n");
flint_printf("e2 = "); fmpz_print(e2); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(d);
fmpz_clear(e1);
fmpz_clear(e2);
fmpz_clear(e3);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("mul_naive....");
fflush(stdout);
flint_randinit(state);
/* test aliasing of c and a */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
acb_t a, b, c;
slong prec;
acb_init(a);
acb_init(b);
acb_init(c);
acb_randtest(a, state, 1 + n_randint(state, 200), 10);
acb_randtest(b, state, 1 + n_randint(state, 200), 10);
acb_randtest(c, state, 1 + n_randint(state, 200), 10);
prec = 2 + n_randint(state, 200);
acb_mul_naive(c, a, b, prec);
acb_mul_naive(a, a, b, prec);
if (!acb_equal(a, c))
{
flint_printf("FAIL: aliasing c, a\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("b = "); acb_print(b); flint_printf("\n\n");
flint_printf("c = "); acb_print(c); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
}
/* test aliasing of c and b */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
acb_t a, b, c;
slong prec;
acb_init(a);
acb_init(b);
acb_init(c);
acb_randtest(a, state, 1 + n_randint(state, 200), 10);
acb_randtest(b, state, 1 + n_randint(state, 200), 10);
acb_randtest(c, state, 1 + n_randint(state, 200), 10);
prec = 2 + n_randint(state, 200);
acb_mul_naive(c, a, b, prec);
acb_mul_naive(b, a, b, prec);
if (!acb_equal(b, c))
{
flint_printf("FAIL: aliasing b, a\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("b = "); acb_print(b); flint_printf("\n\n");
flint_printf("c = "); acb_print(c); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
}
/* test aliasing a, a */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
acb_t a, b, c, d;
slong prec;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(d);
acb_randtest(a, state, 1 + n_randint(state, 200), 10);
acb_randtest(b, state, 1 + n_randint(state, 200), 10);
acb_randtest(c, state, 1 + n_randint(state, 200), 10);
prec = 2 + n_randint(state, 200);
acb_set(b, a);
acb_mul_naive(c, a, a, prec);
acb_mul_naive(d, a, b, prec);
if (!acb_overlaps(c, d))
{
flint_printf("FAIL: aliasing a, a\n\n");
flint_printf("a = "); acb_print(a); 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_printf("d = "); acb_print(d); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(d);
}
/* test aliasing a, a, a */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
acb_t a, b, c;
slong prec;
acb_init(a);
acb_init(b);
acb_init(c);
acb_randtest(a, state, 1 + n_randint(state, 200), 10);
acb_randtest(b, state, 1 + n_randint(state, 200), 10);
acb_randtest(c, state, 1 + n_randint(state, 200), 10);
prec = 2 + n_randint(state, 200);
acb_set(b, a);
acb_mul_naive(c, a, b, prec);
acb_mul_naive(a, a, a, prec);
if (!acb_overlaps(a, c))
{
flint_printf("FAIL: aliasing a, a, a\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("b = "); acb_print(b); flint_printf("\n\n");
flint_printf("c = "); acb_print(c); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
}
/* test a*(b+c) = a*b + a*c */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
acb_t a, b, c, d, e, f;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(d);
acb_init(e);
acb_init(f);
acb_randtest(a, state, 1 + n_randint(state, 200), 10);
acb_randtest(b, state, 1 + n_randint(state, 200), 10);
acb_randtest(c, state, 1 + n_randint(state, 200), 10);
acb_add(d, b, c, 2 + n_randint(state, 200));
acb_mul_naive(e, a, d, 2 + n_randint(state, 200));
acb_mul_naive(d, a, b, 2 + n_randint(state, 200));
acb_mul_naive(f, a, c, 2 + n_randint(state, 200));
acb_add(f, d, f, 2 + n_randint(state, 200));
if (!acb_overlaps(e, f))
{
flint_printf("FAIL: a*(b+c) = a*b + a*c\n\n");
flint_printf("a = "); acb_print(a); 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_printf("e = "); acb_print(e); flint_printf("\n\n");
flint_printf("f = "); acb_print(f); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(d);
acb_clear(e);
acb_clear(f);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("cot....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t x, y, a, b, c, d;
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_init(d);
acb_randtest(x, state, 1 + n_randint(state, 1000), 2 + n_randint(state, 100));
acb_randtest(y, state, 1 + n_randint(state, 1000), 2 + n_randint(state, 100));
acb_cot(a, x, prec1);
acb_cot(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();
}
/* check cot(x+y) = (cot(x) cot(y) - 1) / (cot(x) + cot(y)) */
acb_add(b, x, y, prec1);
acb_cot(b, b, prec1);
acb_cot(c, y, prec1);
acb_add(d, a, c, prec1);
acb_mul(c, a, c, prec1);
acb_sub_ui(c, c, 1, prec1);
acb_div(d, c, d, prec1);
if (!acb_overlaps(b, d))
{
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("b = "); acb_print(b); flint_printf("\n\n");
flint_printf("d = "); acb_print(d); flint_printf("\n\n");
abort();
}
acb_cot(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);
acb_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("pfq_sum_rs....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_ptr a, b;
acb_t z, s1, s2, t1, t2;
slong i, p, q, n, prec1, prec2;
p = n_randint(state, 5);
q = n_randint(state, 5);
n = n_randint(state, 300);
prec1 = 2 + n_randint(state, 500);
prec2 = 2 + n_randint(state, 500);
acb_init(z);
acb_init(s1);
acb_init(s2);
acb_init(t1);
acb_init(t2);
acb_randtest_special(z, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
acb_randtest_special(s1, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
acb_randtest_special(t1, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
acb_randtest_special(s2, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
acb_randtest_special(t2, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
a = _acb_vec_init(p);
b = _acb_vec_init(q);
for (i = 0; i < p; i++)
acb_randtest(a + i, state, 1 + n_randint(state, 100), 1 + n_randint(state, 10));
for (i = 0; i < q; i++)
acb_randtest(b + i, state, 1 + n_randint(state, 100), 1 + n_randint(state, 10));
acb_hypgeom_pfq_sum_forward(s1, t1, a, p, b, q, z, n, prec1);
acb_hypgeom_pfq_sum_rs(s2, t2, a, p, b, q, z, n, prec2);
if (!acb_overlaps(s1, s2) || !acb_overlaps(t1, t2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("z = "); acb_print(a); flint_printf("\n\n");
flint_printf("s1 = "); acb_print(s1); flint_printf("\n\n");
flint_printf("s2 = "); acb_print(s2); flint_printf("\n\n");
flint_printf("t1 = "); acb_print(t1); flint_printf("\n\n");
flint_printf("t2 = "); acb_print(t2); flint_printf("\n\n");
flint_abort();
}
_acb_vec_clear(a, p);
_acb_vec_clear(b, q);
acb_clear(z);
acb_clear(s1);
acb_clear(s2);
acb_clear(t1);
acb_clear(t2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("exp_pi_i....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t a, b, c, d;
slong prec;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(d);
acb_randtest(a, state, 1 + n_randint(state, 200), 3);
acb_randtest(b, state, 1 + n_randint(state, 200), 3);
acb_randtest(c, state, 1 + n_randint(state, 200), 3);
acb_randtest(d, state, 1 + n_randint(state, 200), 3);
prec = 2 + n_randint(state, 200);
acb_exp_pi_i(b, a, prec);
acb_const_pi(c, prec);
acb_mul(c, c, a, prec);
acb_mul_onei(c, c);
acb_exp(d, c, prec);
if (!acb_overlaps(d, b))
{
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");
flint_printf("d = "); acb_printd(d, 30); flint_printf("\n\n");
abort();
}
acb_set(c, a);
acb_exp_pi_i(c, c, prec);
if (!acb_overlaps(c, d))
{
flint_printf("FAIL: aliasing\n\n");
flint_printf("a = "); acb_print(a); 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_printf("d = "); acb_print(d); flint_printf("\n\n");
abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("gamma....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 3000; iter++)
{
acb_t a, b, c;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
acb_init(a);
acb_init(b);
acb_init(c);
arb_randtest_precise(acb_realref(a), state, 1 + n_randint(state, 1000), 3);
arb_randtest_precise(acb_imagref(a), state, 1 + n_randint(state, 1000), 3);
acb_gamma(b, a, prec1);
acb_gamma(c, 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("b = "); acb_print(b); flint_printf("\n\n");
flint_printf("c = "); acb_print(c); flint_printf("\n\n");
abort();
}
/* check gamma(z+1) = z gamma(z) */
acb_mul(b, b, a, prec1);
acb_add_ui(c, a, 1, prec1);
acb_gamma(c, c, prec1);
if (!acb_overlaps(b, c))
{
flint_printf("FAIL: functional equation\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("b = "); acb_print(b); flint_printf("\n\n");
flint_printf("c = "); acb_print(c); 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;
}
int main()
{
long iter;
flint_rand_t state;
printf("det....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
fmpq_mat_t Q;
fmpq_t Qdet;
acb_mat_t A;
acb_t Adet, imagunit;
long n, qbits, prec;
int imaginary;
n = n_randint(state, 8);
qbits = 1 + n_randint(state, 100);
prec = 2 + n_randint(state, 200);
imaginary = n_randint(state, 2);
fmpq_mat_init(Q, n, n);
fmpq_init(Qdet);
acb_mat_init(A, n, n);
acb_init(Adet);
acb_init(imagunit);
fmpq_mat_randtest(Q, state, qbits);
fmpq_mat_det(Qdet, Q);
acb_mat_set_fmpq_mat(A, Q, prec);
if (imaginary)
{
acb_onei(imagunit);
acb_mat_scalar_mul_acb(A, A, imagunit, prec);
}
acb_mat_det(Adet, A, prec);
if (imaginary)
{
acb_onei(imagunit);
acb_inv(imagunit, imagunit, prec);
acb_pow_ui(imagunit, imagunit, n, prec);
acb_mul(Adet, Adet, imagunit, prec);
}
if (!acb_contains_fmpq(Adet, Qdet))
{
printf("FAIL (containment, iter = %ld)\n", iter);
printf("n = %ld, prec = %ld\n", n, prec);
printf("\n");
printf("Q = \n"); fmpq_mat_print(Q); printf("\n\n");
printf("Qdet = \n"); fmpq_print(Qdet); printf("\n\n");
printf("A = \n"); acb_mat_printd(A, 15); printf("\n\n");
printf("Adet = \n"); acb_printd(Adet, 15); printf("\n\n");
printf("Adet = \n"); acb_print(Adet); printf("\n\n");
abort();
}
fmpq_mat_clear(Q);
fmpq_clear(Qdet);
acb_mat_clear(A);
acb_clear(Adet);
acb_clear(imagunit);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("pow....");
fflush(stdout);
flint_randinit(state);
/* check large arguments */
for (iter = 0; iter < 20000 * arb_test_multiplier(); iter++)
{
acb_t a, b, c, d, e, f;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(d);
acb_init(e);
acb_init(f);
acb_randtest(a, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 200));
if (n_randint(state, 4) == 0)
arb_zero(acb_imagref(a));
acb_randtest(b, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 200));
if (n_randint(state, 4) == 0)
arb_zero(acb_imagref(b));
acb_pow(c, a, b, prec1);
acb_pow(d, a, b, prec2);
if (!acb_overlaps(c, d))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("a = "); acb_print(a); 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_printf("d = "); acb_print(d); flint_printf("\n\n");
flint_abort();
}
acb_randtest(c, state, 1 + n_randint(state, 1000), 200);
/* check a^(b+c) = a^b*a^c */
acb_add(e, b, c, prec1);
acb_pow(d, a, e, prec1);
acb_pow(e, a, b, prec1);
acb_pow(f, a, c, prec1);
acb_mul(e, e, f, prec1);
if (!acb_overlaps(d, e))
{
flint_printf("FAIL: functional equation\n\n");
flint_printf("a = "); acb_print(a); 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_printf("d = "); acb_print(d); flint_printf("\n\n");
flint_printf("e = "); acb_print(e); flint_printf("\n\n");
flint_abort();
}
acb_pow(c, a, b, prec1);
acb_set(d, a);
acb_pow(d, d, b, prec2);
if (!acb_overlaps(c, d))
{
flint_printf("FAIL: aliasing 1\n\n");
flint_printf("a = "); acb_print(a); 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_printf("d = "); acb_print(d); flint_printf("\n\n");
flint_abort();
}
acb_set(d, b);
acb_pow(d, a, d, prec2);
if (!acb_overlaps(c, d))
{
flint_printf("FAIL: aliasing 2\n\n");
flint_printf("a = "); acb_print(a); 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_printf("d = "); acb_print(d); flint_printf("\n\n");
flint_abort();
}
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(d);
acb_clear(e);
acb_clear(f);
}
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;
}
