int main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("parity....");
fflush(stdout);
/* check inv(inv(a)) == a */
for (i = 0; i < 10000; i++)
{
slong n, *a, *b, *c;
int ap, bp, cp, ap2, bp2, cp2;
n = n_randint(state, 100);
a = _perm_init(n);
b = _perm_init(n);
c = _perm_init(n);
ap = _perm_randtest(a, n, state);
bp = _perm_randtest(b, n, state);
_perm_compose(c, a, b, n);
cp = ap ^ bp;
ap2 = _perm_parity(a, n);
bp2 = _perm_parity(b, n);
cp2 = _perm_parity(c, n);
if (ap != ap2 || bp != bp2 || cp != cp2)
{
flint_printf("FAIL:\n");
flint_printf("a: "); _perm_print(a, n); flint_printf("\n\n");
flint_printf("b: "); _perm_print(b, n); flint_printf("\n\n");
flint_printf("c: "); _perm_print(c, n); flint_printf("\n\n");
flint_printf("ap = %d\n", ap);
flint_printf("bp = %d\n", bp);
flint_printf("cp = %d\n", cp);
flint_printf("ap2 = %d\n", ap2);
flint_printf("bp2 = %d\n", bp2);
flint_printf("cp2 = %d\n", cp2);
abort();
}
_perm_clear(a);
_perm_clear(b);
_perm_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
nmod_mat_randpermdiag(nmod_mat_t mat, flint_rand_t state,
mp_srcptr diag, long n)
{
int parity;
long i;
long * rows;
long * cols;
rows = _perm_init(mat->r);
cols = _perm_init(mat->c);
parity = _perm_randtest(rows, mat->r, state);
parity ^= _perm_randtest(cols, mat->c, state);
nmod_mat_zero(mat);
for (i = 0; i < n; i++)
nmod_mat_entry(mat, rows[i], cols[i]) = diag[i];
_perm_clear(rows);
_perm_clear(cols);
return parity;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("all_pairs_longest_walk....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
slong m, degree;
bool_mat_t A;
fmpz_mat_t B, C, D;
m = n_randint(state, 50);
bool_mat_init(A, m, m);
fmpz_mat_init(B, m, m);
fmpz_mat_init(C, m, m);
fmpz_mat_init(D, m, m);
bool_mat_randtest(A, state);
degree = bool_mat_all_pairs_longest_walk(B, A);
/* entrywise reasonability */
if (!_is_superficially_ok_entrywise(B))
{
flint_printf("FAIL (entrywise)\n");
bool_mat_print(A); flint_printf("\n");
fmpz_mat_print_pretty(B); flint_printf("\n");
abort();
}
/* nilpotency degree */
{
slong nildegree = bool_mat_nilpotency_degree(A);
if (nildegree != degree + 1)
{
flint_printf("FAIL (nilpotency degree)\n");
bool_mat_print(A); flint_printf("\n");
fmpz_mat_print_pretty(B); flint_printf("\n");
flint_printf("nildegree=%wd degree=%wd\n", nildegree, degree);
abort();
}
}
/* transitive closure */
{
slong i, j;
bool_mat_t U, V;
bool_mat_init(U, m, m);
bool_mat_transitive_closure(U, A);
bool_mat_init(V, m, m);
for (i = 0; i < m; i++)
{
for (j = 0; j < m; j++)
{
slong x = fmpz_get_si(fmpz_mat_entry(B, i, j));
bool_mat_set_entry(V, i, j, (x != -1 && x != 0));
}
}
if (!bool_mat_equal(U, V))
{
flint_printf("FAIL (transitive closure)\n");
bool_mat_print(A); flint_printf("\n");
fmpz_mat_print_pretty(B); flint_printf("\n");
bool_mat_print(U); flint_printf("\n");
bool_mat_print(V); flint_printf("\n");
abort();
}
bool_mat_clear(U);
bool_mat_clear(V);
}
/* test commutativity of all-pairs-longest-walk with permutation */
{
bool_mat_t Ap;
slong *perm;
bool_mat_init(Ap, m, m);
perm = flint_malloc(m * sizeof(slong));
_perm_randtest(perm, m, state);
/* C is the all-pairs-longest-walk of the permutation of A */
_bool_mat_permute(Ap, A, perm);
bool_mat_all_pairs_longest_walk(C, Ap);
/* D is the permutation of the all-pairs-longest-walk of A */
_fmpz_mat_permute(D, B, perm);
if (!fmpz_mat_equal(C, D))
{
flint_printf("FAIL (permutation)\n");
bool_mat_print(A); flint_printf("\n");
fmpz_mat_print_pretty(B); flint_printf("\n");
fmpz_mat_print_pretty(C); flint_printf("\n");
fmpz_mat_print_pretty(D); flint_printf("\n");
abort();
}
flint_free(perm);
bool_mat_clear(Ap);
}
bool_mat_clear(A);
fmpz_mat_clear(B);
fmpz_mat_clear(C);
fmpz_mat_clear(D);
}
/* use powering to check small random examples */
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
slong m;
bool_mat_t A;
fmpz_mat_t B, C;
m = n_randint(state, 10);
bool_mat_init(A, m, m);
fmpz_mat_init(B, m, m);
fmpz_mat_init(C, m, m);
bool_mat_randtest(A, state);
bool_mat_all_pairs_longest_walk(B, A);
_brute_force_all_pairs_longest_walk(C, A);
if (!fmpz_mat_equal(B, C))
{
flint_printf("FAIL (powering)\n");
bool_mat_print(A); flint_printf("\n");
fmpz_mat_print_pretty(B); flint_printf("\n");
fmpz_mat_print_pretty(C); flint_printf("\n");
abort();
}
bool_mat_clear(A);
fmpz_mat_clear(B);
fmpz_mat_clear(C);
}
/* special matrices */
{
slong m;
for (m = 1; m < 100; m++)
{
slong i, j, length;
bool_mat_t A;
fmpz_mat_t B;
bool_mat_init(A, m, m);
fmpz_mat_init(B, m, m);
/* directed path */
{
bool_mat_directed_path(A);
length = bool_mat_all_pairs_longest_walk(B, A);
if (length != m-1)
{
flint_printf("FAIL (directed path)\n");
bool_mat_print(A); flint_printf("\n");
fmpz_mat_print_pretty(B); flint_printf("\n");
flint_printf("m=%wd length=%wd\n", m, length);
abort();
}
for (i = 0; i < m; i++)
{
for (j = 0; j < m; j++)
{
if (fmpz_get_si(fmpz_mat_entry(B, i, j)) !=
FLINT_MAX(-1, j - i))
{
flint_printf("FAIL (directed path)\n");
bool_mat_print(A); flint_printf("\n");
fmpz_mat_print_pretty(B); flint_printf("\n");
abort();
}
}
}
}
/* directed cycle */
{
bool_mat_directed_cycle(A);
length = bool_mat_all_pairs_longest_walk(B, A);
if (length != -2)
{
flint_printf("FAIL (directed cycle)\n");
bool_mat_print(A); flint_printf("\n");
fmpz_mat_print_pretty(B); flint_printf("\n");
flint_printf("m=%wd length=%wd\n", m, length);
abort();
}
for (i = 0; i < m; i++)
{
for (j = 0; j < m; j++)
{
if (fmpz_get_si(fmpz_mat_entry(B, i, j)) != -2)
{
flint_printf("FAIL (directed cycle)\n");
bool_mat_print(A); flint_printf("\n");
fmpz_mat_print_pretty(B); flint_printf("\n");
abort();
}
}
}
}
bool_mat_clear(A);
fmpz_mat_clear(B);
}
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
slong i;
FLINT_TEST_INIT(state);
flint_printf("rref....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
nmod_mat_t A, B, C, D;
mp_limb_t mod;
slong j, k, m, n, rank1, rank2;
slong *perm;
int equal;
mp_limb_t c;
mod = n_randtest_prime(state, 0);
m = n_randint(state, 20);
n = n_randint(state, 20);
perm = _perm_init(2*m);
nmod_mat_init(A, m, n, mod);
nmod_mat_init(D, 2*m, n, mod);
nmod_mat_randtest(A, state);
nmod_mat_init_set(B, A);
nmod_mat_init_set(C, A);
rank1 = nmod_mat_rref(B);
if (!check_rref_form(perm, B, rank1))
{
flint_printf("FAIL (malformed rref)\n");
nmod_mat_print_pretty(A); flint_printf("\n\n");
nmod_mat_print_pretty(B); flint_printf("\n\n");
abort();
}
/* Concatenate the original matrix with the rref, scramble the rows,
and check that the rref is the same */
_perm_randtest(perm, 2 * m, state);
for (j = 0; j < m; j++)
{
do { c = n_randint(state, mod); } while (c == 0);
for (k = 0; k < n; k++)
nmod_mat_entry(D, perm[j], k) =
nmod_mul(nmod_mat_entry(A, j, k), c, A->mod);
}
for (j = 0; j < m; j++)
{
do { c = n_randint(state, mod); } while (c == 0);
for (k = 0; k < n; k++)
nmod_mat_entry(D, perm[m + j], k) =
nmod_mul(nmod_mat_entry(B, j, k), c, A->mod);
}
rank2 = nmod_mat_rref(D);
equal = (rank1 == rank2);
if (equal)
{
for (j = 0; j < rank2; j++)
for (k = 0; k < n; k++)
equal = equal && (nmod_mat_entry(B, j, k) ==
nmod_mat_entry(D, j, k));
for (j = rank2; j < 2 * rank2; j++)
for (k = 0; k < n; k++)
equal = equal && (nmod_mat_entry(D, j, k) == 0);
}
if (!equal)
{
flint_printf("FAIL (rank1 = %wd, rank2 = %wd)!\n", rank1, rank2);
nmod_mat_print_pretty(A); flint_printf("\n\n");
nmod_mat_print_pretty(B); flint_printf("\n\n");
nmod_mat_print_pretty(D); flint_printf("\n\n");
abort();
}
_perm_clear(perm);
nmod_mat_clear(A);
nmod_mat_clear(B);
nmod_mat_clear(C);
nmod_mat_clear(D);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("inv....");
fflush(stdout);
/* check inv(inv(a)) == a */
for (i = 0; i < 10000; i++)
{
slong n, *a, *b, *c;
n = n_randint(state, 100);
a = _perm_init(n);
b = _perm_init(n);
c = _perm_init(n);
_perm_randtest(a, n, state);
_perm_inv(b, a, n);
_perm_inv(c, b, n);
if (!_perm_equal(a, c, n))
{
flint_printf("FAIL:\n");
flint_printf("a: "); _perm_print(a, n); flint_printf("\n\n");
flint_printf("b: "); _perm_print(b, n); flint_printf("\n\n");
flint_printf("c: "); _perm_print(c, n); flint_printf("\n\n");
abort();
}
_perm_clear(a);
_perm_clear(b);
_perm_clear(c);
}
/* check aliasing */
for (i = 0; i < 10000; i++)
{
slong n, *a, *b;
n = n_randint(state, 100);
a = _perm_init(n);
b = _perm_init(n);
_perm_randtest(a, n, state);
_perm_inv(b, a, n);
_perm_inv(a, a, n);
if (!_perm_equal(a, b, n))
{
flint_printf("FAIL:\n");
flint_printf("a: "); _perm_print(a, n); flint_printf("\n\n");
flint_printf("b: "); _perm_print(b, n); flint_printf("\n\n");
abort();
}
_perm_clear(a);
_perm_clear(b);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
