void _fmpq_vec_randtest_uniq_sorted(fmpq * vec, flint_rand_t state, slong len, mp_bitcnt_t bits)
{
slong i;
int do_again;
/* if 2^bits < len we are too likely to have collision */
if (4 * n_sizeinbase(len, 2) > bits)
{
fprintf(stderr, "ERROR (_fmpq_vec_randtest_uniq_sorted): bits too small\n");
abort();
}
_fmpq_vec_randtest(vec, state, len, bits);
if (len <= 1) return;
do
{
do_again = 0;
_fmpq_vec_sort(vec, len);
for (i = 0; i < len - 1; i++)
{
if (fmpq_equal(vec + i, vec + i + 1))
{
fmpq_randtest(vec + i, state, bits);
do_again = 1;
}
}
} while (do_again);
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("content....");
fflush(stdout);
flint_randinit(state);
/* Check that content(a f) = abs(a) content(f) */
for (i = 0; i < 10000; i++)
{
fmpq_poly_t f, g;
fmpq_t a, b, c;
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_init(a);
fmpq_init(b);
fmpq_init(c);
fmpq_poly_randtest_not_zero(f, state, n_randint(state, 100) + 1, 100);
fmpq_randtest_not_zero(a, state, 100);
fmpq_poly_scalar_mul_fmpq(g, f, a);
fmpq_poly_content(b, g);
fmpq_poly_content(c, f);
fmpq_mul(c, a, c);
fmpq_abs(c, c);
result = (fmpq_equal(b, c));
if (!result)
{
printf("FAIL:\n");
fmpq_poly_print(f), printf("\n\n");
fmpq_poly_print(g), printf("\n\n");
fmpq_print(a), printf("\n\n");
fmpq_print(b), printf("\n\n");
fmpq_print(c), printf("\n\n");
abort();
}
fmpq_poly_clear(f);
fmpq_poly_clear(g);
fmpq_clear(a);
fmpq_clear(b);
fmpq_clear(c);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("set_si....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
fmpq_t x, y;
fmpz_t p, q;
slong P, Q;
fmpq_init(x);
fmpq_init(y);
fmpz_init(p);
fmpz_init(q);
P = z_randtest(state);
Q = n_randtest_not_zero(state);
fmpz_set_si(p, P);
fmpz_set_ui(q, Q);
fmpq_set_fmpz_frac(x, p, q);
fmpq_set_si(y, P, Q);
if (!fmpq_is_canonical(y) || !fmpq_equal(x, y))
{
flint_printf("FAIL");
flint_printf("p: "); fmpz_print(p); flint_printf("\n");
flint_printf("q: "); fmpz_print(q); flint_printf("\n");
flint_printf("x: "); fmpq_print(x); flint_printf("\n");
flint_printf("y: "); fmpq_print(y); flint_printf("\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
fmpz_clear(p);
fmpz_clear(q);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main()
{
printf("seq_set_fmpq_pow....");
fflush(stdout);
{
long i;
fmpq_t t, u;
fmpz_holonomic_t op;
fmpq_t c, initial;
fmpz_holonomic_init(op);
fmpq_init(t);
fmpq_init(u);
fmpq_init(c);
fmpq_init(initial);
fmpq_set_si(c, -7, 3);
fmpz_holonomic_seq_set_fmpq_pow(op, c);
fmpq_set_si(initial, -2, 1);
for (i = 0; i < 20; i++)
{
fmpz_holonomic_get_nth_fmpq(t, op, initial, 0, i);
fmpz_pow_ui(fmpq_numref(u), fmpq_numref(c), i);
fmpz_pow_ui(fmpq_denref(u), fmpq_denref(c), i);
fmpz_mul_si(fmpq_numref(u), fmpq_numref(u), -2);
if (!fmpq_equal(t, u))
{
printf("FAIL\n");
printf("i = %ld, t = ", i); fmpq_print(t);
printf(" u = "); fmpq_print(u);
printf("\n");
abort();
}
}
fmpq_clear(c);
fmpq_clear(t);
fmpq_clear(u);
fmpq_clear(initial);
fmpz_holonomic_clear(op);
}
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i;
flint_rand_t state;
flint_randinit(state);
printf("set_cfrac....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
fmpq_t x, y, r;
fmpz * c;
long n, bound;
fmpq_init(x);
fmpq_init(y);
fmpq_init(r);
fmpq_randtest(x, state, 1 + n_randint(state, 1000));
bound = fmpq_cfrac_bound(x);
c = _fmpz_vec_init(bound);
n = fmpq_get_cfrac(c, r, x, bound);
fmpq_set_cfrac(y, c, n);
if (!fmpq_equal(x, y))
{
printf("FAIL: x != y\n");
printf("x = "); fmpq_print(x); printf("\n");
printf("y = "); fmpq_print(y); printf("\n");
printf("c = "); _fmpz_vec_print(c, n); printf("\n\n");
abort();
}
_fmpz_vec_clear(c, bound);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(r);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
bool renf_elem_class::operator==(const renf_elem_class & other) const noexcept
{
if (nf != nullptr)
{
if (other.nf != nullptr && *nf == *other.nf)
{
return renf_elem_equal(a, other.a, nf->renf_t());
}
else
{
assert(other.nf == nullptr && "can not compare renf_elem_class from different number fields");
return renf_elem_equal_fmpq(a, other.b, nf->renf_t());
}
}
else if (other.nf == nullptr)
return fmpq_equal(b, other.b);
else
return renf_elem_equal_fmpq(other.a, b, other.nf->renf_t());
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("one....");
fflush(stdout);
/* x == 1 * x */
for (i = 0; i < 10000; i++)
{
fmpq_t x, y, z;
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
fmpq_randtest(x, state, 200);
fmpq_one(y);
fmpq_mul(z, y, x);
result = fmpq_is_canonical(z) && fmpq_equal(x, z);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("x = "), fmpq_print(x), flint_printf("\n");
flint_printf("y = "), fmpq_print(y), flint_printf("\n");
flint_printf("z = "), fmpq_print(z), flint_printf("\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
}
/* x/x == 1 */
for (i = 0; i < 10000; i++)
{
fmpq_t x, y;
fmpq_init(x);
fmpq_init(y);
while (fmpq_is_zero(x))
fmpq_randtest(x, state, 200);
fmpq_div(y, x, x);
result = fmpq_is_canonical(y) && fmpq_is_one(y);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("x = "), fmpq_print(x), flint_printf("\n");
flint_printf("y = "), fmpq_print(y), flint_printf("\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("resultant_div....");
fflush(stdout);
for (i = 0; i < 50; i++)
{
fmpq_poly_t f, g, h, p;
fmpq_t x, y, z, zz;
fmpz_t den;
slong nbits;
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_poly_init(p);
fmpq_poly_init(h);
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
fmpq_init(zz);
fmpz_init(den);
fmpq_poly_randtest(f, state, n_randint(state, 50), 100);
fmpq_poly_randtest(g, state, n_randint(state, 50), 100);
fmpq_poly_randtest(h, state, n_randint(state, 50), 100);
fmpz_set(den, fmpq_poly_denref(f));
fmpq_poly_scalar_mul_fmpz(f, f, den);
fmpz_set(den, fmpq_poly_denref(g));
fmpq_poly_scalar_mul_fmpz(g, g, den);
fmpz_set(den, fmpq_poly_denref(h));
fmpq_poly_scalar_mul_fmpz(h, h, den);
fmpq_poly_mul(p, f, g);
fmpq_poly_resultant(x, f, h);
if (!fmpz_is_one(fmpq_denref(x)))
{
flint_printf("FAIL resultant not integral\n");
flint_printf("f = "), fmpq_poly_print(f), flint_printf("\n\n");
flint_printf("g = "), fmpq_poly_print(g), flint_printf("\n\n");
flint_printf("y = "), fmpq_print(y), flint_printf("\n\n");
abort();
}
fmpq_poly_resultant(y, g, h);
if (!fmpz_is_one(fmpq_denref(y)))
{
flint_printf("FAIL resultant not integral\n");
flint_printf("h = "), fmpq_poly_print(f), flint_printf("\n\n");
flint_printf("g = "), fmpq_poly_print(g), flint_printf("\n\n");
flint_printf("z = "), fmpq_print(y), flint_printf("\n\n");
abort();
}
fmpq_poly_resultant(z, p, h);
if (!fmpz_is_one(fmpq_denref(z)))
{
flint_printf("FAIL resultant not integral\n");
flint_printf("p = "), fmpq_poly_print(f), flint_printf("\n\n");
flint_printf("g = "), fmpq_poly_print(g), flint_printf("\n\n");
flint_printf("y = "), fmpq_print(y), flint_printf("\n\n");
abort();
}
if (fmpq_is_zero(z))
{
fmpq_poly_clear(f);
fmpq_poly_clear(g);
fmpq_poly_clear(h);
fmpq_poly_clear(p);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
fmpq_clear(zz);
fmpz_clear(den);
continue;
}
nbits = (slong)fmpz_bits(fmpq_numref(y)) + 1;
fmpq_poly_resultant_div(z, p, h, fmpq_numref(x), nbits);
fmpq_poly_resultant(zz, p, h);
result = fmpq_equal(z, y);
if (!result)
{
flint_printf("FAIL (res(p, g)/div == res(p, g)/div:\n");
flint_printf("p = "), fmpq_poly_print_pretty(p, "x"), flint_printf("\n\n");
flint_printf("h = "), fmpq_poly_print_pretty(h, "x"), flint_printf("\n\n");
flint_printf("res(p, h) = "), fmpq_print(zz), flint_printf("\n\n");
flint_printf("res(p, h) = "), fmpq_print(x), flint_printf(" * "), fmpq_print(y), flint_printf("\n\n");
flint_printf("supplied divisor = "), fmpq_print(x), flint_printf("\n\n");
flint_printf("nbits = %wu\n\n", nbits);
flint_printf("divisor found = "), fmpq_print(z), flint_printf("\n\n");
flint_printf("correct result = "), fmpq_print(y), flint_printf("\n\n");
abort();
}
fmpq_poly_clear(f);
fmpq_poly_clear(g);
fmpq_poly_clear(h);
fmpq_poly_clear(p);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
fmpq_clear(zz);
fmpz_clear(den);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
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()
{
fmpz * num1;
fmpz * den1;
fmpz_t num2;
fmpz_t den2;
long n, N;
printf("bernoulli_number....");
fflush(stdout);
N = 4000;
num1 = _fmpz_vec_init(N);
den1 = _fmpz_vec_init(N);
fmpz_init(num2);
fmpz_init(den2);
_bernoulli_number_vec_multi_mod(num1, den1, N);
for (n = 0; n < N; n++)
{
_bernoulli_number(num2, den2, n);
if (!fmpz_equal(num1 + n, num2))
{
printf("FAIL: n = %ld, numerator\n", n);
printf("vec: "); fmpz_print(num1 + n); printf("\n");
printf("single: "); fmpz_print(num2); printf("\n");
abort();
}
if (!fmpz_equal(den1 + n, den2))
{
printf("FAIL: n = %ld, denominator\n", n);
printf("vec: "); fmpz_print(den1 + n); printf("\n");
printf("single: "); fmpz_print(den2); printf("\n");
abort();
}
}
/* Check non underscore versions */
do
{
long N = 100;
fmpq * x;
fmpq_t t;
fmpq_init(t);
x = flint_malloc(sizeof(fmpq) * N);
for (n = 0; n < N; n++)
fmpq_init(x + n);
bernoulli_number_vec(x, N);
for (n = 0; n < N; n++)
{
bernoulli_number(t, n);
if (!fmpq_equal(x + n, t))
{
printf("FAIL!: n = %ld\n", n);
abort();
}
}
for (n = 0; n < N; n++)
fmpq_clear(x + n);
flint_free(x);
fmpq_clear(t);
} while (0);
_fmpz_vec_clear(num1, N);
_fmpz_vec_clear(den1, N);
fmpz_clear(num2);
fmpz_clear(den2);
mpfr_free_cache();
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
bool is_equal(const ElementType& f,const ElementType& g) const {return fmpq_equal(&f,&g);}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("reconstruct_fmpz_2....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
int result;
int modresult;
int special_case;
fmpq_t x, y;
fmpz_t mod, res, N, D, t;
mpz_t tmp;
fmpq_init(x);
fmpq_init(y);
fmpz_init(mod);
fmpz_init(res);
fmpz_init(N);
fmpz_init(D);
fmpz_init(t);
mpz_init(tmp);
fmpq_randtest(x, state, 100);
fmpz_abs(N, fmpq_numref(x));
fmpz_set(D, fmpq_denref(x));
/* Randomly generate larger bounds */
if (n_randint(state, 2))
{
fmpz_randtest_not_zero(t, state, 100);
fmpz_abs(t, t);
fmpz_mul(N, N, t);
}
if (n_randint(state, 2))
{
fmpz_randtest_not_zero(t, state, 100);
fmpz_abs(t, t);
fmpz_mul(D, D, t);
}
fmpz_mul(mod, N, D);
fmpz_mul_ui(mod, mod, UWORD(2));
/* Next prime greater than or equal */
fmpz_get_mpz(tmp, mod);
flint_mpz_sub_ui(tmp, tmp, UWORD(1));
mpz_nextprime(tmp, tmp);
fmpz_set_mpz(mod, tmp);
modresult = fmpq_mod_fmpz(res, x, mod);
result = fmpq_reconstruct_fmpz_2(y, res, mod, N, D);
/* Special case: both 1 and -1 have residue 1 mod 2.
There's probably no particular reason to disallow this. */
special_case = (fmpz_cmp_ui(mod, UWORD(2)) == 0 &&
fmpz_get_si(&x->num) == WORD(-1) &&
fmpz_cmp_ui(&x->den, UWORD(1)) == 0);
if (special_case)
{
if (!modresult || !result ||
!fmpz_is_one(&y->num) || !fmpz_is_one(&y->den))
{
flint_printf("FAIL: special case: -1 mod 2\n");
abort();
}
}
else if (!modresult || !result || !fmpq_equal(x, y))
{
flint_printf("FAIL: reconstruction failed\n");
flint_printf("input = ");
fmpq_print(x);
flint_printf("\nmodulus = ");
fmpz_print(mod);
flint_printf("\nresidue = ");
fmpz_print(res);
flint_printf("\nreconstructed = ");
fmpq_print(y);
flint_printf("\nfmpq_mod_fmpz return value = %d", modresult);
flint_printf("\nfmpq_reconstruct_fmpz return value = %d", result);
flint_printf("\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
fmpz_clear(mod);
fmpz_clear(res);
fmpz_clear(N);
fmpz_clear(D);
fmpz_clear(t);
mpz_clear(tmp);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("exp_sum_bs_powtab....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
slong N;
fmpz_t x, T, Q;
fmpq_t S, V;
mp_bitcnt_t Qexp, r;
fmpz_init(x);
fmpz_init(T);
fmpz_init(Q);
fmpq_init(S);
fmpq_init(V);
N = 1 + n_randint(state, 300);
r = n_randint(state, 10);
fmpz_randtest(x, state, 80);
_arb_exp_sum_bs_simple(T, Q, &Qexp, x, r, N);
fmpq_set_fmpz_frac(S, T, Q);
fmpq_div_2exp(S, S, Qexp);
_arb_exp_sum_bs_powtab(T, Q, &Qexp, x, r, N);
fmpq_set_fmpz_frac(V, T, Q);
fmpq_div_2exp(V, V, Qexp);
if (!fmpq_equal(S, V))
{
flint_printf("FAIL\n\n");
flint_printf("N = %wd\n\n", N);
flint_printf("r = %wu\n\n", r);
flint_printf("x = ");
fmpz_print(x);
flint_printf("\n\n");
flint_printf("T = ");
fmpz_print(T);
flint_printf("\n\n");
flint_printf("Q = ");
fmpz_print(T);
flint_printf("\n\n");
flint_printf("V = ");
fmpq_print(V);
flint_printf("\n\n");
flint_printf("S = ");
fmpq_print(S);
flint_printf("\n\n");
abort();
}
fmpz_clear(x);
fmpz_clear(T);
fmpz_clear(Q);
fmpq_clear(S);
fmpq_clear(V);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i;
flint_rand_t state;
flint_randinit(state);
printf("bsplit_sum_abpq....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
fmpq *ab, *pq;
fmpq_t s1, s2, t, pqp;
fmpq_bsplit_t sum;
long k, n;
n = n_randint(state, 40);
ab = _fmpq_vec_init(n);
pq = _fmpq_vec_init(n);
fmpq_init(s1);
fmpq_init(s2);
fmpq_init(pqp);
fmpq_init(t);
for (k = 0; k < n; k++) fmpq_randtest(ab + k, state, 10);
for (k = 0; k < n; k++) fmpq_randtest(pq + k, state, 10);
fmpq_bsplit_init(sum);
fmpq_bsplit_sum_abpq(sum, ab, pq, 0, n);
fmpq_bsplit_get_fmpq(s1, sum);
fmpq_zero(s2);
fmpq_one(pqp);
for (k = 0; k < n; k++)
{
fmpq_mul(pqp, pqp, pq + k);
fmpq_mul(t, pqp, ab + k);
fmpq_add(s2, s2, t);
}
if (!fmpq_is_canonical(s1) || !fmpq_equal(s1, s2))
{
printf("FAIL\n");
printf("(a/b) = ");
for (k = 0; k < n; k++) fmpq_print(ab+k), printf(" ");
printf("\n");
printf("(p/q) = ");
for (k = 0; k < n; k++) fmpq_print(pq+k), printf(" ");
printf("\n");
printf("s1: ");
fmpq_print(s1);
printf("\n");
printf("s2: ");
fmpq_print(s2);
printf("\n");
abort();
}
/* Check numerical evaluation */
{
mpfr_t f1, f2;
mpfr_prec_t prec;
prec = 5 + n_randint(state, 1000);
mpfr_init2(f1, prec);
mpfr_init2(f2, prec);
fmpq_bsplit_get_mpfr(f1, sum);
fmpq_get_mpfr(f2, s1, MPFR_RNDN);
mpfr_sub(f1, f1, f2, MPFR_RNDN);
if (!mpfr_zero_p(f1) &&
!(mpfr_get_exp(f1) <= mpfr_get_exp(f2) - prec + 3))
{
printf("FAIL: numerical evaluation\n");
printf("%ld, %ld, %ld\n", prec, mpfr_get_exp(f1),
mpfr_get_exp(f2) - prec + 3);
abort();
}
mpfr_clear(f1);
mpfr_clear(f2);
}
fmpq_bsplit_clear(sum);
fmpq_clear(s1);
fmpq_clear(s2);
fmpq_clear(pqp);
fmpq_clear(t);
_fmpq_vec_clear(ab, n);
_fmpq_vec_clear(pq, n);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("mul_fmpz....");
fflush(stdout);
/* Aliasing x = x*z */
for (i = 0; i < 10000; i++)
{
fmpq_t x, y;
fmpz_t z;
fmpq_init(x);
fmpq_init(y);
fmpz_init(z);
fmpq_randtest(x, state, 200);
fmpz_randtest(z, state, 200);
fmpq_mul_fmpz(y, x, z);
fmpq_mul_fmpz(x, x, z);
result = (fmpq_is_canonical(x) && fmpq_is_canonical(y) && fmpq_equal(x, y));
if (!result)
{
printf("FAIL (alias):\n");
printf("x = "), fmpq_print(x), printf("\n");
printf("y = "), fmpq_print(y), printf("\n");
printf("z = "), fmpz_print(z), printf("\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
fmpz_clear(z);
}
/* Compare with fmpq_mul */
for (i = 0; i < 10000; i++)
{
fmpq_t x, y, z;
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
fmpq_randtest(x, state, 200);
fmpz_randtest(fmpq_numref(z), state, 200);
fmpq_mul_fmpz(y, x, fmpq_numref(z));
fmpq_mul(x, x, z);
result = (fmpq_is_canonical(x) && fmpq_is_canonical(y) && fmpq_equal(x, y));
if (!result)
{
printf("FAIL (cmp):\n");
printf("x = "), fmpq_print(x), printf("\n");
printf("y = "), fmpq_print(y), printf("\n");
printf("z = "), fmpq_print(z), printf("\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
}
flint_randclear(state);
_fmpz_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(void)
{
long i;
flint_rand_t state;
printf("trace....");
fflush(stdout);
flint_randinit(state);
/* Test trace(AB) = trace(BA) */
for (i = 0; i < 1000; i++)
{
fmpq_mat_t A, B, AB, BA;
fmpq_t trab, trba;
long m, n;
m = n_randint(state, 10);
n = n_randint(state, 10);
fmpq_mat_init(A, m, n);
fmpq_mat_init(B, n, m);
fmpq_mat_init(AB, m, m);
fmpq_mat_init(BA, n, n);
fmpq_init(trab);
fmpq_init(trba);
fmpq_mat_randtest(A, state, 1 + n_randint(state, 100));
fmpq_mat_randtest(B, state, 1 + n_randint(state, 100));
fmpq_mat_mul(AB, A, B);
fmpq_mat_mul(BA, B, A);
fmpq_mat_trace(trab, AB);
fmpq_mat_trace(trba, BA);
if (!fmpq_equal(trab, trba))
{
printf("FAIL:\n");
fmpq_mat_print(A), printf("\n");
fmpq_mat_print(B), printf("\n");
fmpq_mat_print(AB), printf("\n");
fmpq_mat_print(BA), printf("\n");
printf("tr(AB): "), fmpq_print(trab), printf("\n");
printf("tr(BA): "), fmpq_print(trba), printf("\n");
abort();
}
fmpq_mat_clear(A);
fmpq_mat_clear(B);
fmpq_mat_clear(AB);
fmpq_mat_clear(BA);
fmpq_clear(trab);
fmpq_clear(trba);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
