/* sample (x, y) so that x /in y */
void _sample_arf_in_arb(arf_t x, arb_t y, flint_rand_t state)
{
slong bits, prec, expbits;
arf_t a, b;
slong i, n;
arf_init(a);
arf_init(b);
bits = 2 + n_randint(state, 1000);
prec = 2 + n_randint(state, 1000);
expbits = n_randint(state, 14);
n = n_randint(state, 3);
arf_randtest(x, state, bits, expbits);
arf_set(a, x);
arf_set(b, x);
for (i = 0; i < n; i++)
{
arf_randtest(x, state, bits, expbits);
arf_min(a, a, x);
arf_max(b, b, x);
}
arb_set_interval_arf(y, a, b, prec);
arf_clear(a);
arf_clear(b);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("set_fmpq....");
fflush(stdout);
flint_randinit(state);
/* test exact roundtrip R -> Q -> R */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
slong bits, res;
arf_t x, z;
fmpq_t y;
bits = 2 + n_randint(state, 200);
arf_init(x);
arf_init(z);
fmpq_init(y);
arf_randtest(x, state, bits, 10);
arf_randtest(z, state, bits, 10);
arf_get_fmpq(y, x);
res = arf_set_fmpq(z, y, bits, ARF_RND_DOWN);
if (!arf_equal(x, z) || res != 0)
{
flint_printf("FAIL\n\n");
flint_printf("bits: %wd\n", bits);
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = "); fmpq_print(y); flint_printf("\n\n");
flint_printf("z = "); arf_print(z); flint_printf("\n\n");
abort();
}
arf_clear(x);
arf_clear(z);
fmpq_clear(y);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("contains_arf....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t a;
arf_t b;
fmpq_t am, ar, bm, t;
int c1, c2;
arb_init(a);
arf_init(b);
fmpq_init(am);
fmpq_init(ar);
fmpq_init(bm);
fmpq_init(t);
arb_randtest(a, state, 1 + n_randint(state, 500), 14);
arf_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, b);
c1 = arb_contains_arf(a, b);
fmpq_sub(t, am, ar);
c2 = fmpq_cmp(t, bm) <= 0;
fmpq_add(t, am, ar);
c2 = c2 && (fmpq_cmp(t, bm) >= 0);
if (c1 != c2)
{
flint_printf("FAIL:\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arf_print(b); flint_printf("\n\n");
flint_printf("am = "); fmpq_print(am); flint_printf("\n\n");
flint_printf("ar = "); fmpq_print(ar); flint_printf("\n\n");
flint_printf("bm = "); fmpq_print(bm); flint_printf("\n\n");
flint_printf("t = "); fmpq_print(t); flint_printf("\n\n");
flint_printf("c1 = %d, c2 = %d\n\n", c1, c2);
abort();
}
arb_clear(a);
arf_clear(b);
fmpq_clear(am);
fmpq_clear(ar);
fmpq_clear(bm);
fmpq_clear(t);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
FLINT_TEST_INIT(state);
{
ulong k;
arb_t a,b;
arf_t c,d;
fmpq_poly_t p;
arb_init(a);
arb_init(b);
arf_init(c);
arf_init(d);
/* x+1 */
fmpq_poly_init(p);
fmpq_poly_set_coeff_si(p, 0, 1);
fmpq_poly_set_coeff_si(p, 1, 1);
for (iter = 0; iter < 5000; iter++)
{
k = n_randint(state, 10000);
arb_set_si(a, k);
fmpq_poly_evaluate_arb(b, p, a, 30 + n_randint(state, 100));
if (!arb_equal_si(b, k + 1))
{
printf("FAIL (fmpq_poly_evaluate_arb):\n");
printf("a = "); arb_print(a); printf("\n");
printf("b = "); arb_print(b); printf("\n");
printf("p = "); fmpq_poly_print(p); printf("\n");
abort();
}
arf_set_si(c, k);
fmpq_poly_evaluate_arf(d, p, c, 30 + n_randint(state, 100));
if (!arf_equal_si(d, k + 1))
{
printf("FAIL (fmpq_poly_evaluate_arf):\n");
printf("c = "); arf_print(c); printf("\n");
printf("d = "); arf_print(d); printf("\n");
printf("p = "); fmpq_poly_print(p); printf("\n");
abort();
}
}
/* x^2 */
fmpq_poly_zero(p);
fmpq_poly_set_coeff_si(p, 2, 1);
for (iter = 0; iter < 1000; iter++)
{
k = n_randint(state, 10000);
arb_set_si(a, k);
fmpq_poly_evaluate_arb(b, p, a, 30 + n_randint(state, 100));
if (!arb_equal_si(b, k * k))
{
printf("Error (test_fmpq_poly_evaluate_arb):\n");
printf("a = "); arb_print(a); printf("\n");
printf("b = "); arb_print(b); printf("\n");
printf("p = "); fmpq_poly_print(p); printf("\n");
abort();
}
arf_set_si(c, k);
fmpq_poly_evaluate_arf(d, p, c, 30 + n_randint(state, 100));
if (!arf_equal_si(d, k * k))
{
printf("Error (test_fmpq_poly_evaluate_arf):\n");
printf("c = "); arf_print(c); printf("\n");
printf("d = "); arf_print(d); printf("\n");
printf("p = "); fmpq_poly_print(p); printf("\n");
abort();
}
}
fmpq_poly_clear(p);
arb_clear(a);
arb_clear(b);
arf_clear(c);
arf_clear(d);
}
/* check evaluate_arb agains exact evaluate_fmpq */
for (iter = 0; iter < 1000; iter++)
{
fmpq_poly_t p;
fmpq_t x,y;
arb_t a,b;
fmpq_poly_init(p);
fmpq_init(x);
fmpq_init(y);
arb_init(a);
arb_init(b);
fmpq_poly_randtest(p, state, 1 + n_randint(state,100), 10);
fmpq_randtest(x, state, 10);
arb_set_fmpq(a, x, 64);
fmpq_poly_evaluate_fmpq(y, p, x);
fmpq_poly_evaluate_arb(b, p, a, 60);
if (!arb_contains_fmpq(b, y))
{
printf("FAIL (y not in b):\n");
printf("p = "); fmpq_poly_print(p); printf("\n");
printf("x = "); fmpq_print(x); printf("\n");
printf("y = "); fmpq_print(y); printf("\n");
printf("a = "); arb_print(a); printf("\n");
printf("b = "); arb_print(b); printf("\n");
abort();
}
fmpq_poly_evaluate_arb(a, p, a, 60);
if (!arb_equal(a,b))
{
printf("FAIL (a not equal b):\n");
printf("p = "); fmpq_poly_print(p); printf("\n");
printf("x = "); fmpq_print(x); printf("\n");
printf("y = "); fmpq_print(y); printf("\n");
printf("a = "); arb_print(a); printf("\n");
printf("b = "); arb_print(b); printf("\n");
abort();
}
fmpq_poly_clear(p);
fmpq_clear(x);
fmpq_clear(y);
arb_clear(a);
arb_clear(b);
}
/* test aliasing */
for (iter = 0; iter < 1000; iter++)
{
fmpq_poly_t p;
arb_t a,b;
arf_t c,d;
fmpq_poly_init(p);
arb_init(a);
arb_init(b);
arf_init(c);
arf_init(d);
fmpq_poly_randtest(p, state, 1 + n_randint(state,100), 10);
arb_randtest(a, state, 60, 10);
arb_randtest(b, state, 60, 10);
arf_randtest(c, state, 60, 10);
arf_randtest(d, state, 60, 10);
fmpq_poly_evaluate_arb(b, p, a, 60);
fmpq_poly_evaluate_arb(a, p, a, 60);
if (!arb_equal(a, b))
{
printf("FAIL (a not equal b):\n");
printf("p = "); fmpq_poly_print(p); printf("\n");
printf("a = "); arb_print(a); printf("\n");
printf("b = "); arb_print(b); printf("\n");
abort();
}
fmpq_poly_evaluate_arf(d, p, c, 60);
fmpq_poly_evaluate_arf(c, p, c, 60);
if (!arf_equal(c, d))
{
printf("FAIL (c not equal d):\n");
printf("p = "); fmpq_poly_print(p); printf("\n");
printf("c = "); arf_print(c); printf("\n");
printf("d = "); arf_print(d); printf("\n");
}
fmpq_poly_clear(p);
arb_clear(a);
arb_clear(b);
arf_clear(c);
arf_clear(d);
}
FLINT_TEST_CLEANUP(state);
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("get_mpn_fixed_mod_pi4....");
fflush(stdout);
flint_randinit(state);
/* _flint_rand_init_gmp(state); */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arf_t x;
int octant;
fmpz_t q;
mp_ptr w;
arb_t wb, t, u;
mp_size_t wn;
slong prec, prec2;
int success;
mp_limb_t error;
prec = 2 + n_randint(state, 10000);
wn = 1 + n_randint(state, 200);
prec2 = FLINT_MAX(prec, wn * FLINT_BITS) + 100;
arf_init(x);
arb_init(wb);
arb_init(t);
arb_init(u);
fmpz_init(q);
w = flint_malloc(sizeof(mp_limb_t) * wn);
arf_randtest(x, state, prec, 14);
/* this should generate numbers close to multiples of pi/4 */
if (n_randint(state, 4) == 0)
{
arb_const_pi(t, prec);
arb_mul_2exp_si(t, t, -2);
fmpz_randtest(q, state, 200);
arb_mul_fmpz(t, t, q, prec);
arf_add(x, x, arb_midref(t), prec, ARF_RND_DOWN);
}
arf_abs(x, x);
success = _arb_get_mpn_fixed_mod_pi4(w, q, &octant, &error, x, wn);
if (success)
{
/* could round differently */
if (fmpz_fdiv_ui(q, 8) != octant)
{
flint_printf("bad octant\n");
abort();
}
_arf_set_mpn_fixed(arb_midref(wb), w, wn, wn, 0, FLINT_BITS * wn, ARB_RND);
mag_set_ui_2exp_si(arb_radref(wb), error, -FLINT_BITS * wn);
arb_const_pi(u, prec2);
arb_mul_2exp_si(u, u, -2);
arb_set(t, wb);
if (octant % 2 == 1)
arb_sub(t, u, t, prec2);
arb_addmul_fmpz(t, u, q, prec2);
if (!arb_contains_arf(t, x))
{
flint_printf("FAIL (containment)\n");
flint_printf("x = "); arf_printd(x, 50); flint_printf("\n\n");
flint_printf("q = "); fmpz_print(q); flint_printf("\n\n");
flint_printf("w = "); arb_printd(wb, 50); flint_printf("\n\n");
flint_printf("t = "); arb_printd(t, 50); flint_printf("\n\n");
abort();
}
arb_const_pi(t, prec2);
arb_mul_2exp_si(t, t, -2);
if (arf_sgn(arb_midref(wb)) < 0 ||
arf_cmp(arb_midref(wb), arb_midref(t)) >= 0)
{
flint_printf("FAIL (expected 0 <= w < pi/4)\n");
flint_printf("x = "); arf_printd(x, 50); flint_printf("\n\n");
flint_printf("w = "); arb_printd(wb, 50); flint_printf("\n\n");
abort();
}
}
flint_free(w);
fmpz_clear(q);
arf_clear(x);
arb_clear(wb);
arb_clear(t);
arb_clear(u);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("can_round_mpfr....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000000; iter++)
{
mpfr_t x, y1, y2;
int r1, r2;
arb_t t;
slong prec;
mpfr_rnd_t rnd;
prec = 2 + n_randint(state, 300);
mpfr_init2(x, 2 + n_randint(state, 300));
mpfr_init2(y1, prec);
mpfr_init2(y2, prec);
arb_init(t);
switch (n_randint(state, 5))
{
case 0: rnd = MPFR_RNDN; break;
case 1: rnd = MPFR_RNDZ; break;
case 2: rnd = MPFR_RNDU; break;
case 3: rnd = MPFR_RNDD; break;
default: rnd = MPFR_RNDA;
}
arf_randtest(arb_midref(t), state, mpfr_get_prec(x), 1 + n_randint(state, 10));
arf_abs(arb_midref(t), arb_midref(t));
arf_get_mpfr(x, arb_midref(t), MPFR_RNDN);
arb_root_ui(t, t, 4, 2 + n_randint(state, 300));
if (arb_can_round_mpfr(t, prec, rnd))
{
r1 = mpfr_root(y1, x, 4, rnd);
r2 = arf_get_mpfr(y2, arb_midref(t), rnd);
if (r1 != r2 || !mpfr_equal_p(y1, y2))
{
flint_printf("FAIL! %ld\n");
flint_printf("r1 = %d, r2 = %d, prec = %wd\n", r1, r2, prec);
flint_printf("x = "); mpfr_dump(x); flint_printf("\n");
flint_printf("y1 = "); mpfr_dump(y1); flint_printf("\n");
flint_printf("y2 = "); mpfr_dump(y2); flint_printf("\n");
abort();
}
}
arb_clear(t);
mpfr_clear(x);
mpfr_clear(y1);
mpfr_clear(y2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("get_fmpz....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arf_t x, x2;
fmpz_t z, z2, e;
int ret1, ret2;
arf_init(x);
arf_init(x2);
fmpz_init(z);
fmpz_init(z2);
fmpz_init(e);
arf_randtest(x, state, 2 + n_randint(state, 1000), 10);
fmpz_randtest(z, state, 1 + n_randint(state, 1000));
fmpz_randtest(z2, state, 1 + n_randint(state, 1000));
fmpz_randtest(e, state, 1 + n_randint(state, 200));
arf_mul_2exp_fmpz(x2, x, e);
ret1 = arf_get_fmpz(z, x, ARF_RND_DOWN);
ret2 = arf_get_fmpz_fixed_fmpz(z2, x2, e);
if (!fmpz_equal(z, z2) || (ret1 != ret2))
{
flint_printf("FAIL (fixed_fmpz)\n\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("x2 = "); arf_print(x2); flint_printf("\n\n");
flint_printf("z = "); fmpz_print(z); flint_printf("\n\n");
flint_printf("z2 = "); fmpz_print(z2); flint_printf("\n\n");
flint_printf("ret1 = %d, ret2 = %d\n\n", ret1, ret2);
flint_abort();
}
arf_clear(x);
arf_clear(x2);
fmpz_clear(z);
fmpz_clear(z2);
fmpz_clear(e);
}
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arf_t x, x2;
fmpz_t z, z2;
slong e;
int ret1, ret2;
arf_init(x);
arf_init(x2);
fmpz_init(z);
fmpz_init(z2);
arf_randtest(x, state, 2 + n_randint(state, 1000), 10);
fmpz_randtest(z, state, 1 + n_randint(state, 1000));
fmpz_randtest(z2, state, 1 + n_randint(state, 1000));
e = n_randtest(state);
arf_mul_2exp_si(x2, x, e);
ret1 = arf_get_fmpz(z, x, ARF_RND_DOWN);
ret2 = arf_get_fmpz_fixed_si(z2, x2, e);
if (!fmpz_equal(z, z2) || (ret1 != ret2))
{
flint_printf("FAIL (fixed_si)\n\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("x2 = "); arf_print(x2); flint_printf("\n\n");
flint_printf("z = "); fmpz_print(z); flint_printf("\n\n");
flint_printf("z2 = "); fmpz_print(z2); flint_printf("\n\n");
flint_printf("ret1 = %d, ret2 = %d\n\n", ret1, ret2);
flint_abort();
}
arf_clear(x);
arf_clear(x2);
fmpz_clear(z);
fmpz_clear(z2);
}
for (iter = 0; iter < 1000000 * arb_test_multiplier(); iter++)
{
slong bits;
arf_t x;
mpfr_t y;
fmpz_t z, z2;
mpz_t w;
int ret1, ret2;
bits = 2 + n_randint(state, 1000);
arf_init(x);
mpfr_init2(y, bits);
fmpz_init(z);
fmpz_init(z2);
mpz_init(w);
arf_randtest(x, state, bits, 10);
fmpz_randtest(z, state, 1 + n_randint(state, 1000));
arf_get_mpfr(y, x, MPFR_RNDN);
switch (n_randint(state, 5))
{
case 0:
ret1 = arf_get_fmpz(z, x, ARF_RND_FLOOR);
ret2 = mpfr_get_z(w, y, MPFR_RNDD);
break;
case 1:
ret1 = arf_get_fmpz(z, x, ARF_RND_CEIL);
ret2 = mpfr_get_z(w, y, MPFR_RNDU);
break;
case 2:
ret1 = arf_get_fmpz(z, x, ARF_RND_DOWN);
ret2 = mpfr_get_z(w, y, MPFR_RNDZ);
break;
case 3:
ret1 = arf_get_fmpz(z, x, ARF_RND_UP);
ret2 = mpfr_get_z(w, y, MPFR_RNDA);
break;
default:
ret1 = arf_get_fmpz(z, x, ARF_RND_NEAR);
ret2 = mpfr_get_z(w, y, MPFR_RNDN);
break;
}
fmpz_set_mpz(z2, w);
if (!fmpz_equal(z, z2) || (ret1 != (ret2 != 0)))
{
flint_printf("FAIL\n\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("z = "); fmpz_print(z); flint_printf("\n\n");
flint_printf("z2 = "); fmpz_print(z2); flint_printf("\n\n");
flint_printf("ret1 = %d, ret2 = %d\n\n", ret1, ret2);
flint_abort();
}
arf_clear(x);
mpfr_clear(y);
fmpz_clear(z);
fmpz_clear(z2);
mpz_clear(w);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
