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;
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, result;
flint_rand_t state;
printf("block_triangularise\n");
printf("-------------------\n");
fflush(stdout);
_randinit(state);
/* Run a single example, with output(?) */
{
long m, n;
mat_csr_t A;
ctx_t ctx;
long *P, *Q, *B, nz, b;
ctx_init_long(ctx);
m = n = 10;
P = malloc(n * sizeof(long));
Q = malloc(n * sizeof(long));
B = malloc(n * sizeof(long));
mat_csr_init(A, m, n, ctx);
mat_csr_randtest(A, state, 0.3, ctx);
printf("Matrix A:\n");
mat_csr_print_dense(A, ctx);
printf("\n");
nz = mat_csr_zfdiagonal(P, A);
printf("Matrix A:\n");
mat_csr_permute_rows(A, P, ctx);
mat_csr_print_dense(A, ctx);
printf("\n");
b = mat_csr_block_triangularise(Q, B, A, ctx);
printf("Matrix A:\n");
mat_csr_permute_rows(A, Q, ctx);
mat_csr_permute_cols(A, Q, ctx);
mat_csr_print_dense(A, ctx);
printf("\n");
printf("Blocks B:");
_long_vec_print(B, b);
printf("\n");
free(P);
free(Q);
free(B);
mat_csr_clear(A, ctx);
ctx_clear(ctx);
}
printf("... ");
for (i = 0; i < 1000; i++)
{
long m, n;
mat_csr_t A;
ctx_t ctx;
long *P, *Q, *B, nz, b;
ctx_init_long(ctx);
m = n = 100;
P = malloc(n * sizeof(long));
Q = malloc(n * sizeof(long));
B = malloc(n * sizeof(long));
mat_csr_init(A, m, n, ctx);
mat_csr_randtest(A, state, 0.03, ctx);
nz = mat_csr_zfdiagonal(P, A);
mat_csr_permute_rows(A, P, ctx);
b = mat_csr_block_triangularise(Q, B, A, ctx);
mat_csr_permute_rows(A, Q, ctx);
mat_csr_permute_cols(A, Q, ctx);
result = _is_block_triangular(A, B, b);
if (!result)
{
printf("FAIL:\n\n");
abort();
}
free(P);
free(Q);
free(B);
mat_csr_clear(A, ctx);
ctx_clear(ctx);
}
_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;
printf("transpose... ");
fflush(stdout);
_randinit(state);
/* Check aliasing */
/* Unmanaged element type (long) */
for (i = 0; i < 100; i++)
{
long m, n;
ctx_t ctx;
mat_t A, B, C;
m = n_randint(state, 50) + 1;
n = m;
ctx_init_long(ctx);
mat_init(A, m, n, ctx);
mat_init(B, m, n, ctx);
mat_init(C, m, n, ctx);
mat_randtest(A, state, ctx);
mat_set(B, A, ctx);
mat_transpose(C, B, ctx);
mat_transpose(B, B, ctx);
result = mat_equal(B, C, ctx);
if (!result)
{
printf("FAIL:\n\n");
printf("Matrix A\n");
mat_print(A, ctx);
printf("\n");
printf("Matrix B\n");
mat_print(B, ctx);
printf("\n");
printf("Matrix C\n");
mat_print(C, ctx);
printf("\n");
}
mat_clear(A, ctx);
mat_clear(B, ctx);
mat_clear(C, ctx);
ctx_clear(ctx);
}
/* Check that (A^t)^t == A */
/* Unmanaged element type (long) */
for (i = 0; i < 100; i++)
{
long m, n;
ctx_t ctx;
mat_t A, B, C;
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, n, m, ctx);
mat_init(C, m, n, ctx);
mat_randtest(A, state, ctx);
mat_transpose(B, A, ctx);
mat_transpose(C, B, ctx);
result = mat_equal(A, C, ctx);
if (!result)
{
printf("FAIL:\n\n");
printf("Matrix A\n");
mat_print(A, ctx);
printf("\n");
printf("Matrix B\n");
mat_print(B, ctx);
printf("\n");
printf("Matrix C\n");
mat_print(C, ctx);
printf("\n");
}
mat_clear(A, ctx);
mat_clear(B, ctx);
mat_clear(C, ctx);
ctx_clear(ctx);
}
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
