int main()
{
slong iter;
flint_rand_t state;
flint_printf("root_ui....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c;
ulong k;
slong prec;
prec = 2 + n_randint(state, 2000);
k = n_randtest_not_zero(state);
arb_init(a);
arb_init(b);
arb_init(c);
arb_randtest(a, state, 1 + n_randint(state, 2000), 1 + n_randint(state, 100));
arb_randtest(b, state, 1 + n_randint(state, 2000), 1 + n_randint(state, 100));
arb_root_ui(b, a, k, prec);
arb_pow_ui(c, b, k, prec);
if (!arb_contains(c, a))
{
flint_printf("FAIL: containment\n\n");
flint_printf("k = %wu\n", k);
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("c = "); arb_print(c); flint_printf("\n\n");
abort();
}
arb_root_ui(a, a, k, prec);
if (!arb_equal(a, b))
{
flint_printf("FAIL: aliasing\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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()
{
slong iter;
flint_rand_t state;
flint_printf("rsqrt....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
arb_t a, b, c;
slong prec = 2 + n_randint(state, 200);
arb_init(a);
arb_init(b);
arb_init(c);
arb_randtest(a, state, 1 + n_randint(state, 200), 10);
arb_rsqrt(b, a, prec);
arb_inv(c, b, prec);
arb_mul(c, c, c, prec);
if (!arb_contains(c, a))
{
flint_printf("FAIL: containment\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("c = "); arb_print(c); flint_printf("\n\n");
abort();
}
arb_rsqrt(a, a, prec);
if (!arb_equal(a, b))
{
flint_printf("FAIL: aliasing\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int arb_calc_newton_step(arb_t xnew, arb_calc_func_t func,
void * param, const arb_t x, const arb_t conv_region,
const arf_t conv_factor, slong prec)
{
mag_t err, v;
arb_t t;
arb_struct u[2];
int result;
mag_init(err);
mag_init(v);
arb_init(t);
arb_init(u + 0);
arb_init(u + 1);
mag_mul(err, arb_radref(x), arb_radref(x));
arf_get_mag(v, conv_factor);
mag_mul(err, err, v);
arf_set(arb_midref(t), arb_midref(x));
mag_zero(arb_radref(t));
func(u, t, param, 2, prec);
arb_div(u, u, u + 1, prec);
arb_sub(u, t, u, prec);
mag_add(arb_radref(u), arb_radref(u), err);
if (arb_contains(conv_region, u) &&
(mag_cmp(arb_radref(u), arb_radref(x)) < 0))
{
arb_swap(xnew, u);
result = ARB_CALC_SUCCESS;
}
else
{
arb_set(xnew, x);
result = ARB_CALC_NO_CONVERGENCE;
}
arb_clear(t);
arb_clear(u);
arb_clear(u + 1);
mag_clear(err);
mag_clear(v);
return result;
}
int
_arb_poly_newton_step(arb_t xnew, arb_srcptr poly, long len,
const arb_t x,
const arb_t convergence_interval,
const arf_t convergence_factor, long prec)
{
arf_t err;
arb_t t, u, v;
int result;
arf_init(err);
arb_init(t);
arb_init(u);
arb_init(v);
arf_set_mag(err, arb_radref(x));
arf_mul(err, err, err, MAG_BITS, ARF_RND_UP);
arf_mul(err, err, convergence_factor, MAG_BITS, ARF_RND_UP);
arf_set(arb_midref(t), arb_midref(x));
mag_zero(arb_radref(t));
_arb_poly_evaluate2(u, v, poly, len, t, prec);
arb_div(u, u, v, prec);
arb_sub(u, t, u, prec);
arb_add_error_arf(u, err);
if (arb_contains(convergence_interval, u) &&
(mag_cmp(arb_radref(u), arb_radref(x)) < 0))
{
arb_swap(xnew, u);
result = 1;
}
else
{
arb_set(xnew, x);
result = 0;
}
arb_clear(t);
arb_clear(u);
arb_clear(v);
arf_clear(err);
return result;
}
int
arb_mat_contains(const arb_mat_t mat1, const arb_mat_t mat2)
{
slong i, j;
if ((arb_mat_nrows(mat1) != arb_mat_nrows(mat2)) ||
(arb_mat_ncols(mat1) != arb_mat_ncols(mat2)))
return 0;
for (i = 0; i < arb_mat_nrows(mat1); i++)
for (j = 0; j < arb_mat_ncols(mat1); j++)
if (!arb_contains(arb_mat_entry(mat1, i, j), arb_mat_entry(mat2, i, j)))
return 0;
return 1;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("get_interval_arf....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arb_t x, y;
arf_t a, b;
arb_init(x);
arf_init(a);
arf_init(b);
arb_init(y);
arb_randtest_special(x, state, 200, 100);
arb_get_interval_arf(a, b, x, 2 + n_randint(state, 200));
arb_set_interval_arf(y, a, b, 2 + n_randint(state, 200));
if (!arb_contains(y, x))
{
flint_printf("FAIL:\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("a = "); arf_print(a); flint_printf("\n\n");
flint_printf("b = "); arf_print(b); flint_printf("\n\n");
flint_printf("y = "); arb_print(y); flint_printf("\n\n");
abort();
}
arb_clear(x);
arf_clear(a);
arf_clear(b);
arb_clear(y);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
arb_poly_contains(const arb_poly_t poly1, const arb_poly_t poly2)
{
slong i;
if (poly2->length > poly1->length)
return 0;
for (i = 0; i < poly2->length; i++)
{
if (!arb_contains(poly1->coeffs + i, poly2->coeffs + i))
return 0;
}
for (i = poly2->length; i < poly1->length; i++)
if (!arb_contains_zero(poly1->coeffs + i))
return 0;
return 1;
}
int main()
{
long iter;
flint_rand_t state;
printf("asin....");
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_asin(t, t, MPFR_RNDN);
arb_asin(b, a, prec);
if (!arb_contains_mpfr(b, t))
{
printf("FAIL: containment\n\n");
printf("a = "); arb_print(a); printf("\n\n");
printf("b = "); arb_print(b); printf("\n\n");
abort();
}
arb_asin(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_asin(b, a, prec1);
arb_asin(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_sin(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()
{
long iter;
flint_rand_t state;
printf("union....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
arb_t x, y, z;
long prec;
int alias;
arb_init(x);
arb_init(y);
arb_init(z);
arb_randtest_special(x, state, 200, 10);
arb_randtest_special(y, state, 200, 10);
arb_randtest_special(z, state, 200, 10);
prec = 2 + n_randint(state, 200);
arb_union(z, x, y, prec);
if (!arb_contains(z, x) || !arb_contains(z, y))
{
printf("FAIL:\n\n");
printf("x = "); arb_print(x); printf("\n\n");
printf("y = "); arb_print(y); printf("\n\n");
printf("z = "); arb_print(z); printf("\n\n");
abort();
}
if (n_randint(state, 2))
{
arb_union(x, x, y, prec);
alias = arb_equal(x, z);
}
else
{
arb_union(y, x, y, prec);
alias = arb_equal(y, z);
}
if (!alias)
{
printf("FAIL (aliasing):\n\n");
printf("x = "); arb_print(x); printf("\n\n");
printf("y = "); arb_print(y); printf("\n\n");
printf("z = "); arb_print(z); printf("\n\n");
abort();
}
arb_clear(x);
arb_clear(y);
arb_clear(z);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("exp_arf_bb....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 5000 * arb_test_multiplier(); iter++)
{
arb_t x, y, z;
slong prec = 2 + n_randint(state, 8000);
arb_init(x);
arb_init(y);
arb_init(z);
arb_randtest(x, state, 1 + n_randint(state, 8000), 3);
mag_zero(arb_radref(x));
if (n_randint(state, 2))
{
if ((FLINT_BITS == 64) && (sizeof(mpfr_exp_t) >= sizeof(slong)))
arb_mul_2exp_si(x, x, 1 + n_randint(state, 40));
else
arb_mul_2exp_si(x, x, 1 + n_randint(state, 20));
}
else
{
arb_mul_2exp_si(x, x, -n_randint(state, 1.5 * prec));
}
arb_exp_arf_via_mpfr(y, arb_midref(x), prec + 100);
arb_exp_arf_bb(z, arb_midref(x), prec, 0);
if (!arb_contains(z, y))
{
flint_printf("FAIL: containment\n\n");
flint_printf("prec = %wd\n\n", prec);
flint_printf("x = "); arb_printd(x, 50); flint_printf("\n\n");
flint_printf("y = "); arb_printd(y, 50); flint_printf("\n\n");
flint_printf("z = "); arb_printd(z, 50); flint_printf("\n\n");
flint_abort();
}
if (arb_rel_accuracy_bits(z) < prec - 2)
{
flint_printf("FAIL: poor accuracy\n\n");
flint_printf("prec = %wd, acc = %wd\n\n", prec, arb_rel_accuracy_bits(z));
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("y = "); arb_print(y); flint_printf("\n\n");
flint_printf("z = "); arb_print(z); flint_printf("\n\n");
flint_abort();
}
arb_exp_arf_bb(x, arb_midref(x), prec, 0);
if (!arb_overlaps(x, z))
{
flint_printf("FAIL: aliasing\n\n");
flint_abort();
}
arb_clear(x);
arb_clear(y);
arb_clear(z);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("atanh....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t x, a, b;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
arb_init(x);
arb_init(a);
arb_init(b);
arb_randtest_special(x, state, 1 + n_randint(state, 1000), 2 + n_randint(state, 100));
arb_randtest_special(a, state, 1 + n_randint(state, 1000), 2 + n_randint(state, 100));
arb_randtest_special(b, state, 1 + n_randint(state, 1000), 2 + n_randint(state, 100));
arb_atanh(a, x, prec1);
arb_atanh(b, x, prec2);
/* check consistency */
if (!arb_overlaps(a, b))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("x = "); arb_printd(x, 15); flint_printf("\n\n");
flint_printf("a = "); arb_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); arb_printd(b, 15); flint_printf("\n\n");
abort();
}
/* check tanh(atanh(x)) = x */
arb_tanh(b, b, prec1);
if (!arb_contains(b, x))
{
flint_printf("FAIL: functional equation\n\n");
flint_printf("x = "); arb_printd(x, 15); flint_printf("\n\n");
flint_printf("b = "); arb_printd(b, 15); flint_printf("\n\n");
abort();
}
arb_atanh(x, x, prec1);
if (!arb_overlaps(a, x))
{
flint_printf("FAIL: aliasing\n\n");
flint_printf("a = "); arb_printd(a, 15); flint_printf("\n\n");
flint_printf("x = "); arb_printd(x, 15); flint_printf("\n\n");
abort();
}
arb_clear(x);
arb_clear(a);
arb_clear(b);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("atan_arf_bb....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 5000; iter++)
{
arb_t x, y, z;
slong prec, prec2;
arb_init(x);
arb_init(y);
arb_init(z);
prec = 2 + n_randint(state, 8000);
arb_randtest(x, state, 1 + n_randint(state, 8000), 3);
mag_zero(arb_radref(x));
if (n_randint(state, 2))
arb_mul_2exp_si(x, x, 1 + n_randint(state, 40));
else
arb_mul_2exp_si(x, x, -n_randint(state, 1.5 * prec));
if (!arf_is_special(arb_midref(x)))
prec2 = prec + 100 + 2 * (-ARF_EXP(arb_midref(x)));
else
prec2 = prec + 100;
arb_atan_arf_via_mpfr(y, arb_midref(x), prec2);
arb_atan_arf_bb(z, arb_midref(x), prec);
if (!arb_contains(z, y))
{
flint_printf("FAIL: containment\n\n");
flint_printf("prec = %wd\n\n", prec);
flint_printf("x = "); arb_printd(x, 50); flint_printf("\n\n");
flint_printf("y = "); arb_printd(y, 50); flint_printf("\n\n");
flint_printf("z = "); arb_printd(z, 50); flint_printf("\n\n");
abort();
}
if (arb_rel_accuracy_bits(z) < prec - 2)
{
flint_printf("FAIL: poor accuracy\n\n");
flint_printf("prec = %wd, acc = %wd\n\n", prec, arb_rel_accuracy_bits(z));
flint_printf("x = "); arb_printd(x, 50); flint_printf("\n\n");
flint_printf("y = "); arb_printd(y, 50); flint_printf("\n\n");
flint_printf("z = "); arb_printd(z, 50); flint_printf("\n\n");
abort();
}
arb_atan_arf_bb(x, arb_midref(x), prec);
if (!arb_overlaps(x, z))
{
flint_printf("FAIL: aliasing\n\n");
abort();
}
arb_clear(x);
arb_clear(y);
arb_clear(z);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("agm....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c;
fmpq_t q, r;
mpfr_t t, u;
slong prec = 2 + n_randint(state, 200);
arb_init(a);
arb_init(b);
arb_init(c);
fmpq_init(q);
fmpq_init(r);
mpfr_init2(t, prec + 100);
mpfr_init2(u, prec + 100);
arb_randtest(a, state, 1 + n_randint(state, 200), 3);
arb_randtest(b, state, 1 + n_randint(state, 200), 3);
arb_randtest(c, state, 1 + n_randint(state, 200), 3);
arb_agm(c, a, b, prec);
if (arb_equal(a, b))
{
if (!arb_contains(c, a))
{
flint_printf("FAIL: containment (identity)\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("c = "); arb_print(c); flint_printf("\n\n");
abort();
}
}
else
{
arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200));
arb_get_rand_fmpq(r, state, b, 1 + n_randint(state, 200));
fmpq_get_mpfr(t, q, MPFR_RNDN);
fmpq_get_mpfr(u, r, MPFR_RNDN);
mpfr_agm(t, t, u, MPFR_RNDN);
if (!arb_contains_mpfr(c, t))
{
flint_printf("FAIL: containment\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("c = "); arb_print(c); flint_printf("\n\n");
abort();
}
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
fmpq_clear(q);
fmpq_clear(r);
mpfr_clear(t);
mpfr_clear(u);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("atan....");
fflush(stdout);
flint_randinit(state);
/* Compare with MPFR */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t a, b;
fmpq_t q;
mpfr_t t;
slong 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_atan(t, t, MPFR_RNDN);
arb_atan(b, a, prec);
if (!arb_contains_mpfr(b, t))
{
flint_printf("FAIL: containment\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_abort();
}
arb_atan(a, a, prec);
if (!arb_equal(a, b))
{
flint_printf("FAIL: aliasing\n\n");
flint_abort();
}
arb_clear(a);
arb_clear(b);
fmpq_clear(q);
mpfr_clear(t);
}
/* Check large arguments. */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c, d;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
arb_init(a);
arb_init(b);
arb_init(c);
arb_init(d);
arb_randtest_precise(a, state, 1 + n_randint(state, 1000), 100);
arb_atan(b, a, prec1);
arb_atan(c, a, prec2);
if (!arb_overlaps(b, c))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("c = "); arb_print(c); flint_printf("\n\n");
flint_abort();
}
/* check tan(atan(x)) = x */
arb_sin_cos(c, d, b, prec1);
arb_div(c, c, d, prec1);
if (!arb_contains(c, a))
{
flint_printf("FAIL: functional equation\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("c = "); arb_print(c); flint_printf("\n\n");
flint_printf("d = "); arb_print(d); flint_printf("\n\n");
flint_abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arb_clear(d);
}
/* Compare with MPFR, higher precision. */
for (iter = 0; iter < 200 * arb_test_multiplier(); iter++)
{
arb_t a, b;
fmpq_t q;
mpfr_t t;
slong prec = 2 + n_randint(state, 5000);
arb_init(a);
arb_init(b);
fmpq_init(q);
mpfr_init2(t, prec + 100);
arb_randtest(a, state, 1 + n_randint(state, 5000), 8);
arb_randtest(b, state, 1 + n_randint(state, 5000), 8);
arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200));
fmpq_get_mpfr(t, q, MPFR_RNDN);
mpfr_atan(t, t, MPFR_RNDN);
arb_atan(b, a, prec);
if (!arb_contains_mpfr(b, t))
{
flint_printf("FAIL: containment\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("a = "); arb_printd(a, 50); flint_printf("\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_printd(b, 50); flint_printf("\n\n");
flint_abort();
}
arb_atan(a, a, prec);
if (!arb_equal(a, b))
{
flint_printf("FAIL: aliasing\n\n");
flint_abort();
}
arb_clear(a);
arb_clear(b);
fmpq_clear(q);
mpfr_clear(t);
}
/* Higher precision + large arguments. */
for (iter = 0; iter < 2000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c, d;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 5000);
prec2 = prec1 + 30;
arb_init(a);
arb_init(b);
arb_init(c);
arb_init(d);
arb_randtest_precise(a, state, 1 + n_randint(state, 5000), 100);
arb_atan(b, a, prec1);
arb_atan(c, a, prec2);
if (!arb_overlaps(b, c))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("c = "); arb_print(c); flint_printf("\n\n");
flint_abort();
}
/* check tan(atan(x)) = x */
arb_sin_cos(c, d, b, prec1);
arb_div(c, c, d, prec1);
if (!arb_contains(c, a))
{
flint_printf("FAIL: functional equation\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("c = "); arb_print(c); flint_printf("\n\n");
flint_printf("d = "); arb_print(d); flint_printf("\n\n");
flint_abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arb_clear(d);
}
/* Check wide arguments. */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c, d;
arb_init(a);
arb_init(b);
arb_init(c);
arb_init(d);
arb_randtest_precise(a, state, 1 + n_randint(state, 1000), 100);
arb_randtest_precise(b, state, 1 + n_randint(state, 1000), 100);
if (n_randint(state, 2))
arb_add(a, a, b, 2 + n_randint(state, 1000));
arb_union(d, a, b, 2 + n_randint(state, 1000));
arb_atan(a, a, 2 + n_randint(state, 2000));
arb_atan(b, b, 2 + n_randint(state, 2000));
arb_atan(c, d, 2 + n_randint(state, 2000));
if (!arb_overlaps(c, a) || !arb_overlaps(c, b))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("d = "); arb_print(d); flint_printf("\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("c = "); arb_print(c); flint_printf("\n\n");
flint_abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arb_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("approx_dot....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arb_ptr x, y;
arb_t s1, s2, z;
slong i, len, prec, xbits, ybits, ebits;
int initial, subtract, revx, revy;
if (n_randint(state, 100) == 0)
len = n_randint(state, 100);
else if (n_randint(state, 10) == 0)
len = n_randint(state, 10);
else
len = n_randint(state, 3);
if (n_randint(state, 10) != 0 || len > 10)
{
prec = 2 + n_randint(state, 500);
xbits = 2 + n_randint(state, 500);
ybits = 2 + n_randint(state, 500);
}
else
{
prec = 2 + n_randint(state, 4000);
xbits = 2 + n_randint(state, 4000);
ybits = 2 + n_randint(state, 4000);
}
if (n_randint(state, 100) == 0)
ebits = 2 + n_randint(state, 100);
else
ebits = 2 + n_randint(state, 10);
initial = n_randint(state, 2);
subtract = n_randint(state, 2);
revx = n_randint(state, 2);
revy = n_randint(state, 2);
x = _arb_vec_init(len);
y = _arb_vec_init(len);
arb_init(s1);
arb_init(s2);
arb_init(z);
switch (n_randint(state, 3))
{
case 0:
for (i = 0; i < len; i++)
{
arb_randtest(x + i, state, xbits, ebits);
arb_randtest(y + i, state, ybits, ebits);
}
break;
/* Test with cancellation */
case 1:
for (i = 0; i < len; i++)
{
if (i <= len / 2)
{
arb_randtest(x + i, state, xbits, ebits);
arb_randtest(y + i, state, ybits, ebits);
}
else
{
arb_neg(x + i, x + len - i - 1);
arb_set(y + i, y + len - i - 1);
}
}
break;
default:
for (i = 0; i < len; i++)
{
if (i <= len / 2)
{
arb_randtest(x + i, state, xbits, ebits);
arb_randtest(y + i, state, ybits, ebits);
}
else
{
arb_neg_round(x + i, x + len - i - 1, 2 + n_randint(state, 500));
arb_set_round(y + i, y + len - i - 1, 2 + n_randint(state, 500));
}
}
break;
}
arb_randtest(s1, state, 200, 100);
arb_randtest(s2, state, 200, 100);
arb_randtest(z, state, xbits, ebits);
arb_approx_dot(s1, initial ? z : NULL, subtract,
revx ? (x + len - 1) : x, revx ? -1 : 1,
revy ? (y + len - 1) : y, revy ? -1 : 1,
len, prec);
mag_zero(arb_radref(s1));
/* With the fast algorithm, we expect identical results when
reversing the vectors. */
if (ebits <= 12)
{
arb_approx_dot(s2, initial ? z : NULL, subtract,
!revx ? (x + len - 1) : x, !revx ? -1 : 1,
!revy ? (y + len - 1) : y, !revy ? -1 : 1,
len, prec);
mag_zero(arb_radref(s2));
if (!arb_equal(s1, s2))
{
flint_printf("FAIL (reversal)\n\n");
flint_printf("iter = %wd, len = %wd, prec = %wd, ebits = %wd\n\n", iter, len, prec, ebits);
if (initial)
{
flint_printf("z = ", i); arb_printn(z, 100, ARB_STR_MORE); flint_printf(" (%wd)\n\n", arb_bits(z));
}
for (i = 0; i < len; i++)
{
flint_printf("x[%wd] = ", i); arb_printn(x + i, 100, ARB_STR_MORE); flint_printf(" (%wd)\n", arb_bits(x + i));
flint_printf("y[%wd] = ", i); arb_printn(y + i, 100, ARB_STR_MORE); flint_printf(" (%wd)\n", arb_bits(y + i));
}
flint_printf("\n\n");
flint_printf("s1 = "); arb_printn(s1, 100, ARB_STR_MORE); flint_printf("\n\n");
flint_printf("s2 = "); arb_printn(s2, 100, ARB_STR_MORE); flint_printf("\n\n");
flint_abort();
}
}
/* Verify that radii are ignored */
for (i = 0; i < len; i++)
{
arb_get_mid_arb(x + i, x + i);
arb_get_mid_arb(y + i, y + i);
}
arb_get_mid_arb(z, z);
arb_approx_dot(s2, initial ? z : NULL, subtract,
revx ? (x + len - 1) : x, revx ? -1 : 1,
revy ? (y + len - 1) : y, revy ? -1 : 1,
len, prec);
mag_zero(arb_radref(s2));
if (!arb_equal(s1, s2))
{
flint_printf("FAIL (radii)\n\n");
flint_printf("iter = %wd, len = %wd, prec = %wd, ebits = %wd\n\n", iter, len, prec, ebits);
if (initial)
{
flint_printf("z = ", i); arb_printn(z, 100, ARB_STR_MORE); flint_printf(" (%wd)\n\n", arb_bits(z));
}
for (i = 0; i < len; i++)
{
flint_printf("x[%wd] = ", i); arb_printn(x + i, 100, ARB_STR_MORE); flint_printf(" (%wd)\n", arb_bits(x + i));
flint_printf("y[%wd] = ", i); arb_printn(y + i, 100, ARB_STR_MORE); flint_printf(" (%wd)\n", arb_bits(y + i));
}
flint_printf("\n\n");
flint_printf("s1 = "); arb_printn(s1, 100, ARB_STR_MORE); flint_printf("\n\n");
flint_printf("s2 = "); arb_printn(s2, 100, ARB_STR_MORE); flint_printf("\n\n");
flint_abort();
}
/* Compare with arb_dot */
arb_approx_dot(s2, initial ? z : NULL, subtract,
revx ? (x + len - 1) : x, revx ? -1 : 1,
revy ? (y + len - 1) : y, revy ? -1 : 1,
len, prec);
{
mag_t err, xx, yy;
mag_init(err);
mag_init(xx);
mag_init(yy);
if (initial)
arb_get_mag(err, z);
for (i = 0; i < len; i++)
{
arb_get_mag(xx, revx ? x + len - 1 - i : x + i);
arb_get_mag(yy, revx ? y + len - 1 - i : y + i);
mag_addmul(err, xx, yy);
}
mag_mul_2exp_si(err, err, -prec + 2);
arb_add_error_mag(s2, err);
if (!arb_contains(s2, s1))
{
flint_printf("FAIL (inclusion)\n\n");
flint_printf("iter = %wd, len = %wd, prec = %wd, ebits = %wd\n\n", iter, len, prec, ebits);
if (initial)
{
flint_printf("z = ", i); arb_printn(z, 100, ARB_STR_MORE); flint_printf(" (%wd)\n\n", arb_bits(z));
}
for (i = 0; i < len; i++)
{
flint_printf("x[%wd] = ", i); arb_printn(x + i, 100, ARB_STR_MORE); flint_printf(" (%wd)\n", arb_bits(x + i));
flint_printf("y[%wd] = ", i); arb_printn(y + i, 100, ARB_STR_MORE); flint_printf(" (%wd)\n", arb_bits(y + i));
}
flint_printf("\n\n");
flint_printf("s1 = "); arb_printn(s1, 100, ARB_STR_MORE); flint_printf("\n\n");
flint_printf("s2 = "); arb_printn(s2, 100, ARB_STR_MORE); flint_printf("\n\n");
flint_abort();
}
mag_clear(err);
mag_clear(xx);
mag_clear(yy);
}
arb_clear(s1);
arb_clear(s2);
arb_clear(z);
_arb_vec_clear(x, len);
_arb_vec_clear(y, len);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("add_error....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c;
arf_t m, r;
arb_init(a);
arb_init(b);
arb_init(c);
arf_init(m);
arf_init(r);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(c, state, 1 + n_randint(state, 2000), 10);
arf_randtest_special(m, state, 1 + n_randint(state, 2000), 10);
arf_randtest_special(r, state, 1 + n_randint(state, 2000), 10);
/* c = a plus error bounds */
arb_set(c, a);
arf_set(arb_midref(b), m);
arf_get_mag(arb_radref(b), r);
arb_add_error(c, b);
/* b = a + random point */
arb_set(b, a);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), m, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), m, ARF_PREC_EXACT, ARF_RND_DOWN);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), r, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), r, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
printf("FAIL (arb_add_error)\n\n");
printf("a = "); arb_printn(a, 50, 0); printf("\n\n");
printf("b = "); arb_printn(b, 50, 0); printf("\n\n");
printf("c = "); arb_printn(c, 50, 0); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arf_clear(m);
arf_clear(r);
}
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c;
arf_t m;
arb_init(a);
arb_init(b);
arb_init(c);
arf_init(m);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(c, state, 1 + n_randint(state, 2000), 10);
arf_randtest_special(m, state, 1 + n_randint(state, 2000), 10);
/* c = a plus error bounds */
arb_set(c, a);
arb_add_error_arf(c, m);
/* b = a + random point */
arb_set(b, a);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), m, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), m, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
printf("FAIL (arb_add_error_arf)\n\n");
printf("a = "); arb_printn(a, 50, 0); printf("\n\n");
printf("b = "); arb_printn(b, 50, 0); printf("\n\n");
printf("c = "); arb_printn(c, 50, 0); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arf_clear(m);
}
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c;
arf_t t;
mag_t r;
arb_init(a);
arb_init(b);
arb_init(c);
mag_init(r);
arf_init(t);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
mag_randtest(r, state, 10);
/* c = a plus error bounds */
arb_set(c, a);
arb_add_error_mag(c, r);
/* b = a + random point */
arb_set(b, a);
arf_set_mag(t, r);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
printf("FAIL (arb_add_error_mag)\n\n");
printf("a = "); arb_printn(a, 50, 0); printf("\n\n");
printf("b = "); arb_printn(b, 50, 0); printf("\n\n");
printf("c = "); arb_printn(c, 50, 0); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
mag_clear(r);
arf_clear(t);
}
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c;
arf_t t;
long e;
arb_init(a);
arb_init(b);
arb_init(c);
arf_init(t);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
e = n_randint(state, 10) - 10;
/* c = a plus error bounds */
arb_set(c, a);
arb_add_error_2exp_si(c, e);
/* b = a + random point */
arb_set(b, a);
arf_one(t);
arf_mul_2exp_si(t, t, e);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
printf("FAIL (arb_add_error_2exp_si)\n\n");
printf("a = "); arb_printn(a, 50, 0); printf("\n\n");
printf("b = "); arb_printn(b, 50, 0); printf("\n\n");
printf("c = "); arb_printn(c, 50, 0); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arf_clear(t);
}
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c;
arf_t t;
fmpz_t e;
arb_init(a);
arb_init(b);
arb_init(c);
arf_init(t);
fmpz_init(e);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
fmpz_randtest(e, state, 10);
/* c = a plus error bounds */
arb_set(c, a);
arb_add_error_2exp_fmpz(c, e);
/* b = a + random point */
arb_set(b, a);
arf_one(t);
arf_mul_2exp_fmpz(t, t, e);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
printf("FAIL (arb_add_error_2exp_fmpz)\n\n");
printf("a = "); arb_printn(a, 50, 0); printf("\n\n");
printf("b = "); arb_printn(b, 50, 0); printf("\n\n");
printf("c = "); arb_printn(c, 50, 0); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arf_clear(t);
fmpz_clear(e);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("div....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c;
fmpq_t x, y, z;
arb_init(a);
arb_init(b);
arb_init(c);
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
do {
arb_randtest(a, state, 1 + n_randint(state, 200), 10);
arb_randtest(b, state, 1 + n_randint(state, 200), 10);
arb_randtest(c, state, 1 + n_randint(state, 200), 10);
arb_get_rand_fmpq(x, state, a, 1 + n_randint(state, 200));
arb_get_rand_fmpq(y, state, b, 1 + n_randint(state, 200));
} while (fmpq_is_zero(y));
arb_div(c, a, b, 2 + n_randint(state, 200));
fmpq_div(z, x, y);
if (!arb_contains_fmpq(c, z))
{
flint_printf("FAIL: containment\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("x = "); fmpq_print(x); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("y = "); fmpq_print(y); flint_printf("\n\n");
flint_printf("c = "); arb_print(c); flint_printf("\n\n");
flint_printf("z = "); fmpq_print(z); flint_printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
}
/* aliasing of c and a */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t a, b;
fmpq_t x, y, z;
arb_init(a);
arb_init(b);
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
do {
arb_randtest(a, state, 1 + n_randint(state, 200), 10);
arb_randtest(b, state, 1 + n_randint(state, 200), 10);
arb_get_rand_fmpq(x, state, a, 1 + n_randint(state, 200));
arb_get_rand_fmpq(y, state, b, 1 + n_randint(state, 200));
} while (fmpq_is_zero(y));
arb_div(a, a, b, 2 + n_randint(state, 200));
fmpq_div(z, x, y);
if (!arb_contains_fmpq(a, z))
{
flint_printf("FAIL: aliasing (c, a)\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("x = "); fmpq_print(x); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("y = "); fmpq_print(y); flint_printf("\n\n");
flint_printf("z = "); fmpq_print(z); flint_printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
}
/* aliasing of c and b */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t a, b;
fmpq_t x, y, z;
arb_init(a);
arb_init(b);
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
do {
arb_randtest(a, state, 1 + n_randint(state, 200), 10);
arb_randtest(b, state, 1 + n_randint(state, 200), 10);
arb_get_rand_fmpq(x, state, a, 1 + n_randint(state, 200));
arb_get_rand_fmpq(y, state, b, 1 + n_randint(state, 200));
} while (fmpq_is_zero(y));
arb_div(b, a, b, 2 + n_randint(state, 200));
fmpq_div(z, x, y);
if (!arb_contains_fmpq(b, z))
{
flint_printf("FAIL: aliasing (c, b)\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("x = "); fmpq_print(x); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("y = "); fmpq_print(y); flint_printf("\n\n");
flint_printf("z = "); fmpq_print(z); flint_printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
}
/* test special values */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c, d;
arb_init(a);
arb_init(b);
arb_init(c);
arb_init(d);
arb_randtest_special(a, state, 1 + n_randint(state, 200), 1 + n_randint(state, 100));
arb_randtest_special(b, state, 1 + n_randint(state, 200), 1 + n_randint(state, 100));
arb_randtest_special(c, state, 1 + n_randint(state, 200), 1 + n_randint(state, 100));
arb_div(c, a, b, 2 + n_randint(state, 200));
arb_mul(d, c, b, 2 + n_randint(state, 200));
if (!arb_contains(d, a))
{
flint_printf("FAIL: containment\n\n");
flint_printf("a = "); arb_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); arb_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); arb_printd(c, 15); flint_printf("\n\n");
flint_printf("d = "); arb_printd(d, 15); flint_printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arb_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("contains....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
arb_t a, b;
fmpq_t am, ar, bm, br, t, u;
int c1, c2;
arb_init(a);
arb_init(b);
fmpq_init(am);
fmpq_init(ar);
fmpq_init(bm);
fmpq_init(br);
fmpq_init(t);
fmpq_init(u);
arb_randtest(a, state, 1 + n_randint(state, 500), 14);
arb_randtest(b, state, 1 + n_randint(state, 500), 14);
arf_get_fmpq(am, arb_midref(a));
mag_get_fmpq(ar, arb_radref(a));
arf_get_fmpq(bm, arb_midref(b));
mag_get_fmpq(br, arb_radref(b));
c1 = arb_contains(a, b);
fmpq_sub(t, am, ar);
fmpq_sub(u, bm, br);
c2 = fmpq_cmp(t, u) <= 0;
fmpq_add(t, am, ar);
fmpq_add(u, bm, br);
c2 = c2 && (fmpq_cmp(t, u) >= 0);
if (c1 != c2)
{
printf("FAIL:\n\n");
printf("a = "); arb_print(a); printf("\n\n");
printf("b = "); arb_print(b); printf("\n\n");
printf("am = "); fmpq_print(am); printf("\n\n");
printf("ar = "); fmpq_print(ar); printf("\n\n");
printf("bm = "); fmpq_print(bm); printf("\n\n");
printf("br = "); fmpq_print(br); printf("\n\n");
printf("t = "); fmpq_print(t); printf("\n\n");
printf("u = "); fmpq_print(u); printf("\n\n");
printf("c1 = %d, c2 = %d\n\n", c1, c2);
abort();
}
arb_clear(a);
arb_clear(b);
fmpq_clear(am);
fmpq_clear(ar);
fmpq_clear(bm);
fmpq_clear(br);
fmpq_clear(t);
fmpq_clear(u);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}