void check_renf(renf_t nf)
{
arb_ptr a;
arb_t b;
a = nf->emb;
if (fmpq_poly_length(nf->nf->pol) != fmpz_poly_length(nf->der) + 1)
{
printf("FAIL:\n");
printf("uninitalized derivative");
fflush(stdout);
abort();
}
arb_init(b);
fmpq_poly_evaluate_arb(b, nf->nf->pol, a, nf->prec);
if (!arb_contains_zero(b))
{
printf("FAIL:\n");
printf("evaluation does not contain zero\n");
printf("pol = "); fmpq_poly_print_pretty(nf->nf->pol, "x"); printf("\n");
printf("a = "); arb_printd(a, 10); printf("\n");
printf("b = "); arb_printd(b, 10); printf("\n");
fflush(stdout);
abort();
}
arb_clear(b);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("evaluate2_rectangular....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_poly_t f, g;
arb_t x, y1, z1, y2, z2;
arb_init(x);
arb_init(y1);
arb_init(z1);
arb_init(y2);
arb_init(z2);
arb_poly_init(f);
arb_poly_init(g);
arb_randtest(x, state, 2 + n_randint(state, 1000), 5);
arb_poly_randtest(f, state, 2 + n_randint(state, 100), 2 + n_randint(state, 1000), 5);
arb_poly_derivative(g, f, 2 + n_randint(state, 1000));
arb_poly_evaluate2_rectangular(y1, z1, f, x, 2 + n_randint(state, 1000));
arb_poly_evaluate_horner(y2, f, x, 2 + n_randint(state, 1000));
arb_poly_evaluate_horner(z2, g, x, 2 + n_randint(state, 1000));
if (!arb_overlaps(y1, y2) || !arb_overlaps(z1, z2))
{
flint_printf("FAIL\n\n");
flint_printf("f = "); arb_poly_printd(f, 15); flint_printf("\n\n");
flint_printf("g = "); arb_poly_printd(g, 15); flint_printf("\n\n");
flint_printf("x = "); arb_printd(x, 15); flint_printf("\n\n");
flint_printf("y1 = "); arb_printd(y1, 15); flint_printf("\n\n");
flint_printf("z1 = "); arb_printd(z1, 15); flint_printf("\n\n");
flint_printf("y2 = "); arb_printd(y2, 15); flint_printf("\n\n");
flint_printf("z2 = "); arb_printd(z2, 15); flint_printf("\n\n");
abort();
}
arb_poly_clear(f);
arb_poly_clear(g);
arb_clear(x);
arb_clear(y1);
arb_clear(z1);
arb_clear(y2);
arb_clear(z2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("log_ui_from_prev....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t z1, z2, z3;
ulong n1, n2;
slong prec, accuracy;
prec = 2 + n_randint(state, 3000);
n1 = n_randint(state, 100000);
n2 = n1 + 1 + n_randint(state, 1000);
arb_init(z1);
arb_init(z2);
arb_init(z3);
arb_log_ui(z1, n1, prec);
arb_log_ui(z2, n2, prec);
arb_log_ui_from_prev(z3, n2, z1, n1, prec);
if (!arb_overlaps(z2, z3))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("prec = %wd, n1 = %wu, n2 = %wu\n\n", prec, n1, n2);
flint_printf("z1 = "); arb_printd(z1, prec / 3.33); flint_printf("\n\n");
flint_printf("z2 = "); arb_printd(z2, prec / 3.33); flint_printf("\n\n");
flint_printf("z3 = "); arb_printd(z3, prec / 3.33); flint_printf("\n\n");
abort();
}
accuracy = arb_rel_accuracy_bits(z3);
if (accuracy < prec - 4)
{
flint_printf("FAIL: accuracy = %wd, prec = %wd\n\n", accuracy, prec);
flint_printf("n1 = %wu, n2 = %wu\n\n", n1, n2);
flint_printf("z3 = "); arb_printd(z3, prec / 3.33); flint_printf("\n\n");
abort();
}
arb_clear(z1);
arb_clear(z2);
arb_clear(z3);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("const_log10....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 250; iter++)
{
arb_t r;
mpfr_t s;
long accuracy, prec;
prec = 2 + n_randint(state, 1 << n_randint(state, 16));
arb_init(r);
mpfr_init2(s, prec + 1000);
arb_const_log10(r, prec);
mpfr_set_ui(s, 10, MPFR_RNDN);
mpfr_log(s, s, MPFR_RNDN);
if (!arb_contains_mpfr(r, s))
{
printf("FAIL: containment\n\n");
printf("prec = %ld\n", prec);
printf("r = ");
arb_printd(r, prec / 3.33);
printf("\n\n");
abort();
}
accuracy = arb_rel_accuracy_bits(r);
if (accuracy < prec - 4)
{
printf("FAIL: poor accuracy\n\n");
printf("prec = %ld\n", prec);
printf("r = ");
arb_printd(r, prec / 3.33);
printf("\n\n");
abort();
}
arb_clear(r);
mpfr_clear(s);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("zeta_ui_euler_product....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t r;
ulong n;
mpfr_t s;
slong prec, accuracy;
do { n = n_randint(state, 1 << n_randint(state, 10)); } while (n < 6);
prec = 2 + n_randint(state, n * FLINT_BIT_COUNT(n));
arb_init(r);
mpfr_init2(s, prec + 100);
arb_zeta_ui_euler_product(r, n, prec);
mpfr_zeta_ui(s, n, MPFR_RNDN);
if (!arb_contains_mpfr(r, s))
{
flint_printf("FAIL: containment\n\n");
flint_printf("n = %wu\n\n", n);
flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n");
flint_printf("s = "); mpfr_printf("%.275Rf\n", s); flint_printf("\n\n");
flint_abort();
}
accuracy = arb_rel_accuracy_bits(r);
if (accuracy < prec - 4)
{
flint_printf("FAIL: accuracy = %wd, prec = %wd\n\n", accuracy, prec);
flint_printf("n = %wu\n\n", n);
flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n");
flint_abort();
}
arb_clear(r);
mpfr_clear(s);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("cauchy_bound....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100; iter++)
{
arb_t b, radius, ans;
acb_t x;
slong r, prec, maxdepth;
arb_init(b);
arb_init(radius);
arb_init(ans);
acb_init(x);
acb_set_ui(x, 5);
r = 1 + n_randint(state, 10);
arb_set_ui(radius, r);
prec = 2 + n_randint(state, 100);
maxdepth = n_randint(state, 10);
acb_calc_cauchy_bound(b, sin_x, NULL, x, radius, maxdepth, prec);
arf_set_d(arb_midref(ans), answers[r-1]);
mag_set_d(arb_radref(ans), 1e-8);
if (!arb_overlaps(b, ans))
{
flint_printf("FAIL\n");
flint_printf("r = %wd, prec = %wd, maxdepth = %wd\n\n", r, prec, maxdepth);
arb_printd(b, 15); flint_printf("\n\n");
arb_printd(ans, 15); flint_printf("\n\n");
abort();
}
arb_clear(b);
arb_clear(radius);
arb_clear(ans);
acb_clear(x);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("zeta_ui_bernoulli....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
arb_t r;
ulong n;
mpfr_t s;
slong prec, accuracy;
prec = 2 + n_randint(state, 1 << n_randint(state, 14));
arb_init(r);
mpfr_init2(s, prec + 100);
do { n = n_randint(state, 1 << n_randint(state, 10)); }
while (n % 2 || n == 0);
arb_zeta_ui_bernoulli(r, n, prec);
mpfr_zeta_ui(s, (unsigned long) FLINT_MIN(n, ULONG_MAX), MPFR_RNDN);
if (!arb_contains_mpfr(r, s))
{
flint_printf("FAIL: containment\n\n");
flint_printf("n = %wu\n\n", n);
flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n");
flint_printf("s = "); mpfr_printf("%.275Rf\n", s); flint_printf("\n\n");
abort();
}
accuracy = arb_rel_accuracy_bits(r);
if (accuracy < prec - 4)
{
flint_printf("FAIL: accuracy = %wd, prec = %wd\n\n", accuracy, prec);
flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n");
abort();
}
arb_clear(r);
mpfr_clear(s);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("zeta_ui_borwein_bsplit....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
arb_t r;
ulong n;
mpfr_t s;
long prec, accuracy;
prec = 2 + n_randint(state, 1 << n_randint(state, 14));
arb_init(r);
mpfr_init2(s, prec + 100);
do { n = n_randint(state, 1 << n_randint(state, 10)); } while (n == 1);
arb_zeta_ui_borwein_bsplit(r, n, prec);
mpfr_zeta_ui(s, n, MPFR_RNDN);
if (!arb_contains_mpfr(r, s))
{
printf("FAIL: containment\n\n");
printf("n = %lu\n\n", n);
printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n");
printf("s = "); mpfr_printf("%.275Rf\n", s); printf("\n\n");
abort();
}
accuracy = arb_rel_accuracy_bits(r);
if (accuracy < prec - 4)
{
printf("FAIL: accuracy = %ld, prec = %ld\n\n", accuracy, prec);
printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n");
abort();
}
arb_clear(r);
mpfr_clear(s);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sin_pi_fmpq....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t s1, s2;
fmpq_t x;
slong prec;
prec = 2 + n_randint(state, 5000);
arb_init(s1);
arb_init(s2);
fmpq_init(x);
fmpq_randtest(x, state, 1 + n_randint(state, 200));
arb_sin_pi_fmpq(s1, x, prec);
arb_const_pi(s2, prec);
arb_mul_fmpz(s2, s2, fmpq_numref(x), prec);
arb_div_fmpz(s2, s2, fmpq_denref(x), prec);
arb_sin(s2, s2, prec);
if (!arb_overlaps(s1, s2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("x = "); fmpq_print(x); flint_printf("\n\n");
flint_printf("s1 = "); arb_printd(s1, 15); flint_printf("\n\n");
flint_printf("s2 = "); arb_printd(s2, 15); flint_printf("\n\n");
abort();
}
arb_clear(s1);
arb_clear(s2);
fmpq_clear(x);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("richcmp....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000000; iter++)
{
arb_t a, b;
int op, res1, res2;
arb_init(a);
arb_init(b);
arb_randtest_special(a, state, 1 + n_randint(state, 100), 5);
arb_randtest_special(b, state, 1 + n_randint(state, 100), 5);
op = n_randint(state, 6);
res1 = arb_richcmp(a, b, op);
res2 = arb_richcmp_fallback(a, b, op);
if (res1 != res2)
{
printf("FAIL:\n\n");
printf("a = "); arb_print(a); printf("\n\n");
printf("b = "); arb_print(b); printf("\n\n");
printf("a = "); arb_printd(a, 30); printf("\n\n");
printf("b = "); arb_printd(b, 30); printf("\n\n");
printf("op = %d\n\n", op);
printf("res1 (cmp) = %d\n\n", res1);
printf("res2 (fallback) = %d\n\n", res2);
abort();
}
arb_clear(a);
arb_clear(b);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
static __inline__ void
_arb_vec_printd(arb_srcptr vec, long len, long digits)
{
long i;
for (i = 0; i < len; i++)
arb_printd(vec + i, digits), printf("\n");
}
void
partitions_fmpz_fmpz_hrr(fmpz_t p, const fmpz_t n, int use_doubles)
{
arb_t x;
arf_t bound;
slong N;
arb_init(x);
arf_init(bound);
N = partitions_hrr_needed_terms(fmpz_get_d(n));
if (fmpz_cmp_ui(n, 4e8) >= 0 && flint_get_num_threads() > 1)
{
hrr_sum_threaded(x, n, N, use_doubles);
}
else
{
partitions_hrr_sum_arb(x, n, 1, N, use_doubles);
}
partitions_rademacher_bound(bound, n, N);
arb_add_error_arf(x, bound);
if (!arb_get_unique_fmpz(p, x))
{
flint_printf("not unique!\n");
arb_printd(x, 50);
flint_printf("\n");
abort();
}
arb_clear(x);
arf_clear(bound);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("csgn....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_t x, y;
arb_t a;
slong prec;
acb_init(x);
acb_init(y);
arb_init(a);
acb_randtest_special(x, state, 1 + n_randint(state, 200), 2 + n_randint(state, 100));
arb_randtest_special(a, state, 1 + n_randint(state, 200), 2 + n_randint(state, 100));
prec = 2 + n_randint(state, 200);
acb_csgn(a, x);
if (acb_is_zero(x))
{
acb_zero(y);
}
else
{
acb_mul(y, x, x, prec);
acb_sqrt(y, y, prec);
acb_div(y, y, x, prec);
}
if (!arb_contains(acb_realref(y), a))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("x = "); acb_printd(x, 15); flint_printf("\n\n");
flint_printf("a = "); arb_printd(a, 15); flint_printf("\n\n");
flint_printf("y = "); acb_printd(y, 15); flint_printf("\n\n");
abort();
}
acb_clear(x);
acb_clear(y);
arb_clear(a);
}
flint_randclear(state);
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 main()
{
slong iter;
flint_rand_t state;
flint_printf("zeta_ui_asymp....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
arb_t r;
ulong n;
mpfr_t s;
slong prec;
prec = 2 + n_randint(state, 1 << n_randint(state, 10));
arb_init(r);
mpfr_init2(s, prec + 100);
n = 2 + n_randint(state, 1 << n_randint(state, 10));
arb_zeta_ui_asymp(r, n, prec);
mpfr_zeta_ui(s, (unsigned long) FLINT_MIN(n, ULONG_MAX), MPFR_RNDN);
if (!arb_contains_mpfr(r, s))
{
flint_printf("FAIL: containment\n\n");
flint_printf("n = %wu\n\n", n);
flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n");
flint_printf("s = "); mpfr_printf("%.275Rf\n", s); flint_printf("\n\n");
abort();
}
arb_clear(r);
mpfr_clear(s);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
/* todo: do this more intelligently and update axis requests for precision */
int
nd_accum_can_round(nd_accum_t a)
{
int i;
for (i = 0; i < a->size; i++)
{
if (!_can_round(a->data + i))
{
if (DEBUG_ROUNDING)
{
flint_printf("debug: failed to round element %d of %d:\n",
i, a->size);
arb_printd(a->data + i, 15); flint_printf("\n");
}
return 0;
}
}
return 1;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("gamma_fmpq....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t r, s;
fmpq_t q;
slong accuracy, prec, pp, qq;
prec = 2 + n_randint(state, 1 << n_randint(state, 12));
prec += 20;
arb_init(r);
arb_init(s);
fmpq_init(q);
pp = -100 + n_randint(state, 10000);
qq = 1 + n_randint(state, 20);
fmpq_set_si(q, pp, qq);
arb_gamma_fmpq(r, q, prec);
arb_set_fmpq(s, q, prec);
arb_gamma(s, s, prec);
if (!arb_overlaps(r, s))
{
flint_printf("FAIL: containment\n\n");
flint_printf("prec = %wd\n", prec);
flint_printf("q = "); fmpq_print(q); flint_printf("\n\n");
flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n");
flint_printf("s = "); arb_printd(s, prec / 3.33); flint_printf("\n\n");
abort();
}
if (!(fmpz_is_one(fmpq_denref(q)) && fmpz_sgn(fmpq_numref(q)) <= 0)
&& FLINT_ABS(pp / qq) < 10)
{
accuracy = arb_rel_accuracy_bits(r);
if (accuracy < prec - 6)
{
flint_printf("FAIL: poor accuracy\n\n");
flint_printf("prec = %wd\n", prec);
flint_printf("q = "); fmpq_print(q); flint_printf("\n\n");
flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n");
abort();
}
}
arb_clear(r);
arb_clear(s);
fmpq_clear(q);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("taylor_shift_convolution....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000 * arb_test_multiplier(); iter++)
{
slong prec1, prec2;
arb_poly_t f, g;
arb_t c, d, e;
prec1 = 2 + n_randint(state, 500);
prec2 = 2 + n_randint(state, 500);
arb_poly_init(f);
arb_poly_init(g);
arb_init(c);
arb_init(d);
arb_init(e);
arb_poly_randtest(f, state, 1 + n_randint(state, 40), 1 + n_randint(state, 500), 10);
arb_poly_randtest(g, state, 1 + n_randint(state, 20), 1 + n_randint(state, 500), 10);
if (n_randint(state, 2))
arb_set_si(c, n_randint(state, 5) - 2);
else
arb_randtest(c, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
if (n_randint(state, 2))
arb_set_si(d, n_randint(state, 5) - 2);
else
arb_randtest(d, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
arb_add(e, c, d, prec1);
/* check f(x+c)(x+d) = f(x+c+d) */
arb_poly_taylor_shift_convolution(g, f, e, prec2);
arb_poly_taylor_shift_convolution(f, f, c, prec1);
arb_poly_taylor_shift_convolution(f, f, d, prec1);
if (!arb_poly_overlaps(f, g))
{
flint_printf("FAIL\n\n");
flint_printf("c = ");
arb_printd(c, 15);
flint_printf("\n\n");
flint_printf("d = ");
arb_printd(d, 15);
flint_printf("\n\n");
flint_printf("f = ");
arb_poly_printd(f, 15);
flint_printf("\n\n");
flint_printf("g = ");
arb_poly_printd(g, 15);
flint_printf("\n\n");
abort();
}
arb_poly_clear(f);
arb_poly_clear(g);
arb_clear(c);
arb_clear(d);
arb_clear(e);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("evaluate_vec_fast....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
slong i, n, qbits1, qbits2, rbits1, rbits2, rbits3;
fmpq_poly_t F;
fmpq * X, * Y;
arb_poly_t f;
arb_ptr x, y;
qbits1 = 2 + n_randint(state, 100);
qbits2 = 2 + n_randint(state, 100);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
rbits3 = 2 + n_randint(state, 200);
n = n_randint(state, 10);
fmpq_poly_init(F);
X = _fmpq_vec_init(n);
Y = _fmpq_vec_init(n);
arb_poly_init(f);
x = _arb_vec_init(n);
y = _arb_vec_init(n);
fmpq_poly_randtest(F, state, 1 + n_randint(state, 20), qbits1);
for (i = 0; i < n; i++)
fmpq_randtest(X + i, state, qbits2);
for (i = 0; i < n; i++)
fmpq_poly_evaluate_fmpq(Y + i, F, X + i);
arb_poly_set_fmpq_poly(f, F, rbits1);
for (i = 0; i < n; i++)
arb_set_fmpq(x + i, X + i, rbits2);
arb_poly_evaluate_vec_fast(y, f, x, n, rbits3);
for (i = 0; i < n; i++)
{
if (!arb_contains_fmpq(y + i, Y + i))
{
flint_printf("FAIL (%wd of %wd)\n\n", i, n);
flint_printf("F = "); fmpq_poly_print(F); flint_printf("\n\n");
flint_printf("X = "); fmpq_print(X + i); flint_printf("\n\n");
flint_printf("Y = "); fmpq_print(Y + i); flint_printf("\n\n");
flint_printf("f = "); arb_poly_printd(f, 15); flint_printf("\n\n");
flint_printf("x = "); arb_printd(x + i, 15); flint_printf("\n\n");
flint_printf("y = "); arb_printd(y + i, 15); flint_printf("\n\n");
abort();
}
}
fmpq_poly_clear(F);
_fmpq_vec_clear(X, n);
_fmpq_vec_clear(Y, n);
arb_poly_clear(f);
_arb_vec_clear(x, n);
_arb_vec_clear(y, n);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("evaluate_horner....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
slong qbits1, qbits2, rbits1, rbits2, rbits3;
fmpq_poly_t F;
fmpq_t X, Y;
arb_poly_t f;
arb_t x, y;
qbits1 = 2 + n_randint(state, 200);
qbits2 = 2 + n_randint(state, 200);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
rbits3 = 2 + n_randint(state, 200);
fmpq_poly_init(F);
fmpq_init(X);
fmpq_init(Y);
arb_poly_init(f);
arb_init(x);
arb_init(y);
fmpq_poly_randtest(F, state, 1 + n_randint(state, 20), qbits1);
fmpq_randtest(X, state, qbits2);
fmpq_poly_evaluate_fmpq(Y, F, X);
arb_poly_set_fmpq_poly(f, F, rbits1);
arb_set_fmpq(x, X, rbits2);
arb_poly_evaluate_horner(y, f, x, rbits3);
if (!arb_contains_fmpq(y, Y))
{
flint_printf("FAIL\n\n");
flint_printf("F = "); fmpq_poly_print(F); flint_printf("\n\n");
flint_printf("X = "); fmpq_print(X); flint_printf("\n\n");
flint_printf("Y = "); fmpq_print(Y); flint_printf("\n\n");
flint_printf("f = "); arb_poly_printd(f, 15); flint_printf("\n\n");
flint_printf("x = "); arb_printd(x, 15); flint_printf("\n\n");
flint_printf("y = "); arb_printd(y, 15); flint_printf("\n\n");
abort();
}
/* aliasing */
arb_poly_evaluate_horner(x, f, x, rbits3);
if (!arb_contains_fmpq(x, Y))
{
flint_printf("FAIL (aliasing)\n\n");
abort();
}
fmpq_poly_clear(F);
fmpq_clear(X);
fmpq_clear(Y);
arb_poly_clear(f);
arb_clear(x);
arb_clear(y);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("const_glaisher....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 250; iter++)
{
arb_t r, s, t;
fmpz_t v;
long accuracy, prec;
prec = 2 + n_randint(state, 2000);
arb_init(r);
arb_init(s);
arb_init(t);
fmpz_init(v);
arb_const_glaisher(r, prec);
arb_const_glaisher(s, prec + 100);
if (!arb_overlaps(r, s))
{
printf("FAIL: containment\n\n");
printf("prec = %ld\n", prec);
printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n");
abort();
}
accuracy = arb_rel_accuracy_bits(r);
if (accuracy < prec - 4)
{
printf("FAIL: poor accuracy\n\n");
printf("prec = %ld\n", prec);
printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n");
abort();
}
if (n_randint(state, 30) == 0)
{
flint_cleanup();
}
fmpz_set_str(v, "128242712910062263687534256886979172776768892732500", 10);
arb_set_fmpz(t, v);
mag_one(arb_radref(t));
fmpz_ui_pow_ui(v, 10, 50);
arb_div_fmpz(t, t, v, 170);
if (!arb_overlaps(r, t))
{
printf("FAIL: reference value\n\n");
printf("prec = %ld\n", prec);
printf("r = "); arb_printd(r, prec / 3.33); printf("\n\n");
abort();
}
arb_clear(r);
arb_clear(s);
arb_clear(t);
fmpz_clear(v);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("acos....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b;
fmpq_t q;
mpfr_t t;
long prec = 2 + n_randint(state, 200);
arb_init(a);
arb_init(b);
fmpq_init(q);
mpfr_init2(t, prec + 100);
arb_randtest(a, state, 1 + n_randint(state, 200), 3);
arb_randtest(b, state, 1 + n_randint(state, 200), 3);
arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200));
fmpq_get_mpfr(t, q, MPFR_RNDN);
mpfr_acos(t, t, MPFR_RNDN);
arb_acos(b, a, prec);
if (!arb_contains_mpfr(b, t))
{
printf("FAIL: containment\n\n");
printf("a = "); arb_printd(a, 100); printf("\n\n");
printf("b = "); arb_printd(b, 100); printf("\n\n");
abort();
}
arb_acos(a, a, prec);
if (!arb_equal(a, b))
{
printf("FAIL: aliasing\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
fmpq_clear(q);
mpfr_clear(t);
}
/* check large arguments */
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c;
long prec1, prec2;
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
arb_init(a);
arb_init(b);
arb_init(c);
arb_randtest_precise(a, state, 1 + n_randint(state, 1000), 100);
arb_acos(b, a, prec1);
arb_acos(c, a, prec2);
if (!arb_overlaps(b, c))
{
printf("FAIL: overlap\n\n");
printf("a = "); arb_print(a); printf("\n\n");
printf("b = "); arb_print(b); printf("\n\n");
printf("c = "); arb_print(c); printf("\n\n");
abort();
}
/* check sin(asin(x)) = x */
arb_cos(c, b, prec1);
if (!arb_contains(c, a))
{
printf("FAIL: functional equation\n\n");
printf("a = "); arb_print(a); printf("\n\n");
printf("b = "); arb_print(b); printf("\n\n");
printf("c = "); arb_print(c); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
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()
{
slong iter;
flint_rand_t state;
flint_printf("zeta_ui_vec_borwein....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100; iter++)
{
arb_ptr r;
ulong n;
slong i, num, step;
mpfr_t s;
slong prec, accuracy;
prec = 2 + n_randint(state, 1 << n_randint(state, 13));
num = 1 + n_randint(state, 20);
step = 1 + n_randint(state, 5);
r = _arb_vec_init(num);
mpfr_init2(s, prec + 100);
do { n = n_randint(state, 1 << n_randint(state, 10)); } while (n < 2);
arb_zeta_ui_vec_borwein(r, n, num, step, prec);
for (i = 0; i < num; i++)
{
mpfr_zeta_ui(s, (unsigned long) FLINT_MIN(n + i * step, ULONG_MAX), MPFR_RNDN);
if (!arb_contains_mpfr(r + i, s))
{
flint_printf("FAIL: containment\n\n");
flint_printf("n = %wu\n\n", n + i * step);
flint_printf("r = "); arb_printd(r + i, prec / 3.33); flint_printf("\n\n");
flint_printf("s = "); mpfr_printf("%.275Rf\n", s); flint_printf("\n\n");
abort();
}
accuracy = arb_rel_accuracy_bits(r + i);
if (accuracy < prec - 4)
{
flint_printf("FAIL: accuracy = %wd, prec = %wd\n\n", accuracy, prec);
flint_printf("n = %wu\n\n", n + i * step);
flint_printf("r = "); arb_printd(r + i, prec / 3.33); flint_printf("\n\n");
abort();
}
}
_arb_vec_clear(r, num);
mpfr_clear(s);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("zeta_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 500; iter++)
{
long m, n1, n2, bits1, bits2, bits3;
int deflate;
arb_poly_t S, A, B, C, D, E, F;
arb_t a, a1;
bits1 = 2 + n_randint(state, 300);
bits2 = 2 + n_randint(state, 300);
bits3 = 2 + n_randint(state, 300);
m = 1 + n_randint(state, 30);
n1 = 1 + n_randint(state, 30);
n2 = 1 + n_randint(state, 30);
arb_poly_init(S);
arb_poly_init(A);
arb_poly_init(B);
arb_poly_init(C);
arb_poly_init(D);
arb_poly_init(E);
arb_poly_init(F);
arb_init(a);
arb_init(a1);
deflate = n_randint(state, 2);
arb_poly_randtest(S, state, m, bits1, 3);
arb_randtest_precise(a, state, bits1, 3);
arb_poly_set_coeff_arb(S, 0, a);
if (n_randint(state, 2))
arb_randtest(a, state, bits1, 3);
else
arb_one(a);
arb_poly_zeta_series(A, S, a, deflate, n1, bits2);
arb_poly_zeta_series(B, S, a, deflate, n2, bits3);
arb_poly_set(C, A);
arb_poly_truncate(C, FLINT_MIN(n1, n2));
arb_poly_truncate(B, FLINT_MIN(n1, n2));
if (!arb_poly_overlaps(B, C))
{
printf("FAIL\n\n");
printf("S = "); arb_poly_printd(S, 15); printf("\n\n");
printf("a = "); arb_printd(a, 15); printf("\n\n");
printf("A = "); arb_poly_printd(A, 15); printf("\n\n");
printf("B = "); arb_poly_printd(B, 15); printf("\n\n");
abort();
}
/* check zeta(s,a) = zeta(s,a+1) + a^(-s) */
arb_poly_set_arb(D, a);
arb_poly_log_series(D, D, n1, bits2);
arb_poly_mullow(D, D, S, n1, bits2);
arb_poly_neg(D, D);
arb_poly_exp_series(D, D, n1, bits2);
arb_add_ui(a1, a, 1, bits2);
arb_poly_zeta_series(E, S, a1, deflate, n1, bits2);
arb_poly_add(E, E, D, bits2);
if (!arb_poly_overlaps(A, E))
{
printf("FAIL (functional equation)\n\n");
printf("S = "); arb_poly_printd(S, 15); printf("\n\n");
printf("a = "); arb_printd(a, 15); printf("\n\n");
printf("A = "); arb_poly_printd(A, 15); printf("\n\n");
printf("E = "); arb_poly_printd(A, 15); printf("\n\n");
abort();
}
arb_poly_zeta_series(S, S, a, deflate, n1, bits2);
if (!arb_poly_overlaps(A, S))
{
printf("FAIL (aliasing)\n\n");
abort();
}
arb_poly_clear(S);
arb_poly_clear(A);
arb_poly_clear(B);
arb_poly_clear(C);
arb_poly_clear(D);
arb_poly_clear(E);
arb_poly_clear(F);
arb_clear(a);
arb_clear(a1);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
arf_interval_ptr blocks;
arb_calc_func_t function;
int * info;
long digits, low_prec, high_prec, i, num, found_roots, found_unknown;
long maxdepth, maxeval, maxfound;
int refine;
double a, b;
arf_t C;
arf_interval_t t, interval;
arb_t v, w, z;
if (argc < 4)
{
printf("real_roots function a b [-refine d] [-verbose] "
"[-maxdepth n] [-maxeval n] [-maxfound n] [-prec n]\n");
printf("available functions:\n");
printf(" 0 Z(x), Riemann-Siegel Z-function\n");
printf(" 1 sin(x)\n");
printf(" 2 sin(x^2)\n");
printf(" 3 sin(1/x)\n");
return 1;
}
switch (atoi(argv[1]))
{
case 0:
function = z_function;
break;
case 1:
function = sin_x;
break;
case 2:
function = sin_x2;
break;
case 3:
function = sin_1x;
break;
default:
printf("require a function 0-3\n");
return 1;
}
a = atof(argv[2]);
b = atof(argv[3]);
if (a >= b)
{
printf("require a < b!\n");
return 1;
}
refine = 0;
digits = 0;
maxdepth = 30;
maxeval = 100000;
maxfound = 100000;
low_prec = 30;
for (i = 4; i < argc; i++)
{
if (!strcmp(argv[i], "-refine"))
{
refine = 1;
digits = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-verbose"))
{
arb_calc_verbose = 1;
}
else if (!strcmp(argv[i], "-maxdepth"))
{
maxdepth = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-maxeval"))
{
maxeval = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-maxfound"))
{
maxfound = atol(argv[i+1]);
}
else if (!strcmp(argv[i], "-prec"))
{
low_prec = atol(argv[i+1]);
}
}
high_prec = digits * 3.32192809488736 + 10;
found_roots = 0;
found_unknown = 0;
arf_init(C);
arf_interval_init(t);
arf_interval_init(interval);
arb_init(v);
arb_init(w);
arb_init(z);
arf_set_d(&interval->a, a);
arf_set_d(&interval->b, b);
printf("interval: ");
arf_interval_printd(interval, 15);
printf("\n");
printf("maxdepth = %ld, maxeval = %ld, maxfound = %ld, low_prec = %ld\n",
maxdepth, maxeval, maxfound, low_prec);
TIMEIT_ONCE_START
num = arb_calc_isolate_roots(&blocks, &info, function,
NULL, interval, maxdepth, maxeval, maxfound, low_prec);
for (i = 0; i < num; i++)
{
if (info[i] != 1)
{
if (arb_calc_verbose)
{
printf("unable to count roots in ");
arf_interval_printd(blocks + i, 15);
printf("\n");
}
found_unknown++;
continue;
}
found_roots++;
if (!refine)
continue;
if (arb_calc_refine_root_bisect(t,
function, NULL, blocks + i, 5, low_prec)
!= ARB_CALC_SUCCESS)
{
printf("warning: some bisection steps failed!\n");
}
if (arb_calc_verbose)
{
printf("after bisection 1: ");
arf_interval_printd(t, 15);
printf("\n");
}
if (arb_calc_refine_root_bisect(blocks + i,
function, NULL, t, 5, low_prec)
!= ARB_CALC_SUCCESS)
{
printf("warning: some bisection steps failed!\n");
}
if (arb_calc_verbose)
{
printf("after bisection 2: ");
arf_interval_printd(blocks + i, 15);
printf("\n");
}
arf_interval_get_arb(v, t, high_prec);
arb_calc_newton_conv_factor(C, function, NULL, v, low_prec);
arf_interval_get_arb(w, blocks + i, high_prec);
if (arb_calc_refine_root_newton(z, function, NULL,
w, v, C, 10, high_prec) != ARB_CALC_SUCCESS)
{
printf("warning: some newton steps failed!\n");
}
printf("refined root:\n");
arb_printd(z, digits + 2);
printf("\n\n");
}
printf("---------------------------------------------------------------\n");
printf("Found roots: %ld\n", found_roots);
printf("Subintervals possibly containing undetected roots: %ld\n", found_unknown);
printf("Function evaluations: %ld\n", eval_count);
TIMEIT_ONCE_STOP
SHOW_MEMORY_USAGE
for (i = 0; i < num; i++)
arf_interval_clear(blocks + i);
flint_free(blocks);
flint_free(info);
arf_interval_clear(t);
arf_interval_clear(interval);
arf_clear(C);
arb_clear(v);
arb_clear(w);
arb_clear(z);
flint_cleanup();
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("cos_pi_fmpq_algebraic....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t c1, c2;
ulong p, q, g;
slong prec;
prec = 2 + n_randint(state, 5000);
q = 1 + n_randint(state, 500);
p = n_randint(state, q / 2 + 1);
g = n_gcd(q, p);
q /= g;
p /= g;
arb_init(c1);
arb_init(c2);
_arb_cos_pi_fmpq_algebraic(c1, p, q, prec);
arb_const_pi(c2, prec);
arb_mul_ui(c2, c2, p, prec);
arb_div_ui(c2, c2, q, prec);
arb_cos(c2, c2, prec);
if (!arb_overlaps(c1, c2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("p/q = %wu/%wu", p, q); flint_printf("\n\n");
flint_printf("c1 = "); arb_printd(c1, 15); flint_printf("\n\n");
flint_printf("c2 = "); arb_printd(c2, 15); flint_printf("\n\n");
abort();
}
if (arb_rel_accuracy_bits(c1) < prec - 2)
{
flint_printf("FAIL: accuracy\n\n");
flint_printf("p/q = %wu/%wu", p, q); flint_printf("\n\n");
flint_printf("prec=%wd eff=%wd\n", prec, arb_rel_accuracy_bits(c1));
flint_printf("c1 = "); arb_printd(c1, 15); flint_printf("\n\n");
flint_printf("c2 = "); arb_printd(c2, 15); flint_printf("\n\n");
abort();
}
arb_clear(c1);
arb_clear(c2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("power_sum_vec....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
arb_t a, b, s, t;
arb_ptr res;
slong aa, bb, k, n, len;
slong prec;
len = n_randint(state, 30);
prec = 2 + n_randint(state, 500);
aa = n_randint(state, 50) - 50;
bb = aa + n_randint(state, 50);
arb_init(a);
arb_init(b);
arb_init(s);
arb_init(t);
res = _arb_vec_init(len);
arb_set_si(a, aa);
arb_set_si(b, bb);
arb_power_sum_vec(res, a, b, len, prec);
for (n = 0; n < len; n++)
{
arb_zero(s);
for (k = aa; k < bb; k++)
{
arb_set_si(t, k);
arb_pow_ui(t, t, n, prec);
arb_add(s, s, t, prec);
}
if (!arb_overlaps(res + n, s))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("a = %wd, b = %wd, n = %wd\n\n", aa, bb, n);
flint_printf("res = "); arb_printd(res + n, 30); flint_printf("\n\n");
flint_printf("s = "); arb_printd(s, 30); flint_printf("\n\n");
abort();
}
}
arb_clear(a);
arb_clear(b);
arb_clear(s);
arb_clear(t);
_arb_vec_clear(res, len);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
slong i, len, prec, num_threads;
char * out_file;
arb_ptr z;
if (argc < 2)
{
flint_printf("keiper_li n [-prec prec] [-threads num_threads] [-out out_file]\n");
return 1;
}
len = atol(argv[1]) + 1;
prec = 1.1 * len + 50;
num_threads = 1;
out_file = NULL;
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-prec"))
prec = atol(argv[i+1]);
else if (!strcmp(argv[i], "-threads"))
num_threads = atol(argv[i+1]);
else if (!strcmp(argv[i], "-out"))
out_file = argv[i+1];
}
flint_set_num_threads(num_threads);
z = _arb_vec_init(len);
keiper_li_series(z, len, prec);
for (i = 0; i < len; i++)
{
if (i <= 10 || len - i <= 10)
{
flint_printf("%wd: ", i); arb_printd(z + i, 50); flint_printf("\n");
}
}
SHOW_MEMORY_USAGE
if (out_file != NULL)
{
fmpz_t man, exp;
arf_t t;
FILE * fp = fopen(out_file, "w");
fmpz_init(man);
fmpz_init(exp);
arf_init(t);
for (i = 0; i < len; i++)
{
arf_get_fmpz_2exp(man, exp, arb_midref(z + i));
flint_fprintf(fp, "%wd ", i);
fmpz_fprint(fp, man);
flint_fprintf(fp, " ");
fmpz_fprint(fp, exp);
flint_fprintf(fp, " ");
arf_set_mag(t, arb_radref(z + i));
arf_get_fmpz_2exp(man, exp, t);
fmpz_fprint(fp, man);
flint_fprintf(fp, " ");
fmpz_fprint(fp, exp);
flint_fprintf(fp, "\n");
}
fclose(fp);
fmpz_clear(man);
fmpz_clear(exp);
arf_clear(t);
}
_arb_vec_clear(z, len);
flint_cleanup();
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("euler_product_real_ui....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 3000 * arb_test_multiplier(); iter++)
{
arb_t res1, res2;
ulong s;
slong prec1, prec2, accuracy;
int choice, reciprocal1, reciprocal2;
if (iter % 10 == 0)
{
s = n_randtest(state);
prec1 = 2 + n_randint(state, 300);
prec2 = 2 + n_randint(state, 300);
}
else
{
s = 6 + n_randint(state, 1 << n_randint(state, 12));
prec1 = 2 + n_randint(state, 12 * s);
prec2 = 2 + n_randint(state, 12 * s);
}
if (n_randint(state, 30) == 0)
prec1 = 2 + n_randint(state, 4000);
choice = n_randint(state, 7);
reciprocal1 = n_randint(state, 2);
reciprocal2 = n_randint(state, 2);
arb_init(res1);
arb_init(res2);
arb_randtest(res1, state, 200, 100);
_acb_dirichlet_euler_product_real_ui(res1, s, chi[choice] + 1,
chi[choice][0], reciprocal1, prec1);
_acb_dirichlet_euler_product_real_ui(res2, s, chi[choice] + 1,
chi[choice][0], reciprocal2, prec2);
if (reciprocal1 != reciprocal2)
arb_inv(res2, res2, prec2);
if (!arb_overlaps(res1, res2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("s = %wu\n\n", s);
flint_printf("chi: %d\n", choice);
flint_printf("res1 = "); arb_printd(res1, prec1 / 3.33); flint_printf("\n\n");
flint_printf("res2 = "); arb_printd(res2, prec2 / 3.33); flint_printf("\n\n");
abort();
}
if (s >= 6 && prec1 < 2 * s * log(s))
{
accuracy = arb_rel_accuracy_bits(res1);
if (accuracy < prec1 - 4)
{
flint_printf("FAIL: accuracy = %wd, prec = %wd\n\n", accuracy, prec1);
flint_printf("res1 = "); arb_printd(res1, prec1 / 3.33); flint_printf("\n\n");
abort();
}
}
if (s == 10)
{
arf_set_d(arb_midref(res2), L10[choice]);
mag_set_d(arb_radref(res2), 1e-15);
if (reciprocal1)
arb_inv(res2, res2, 53);
if (!arb_overlaps(res1, res2))
{
flint_printf("FAIL: overlap (2)\n\n");
flint_printf("s = %wu\n\n", s);
flint_printf("chi: %d\n", choice);
flint_printf("res1 = "); arb_printd(res1, prec1 / 3.33); flint_printf("\n\n");
flint_printf("res2 = "); arb_printd(res2, prec2 / 3.33); flint_printf("\n\n");
abort();
}
}
arb_clear(res1);
arb_clear(res2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
