int
main(void)
{
int i, result;
flint_rand_t state;
printf("init_set....");
fflush(stdout);
flint_randinit(state);
/* Small integers */
for (i = 0; i < 100000; i++)
{
fmpz_t a, b;
fmpz_init(a);
fmpz_randtest(a, state, FLINT_BITS - 2);
fmpz_init_set(b, a);
result = fmpz_equal(a, b);
if (!result)
{
printf("FAIL:\n\n");
printf("a = "), fmpz_print(a), printf("\n");
printf("b = "), fmpz_print(b), printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
}
/* Large integers */
for (i = 0; i < 100000; i++)
{
fmpz_t a, b;
fmpz_init(a);
fmpz_randtest(a, state, 2 * FLINT_BITS);
fmpz_init_set(b, a);
result = fmpz_equal(a, b);
if (!result)
{
printf("FAIL:\n\n");
printf("a = "), fmpz_print(a), printf("\n");
printf("b = "), fmpz_print(b), printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
void
fmpr_randtest(fmpr_t x, flint_rand_t state, slong bits, slong mag_bits)
{
fmpz_randtest(fmpr_manref(x), state, bits);
fmpz_randtest(fmpr_expref(x), state, mag_bits);
fmpz_sub_ui(fmpr_expref(x), fmpr_expref(x), fmpz_bits(fmpr_manref(x)));
_fmpr_normalise(fmpr_manref(x), fmpr_expref(x), bits, FMPR_RND_DOWN);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sub_si_inline....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
fmpz_t a, c, d;
slong b;
fmpz_init(a);
fmpz_init(c);
fmpz_init(d);
fmpz_randtest(a, state, 1 + n_randint(state, 200));
fmpz_randtest(c, state, 1 + n_randint(state, 200));
fmpz_randtest(d, state, 1 + n_randint(state, 200));
b = n_randtest(state);
fmpz_sub_si(c, a, b);
fmpz_sub_si_inline(d, a, b);
if (!fmpz_equal(c, d))
{
flint_printf("FAIL\n");
fmpz_print(a); flint_printf("\n\n");
flint_printf("%wd", b); flint_printf("\n\n");
fmpz_print(c); flint_printf("\n\n");
fmpz_print(d); flint_printf("\n\n");
abort();
}
fmpz_sub_si_inline(a, a, b);
if (!fmpz_equal(c, a))
{
flint_printf("FAIL (aliasing)\n");
fmpz_print(a); flint_printf("\n\n");
flint_printf("%wd", b); flint_printf("\n\n");
fmpz_print(c); flint_printf("\n\n");
fmpz_print(d); flint_printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(c);
fmpz_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("lshift_mpn....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
fmpz_t a, b, c;
ulong e;
mp_limb_t atmp;
mp_ptr aptr;
mp_size_t an;
int asgnbit;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_randtest_not_zero(a, state, 1 + n_randint(state, 2000));
fmpz_randtest(b, state, 1 + n_randint(state, 2000));
fmpz_randtest(c, state, 1 + n_randint(state, 2000));
e = n_randint(state, 1000);
FMPZ_GET_MPN_READONLY(asgnbit, an, aptr, atmp, *a)
fmpz_lshift_mpn(b, aptr, an, asgnbit, e);
fmpz_mul_2exp(c, a, e);
if (!fmpz_equal(b, c))
{
flint_printf("FAIL\n");
fmpz_print(a); flint_printf("\n\n");
fmpz_print(b); flint_printf("\n\n");
fmpz_print(c); flint_printf("\n\n");
flint_abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("fmpz....");
fflush(stdout);
for (i = 0; i < 100000; i++)
{
fmpz_t a, b;
*a = 0L;
fmpz_randtest(a, state, FLINT_BITS - 2);
*b = *a;
_fmpz_promote_val(a);
_fmpz_demote_val(a);
result = (*b == *a);
if (!result)
{
printf("FAIL\n");
abort();
}
}
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
void
fmpz_poly_randtest(fmpz_poly_t f, flint_rand_t state,
long len, mp_bitcnt_t bits)
{
long i;
fmpz_poly_fit_length(f, len);
for (i = 0; i < len; i++)
fmpz_randtest(f->coeffs + i, state, bits);
_fmpz_poly_set_length(f, len);
_fmpz_poly_normalise(f);
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("setbit....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 100000; i++)
{
ulong j;
fmpz_t a, c;
mpz_t b;
fmpz_init(a);
fmpz_init(c);
mpz_init(b);
fmpz_randtest(a, state, 2 * FLINT_BITS);
fmpz_get_mpz(b, a);
j = n_randint(state, 3 * FLINT_BITS);
fmpz_setbit(a, j);
mpz_setbit(b, j);
fmpz_set_mpz(c, b);
result = (fmpz_equal(a, c));
if (!result)
{
printf("FAIL:\n");
printf("a = "), fmpz_print(a), printf("\n");
gmp_printf("b = %Zd\n", b);
printf("c = "), fmpz_print(c), printf("\n");
printf("j = %ld\n", j);
abort();
}
fmpz_clear(a);
fmpz_clear(c);
mpz_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("content....");
fflush(stdout);
/* Check that content(a f) = abs(a) content(f) */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_t a, c, d;
fmpz *f;
slong len = n_randint(state, 100);
fmpz_init(a);
fmpz_init(c);
fmpz_init(d);
f = _fmpz_vec_init(len);
_fmpz_vec_randtest(f, state, len, 200);
fmpz_randtest(a, state, 100);
_fmpz_vec_content(c, f, len);
_fmpz_vec_scalar_mul_fmpz(f, f, len, a);
fmpz_abs(a, a);
fmpz_mul(c, a, c);
_fmpz_vec_content(d, f, len);
result = (fmpz_equal(c, d));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_print(c), flint_printf("\n\n");
fmpz_print(d), flint_printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(c);
fmpz_clear(d);
_fmpz_vec_clear(f, len);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("is_square....");
fflush(stdout);
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a;
mpz_t b;
int r1, r2;
fmpz_init(a);
mpz_init(b);
fmpz_randtest(a, state, 200);
if (n_randint(state, 2) == 0)
fmpz_mul(a, a, a);
fmpz_get_mpz(b, a);
r1 = fmpz_is_square(a);
r2 = mpz_perfect_square_p(b);
result = (r1 == r2);
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf("b = %Zd\n", b);
abort();
}
fmpz_clear(a);
mpz_clear(b);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void
acb_randtest_maybe_half_int(acb_t x, flint_rand_t state, long prec, long size)
{
if (n_randint(state, 8) == 0)
{
fmpz_t t;
fmpz_init(t);
fmpz_randtest(t, state, 1 + n_randint(state, prec));
arb_set_fmpz(acb_realref(x), t);
arb_zero(acb_imagref(x));
acb_mul_2exp_si(x, x, -1);
fmpz_clear(t);
}
else
{
acb_randtest(x, state, prec, size);
}
}
int
main(void)
{
int i, result;
double output;
slong exp;
FLINT_TEST_INIT(state);
flint_printf("get_d_2exp....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_t a;
fmpz_init(a);
fmpz_randtest(a, state, 200);
output = fmpz_get_d_2exp(&exp, a);
result = (fmpz_bits(a) == exp);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("a = "), fmpz_print(a), flint_printf("\n");
flint_printf("output = %f\n", output);
flint_printf("exp = %wd, bits = %wu\n", exp, fmpz_bits(a));
abort();
}
fmpz_clear(a);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void fmpq_poly_randtest(fmpq_poly_t poly, flint_rand_t state,
long len, mp_bitcnt_t bits)
{
ulong m;
m = n_randlimb(NULL);
fmpq_poly_fit_length(poly, len);
_fmpq_poly_set_length(poly, len);
if (m & 1UL)
{
_fmpz_vec_randtest(poly->coeffs, state, len, bits);
}
else
{
fmpz_t x;
fmpz_init(x);
fmpz_randtest(x, state, bits / 2);
_fmpz_vec_randtest(poly->coeffs, state, len, (bits + 1) / 2);
_fmpz_vec_scalar_mul_fmpz(poly->coeffs, poly->coeffs, len, x);
fmpz_clear(x);
}
if (m & 2UL)
{
fmpz_randtest_not_zero(poly->den, state, FLINT_MAX(bits, 1));
fmpz_abs(poly->den, poly->den);
fmpq_poly_canonicalise(poly);
}
else
{
fmpz_set_ui(poly->den, 1);
_fmpq_poly_normalise(poly);
}
}
void
_fmpq_randtest(fmpz_t num, fmpz_t den, flint_rand_t state, mp_bitcnt_t bits)
{
ulong x = n_randlimb(state);
fmpz_randtest(num, state, bits);
fmpz_randtest_not_zero(den, state, bits);
switch (x % 16)
{
case 0:
fmpz_set_si(num, 1);
break;
case 1:
fmpz_set_si(num, -1);
break;
case 2:
fmpz_set_si(num, 2);
break;
case 3:
fmpz_set_si(num, -2);
break;
}
switch ((x / 16) % 16)
{
case 0:
fmpz_set_si(den, 1);
break;
case 2:
fmpz_set_si(den, 2);
break;
}
_fmpq_canonicalise(num, den);
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("divexact_si....");
fflush(stdout);
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, c;
mpz_t e, f, g;
slong n;
fmpz_init(a);
fmpz_init(c);
mpz_init(e);
mpz_init(f);
mpz_init(g);
fmpz_randtest(a, state, 200);
n = z_randtest_not_zero(state);
fmpz_mul_si(c, a, n);
fmpz_get_mpz(e, c);
fmpz_divexact_si(a, c, n);
flint_mpz_divexact_ui(f, e, FLINT_ABS(n));
if (n < 0)
mpz_neg(f, f);
fmpz_get_mpz(g, a);
result = (mpz_cmp(f, g) == 0);
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf("n = %wd, e = %Zd, f = %Zd, g = %Zd\n", n, e, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(c);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
}
/* Test aliasing of a and c */
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, c;
mpz_t d, f, g;
slong n;
fmpz_init(a);
fmpz_init(c);
mpz_init(d);
mpz_init(f);
mpz_init(g);
fmpz_randtest(a, state, 200);
n = z_randtest_not_zero(state);
fmpz_mul_si(c, a, n);
fmpz_get_mpz(d, c);
fmpz_divexact_si(c, c, n);
flint_mpz_divexact_ui(f, d, FLINT_ABS(n));
if (n < 0)
mpz_neg(f, f);
fmpz_get_mpz(g, c);
result = (mpz_cmp(f, g) == 0);
if (!result)
{
flint_printf("FAIL;\n");
gmp_printf("d = %Zd, n = %wd, f = %Zd, g = %Zd\n", d, n, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(c);
mpz_clear(d);
mpz_clear(f);
mpz_clear(g);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("cdiv_q....");
fflush(stdout);
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, b, c;
mpz_t d, e, f, g;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
mpz_init(d);
mpz_init(e);
mpz_init(f);
mpz_init(g);
fmpz_randtest(a, state, 200);
fmpz_randtest_not_zero(b, state, 200);
fmpz_get_mpz(d, a);
fmpz_get_mpz(e, b);
fmpz_cdiv_q(c, a, b);
mpz_cdiv_q(f, d, e);
fmpz_get_mpz(g, c);
result = (mpz_cmp(f, g) == 0);
if (!result)
{
flint_printf("FAIL\n");
gmp_printf("d = %Zd, e = %Zd, f = %Zd, g = %Zd\n", d, e, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
mpz_clear(d);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
}
/* Check aliasing of a and b */
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, c;
mpz_t d, f, g;
fmpz_init(a);
fmpz_init(c);
mpz_init(d);
mpz_init(f);
mpz_init(g);
fmpz_randtest_not_zero(a, state, 200);
fmpz_get_mpz(d, a);
fmpz_cdiv_q(c, a, a);
mpz_cdiv_q(f, d, d);
fmpz_get_mpz(g, c);
result = (mpz_cmp(f, g) == 0);
if (!result)
{
flint_printf("FAIL\n");
gmp_printf("d = %Zd, f = %Zd, g = %Zd\n", d, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(c);
mpz_clear(d);
mpz_clear(f);
mpz_clear(g);
}
/* Test aliasing of a and c */
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, b;
mpz_t d, e, f, g;
fmpz_init(a);
fmpz_init(b);
mpz_init(d);
mpz_init(e);
mpz_init(f);
mpz_init(g);
fmpz_randtest(a, state, 200);
fmpz_randtest_not_zero(b, state, 200);
fmpz_get_mpz(d, a);
fmpz_get_mpz(e, b);
fmpz_cdiv_q(a, a, b);
mpz_cdiv_q(f, d, e);
fmpz_get_mpz(g, a);
result = (mpz_cmp(f, g) == 0);
if (!result)
{
flint_printf("FAIL\n");
gmp_printf("d = %Zd, e = %Zd, f = %Zd, g = %Zd\n", d, e, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
mpz_clear(d);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
}
/* Test aliasing of b and c */
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, b;
mpz_t d, e, f, g;
fmpz_init(a);
fmpz_init(b);
mpz_init(d);
mpz_init(e);
mpz_init(f);
mpz_init(g);
fmpz_randtest(a, state, 200);
fmpz_randtest_not_zero(b, state, 200);
fmpz_get_mpz(d, a);
fmpz_get_mpz(e, b);
fmpz_cdiv_q(b, a, b);
mpz_cdiv_q(f, d, e);
fmpz_get_mpz(g, b);
result = (mpz_cmp(f, g) == 0);
if (!result)
{
flint_printf("FAIL\n");
gmp_printf("d = %Zd, e = %Zd, f = %Zd, g = %Zd\n", d, e, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
mpz_clear(d);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, j, result;
ulong cflags = UWORD(0);
mpq_t n1, n2;
FLINT_TEST_INIT(state);
flint_printf("get/set_coeff_fmpz....");
fflush(stdout);
mpq_init(n1);
mpq_init(n2);
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpq_poly_t a;
fmpz_t x1, x2;
slong coeff, len;
fmpq_poly_init(a);
fmpz_init(x1);
fmpz_init(x2);
len = (slong) (n_randint(state, 100) + 1);
for (j = 0; j < 100; j++)
{
fmpz_randtest(x1, state, 200);
fmpz_get_mpz(mpq_numref(n1), x1);
flint_mpz_set_si(mpq_denref(n1), 1);
coeff = (slong) n_randint(state, len);
fmpq_poly_set_coeff_fmpz(a, coeff, x1);
fmpq_poly_get_coeff_mpq(n2, a, coeff);
cflags |= fmpq_poly_is_canonical(a) ? 0 : 1;
result = (mpq_equal(n1, n2) && !cflags);
if (!result)
{
flint_printf("FAIL:\n\n");
flint_printf("a = "), fmpq_poly_debug(a), flint_printf("\n\n");
flint_printf("coeff = %wd\n\n", coeff);
flint_printf("len = %wd\n\n", len);
flint_printf("cflags = %wu\n\n", cflags);
gmp_printf("n1 = %Qd\n\n", n1);
gmp_printf("n2 = %Qd\n\n", n2);
abort();
}
}
fmpz_clear(x1);
fmpz_clear(x2);
fmpq_poly_clear(a);
}
mpq_clear(n1);
mpq_clear(n2);
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("divexact_ui....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 100000; i++)
{
fmpz_t a, c;
mpz_t e, f, g;
ulong n;
fmpz_init(a);
fmpz_init(c);
mpz_init(e);
mpz_init(f);
mpz_init(g);
fmpz_randtest(a, state, 200);
n = n_randtest_not_zero(state);
fmpz_mul_ui(c, a, n);
fmpz_get_mpz(e, c);
fmpz_divexact_ui(a, c, n);
mpz_divexact_ui(f, e, n);
fmpz_get_mpz(g, a);
result = (mpz_cmp(f, g) == 0);
if (!result)
{
printf("FAIL1\n");
gmp_printf("n = %lu, e = %Zd, f = %Zd, g = %Zd\n", n, e, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(c);
mpz_clear(e);
mpz_clear(f);
mpz_clear(g);
}
/* Test aliasing of a and c */
for (i = 0; i < 100000; i++)
{
fmpz_t a, c;
mpz_t d, f, g;
ulong n;
fmpz_init(a);
fmpz_init(c);
mpz_init(d);
mpz_init(f);
mpz_init(g);
fmpz_randtest(a, state, 200);
n = n_randtest_not_zero(state);
fmpz_mul_ui(c, a, n);
fmpz_get_mpz(d, c);
fmpz_divexact_ui(c, c, n);
mpz_divexact_ui(f, d, n);
fmpz_get_mpz(g, c);
result = (mpz_cmp(f, g) == 0);
if (!result)
{
printf("FAIL:\n");
gmp_printf("d = %Zd, n = %lu, f = %Zd, g = %Zd\n", d, n, f, g);
abort();
}
fmpz_clear(a);
fmpz_clear(c);
mpz_clear(d);
mpz_clear(f);
mpz_clear(g);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int main()
{
long iter;
flint_rand_t state;
printf("submul_fmpz....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c, d;
fmpz_t x;
long prec;
arb_init(a);
arb_init(b);
arb_init(c);
arb_init(d);
fmpz_init(x);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 100);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 100);
arb_randtest_special(c, state, 1 + n_randint(state, 2000), 100);
fmpz_randtest(x, state, 1 + n_randint(state, 2000));
prec = 2 + n_randint(state, 2000);
arb_set_fmpz(b, x);
arb_set(d, c);
arb_submul_fmpz(c, a, x, prec);
arb_submul(d, a, b, prec);
if (!arb_equal(c, d))
{
printf("FAIL\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");
printf("d = "); arb_print(d); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arb_clear(d);
fmpz_clear(x);
}
/* aliasing */
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c;
fmpz_t x;
long prec;
arb_init(a);
arb_init(b);
arb_init(c);
fmpz_init(x);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 100);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 100);
arb_randtest_special(c, state, 1 + n_randint(state, 2000), 100);
fmpz_randtest(x, state, 1 + n_randint(state, 2000));
prec = 2 + n_randint(state, 2000);
arb_set_fmpz(b, x);
arb_set(c, a);
arb_submul_fmpz(c, a, x, prec);
arb_submul_fmpz(a, a, x, prec);
if (!arb_equal(a, c))
{
printf("FAIL (aliasing)\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);
fmpz_clear(x);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("evaluate_fmpz....");
fflush(stdout);
/* Check that (f+g)(a) = f(a) + g(a) */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_t a;
fmpq_poly_t f, g, h;
fmpq_t x, y;
fmpq_init(x);
fmpq_init(y);
fmpz_init(a);
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_poly_init(h);
fmpq_poly_randtest(f, state, n_randint(state, 100), 200);
fmpq_poly_randtest(g, state, n_randint(state, 100), 200);
fmpz_randtest(a, state, n_randint(state, 100));
fmpq_poly_evaluate_fmpz(x, f, a);
fmpq_poly_evaluate_fmpz(y, g, a);
fmpq_add(x, x, y);
fmpq_poly_add(h, f, g);
fmpq_poly_evaluate_fmpz(y, h, a);
result = (fmpq_equal(x, y));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("f = "), fmpq_poly_debug(f), flint_printf("\n");
flint_printf("g = "), fmpq_poly_debug(g), flint_printf("\n");
flint_printf("a = "), fmpz_print(a), flint_printf("\n");
flint_printf("f(a) + g(a) = "), fmpq_print(x), flint_printf("\n\n");
flint_printf("(f + g)(a) = "), fmpq_print(y), flint_printf("\n\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
fmpz_clear(a);
fmpq_poly_clear(f);
fmpq_poly_clear(g);
fmpq_poly_clear(h);
}
/* Check that (f*g)(a) = f(a) * g(a) */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_t a;
fmpq_poly_t f, g;
fmpq_t x, y;
fmpq_init(x);
fmpq_init(y);
fmpz_init(a);
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_poly_randtest(f, state, n_randint(state, 100), 200);
fmpq_poly_randtest(g, state, n_randint(state, 100), 200);
fmpz_randtest(a, state, n_randint(state, 100));
fmpq_poly_evaluate_fmpz(x, f, a);
fmpq_poly_evaluate_fmpz(y, g, a);
fmpq_mul(x, x, y);
fmpq_poly_mul(f, f, g);
fmpq_poly_evaluate_fmpz(y, f, a);
result = (fmpq_equal(x, y));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_print(a), flint_printf("\n\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
fmpz_clear(a);
fmpq_poly_clear(f);
fmpq_poly_clear(g);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("cmpabs....");
fflush(stdout);
flint_randinit(state);
/* compare with fmpz */
{
arf_t x, y;
fmpz_t X, Y;
arf_init(x);
arf_init(y);
fmpz_init(X);
fmpz_init(Y);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
int cmp1, cmp2;
fmpz_randtest(X, state, 1 + n_randint(state, 1000));
switch (n_randint(state, 8))
{
case 0:
fmpz_neg(Y, X);
break;
case 1:
fmpz_set(Y, X);
break;
default:
fmpz_randtest(Y, state, 1 + n_randint(state, 1000));
}
arf_set_fmpz(x, X);
arf_set_fmpz(y, Y);
cmp1 = arf_cmpabs(x, y);
cmp2 = fmpz_cmpabs(X, Y);
cmp2 = (cmp2 > 0) - (cmp2 < 0);
if (cmp1 != cmp2)
{
flint_printf("FAIL\n\n");
flint_printf("x = "); arf_debug(x); flint_printf("\n\n");
flint_printf("y = "); arf_debug(y); flint_printf("\n\n");
flint_printf("X = "); fmpz_print(X); flint_printf("\n\n");
flint_printf("Y = "); fmpz_print(Y); flint_printf("\n\n");
flint_printf("cmp1 = %d, cmp2 = %d\n\n", cmp1, cmp2);
abort();
}
}
arf_clear(x);
arf_clear(y);
fmpz_clear(X);
fmpz_clear(Y);
}
/* compare with mpfr */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
slong bits;
arf_t x, y;
mpfr_t X, Y;
int cmp1, cmp2;
bits = 2 + n_randint(state, 200);
arf_init(x);
arf_init(y);
mpfr_init2(X, bits);
mpfr_init2(Y, bits);
arf_randtest_special(x, state, bits, 10);
arf_randtest_special(y, state, bits, 10);
arf_get_mpfr(X, x, MPFR_RNDN);
arf_get_mpfr(Y, y, MPFR_RNDN);
mpfr_abs(X, X, MPFR_RNDN);
mpfr_abs(Y, Y, MPFR_RNDN);
cmp1 = arf_cmpabs(x, y);
cmp2 = mpfr_cmp(X, Y);
if (cmp1 != cmp2)
{
flint_printf("FAIL\n\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = "); arf_print(y); flint_printf("\n\n");
flint_printf("cmp1 = %d, cmp2 = %d\n\n", cmp1, cmp2);
abort();
}
arf_clear(x);
arf_clear(y);
mpfr_clear(X);
mpfr_clear(Y);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("scalar_mul_mpq... ");
fflush(stdout);
flint_randinit(state);
/* Check aliasing of a and b */
for (i = 0; i < 100; i++)
{
fmpz_poly_q_t a, b;
fmpz_t x1, x2;
mpq_t y;
fmpz_poly_q_init(a);
fmpz_poly_q_init(b);
fmpz_init(x1);
fmpz_init(x2);
mpq_init(y);
fmpz_poly_q_randtest(b, state, n_randint(state, 50), 50, n_randint(state, 50), 50);
fmpz_randtest(x1, state, 50);
fmpz_randtest_not_zero(x2, state, 50);
fmpz_get_mpz(mpq_numref(y), x1);
fmpz_get_mpz(mpq_denref(y), x2);
mpq_canonicalize(y);
fmpz_poly_q_scalar_mul_mpq(a, b, y);
fmpz_poly_q_scalar_mul_mpq(b, b, y);
result = fmpz_poly_q_equal(a, b);
if (!result)
{
printf("FAIL:\n");
fmpz_poly_q_print(a), printf("\n\n");
fmpz_poly_q_print(b), printf("\n\n");
abort();
}
fmpz_poly_q_clear(a);
fmpz_poly_q_clear(b);
fmpz_clear(x1);
fmpz_clear(x2);
mpq_clear(y);
}
/* Check that x (a + b) == x * a + x * b */
for (i = 0; i < 100; i++)
{
fmpz_poly_q_t a, b, c, d;
fmpz_t x1, x2;
mpq_t y;
fmpz_poly_q_init(a);
fmpz_poly_q_init(b);
fmpz_poly_q_init(c);
fmpz_poly_q_init(d);
fmpz_init(x1);
fmpz_init(x2);
mpq_init(y);
fmpz_poly_q_randtest(a, state, n_randint(state, 50), 50, n_randint(state, 50), 50);
fmpz_poly_q_randtest(b, state, n_randint(state, 50), 50, n_randint(state, 50), 50);
fmpz_randtest(x1, state, 50);
fmpz_randtest_not_zero(x2, state, 50);
fmpz_get_mpz(mpq_numref(y), x1);
fmpz_get_mpz(mpq_denref(y), x2);
mpq_canonicalize(y);
fmpz_poly_q_scalar_mul_mpq(c, a, y);
fmpz_poly_q_scalar_mul_mpq(d, b, y);
fmpz_poly_q_add(d, c, d);
fmpz_poly_q_add(c, a, b);
fmpz_poly_q_scalar_mul_mpq(c, c, y);
result = fmpz_poly_q_equal(c, d) && fmpz_poly_q_is_canonical(c);
if (!result)
{
printf("FAIL:\n");
printf("a = "), fmpz_poly_q_print(a), printf("\n\n");
printf("b = "), fmpz_poly_q_print(b), printf("\n\n");
printf("c = "), fmpz_poly_q_print(c), printf("\n\n");
printf("d = "), fmpz_poly_q_print(d), printf("\n\n");
gmp_printf("y = %Qd\n\n", y);
abort();
}
fmpz_poly_q_clear(a);
fmpz_poly_q_clear(b);
fmpz_poly_q_clear(c);
fmpz_poly_q_clear(d);
fmpz_clear(x1);
fmpz_clear(x2);
mpq_clear(y);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter, iter2;
flint_rand_t state;
flint_printf("mul_fmpz....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arf_t x, z, v;
fmpz_t y;
slong prec, r1, r2;
arf_rnd_t rnd;
arf_init(x);
arf_init(z);
arf_init(v);
fmpz_init(y);
for (iter2 = 0; iter2 < 100; iter2++)
{
arf_randtest_special(x, state, 2000, 10);
fmpz_randtest(y, state, 2000);
prec = 2 + n_randint(state, 2000);
if (n_randint(state, 10))
prec = ARF_PREC_EXACT;
switch (n_randint(state, 5))
{
case 0: rnd = ARF_RND_DOWN; break;
case 1: rnd = ARF_RND_UP; break;
case 2: rnd = ARF_RND_FLOOR; break;
case 3: rnd = ARF_RND_CEIL; break;
default: rnd = ARF_RND_NEAR; break;
}
switch (n_randint(state, 2))
{
case 0:
r1 = arf_mul_fmpz(z, x, y, prec, rnd);
r2 = arf_mul_fmpz_naive(v, x, y, prec, rnd);
if (!arf_equal(z, v) || r1 != r2)
{
flint_printf("FAIL!\n");
flint_printf("prec = %wd, rnd = %d\n\n", prec, rnd);
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = "); fmpz_print(y); flint_printf("\n\n");
flint_printf("z = "); arf_print(z); flint_printf("\n\n");
flint_printf("v = "); arf_print(v); flint_printf("\n\n");
flint_printf("r1 = %wd, r2 = %wd\n", r1, r2);
flint_abort();
}
break;
default:
r2 = arf_mul_fmpz_naive(v, x, y, prec, rnd);
r1 = arf_mul_fmpz(x, x, y, prec, rnd);
if (!arf_equal(x, v) || r1 != r2)
{
flint_printf("FAIL (aliasing)!\n");
flint_printf("prec = %wd, rnd = %d\n\n", prec, rnd);
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = "); fmpz_print(y); flint_printf("\n\n");
flint_printf("v = "); arf_print(v); flint_printf("\n\n");
flint_printf("r1 = %wd, r2 = %wd\n", r1, r2);
flint_abort();
}
break;
}
}
arf_clear(x);
arf_clear(z);
arf_clear(v);
fmpz_clear(y);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("add_inline....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
fmpz_t a, b, c, d;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(d);
fmpz_randtest(a, state, 1 + n_randint(state, 200));
fmpz_randtest(b, state, 1 + n_randint(state, 200));
fmpz_randtest(c, state, 1 + n_randint(state, 200));
fmpz_randtest(d, state, 1 + n_randint(state, 200));
fmpz_add(c, a, b);
fmpz_add_inline(d, a, b);
if (!fmpz_equal(c, d))
{
flint_printf("FAIL\n");
fmpz_print(a); flint_printf("\n\n");
fmpz_print(b); flint_printf("\n\n");
fmpz_print(c); flint_printf("\n\n");
fmpz_print(d); flint_printf("\n\n");
abort();
}
fmpz_add_inline(a, a, b);
if (!fmpz_equal(c, a))
{
flint_printf("FAIL (aliasing 1)\n");
fmpz_print(a); flint_printf("\n\n");
fmpz_print(b); flint_printf("\n\n");
fmpz_print(c); flint_printf("\n\n");
fmpz_print(d); flint_printf("\n\n");
abort();
}
fmpz_randtest(a, state, 1 + n_randint(state, 200));
fmpz_add(c, a, b);
fmpz_add_inline(b, a, b);
if (!fmpz_equal(c, b))
{
flint_printf("FAIL (aliasing 2)\n");
fmpz_print(a); flint_printf("\n\n");
fmpz_print(b); flint_printf("\n\n");
fmpz_print(c); flint_printf("\n\n");
fmpz_print(d); flint_printf("\n\n");
abort();
}
fmpz_add(d, a, a);
fmpz_add_inline(c, a, a);
if (!fmpz_equal(c, d))
{
flint_printf("FAIL (aliasing 3)\n");
fmpz_print(a); flint_printf("\n\n");
fmpz_print(b); flint_printf("\n\n");
fmpz_print(c); flint_printf("\n\n");
fmpz_print(d); flint_printf("\n\n");
abort();
}
fmpz_add(d, a, a);
fmpz_add_inline(a, a, a);
if (!fmpz_equal(d, a))
{
flint_printf("FAIL (aliasing 4)\n");
fmpz_print(a); flint_printf("\n\n");
fmpz_print(b); flint_printf("\n\n");
fmpz_print(c); flint_printf("\n\n");
fmpz_print(d); flint_printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("evaluate...");
fflush(stdout);
flint_randinit(state);
/* Check aliasing */
for (i = 0; i < 100; i++)
{
int ans1, ans2;
mpq_t a, b;
fmpz_t num, den;
fmpz_poly_q_t f;
mpq_init(a);
mpq_init(b);
fmpz_init(num);
fmpz_init(den);
fmpz_poly_q_init(f);
fmpz_poly_q_randtest(f, state, n_randint(state, 10), 10, n_randint(state, 10), 10);
fmpz_randtest(num, state, 50);
fmpz_randtest_not_zero(den, state, 50);
fmpz_get_mpz(mpq_numref(a), num);
fmpz_get_mpz(mpq_denref(a), den);
mpq_canonicalize(a);
ans1 = fmpz_poly_q_evaluate(b, f, a);
ans2 = fmpz_poly_q_evaluate(a, f, a);
result = (ans1 == ans2) && mpq_equal(a, b);
if (!result)
{
printf("FAIL:\n");
printf("f = "), fmpz_poly_q_print(f), printf("\n");
printf("num = "), fmpz_print(num), printf("\n");
printf("den = "), fmpz_print(den), printf("\n");
gmp_printf("a = %Qd\n", a);
gmp_printf("b = %Qd\n", b);
printf("ans1 = %d\n", ans1);
printf("ans2 = %d\n", ans2);
abort();
}
mpq_clear(a);
mpq_clear(b);
fmpz_clear(num);
fmpz_clear(den);
fmpz_poly_q_clear(f);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("mul_2exp_fmpz....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
fmpr_t x, y, z;
mag_t xb, yb;
fmpz_t e;
fmpr_init(x);
fmpr_init(y);
fmpr_init(z);
fmpz_init(e);
mag_init(xb);
mag_init(yb);
mag_randtest_special(xb, state, 100);
fmpz_randtest(e, state, 100);
mag_get_fmpr(x, xb);
mag_mul_2exp_fmpz(yb, xb, e);
fmpr_mul_2exp_fmpz(y, x, e);
mag_get_fmpr(z, yb);
MAG_CHECK_BITS(yb)
if (!fmpr_equal(z, y))
{
flint_printf("FAIL\n\n");
flint_printf("x = "); fmpr_printd(x, 15); flint_printf("\n\n");
flint_printf("y = "); fmpr_printd(y, 15); flint_printf("\n\n");
flint_printf("z = "); fmpr_printd(z, 15); flint_printf("\n\n");
abort();
}
fmpr_clear(x);
fmpr_clear(y);
fmpr_clear(z);
mag_clear(xb);
mag_clear(yb);
fmpz_clear(e);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("set_round....");
fflush(stdout);
flint_randinit(state);
{
arf_t x, y, z;
arf_init(x);
arf_init(y);
arf_init(z);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
slong bits1, bits2;
int ret1, ret2;
mpfr_t g1, g2;
fmpz_t e;
arf_rnd_t rnd;
bits1 = 1 + n_randint(state, 1000);
bits2 = 2 + n_randint(state, 1000);
if (n_randint(state, 100) == 0)
bits2 = ARF_PREC_EXACT;
switch (n_randint(state, 5))
{
case 0: rnd = ARF_RND_DOWN; break;
case 1: rnd = ARF_RND_UP; break;
case 2: rnd = ARF_RND_FLOOR; break;
case 3: rnd = ARF_RND_CEIL; break;
default: rnd = ARF_RND_NEAR; break;
}
fmpz_init(e);
mpfr_init2(g1, FLINT_MAX(2, bits1));
mpfr_init2(g2, FLINT_MIN(bits2, 10000));
if (n_randint(state, 100) == 0)
{
arf_clear(x); arf_clear(y); arf_clear(z);
arf_init(x); arf_init(y); arf_init(z);
}
/* dirty output variables */
if (n_randint(state, 2))
{
arf_randtest_special(y, state, 1 + n_randint(state, 1000),
1 + n_randint(state, 100));
arf_randtest_special(z, state, 1 + n_randint(state, 1000),
1 + n_randint(state, 100));
}
arf_randtest_special(x, state, bits1, 1 + n_randint(state, 10));
arf_get_mpfr(g1, x, MPFR_RNDD); /* exact */
/* test large exponents */
if (n_randint(state, 4) == 0)
fmpz_randtest(e, state, 1 + n_randint(state, 100));
if (!arf_is_special(x))
fmpz_add(ARF_EXPREF(x), ARF_EXPREF(x), e);
ret1 = arf_set_round(y, x, bits2, rnd);
ret2 = mpfr_set(g2, g1, arf_rnd_to_mpfr(rnd));
arf_set_mpfr(z, g2);
if (!arf_is_special(y))
fmpz_sub(ARF_EXPREF(y), ARF_EXPREF(y), e);
if (!arf_equal(y, z) || ((ret1 == ARF_RESULT_EXACT) != (ret2 == 0)))
{
flint_printf("FAIL\n\n");
flint_printf("bits1: %wd\n", bits1);
flint_printf("bits2: %wd\n", bits2);
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = "); arf_print(y); flint_printf("\n\n");
flint_printf("z = "); arf_print(z); flint_printf("\n\n");
flint_printf("ret1 = %d, ret2 = %d\n\n", ret1, ret2);
flint_abort();
}
if (!arf_is_special(x))
fmpz_add(ARF_EXPREF(x), ARF_EXPREF(x), e);
ret1 = arf_set_round(y, x, bits2, rnd);
arf_set(z, x);
ret2 = arf_set_round(z, z, bits2, rnd);
if (!arf_equal(y, z) || ret1 != ret2)
{
flint_printf("FAIL (aliasing)\n\n");
flint_printf("bits1: %wd\n", bits1);
flint_printf("bits2: %wd\n", bits2);
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = "); arf_print(y); flint_printf("\n\n");
flint_printf("z = "); arf_print(z); flint_printf("\n\n");
flint_printf("ret1 = %d, ret2 = %d\n\n", ret1, ret2);
flint_abort();
}
mpfr_clear(g1);
mpfr_clear(g2);
fmpz_clear(e);
}
arf_clear(x);
arf_clear(y);
arf_clear(z);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("set_round_ui_2exp_fmpz....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
long prec, ret1, ret2;
fmpz_t man, exp;
fmpr_t x, y;
mp_limb_t lo;
fmpr_rnd_t rnd;
int negative;
fmpz_init(man);
fmpz_init(exp);
fmpr_init(x);
fmpr_init(y);
prec = 2 + n_randint(state, 1000);
if (n_randint(state, 10) == 0)
prec = FMPR_PREC_EXACT;
negative = n_randint(state, 2);
lo = n_randtest(state);
fmpz_randtest(exp, state, 1 + n_randint(state, 100));
if (negative)
fmpz_neg_ui(man, lo);
else
fmpz_set_ui(man, lo);
switch (n_randint(state, 4))
{
case 0: rnd = FMPR_RND_DOWN; break;
case 1: rnd = FMPR_RND_UP; break;
case 2: rnd = FMPR_RND_FLOOR; break;
default: rnd = FMPR_RND_CEIL; break;
}
ret1 = fmpr_set_round_ui_2exp_fmpz(x, lo, exp, negative, prec, rnd);
fmpr_set_fmpz_2exp(y, man, exp);
ret2 = fmpr_set_round(y, y, prec, rnd);
if (!fmpr_equal(x, y) || ret1 != ret2 ||
!fmpr_check_ulp(x, ret1, prec) || !fmpr_check_ulp(y, ret2, prec))
{
printf("FAIL\n\n");
printf("prec: %ld\n", prec);
printf("man = "); fmpz_print(man); printf("\n\n");
printf("exp = "); fmpz_print(exp); printf("\n\n");
printf("x = "); fmpr_print(x); printf("\n\n");
printf("y = "); fmpr_print(y); printf("\n\n");
printf("ret1 = %ld, ret2 = %ld\n\n", ret1, ret2);
abort();
}
fmpz_clear(man);
fmpz_clear(exp);
fmpr_clear(x);
fmpr_clear(y);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("evaluate_fmpq....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing */
for (i = 0; i < 1000; i++)
{
fmpz_t a, b;
fmpq_t x, y;
fmpq_poly_t f;
fmpz_init(a);
fmpz_init(b);
fmpq_init(x);
fmpq_init(y);
fmpq_poly_init(f);
fmpq_poly_randtest(f, state, n_randint(state, 80), 100);
fmpz_randtest(a, state, 80);
fmpz_randtest_not_zero(b, state, 80);
fmpz_set(fmpq_numref(x), a);
fmpz_set(fmpq_denref(x), a);
fmpq_canonicalise(x);
fmpq_poly_evaluate_fmpq(y, f, x);
fmpq_poly_evaluate_fmpq(x, f, x);
result = (fmpq_equal(x, y));
if (!result)
{
printf("FAIL:\n");
fmpz_print(a), printf("\n\n");
fmpz_print(b), printf("\n\n");
fmpq_poly_debug(f), printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpq_clear(x);
fmpq_clear(y);
fmpq_poly_clear(f);
}
/* Check that (f+g)(a) = f(a) + g(a) */
for (i = 0; i < 1000; i++)
{
fmpz_t a, b;
fmpq_t x, y, z;
fmpq_poly_t f, g;
fmpz_init(a);
fmpz_init(b);
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_poly_randtest(f, state, n_randint(state, 80), 100);
fmpq_poly_randtest(g, state, n_randint(state, 80), 100);
fmpz_randtest(a, state, 80);
fmpz_randtest_not_zero(b, state, 80);
fmpz_set(fmpq_numref(x), a);
fmpz_set(fmpq_denref(x), a);
fmpq_canonicalise(x);
fmpq_poly_evaluate_fmpq(y, f, x);
fmpq_poly_evaluate_fmpq(z, g, x);
fmpq_add(y, y, z);
fmpq_poly_add(f, f, g);
fmpq_poly_evaluate_fmpq(z, f, x);
result = (fmpq_equal(y, z));
if (!result)
{
printf("FAIL:\n");
fmpz_print(a), printf("\n\n");
fmpz_print(b), printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
fmpq_poly_clear(f);
fmpq_poly_clear(g);
}
/* Check that (f*g)(a) = f(a) * g(a) */
for (i = 0; i < 1000; i++)
{
fmpz_t a, b;
fmpq_t x, y, z;
fmpq_poly_t f, g;
fmpz_init(a);
fmpz_init(b);
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_poly_randtest(f, state, n_randint(state, 50), 80);
fmpq_poly_randtest(g, state, n_randint(state, 50), 80);
fmpz_randtest(a, state, 80);
fmpz_randtest_not_zero(b, state, 80);
fmpz_set(fmpq_numref(x), a);
fmpz_set(fmpq_denref(x), a);
fmpq_canonicalise(x);
fmpq_poly_evaluate_fmpq(y, f, x);
fmpq_poly_evaluate_fmpq(z, g, x);
fmpq_mul(y, y, z);
fmpq_poly_mul(f, f, g);
fmpq_poly_evaluate_fmpq(z, f, x);
result = (fmpq_equal(y, z));
if (!result)
{
printf("FAIL:\n");
fmpz_print(a), printf("\n\n");
fmpz_print(b), printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
fmpq_poly_clear(f);
fmpq_poly_clear(g);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("scalar_addmul_fmpz....");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c;
fmpz_t x;
fmpz_init(x);
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_randtest(x, state, n_randint(state, 100));
fmpz_poly_randtest(a, state, n_randint(state, 100), 200);
fmpz_poly_set(b, a);
fmpz_poly_set(c, a);
fmpz_poly_scalar_addmul_fmpz(b, a, x);
fmpz_poly_scalar_addmul_fmpz(a, a, x);
result = (fmpz_poly_equal(a, b));
if (!result)
{
flint_printf("FAIL (1):\n");
flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n");
flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n");
flint_printf("c = "), fmpz_poly_print(c), flint_printf("\n\n");
flint_printf("x = "), fmpz_print(x), flint_printf("\n\n");
abort();
}
fmpz_clear(x);
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
/* Check that b += x*a is the same as c = b + x*a */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c;
fmpz_t x;
fmpz_init(x);
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_randtest(x, state, n_randint(state, 100));
fmpz_poly_randtest(a, state, n_randint(state, 100), 200);
fmpz_poly_randtest(b, state, n_randint(state, 100), 200);
fmpz_poly_scalar_mul_fmpz(c, a, x);
fmpz_poly_add(c, b, c);
fmpz_poly_scalar_addmul_fmpz(b, a, x);
result = (fmpz_poly_equal(b, c));
if (!result)
{
flint_printf("FAIL (2):\n");
flint_printf("a = "), fmpz_poly_print(a), flint_printf("\n\n");
flint_printf("b = "), fmpz_poly_print(b), flint_printf("\n\n");
flint_printf("c = "), fmpz_poly_print(c), flint_printf("\n\n");
flint_printf("x = "), fmpz_print(x), flint_printf("\n\n");
abort();
}
fmpz_clear(x);
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
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;
}
