int
main(void)
{
int i;
flint_rand_t state;
printf("init/ clear... ");
fflush(stdout);
_randinit(state);
/* Unmanaged element type (long) */
for (i = 0; i < 100; i++)
{
long m, n;
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);
mat_coo_clear(A, 1, ctx);
ctx_clear(ctx);
}
/* Managed element type (mpq_t) */
for (i = 0; i < 100; i++)
{
long m, n;
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);
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;
ctx_t ctx;
printf("degree... ");
fflush(stdout);
_randinit(state);
ctx_init_mpq(ctx);
/* Check deg(a) + deg(b) == deg(ab) for a, b != 0 */
for (i = 0; i < 1000; i++)
{
mpoly_t a, b, c;
long n, d, N;
n = n_randint(state, MON_MAX_VARS) + 1;
d = n_randint(state, 50) + 1;
N = n_randint(state, 50) + 1;
mpoly_init(a, n, ctx);
mpoly_init(b, n, ctx);
mpoly_init(c, n, ctx);
mpoly_randtest_not_zero(a, state, d, N, ctx);
mpoly_randtest_not_zero(b, state, d, N, ctx);
mpoly_mul(c, a, b, ctx);
result = (mpoly_degree(c, -1, ctx) == mpoly_degree(a, -1, ctx) + mpoly_degree(b, -1, ctx));
if (!result)
{
printf("FAIL:\n");
printf("n d N = %ld %ld %ld\n", n, d, N);
printf("a = "), mpoly_print(a, ctx), printf("\n");
printf("b = "), mpoly_print(b, ctx), printf("\n");
printf("c = "), mpoly_print(c, ctx), printf("\n");
printf("deg(a) = %ld\n", mpoly_degree(a, -1, ctx));
printf("deg(b) = %ld\n", mpoly_degree(b, -1, ctx));
printf("deg(c) = %ld\n", mpoly_degree(c, -1, ctx));
abort();
}
mpoly_clear(a, ctx);
mpoly_clear(b, ctx);
mpoly_clear(c, ctx);
}
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("zero... ");
fflush(stdout);
_randinit(state);
/* Unmanaged element type (long) */
for (i = 0; i < 100; i++)
{
long m, n;
ctx_t ctx;
mat_t A;
m = n_randint(state, 100) + 1;
n = n_randint(state, 100) + 1;
ctx_init_long(ctx);
mat_init(A, m, n, ctx);
mat_randtest(A, state, ctx);
mat_zero(A, ctx);
result = mat_is_zero(A, ctx);
if (!result)
{
printf("FAIL:\n\n");
printf("Matrix A\n");
mat_print(A, ctx);
printf("\n");
abort();
}
mat_clear(A, ctx);
ctx_clear(ctx);
}
/* Managed element type (mpq_t) */
for (i = 0; i < 100; i++)
{
long m, n;
ctx_t ctx;
mat_t A;
m = n_randint(state, 100) + 1;
n = n_randint(state, 100) + 1;
ctx_init_mpq(ctx);
mat_init(A, m, n, ctx);
mat_randtest(A, state, ctx);
mat_zero(A, ctx);
result = mat_is_zero(A, ctx);
if (!result)
{
printf("FAIL:\n\n");
printf("Matrix A\n");
mat_print(A, ctx);
printf("\n");
abort();
}
mat_clear(A, ctx);
ctx_clear(ctx);
}
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
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, j, result;
flint_rand_t state;
ctx_t ctx;
printf("decompose_poly... ");
fflush(stdout);
_randinit(state);
ctx_init_mpq(ctx);
{
mpoly_t P;
mon_t *B;
long *iB, lenB, l, u, k;
long n, d;
printf("\n");
fflush(stdout);
mpoly_init(P, 3, ctx);
mpoly_set_str(P, "3 [3 0 0] [0 3 0] [0 0 3] (2)[1 1 1]", ctx);
n = P->n - 1;
d = mpoly_degree(P, -1, ctx);
gmc_basis_sets(&B, &iB, &lenB, &l, &u, n, d);
printf("P = "), mpoly_print(P, ctx), printf("\n");
printf("n = %ld\n", n);
printf("d = %ld\n", d);
printf("l u = %ld %ld\n", l, u);
printf("B = "), gmc_basis_print(B, iB, lenB, n, d), printf("\n");
for (k = l + 1; k <= u + 1; k++)
{
mat_csr_t mat;
mat_csr_solve_t s;
mon_t *rows, *cols;
long *p;
mpoly_t *A, *D;
p = malloc((n + 2) * sizeof(long));
gmc_init_auxmatrix(mat, &rows, &cols, p, P, k, ctx);
mat_csr_solve_init(s, mat, ctx);
A = malloc((n + 1) * sizeof(mpoly_t));
for (j = 0; j <= n; j++)
mpoly_init(A[j], n + 1, ctx);
D = malloc((n + 1) * sizeof(mpoly_t));
for (j = 0; j <= n; j++)
mpoly_init(D[j], n + 1, ctx);
gmc_derivatives(D, P, ctx);
printf("k = %ld\n", k);
printf("[");
for (i = 0; i < RUNS; i++)
{
mpoly_t poly1, poly2, poly3;
char *zero;
mpoly_init(poly1, n + 1, ctx);
mpoly_init(poly2, n + 1, ctx);
mpoly_init(poly3, n + 1, ctx);
zero = malloc(ctx->size);
ctx->init(ctx, zero);
ctx->zero(ctx, zero);
mpoly_randtest_hom(poly1, state, k * d - (n + 1), 20, ctx);
for (j = iB[k]; j < iB[k + 1]; j++)
mpoly_set_coeff(poly1, B[j], zero, ctx);
gmc_decompose_poly(A, poly1, s, rows, cols, p, ctx);
for (j = 0; j <= n; j++)
mpoly_addmul(poly2, A[j], D[j], ctx);
for (j = iB[k]; j < iB[k + 1]; j++)
mpoly_set_coeff(poly2, B[j], zero, ctx);
if (!mpoly_is_zero(poly1, ctx))
printf("."), fflush(stdout);
result = (mpoly_equal(poly1, poly2, ctx));
if (!result)
{
printf("FAIL:\n\n");
printf("poly1 = "), mpoly_print(poly1, ctx), printf("\n");
printf("poly2 = "), mpoly_print(poly2, ctx), printf("\n");
for (j = 0; j <= n; j++)
printf("D[%d] = ", j), mpoly_print(D[j], ctx), printf("\n");
for (j = 0; j <= n; j++)
printf("A[%d] = ", j), mpoly_print(A[j], ctx), printf("\n");
abort();
}
mpoly_clear(poly1, ctx);
mpoly_clear(poly2, ctx);
mpoly_clear(poly3, ctx);
ctx->clear(ctx, zero);
free(zero);
}
printf("]\n");
mat_csr_clear(mat, ctx);
mat_csr_solve_clear(s, ctx);
free(rows);
free(cols);
free(p);
for (j = 0; j <= n; j++)
mpoly_clear(A[j], ctx);
free(A);
for (j = 0; j <= n; j++)
mpoly_clear(D[j], ctx);
free(D);
}
mpoly_clear(P, ctx);
free(B);
free(iB);
}
ctx_clear(ctx);
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("inv... ");
fflush(stdout);
_randinit(state);
/* Check aliasing */
/* Managed element type (mpq_t) */
for (i = 0; i < 50; i++)
{
long n;
ctx_t ctx;
mat_t A, B, C;
long ansB, ansC;
n = n_randint(state, 20) + 1;
ctx_init_mpq(ctx);
mat_init(A, n, n, ctx);
mat_init(B, n, n, ctx);
mat_init(C, n, n, ctx);
mat_randtest(A, state, ctx);
mat_set(B, A, ctx);
ansC = mat_inv(C, B, ctx);
ansB = mat_inv(B, B, ctx);
result = ((ansB == ansC) && (!ansB || mat_equal(B, C, ctx)));
if (!result)
{
printf("FAIL:\n\n");
printf("A: \n"), mat_print(A, ctx), printf("\n");
printf("B: \n"), mat_print(B, ctx), printf("\n");
printf("C: \n"), mat_print(C, ctx), printf("\n");
printf("ansB = %ld\n", ansB);
printf("ansC = %ld\n", ansC);
}
mat_clear(A, ctx);
mat_clear(B, ctx);
mat_clear(C, ctx);
ctx_clear(ctx);
}
/* Check A * A^{-1} == A^{-1} * A == Id */
/* Managed element type (mpq_t) */
for (i = 0; i < 50; i++)
{
long n;
ctx_t ctx;
mat_t A, B, C, D, I;
long ansB;
n = n_randint(state, 20) + 1;
ctx_init_mpq(ctx);
mat_init(A, n, n, ctx);
mat_init(B, n, n, ctx);
mat_init(C, n, n, ctx);
mat_init(D, n, n, ctx);
mat_init(I, n, n, ctx);
mat_randtest(A, state, ctx);
ansB = mat_inv(B, A, ctx);
if (!ansB)
{
mat_mul(C, A, B, ctx);
mat_mul(D, B, A, ctx);
}
result = (ansB || (mat_equal(C, D, ctx) && mat_is_one(C, ctx)));
if (!result)
{
printf("FAIL:\n\n");
printf("A: \n"), mat_print(A, ctx), printf("\n");
printf("B: \n"), mat_print(B, ctx), printf("\n");
printf("C: \n"), mat_print(C, ctx), printf("\n");
printf("D: \n"), mat_print(D, ctx), printf("\n");
printf("ansB = %ld\n", ansB);
}
mat_clear(A, ctx);
mat_clear(B, ctx);
mat_clear(C, ctx);
mat_clear(D, ctx);
ctx_clear(ctx);
}
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
ctx_t ctx;
printf("add_coeff... ");
fflush(stdout);
_randinit(state);
ctx_init_mpq(ctx);
for (i = 0; i < 1000; i++)
{
mpoly_t a;
long n, d, N;
mon_t m;
char *x, *y, *z;
n = n_randint(state, MON_MAX_VARS) + 1;
d = n_randint(state, 50) + 1;
N = n_randint(state, 50) + 1;
mon_init(m);
mon_randtest(m, state, n, d);
x = malloc(ctx->size);
y = malloc(ctx->size);
z = malloc(ctx->size);
ctx->init(ctx, x);
ctx->init(ctx, y);
ctx->init(ctx, z);
ctx->randtest(ctx, x, state);
mpoly_init(a, n, ctx);
mpoly_randtest(a, state, d, N, ctx);
mpoly_get_coeff(y, a, m, ctx);
ctx->add(ctx, y, y, x);
mpoly_add_coeff(a, m, x, ctx);
mpoly_get_coeff(z, a, m, ctx);
result = (ctx->equal(ctx, y, z));
if (!result)
{
printf("FAIL:\n");
mpoly_print(a, ctx); printf("\n");
ctx->print(ctx, x); printf("\n");
ctx->print(ctx, y); printf("\n");
ctx->print(ctx, z); printf("\n");
abort();
}
mpoly_clear(a, ctx);
mon_clear(m);
ctx->clear(ctx, x);
ctx->clear(ctx, y);
ctx->clear(ctx, z);
free(x);
free(y);
free(z);
}
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
ctx_t ctx;
printf("addmul... ");
fflush(stdout);
_randinit(state);
ctx_init_mpq(ctx);
/* Check aliasing of a and c */
for (i = 0; i < 1000; i++)
{
mpoly_t a, b, c;
long n, d, N;
n = n_randint(state, MON_MAX_VARS) + 1;
d = n_randint(state, 50) + 1;
N = n_randint(state, 50) + 1;
mpoly_init(a, n, ctx);
mpoly_init(b, n, ctx);
mpoly_init(c, n, ctx);
mpoly_randtest(a, state, d, N, ctx);
mpoly_randtest(b, state, d, N, ctx);
mpoly_set(c, a, ctx);
mpoly_addmul(c, a, b, ctx);
mpoly_addmul(a, a, b, ctx);
result = (mpoly_equal(a, c, ctx));
if (!result)
{
printf("FAIL:\n");
mpoly_print(a, ctx); printf("\n");
mpoly_print(b, ctx); printf("\n");
mpoly_print(c, ctx); printf("\n");
abort();
}
mpoly_clear(a, ctx);
mpoly_clear(b, ctx);
mpoly_clear(c, ctx);
}
/* Check aliasing of b and c */
for (i = 0; i < 1000; i++)
{
mpoly_t a, b, c;
long n, d, N;
n = n_randint(state, MON_MAX_VARS) + 1;
d = n_randint(state, 50) + 1;
N = n_randint(state, 50) + 1;
mpoly_init(a, n, ctx);
mpoly_init(b, n, ctx);
mpoly_init(c, n, ctx);
mpoly_randtest(a, state, d, N, ctx);
mpoly_randtest(b, state, d, N, ctx);
mpoly_set(c, b, ctx);
mpoly_addmul(c, a, b, ctx);
mpoly_addmul(b, a, b, ctx);
result = (mpoly_equal(b, c, ctx));
if (!result)
{
printf("FAIL:\n");
mpoly_print(a, ctx); printf("\n");
mpoly_print(b, ctx); printf("\n");
mpoly_print(c, ctx); printf("\n");
abort();
}
mpoly_clear(a, ctx);
mpoly_clear(b, ctx);
mpoly_clear(c, ctx);
}
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
ctx_t ctx;
printf("mul_mon... ");
fflush(stdout);
_randinit(state);
ctx_init_mpq(ctx);
/* Check aliasing of a and b */
for (i = 0; i < 1000; i++)
{
mpoly_t a, b;
mon_t m;
long n, d, N;
n = n_randint(state, MON_MAX_VARS) + 1;
d = n_randint(state, 50) + 1;
N = n_randint(state, 50) + 1;
mon_init(m);
mon_randtest(m, state, n, d);
mpoly_init(a, n, ctx);
mpoly_init(b, n, ctx);
mpoly_randtest(a, state, d, N, ctx);
mpoly_mul_mon(b, a, m, ctx);
mpoly_mul_mon(a, a, m, ctx);
result = (mpoly_equal(a, b, ctx));
if (!result)
{
printf("FAIL:\n");
mpoly_print(a, ctx); printf("\n");
mpoly_print(b, ctx); printf("\n");
mon_print(m, n); printf("\n");
abort();
}
mpoly_clear(a, ctx);
mpoly_clear(b, ctx);
mon_clear(m);
}
/* Check (b*c) + (b*d) = b*(c+d) */
for (i = 0; i < 1000; i++)
{
mpoly_t a1, a2, c1, c2;
mon_t b;
long n, d, N;
n = n_randint(state, MON_MAX_VARS) + 1;
d = n_randint(state, 50) + 1;
N = n_randint(state, 50) + 1;
mon_init(b);
mon_randtest(b, state, n, d);
mpoly_init(a1, n, ctx);
mpoly_init(a2, n, ctx);
mpoly_init(c1, n, ctx);
mpoly_init(c2, n, ctx);
mpoly_randtest(c1, state, d, N, ctx);
mpoly_randtest(c2, state, d, N, ctx);
mpoly_mul_mon(a1, c1, b, ctx);
mpoly_mul_mon(a2, c2, b, ctx);
mpoly_add(a1, a1, a2, ctx);
mpoly_add(c1, c1, c2, ctx);
mpoly_mul_mon(a2, c1, b, ctx);
result = (mpoly_equal(a1, a2, ctx));
if (!result)
{
printf("FAIL:\n");
mpoly_print(a1, ctx); printf("\n");
mpoly_print(a2, ctx); printf("\n");
mon_print(b, n); printf("\n");
mpoly_print(c1, ctx); printf("\n");
mpoly_print(c2, ctx); printf("\n");
abort();
}
mpoly_clear(a1, ctx);
mpoly_clear(a2, ctx);
mpoly_clear(c1, ctx);
mpoly_clear(c2, ctx);
mon_clear(b);
}
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
int c;
__ctx_struct *ctx;
ctx_t *CTX;
printf("mul_vec... ");
fflush(stdout);
_randinit(state);
CTX = malloc(2 * sizeof(ctx_t));
ctx_init_long(CTX[0]);
ctx_init_mpq(CTX[1]);
for (c = 0; c < 2; c++)
{
ctx = CTX[c];
/* A (x1 + x2) == A x1 + A x2 */
for (i = 0; i < 100; i++)
{
mat_csr_t A;
long m, n;
char *x1, *x2, *y, *z;
m = n_randint(state, 100) + 1;
n = n_randint(state, 100) + 1;
mat_csr_init(A, m, n, ctx);
x1 = _vec_init(n, ctx);
x2 = _vec_init(n, ctx);
y = _vec_init(m, ctx);
z = _vec_init(m, ctx);
mat_csr_randtest(A, state, 0.3, ctx);
mat_csr_mul_vec(y, A, x1, ctx);
mat_csr_mul_vec(z, A, x2, ctx);
_vec_add(z, y, z, m, ctx);
_vec_add(x1, x1, x2, n, ctx);
mat_csr_mul_vec(y, A, x1, ctx);
result = _vec_equal(y, z, m, ctx);
if (!result)
{
printf("FAIL:\n\n");
abort();
}
mat_csr_clear(A, ctx);
_vec_clear(x1, n, ctx);
_vec_clear(x2, n, ctx);
_vec_clear(y, m, ctx);
_vec_clear(z, m, ctx);
}
}
ctx_clear(CTX[0]);
ctx_clear(CTX[1]);
free(CTX);
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("add... ");
fflush(stdout);
_randinit(state);
/* Check that addition is abelian */
/* Unmanaged element type (long) */
for (i = 0; i < 100; i++)
{
long m, n;
ctx_t ctx;
mat_t A, B, C, D;
m = n_randint(state, 50) + 1;
n = n_randint(state, 50) + 1;
ctx_init_long(ctx);
mat_init(A, m, n, ctx);
mat_init(B, m, n, ctx);
mat_init(C, m, n, ctx);
mat_init(D, m, n, ctx);
mat_randtest(A, state, ctx);
mat_randtest(B, state, ctx);
mat_add(C, A, B, ctx);
mat_add(D, B, A, ctx);
result = mat_equal(C, D, ctx);
if (!result)
{
printf("FAIL:\n\n");
printf("Matrix A\n");
mat_print(A, ctx);
printf("\n");
printf("Matrix A\n");
mat_print(B, ctx);
printf("\n");
}
mat_clear(A, ctx);
mat_clear(B, ctx);
mat_clear(C, ctx);
mat_clear(D, ctx);
ctx_clear(ctx);
}
/* Managed element type (mpq_t) */
for (i = 0; i < 100; i++)
{
long m, n;
ctx_t ctx;
mat_t A, B, C, D;
m = n_randint(state, 50) + 1;
n = n_randint(state, 50) + 1;
ctx_init_mpq(ctx);
mat_init(A, m, n, ctx);
mat_init(B, m, n, ctx);
mat_init(C, m, n, ctx);
mat_init(D, m, n, ctx);
mat_randtest(A, state, ctx);
mat_randtest(B, state, ctx);
mat_add(C, A, B, ctx);
mat_add(D, B, A, ctx);
result = mat_equal(C, D, ctx);
if (!result)
{
printf("FAIL:\n\n");
printf("Matrix A\n");
mat_print(A, ctx);
printf("\n");
printf("Matrix A\n");
mat_print(B, ctx);
printf("\n");
}
mat_clear(A, ctx);
mat_clear(B, ctx);
mat_clear(C, ctx);
mat_clear(D, ctx);
ctx_clear(ctx);
}
/* Check that the zero matrix does what it's supposed to do */
/* Unmanaged element type (long) */
for (i = 0; i < 100; i++)
{
long m, n;
ctx_t ctx;
mat_t A, B, C, D;
m = n_randint(state, 50) + 1;
n = n_randint(state, 50) + 1;
ctx_init_long(ctx);
mat_init(A, m, n, ctx);
mat_init(B, m, n, ctx);
mat_init(C, m, n, ctx);
mat_init(D, m, n, ctx);
mat_randtest(A, state, ctx);
mat_zero(B, ctx);
mat_add(C, A, B, ctx);
mat_add(D, B, A, ctx);
result = mat_equal(A, C, ctx) && mat_equal(C, D, ctx);
if (!result)
{
printf("FAIL:\n\n");
printf("Matrix A\n");
mat_print(A, ctx);
printf("\n");
printf("Matrix A\n");
mat_print(B, ctx);
printf("\n");
}
mat_clear(A, ctx);
mat_clear(B, ctx);
mat_clear(C, ctx);
mat_clear(D, ctx);
ctx_clear(ctx);
}
/* Managed element type (mpq_t) */
for (i = 0; i < 100; i++)
{
long m, n;
ctx_t ctx;
mat_t A, B, C, D;
m = n_randint(state, 50) + 1;
n = n_randint(state, 50) + 1;
ctx_init_mpq(ctx);
mat_init(A, m, n, ctx);
mat_init(B, m, n, ctx);
mat_init(C, m, n, ctx);
mat_init(D, m, n, ctx);
mat_randtest(A, state, ctx);
mat_zero(B, ctx);
mat_add(C, A, B, ctx);
mat_add(D, B, A, ctx);
result = mat_equal(A, C, ctx) && mat_equal(C, D, ctx);
if (!result)
{
printf("FAIL:\n\n");
printf("Matrix A\n");
mat_print(A, ctx);
printf("\n");
printf("Matrix A\n");
mat_print(B, ctx);
printf("\n");
}
mat_clear(A, ctx);
mat_clear(B, ctx);
mat_clear(C, ctx);
mat_clear(D, ctx);
ctx_clear(ctx);
}
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
ctx_t ctx;
printf("is_zero/ zero... ");
fflush(stdout);
_randinit(state);
ctx_init_mpq(ctx);
for (i = 0; i < 1000; i++)
{
mpoly_t a;
long n, d, N;
n = n_randint(state, MON_MAX_VARS) + 1;
d = n_randint(state, 50) + 1;
N = n_randint(state, 50) + 1;
mpoly_init(a, n, ctx);
mpoly_randtest(a, state, d, N, ctx);
mpoly_zero(a, ctx);
result = (mpoly_is_zero(a, ctx));
if (!result)
{
printf("FAIL:\n");
mpoly_print(a, ctx); printf("\n");
abort();
}
mpoly_clear(a, ctx);
}
for (i = 0; i < 1000; i++)
{
mpoly_t a;
long n, d, N;
n = n_randint(state, MON_MAX_VARS) + 1;
d = n_randint(state, 50) + 1;
N = n_randint(state, 50) + 1;
mpoly_init(a, n, ctx);
mpoly_randtest_not_zero(a, state, d, N, ctx);
result = (!mpoly_is_zero(a, ctx));
if (!result)
{
printf("FAIL:\n");
mpoly_print(a, ctx); printf("\n");
abort();
}
mpoly_clear(a, ctx);
}
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
ctx_t ctx;
printf("scalar_div... ");
fflush(stdout);
_randinit(state);
ctx_init_mpq(ctx);
/* Check aliasing of a and b */
for (i = 0; i < 1000; i++)
{
mpoly_t a, b;
long n, d, N;
char *x;
n = n_randint(state, MON_MAX_VARS) + 1;
d = n_randint(state, 50) + 1;
N = n_randint(state, 50) + 1;
x = malloc(ctx->size);
ctx->init(ctx, x);
mpoly_init(a, n, ctx);
mpoly_init(b, n, ctx);
mpoly_randtest(b, state, d, N, ctx);
ctx->randtest_not_zero(ctx, x, state);
mpoly_scalar_div(a, b, x, ctx);
mpoly_scalar_div(b, b, x, ctx);
result = (mpoly_equal(a, b, ctx));
if (!result)
{
printf("FAIL:\n");
mpoly_print(a, ctx); printf("\n");
mpoly_print(b, ctx); printf("\n");
ctx->print(ctx, x); printf("\n");
abort();
}
mpoly_clear(a, ctx);
mpoly_clear(b, ctx);
ctx->clear(ctx, x);
free(x);
}
/* Check that (a + b) / x == a / x + b / x */
for (i = 0; i < 1000; i++)
{
mpoly_t a, b, c1, c2;
long n, d, N;
char *x;
n = n_randint(state, MON_MAX_VARS) + 1;
d = n_randint(state, 50) + 1;
N = n_randint(state, 50) + 1;
x = malloc(ctx->size);
ctx->init(ctx, x);
mpoly_init(a, n, ctx);
mpoly_init(b, n, ctx);
mpoly_init(c1, n, ctx);
mpoly_init(c2, n, ctx);
mpoly_randtest(a, state, d, N, ctx);
mpoly_randtest(b, state, d, N, ctx);
ctx->randtest_not_zero(ctx, x, state);
mpoly_scalar_div(c1, a, x, ctx);
mpoly_scalar_div(c2, b, x, ctx);
mpoly_add(c2, c1, c2, ctx);
mpoly_add(c1, a, b, ctx);
mpoly_scalar_div(c1, c1, x, ctx);
result = (mpoly_equal(c1, c2, ctx));
if (!result)
{
printf("FAIL:\n");
mpoly_print(a, ctx); printf("\n");
mpoly_print(b, ctx); printf("\n");
mpoly_print(c1, ctx); printf("\n");
mpoly_print(c2, ctx); printf("\n");
ctx->print(ctx, x); printf("\n");
abort();
}
mpoly_clear(a, ctx);
mpoly_clear(b, ctx);
mpoly_clear(c1, ctx);
mpoly_clear(c2, ctx);
ctx->clear(ctx, x);
free(x);
}
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
