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; }