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()
{
slong iter;
flint_rand_t state;
flint_printf("get_rand_fmpq....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
fmprb_t x;
fmpq_t q;
fmprb_init(x);
fmpq_init(q);
fmprb_randtest(x, state, 1 + n_randint(state, 200), 10);
fmprb_get_rand_fmpq(q, state, x, 1 + n_randint(state, 200));
if (!fmprb_contains_fmpq(x, q) || !fmpq_is_canonical(q))
{
flint_printf("FAIL:\n\n");
flint_printf("x = "); fmprb_print(x); flint_printf("\n\n");
flint_printf("q = "); fmpq_print(q); flint_printf("\n\n");
abort();
}
fmprb_clear(x);
fmpq_clear(q);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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_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;
flint_rand_t state;
flint_randinit(state);
printf("canonicalise....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
fmpq_t x;
fmpz_t mult;
fmpq_init(x);
fmpq_randtest(x, state, 200);
if (!fmpq_is_canonical(x))
{
printf("FAIL: expected fmpq_randtest output to be canonical\n");
fmpq_print(x);
printf("\n");
abort();
}
fmpz_init(mult);
fmpz_randtest_not_zero(mult, state, 200);
fmpz_add_ui(mult, mult, 1UL);
fmpz_mul(&x->num, &x->num, mult);
fmpz_mul(&x->den, &x->den, mult);
if (fmpq_is_canonical(x))
{
printf("FAIL: expected fmpq_is_canonical to detect common factor\n");
fmpq_print(x);
printf("\n");
abort();
}
fmpq_canonicalise(x);
if (!fmpq_is_canonical(x))
{
printf("FAIL: result not canonical after calling fmpq_canonicalise\n");
fmpq_print(x);
printf("\n");
abort();
}
fmpz_neg(&x->den, &x->den);
if (fmpq_is_canonical(x))
{
printf("FAIL: negative denominator reported as being canonical\n");
fmpq_print(x);
printf("\n");
abort();
}
fmpq_canonicalise(x);
if (!fmpq_is_canonical(x))
{
printf("FAIL: result not canonical after calling fmpq_canonicalise\n");
fmpq_print(x);
printf("\n");
abort();
}
fmpz_clear(mult);
fmpq_clear(x);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("submul....");
fflush(stdout);
/* x -= y * z */
for (i = 0; i < 10000; i++)
{
fmpq_t x, y, z;
mpq_t X, Y, Z;
fmpq_init(x);
fmpq_init(y);
fmpq_init(z);
mpq_init(X);
mpq_init(Y);
mpq_init(Z);
fmpq_randtest(x, state, 200);
fmpq_randtest(y, state, 200);
fmpq_randtest(z, state, 200);
fmpq_get_mpq(X, x);
fmpq_get_mpq(Y, y);
fmpq_get_mpq(Z, z);
fmpq_submul(x, y, z);
if (!fmpq_is_canonical(x))
{
flint_printf("FAIL: result not canonical!\n");
abort();
}
mpq_submul(X, Y, Z);
fmpq_get_mpq(Y, x);
if (!mpq_equal(X, Y))
{
flint_printf("FAIL: fmpq_submul(x,y,z) != mpq_submul(X,Y,Z)\n");
flint_printf("x = ");
fmpq_print(x);
flint_printf("\ny = ");
fmpq_print(y);
flint_printf("\nz = ");
fmpq_print(z);
flint_printf("\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(z);
mpq_clear(X);
mpq_clear(Y);
mpq_clear(Z);
}
/* x -= x * y */
for (i = 0; i < 10000; i++)
{
fmpq_t x, y;
mpq_t X, Y;
fmpq_init(x);
fmpq_init(y);
mpq_init(X);
mpq_init(Y);
fmpq_randtest(x, state, 200);
fmpq_randtest(y, state, 200);
fmpq_get_mpq(X, x);
fmpq_get_mpq(Y, y);
fmpq_submul(x, x, y);
if (!fmpq_is_canonical(x))
{
flint_printf("FAIL: result not canonical!\n");
abort();
}
mpq_submul(X, X, Y);
fmpq_get_mpq(Y, x);
if (!mpq_equal(X, Y))
{
flint_printf("FAIL: fmpq_submul(x,x,y) != mpq_submul(X,X,Y)\n");
flint_printf("x = ");
fmpq_print(x);
flint_printf("\ny = ");
fmpq_print(y);
flint_printf("\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
mpq_clear(X);
mpq_clear(Y);
}
/* x -= y * x */
for (i = 0; i < 10000; i++)
{
fmpq_t x, y;
mpq_t X, Y;
fmpq_init(x);
fmpq_init(y);
mpq_init(X);
mpq_init(Y);
fmpq_randtest(x, state, 200);
fmpq_randtest(y, state, 200);
fmpq_get_mpq(X, x);
fmpq_get_mpq(Y, y);
fmpq_submul(x, y, x);
if (!fmpq_is_canonical(x))
{
flint_printf("FAIL: result not canonical!\n");
abort();
}
mpq_submul(X, Y, X);
fmpq_get_mpq(Y, x);
if (!mpq_equal(X, Y))
{
flint_printf("FAIL: fmpq_submul(x,y,x) != mpq_submul(X,Y,X)\n");
flint_printf("x = ");
fmpq_print(x);
flint_printf("\ny = ");
fmpq_print(y);
flint_printf("\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
mpq_clear(X);
mpq_clear(Y);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
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;
}
