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;
flint_rand_t state;
printf("set_entry\n");
printf("---------\n");
fflush(stdout);
_randinit(state);
/* Run a single example */
{
ctx_t ctx;
mat_coo_t A;
long x;
ctx_init_long(ctx);
/*
[ 0 -4 1 ]
[ 0 0 1 0 ]
[ 2 0 0 -3 ]
[ 0 1 0 0 ]
*/
mat_coo_init(A, 4, 4, ctx);
x = -4;
mat_coo_set_entry(A, 0, 1, &x, ctx);
x = 1;
mat_coo_set_entry(A, 0, 3, &x, ctx);
x = 1;
mat_coo_set_entry(A, 1, 2, &x, ctx);
x = 2;
mat_coo_set_entry(A, 2, 0, &x, ctx);
x = -3;
mat_coo_set_entry(A, 2, 3, &x, ctx);
x = 1;
mat_coo_set_entry(A, 3, 1, &x, ctx);
printf("Matrix A (debug):\n");
mat_coo_debug(A, ctx);
printf("\n");
printf("Matrix A (dense):\n");
mat_coo_print_dense(A, ctx);
printf("\n");
mat_coo_clear(A, 1, ctx);
ctx_clear(ctx);
}
printf("... ");
/* Unmanaged type (long) */
for (i = 0; i < 1000; i++)
{
long m, n, z;
double d;
ctx_t ctx;
mat_coo_t A;
m = n_randint(state, 100) + 1;
n = n_randint(state, 100) + 1;
d = (double) n_randint(state, 101) / (double) 100;
ctx_init_long(ctx);
mat_coo_init(A, m, n, ctx);
mat_coo_randtest(A, state, d, ctx);
for (z = 0; z < 10; z++)
{
long row, col;
long x;
row = n_randint(state, m);
col = n_randint(state, n);
x = z_randtest_not_zero(state);
mat_coo_set_entry(A, row, col, &x, ctx);
}
mat_coo_clear(A, 1, ctx);
ctx_clear(ctx);
}
/* Managed type (mpq_t) */
for (i = 0; i < 1000; i++)
{
long m, n, z;
double d;
ctx_t ctx;
mat_coo_t A;
m = n_randint(state, 100) + 1;
n = n_randint(state, 100) + 1;
d = (double) n_randint(state, 101) / (double) 100;
ctx_init_mpq(ctx);
mat_coo_init(A, m, n, ctx);
mat_coo_randtest(A, state, d, ctx);
for (z = 0; z < 10; z++)
{
long row, col;
mpq_t x;
row = n_randint(state, m);
col = n_randint(state, n);
mpq_init(x);
ctx->randtest_not_zero(ctx, x, state);
mat_coo_set_entry(A, row, col, &x, ctx);
mpq_clear(x);
}
mat_coo_clear(A, 1, ctx);
ctx_clear(ctx);
}
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("scalar_div_si... ");
fflush(stdout);
flint_randinit(state);
/* Check aliasing of a and b */
for (i = 0; i < 100; i++)
{
fmpz_poly_q_t a, b;
long x;
fmpz_poly_q_init(a);
fmpz_poly_q_init(b);
fmpz_poly_q_randtest(b, state, n_randint(state, 50), 50, n_randint(state, 50), 50);
x = z_randtest_not_zero(state);
fmpz_poly_q_scalar_div_si(a, b, x);
fmpz_poly_q_scalar_div_si(b, b, x);
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);
}
/* Check that (a + b) / x == a / x + b / x */
for (i = 0; i < 100; i++)
{
fmpz_poly_q_t a, b, c, d;
long x;
fmpz_poly_q_init(a);
fmpz_poly_q_init(b);
fmpz_poly_q_init(c);
fmpz_poly_q_init(d);
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);
x = z_randtest_not_zero(state);
fmpz_poly_q_scalar_div_si(c, a, x);
fmpz_poly_q_scalar_div_si(d, b, x);
fmpz_poly_q_add(d, c, d);
fmpz_poly_q_add(c, a, b);
fmpz_poly_q_scalar_div_si(c, c, x);
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");
printf("x = %ld\n\n", x);
abort();
}
fmpz_poly_q_clear(a);
fmpz_poly_q_clear(b);
fmpz_poly_q_clear(c);
fmpz_poly_q_clear(d);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("root....");
fflush(stdout);
flint_randinit(state);
/* check (a^(1/m))^m = a */
for (iter = 0; iter < 10000; iter++)
{
fmpcb_t a, b, c;
long prec;
ulong m, index;
fmpcb_init(a);
fmpcb_init(b);
fmpcb_init(c);
m = z_randtest_not_zero(state);
index = z_randtest(state);
fmpcb_randtest(a, state, 1 + n_randint(state, 2000), 3);
fmpcb_randtest(b, state, 1 + n_randint(state, 2000), 3);
prec = 2 + n_randint(state, 2000);
fmpcb_root(b, a, m, index, prec);
fmpcb_pow_si(c, b, m, prec);
if (!fmpcb_contains(c, a))
{
printf("FAIL: containment\n\n");
printf("m = %ld\n\n", m);
printf("index = %ld\n\n", index);
printf("a = "); fmpcb_print(a); printf("\n\n");
printf("b = "); fmpcb_print(b); printf("\n\n");
printf("c = "); fmpcb_print(c); printf("\n\n");
abort();
}
fmpcb_root(a, a, m, index, prec);
if (!fmpcb_equal(a, b))
{
printf("FAIL: aliasing\n\n");
printf("m = %ld\n\n", m);
printf("index = %ld\n\n", index);
printf("a = "); fmpcb_print(a); printf("\n\n");
printf("b = "); fmpcb_print(b); printf("\n\n");
abort();
}
fmpcb_clear(a);
fmpcb_clear(b);
fmpcb_clear(c);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
ulong cflags = UWORD(0);
FLINT_TEST_INIT(state);
flint_printf("scalar_div_fmpz....");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, b;
fmpz_t n;
fmpz_init(n);
fmpz_randtest_not_zero(n, state, 200);
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_scalar_div_fmpz(b, a, n);
fmpq_poly_scalar_div_fmpz(a, a, n);
cflags |= fmpq_poly_is_canonical(a) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(b) ? 0 : 2;
result = (fmpq_poly_equal(a, b) && !cflags);
if (!result)
{
flint_printf("FAIL (aliasing):\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpq_poly_debug(b), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
fmpz_print(n);
abort();
}
fmpz_clear(n);
fmpq_poly_clear(a);
fmpq_poly_clear(b);
}
/* Compare with fmpq_poly_scalar_mul_si */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, b, c;
fmpz_t n1;
slong n;
n = z_randtest_not_zero(state);
fmpz_init(n1);
fmpz_set_si(n1, n);
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(c);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_scalar_div_fmpz(b, a, n1);
fmpq_poly_scalar_div_si(c, a, n);
cflags |= fmpq_poly_is_canonical(b) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(c) ? 0 : 2;
result = (fmpq_poly_equal(b, c) && !cflags);
if (!result)
{
flint_printf("FAIL (comparison with _si):\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpz_print(n1), flint_printf("\n\n");
fmpq_poly_debug(b), flint_printf("\n\n");
fmpq_poly_debug(c), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpz_clear(n1);
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(c);
}
/* Check that (a / n1) / n2 == a / (n1 * n2) */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, lhs, rhs;
fmpz_t n1, n2, n;
fmpz_init(n1);
fmpz_init(n2);
fmpz_init(n);
fmpz_randtest_not_zero(n1, state, 100);
fmpz_randtest_not_zero(n2, state, 100);
fmpz_mul(n, n1, n2);
fmpq_poly_init(a);
fmpq_poly_init(lhs);
fmpq_poly_init(rhs);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_scalar_div_fmpz(lhs, a, n1);
fmpq_poly_scalar_div_fmpz(lhs, lhs, n2);
fmpq_poly_scalar_div_fmpz(rhs, a, n);
cflags |= fmpq_poly_is_canonical(lhs) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(rhs) ? 0 : 2;
result = (fmpq_poly_equal(lhs, rhs) && !cflags);
if (!result)
{
flint_printf("FAIL (a / n1 / n2):\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpz_print(n1), flint_printf("\n\n");
fmpz_print(n2), flint_printf("\n\n");
fmpz_print(n), flint_printf("\n\n");
fmpq_poly_debug(lhs), flint_printf("\n\n");
fmpq_poly_debug(rhs), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpz_clear(n1);
fmpz_clear(n2);
fmpz_clear(n);
fmpq_poly_clear(a);
fmpq_poly_clear(lhs);
fmpq_poly_clear(rhs);
}
/* Check that (a + b) / n == a/n + b/n */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_poly_t a, b, lhs, rhs;
fmpz_t n;
fmpz_init(n);
fmpz_randtest_not_zero(n, state, 100);
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(lhs);
fmpq_poly_init(rhs);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_randtest(b, state, n_randint(state, 100), 200);
fmpq_poly_scalar_div_fmpz(lhs, a, n);
fmpq_poly_scalar_div_fmpz(rhs, b, n);
fmpq_poly_add(rhs, lhs, rhs);
fmpq_poly_add(lhs, a, b);
fmpq_poly_scalar_div_fmpz(lhs, lhs, n);
cflags |= fmpq_poly_is_canonical(lhs) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(rhs) ? 0 : 2;
result = (fmpq_poly_equal(lhs, rhs) && !cflags);
if (!result)
{
flint_printf("FAIL ((a + b) / n):\n");
fmpq_poly_debug(a), flint_printf("\n\n");
fmpq_poly_debug(b), flint_printf("\n\n");
fmpz_print(n), flint_printf("\n\n");
fmpq_poly_debug(lhs), flint_printf("\n\n");
fmpq_poly_debug(rhs), flint_printf("\n\n");
flint_printf("cflags = %wu\n\n", cflags);
abort();
}
fmpz_clear(n);
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(lhs);
fmpq_poly_clear(rhs);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
