int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("one....");
fflush(stdout);
/* 1 * A == A * 1 == A */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpq_mat_t A, B, C, I;
slong n, bits;
n = n_randint(state, 10);
bits = 1 + n_randint(state, 100);
fmpq_mat_init(A, n, n);
fmpq_mat_init(B, n, n);
fmpq_mat_init(C, n, n);
fmpq_mat_init(I, n, n);
fmpq_mat_randtest(A, state, bits);
fmpq_mat_one(I);
fmpq_mat_mul(B, I, A);
fmpq_mat_mul(C, A, I);
result = fmpq_mat_equal(A, B) && fmpq_mat_equal(A, C);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("A:\n");
fmpq_mat_print(A);
flint_printf("B:\n");
fmpq_mat_print(B);
flint_printf("C:\n");
fmpq_mat_print(C);
flint_printf("I:\n");
fmpq_mat_print(I);
abort();
}
fmpq_mat_clear(A);
fmpq_mat_clear(B);
fmpq_mat_clear(C);
fmpq_mat_clear(I);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
inline void subtractMultipleTo(DMatQQFlint& C,
const DMatQQFlint& A,
const DMatQQFlint& B)
{
DMatQQFlint D(C.ring(), A.numRows(), B.numColumns());
fmpq_mat_mul(D.fmpq_mat(), A.fmpq_mat(), B.fmpq_mat());
fmpq_mat_sub(C.fmpq_mat(), C.fmpq_mat(), D.fmpq_mat());
}
inline void mult(const DMatQQFlint& A,
const DMatQQFlint& B,
DMatQQFlint& result_product)
{
// The A and B on the next line are switched because the memory layout expected
// is the transpose of what we have for DMat.
fmpq_mat_mul(result_product.fmpq_mat(), A.fmpq_mat(), B.fmpq_mat());
}
inline void mult(const DMatQQ& A,
const DMatQQ& B,
DMatQQ& result_product)
{
FlintQQMat A1(A);
FlintQQMat B1(B);
FlintQQMat result1(A.numRows(), B.numColumns());
fmpq_mat_mul(result1.value(), A1.value(), B1.value());
result1.toDMat(result_product);
}
void
_fmpq_mat_randtest_positive_semidefinite(fmpq_mat_t mat, flint_rand_t state, mp_bitcnt_t bits)
{
slong n;
fmpq_mat_t R, RT;
if (!fmpq_mat_is_square(mat)) abort(); /* assert */
n = fmpq_mat_nrows(mat);
fmpq_mat_init(R, n, n);
fmpq_mat_init(RT, n, n);
fmpq_mat_randtest(R, state, bits);
fmpq_mat_transpose(RT, R);
fmpq_mat_mul(mat, R, RT);
fmpq_mat_clear(R);
fmpq_mat_clear(RT);
}
inline void subtractMultipleTo(DMatQQ& C,
const DMatQQ& A,
const DMatQQ& B)
{
FlintQQMat A1(A);
FlintQQMat B1(B);
FlintQQMat C1(C);
FlintQQMat result1(A.numRows(), B.numColumns());
FlintQQMat D1(A.numRows(), B.numColumns());
fmpq_mat_mul(D1.value(), A1.value(), B1.value());
fmpq_mat_sub(C1.value(), C1.value(), D1.value());
C1.toDMat(C);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("mul....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
slong m, n, k, qbits1, qbits2, rbits1, rbits2, rbits3;
fmpq_mat_t A, B, C;
acb_mat_t a, b, c, d;
qbits1 = 2 + n_randint(state, 200);
qbits2 = 2 + n_randint(state, 200);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
rbits3 = 2 + n_randint(state, 200);
m = n_randint(state, 10);
n = n_randint(state, 10);
k = n_randint(state, 10);
fmpq_mat_init(A, m, n);
fmpq_mat_init(B, n, k);
fmpq_mat_init(C, m, k);
acb_mat_init(a, m, n);
acb_mat_init(b, n, k);
acb_mat_init(c, m, k);
acb_mat_init(d, m, k);
fmpq_mat_randtest(A, state, qbits1);
fmpq_mat_randtest(B, state, qbits2);
fmpq_mat_mul(C, A, B);
acb_mat_set_fmpq_mat(a, A, rbits1);
acb_mat_set_fmpq_mat(b, B, rbits2);
acb_mat_mul(c, a, b, rbits3);
if (!acb_mat_contains_fmpq_mat(c, C))
{
flint_printf("FAIL\n\n");
flint_printf("m = %wd, n = %wd, k = %wd, bits3 = %wd\n", m, n, k, rbits3);
flint_printf("A = "); fmpq_mat_print(A); flint_printf("\n\n");
flint_printf("B = "); fmpq_mat_print(B); flint_printf("\n\n");
flint_printf("C = "); fmpq_mat_print(C); flint_printf("\n\n");
flint_printf("a = "); acb_mat_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_mat_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); acb_mat_printd(c, 15); flint_printf("\n\n");
abort();
}
/* test aliasing with a */
if (acb_mat_nrows(a) == acb_mat_nrows(c) &&
acb_mat_ncols(a) == acb_mat_ncols(c))
{
acb_mat_set(d, a);
acb_mat_mul(d, d, b, rbits3);
if (!acb_mat_equal(d, c))
{
flint_printf("FAIL (aliasing 1)\n\n");
abort();
}
}
/* test aliasing with b */
if (acb_mat_nrows(b) == acb_mat_nrows(c) &&
acb_mat_ncols(b) == acb_mat_ncols(c))
{
acb_mat_set(d, b);
acb_mat_mul(d, a, d, rbits3);
if (!acb_mat_equal(d, c))
{
flint_printf("FAIL (aliasing 2)\n\n");
abort();
}
}
fmpq_mat_clear(A);
fmpq_mat_clear(B);
fmpq_mat_clear(C);
acb_mat_clear(a);
acb_mat_clear(b);
acb_mat_clear(c);
acb_mat_clear(d);
}
/* check algebraic properties like associativity and distributivity */
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
slong m, n, k, l;
slong rbits;
acb_mat_t a, b, c, d, ab, ac, bd, cd, s;
rbits = 2 + n_randint(state, 200);
m = n_randint(state, 10);
n = n_randint(state, 10);
k = n_randint(state, 10);
l = n_randint(state, 10);
_acb_mat_init_randtest(a, m, n, state);
_acb_mat_init_randtest(b, n, k, state);
_acb_mat_init_randtest(c, n, k, state);
_acb_mat_init_randtest(d, k, l, state);
acb_mat_init(ab, m, k);
acb_mat_init(ac, m, k);
acb_mat_init(bd, n, l);
acb_mat_init(cd, n, l);
acb_mat_init(s, n, k);
acb_mat_mul(ab, a, b, rbits);
acb_mat_mul(ac, a, c, rbits);
acb_mat_mul(bd, b, d, rbits);
acb_mat_mul(cd, c, d, rbits);
acb_mat_add(s, b, c, rbits);
/* check associativity of multiplication */
/* (A*B)*D = A*(B*D) */
{
acb_mat_t lhs, rhs;
acb_mat_init(lhs, m, l);
acb_mat_init(rhs, m, l);
acb_mat_mul(lhs, ab, d, rbits);
acb_mat_mul(rhs, a, bd, rbits);
if (!acb_mat_overlaps(lhs, rhs))
{
flint_printf("FAIL\n\n");
flint_printf("m, n, k, l = %wd, %wd, %wd, %wd\n", m, n, k, l);
flint_printf("rbits = %wd\n", rbits);
_acb_mat_nprintd("a", a);
_acb_mat_nprintd("b", b);
_acb_mat_nprintd("d", d);
_acb_mat_nprintd("(a*b)*d", lhs);
_acb_mat_nprintd("a*(b*d)", rhs);
abort();
}
acb_mat_clear(lhs);
acb_mat_clear(rhs);
}
/* check left distributivity of multiplication over addition */
/* A*(B + C) = A*B + A*C */
{
acb_mat_t lhs, rhs;
acb_mat_init(lhs, m, k);
acb_mat_init(rhs, m, k);
acb_mat_mul(lhs, a, s, rbits);
acb_mat_add(rhs, ab, ac, rbits);
if (!acb_mat_overlaps(lhs, rhs))
{
flint_printf("FAIL\n\n");
flint_printf("m, n, k, l = %wd, %wd, %wd, %wd\n", m, n, k, l);
flint_printf("rbits = %wd\n", rbits);
_acb_mat_nprintd("a", a);
_acb_mat_nprintd("b", b);
_acb_mat_nprintd("c", c);
_acb_mat_nprintd("a*(b + c)", lhs);
_acb_mat_nprintd("a*b + b*c", rhs);
abort();
}
acb_mat_clear(lhs);
acb_mat_clear(rhs);
}
/* check right distributivity of multiplication over addition */
/* (B + C)*D = B*D + C*D */
{
acb_mat_t lhs, rhs;
acb_mat_init(lhs, n, l);
acb_mat_init(rhs, n, l);
acb_mat_mul(lhs, s, d, rbits);
acb_mat_add(rhs, bd, cd, rbits);
if (!acb_mat_overlaps(lhs, rhs))
{
flint_printf("FAIL\n\n");
flint_printf("m, n, k, l = %wd, %wd, %wd, %wd\n", m, n, k, l);
flint_printf("rbits = %wd\n", rbits);
_acb_mat_nprintd("b", b);
_acb_mat_nprintd("c", c);
_acb_mat_nprintd("d", d);
_acb_mat_nprintd("(b + c)*d", lhs);
_acb_mat_nprintd("b*d + c*d", rhs);
abort();
}
acb_mat_clear(lhs);
acb_mat_clear(rhs);
}
/* check left multiplicative identity I*D = D */
{
acb_mat_t one, lhs;
acb_mat_init(one, k, k);
acb_mat_init(lhs, k, l);
acb_mat_one(one);
acb_mat_mul(lhs, one, d, rbits);
if (!acb_mat_contains(lhs, d))
{
flint_printf("FAIL\n\n");
flint_printf("k = %wd, l = %wd\n", k, l);
flint_printf("rbits = %wd\n", rbits);
_acb_mat_nprintd("identity * d", lhs);
_acb_mat_nprintd("d", d);
abort();
}
acb_mat_clear(one);
acb_mat_clear(lhs);
}
/* check right multiplicative identity A*I = A */
{
acb_mat_t one, lhs;
acb_mat_init(one, n, n);
acb_mat_init(lhs, m, n);
acb_mat_one(one);
acb_mat_mul(lhs, a, one, rbits);
if (!acb_mat_contains(lhs, a))
{
flint_printf("FAIL\n\n");
flint_printf("m = %wd, n = %wd\n", m, n);
flint_printf("rbits = %wd\n", rbits);
_acb_mat_nprintd("a * identity", lhs);
_acb_mat_nprintd("a", a);
abort();
}
acb_mat_clear(one);
acb_mat_clear(lhs);
}
acb_mat_clear(a);
acb_mat_clear(b);
acb_mat_clear(c);
acb_mat_clear(d);
acb_mat_clear(ab);
acb_mat_clear(ac);
acb_mat_clear(bd);
acb_mat_clear(cd);
acb_mat_clear(s);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("mul_threaded....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 5000 * arb_test_multiplier(); iter++)
{
slong m, n, k, qbits1, qbits2, rbits1, rbits2, rbits3;
fmpq_mat_t A, B, C;
acb_mat_t a, b, c, d;
flint_set_num_threads(1 + n_randint(state, 5));
qbits1 = 2 + n_randint(state, 200);
qbits2 = 2 + n_randint(state, 200);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
rbits3 = 2 + n_randint(state, 200);
m = n_randint(state, 10);
n = n_randint(state, 10);
k = n_randint(state, 10);
fmpq_mat_init(A, m, n);
fmpq_mat_init(B, n, k);
fmpq_mat_init(C, m, k);
acb_mat_init(a, m, n);
acb_mat_init(b, n, k);
acb_mat_init(c, m, k);
acb_mat_init(d, m, k);
fmpq_mat_randtest(A, state, qbits1);
fmpq_mat_randtest(B, state, qbits2);
fmpq_mat_mul(C, A, B);
acb_mat_set_fmpq_mat(a, A, rbits1);
acb_mat_set_fmpq_mat(b, B, rbits2);
acb_mat_mul_threaded(c, a, b, rbits3);
if (!acb_mat_contains_fmpq_mat(c, C))
{
flint_printf("FAIL\n\n");
flint_printf("threads = %d, m = %wd, n = %wd, k = %wd, bits3 = %wd\n",
flint_get_num_threads(), m, n, k, rbits3);
flint_printf("A = "); fmpq_mat_print(A); flint_printf("\n\n");
flint_printf("B = "); fmpq_mat_print(B); flint_printf("\n\n");
flint_printf("C = "); fmpq_mat_print(C); flint_printf("\n\n");
flint_printf("a = "); acb_mat_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_mat_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); acb_mat_printd(c, 15); flint_printf("\n\n");
flint_abort();
}
/* test aliasing with a */
if (acb_mat_nrows(a) == acb_mat_nrows(c) &&
acb_mat_ncols(a) == acb_mat_ncols(c))
{
acb_mat_set(d, a);
acb_mat_mul_threaded(d, d, b, rbits3);
if (!acb_mat_equal(d, c))
{
flint_printf("FAIL (aliasing 1)\n\n");
flint_abort();
}
}
/* test aliasing with b */
if (acb_mat_nrows(b) == acb_mat_nrows(c) &&
acb_mat_ncols(b) == acb_mat_ncols(c))
{
acb_mat_set(d, b);
acb_mat_mul_threaded(d, a, d, rbits3);
if (!acb_mat_equal(d, c))
{
flint_printf("FAIL (aliasing 2)\n\n");
flint_abort();
}
}
fmpq_mat_clear(A);
fmpq_mat_clear(B);
fmpq_mat_clear(C);
acb_mat_clear(a);
acb_mat_clear(b);
acb_mat_clear(c);
acb_mat_clear(d);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sqr....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
slong n, qbits1, rbits1, rbits2;
fmpq_mat_t A, B;
acb_mat_t a, b, c;
qbits1 = 2 + n_randint(state, 200);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
n = n_randint(state, 10);
fmpq_mat_init(A, n, n);
fmpq_mat_init(B, n, n);
acb_mat_init(a, n, n);
acb_mat_init(b, n, n);
acb_mat_init(c, n, n);
fmpq_mat_randtest(A, state, qbits1);
fmpq_mat_mul(B, A, A);
acb_mat_set_fmpq_mat(a, A, rbits1);
acb_mat_sqr(b, a, rbits2);
if (!acb_mat_contains_fmpq_mat(b, B))
{
flint_printf("FAIL\n\n");
flint_printf("n = %wd, bits2 = %wd\n", n, rbits2);
flint_printf("A = "); fmpq_mat_print(A); flint_printf("\n\n");
flint_printf("B = "); fmpq_mat_print(B); flint_printf("\n\n");
flint_printf("a = "); acb_mat_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_mat_printd(b, 15); flint_printf("\n\n");
abort();
}
/* test aliasing */
acb_mat_set(c, a);
acb_mat_sqr(c, c, rbits2);
if (!acb_mat_equal(c, b))
{
flint_printf("FAIL (aliasing)\n\n");
abort();
}
fmpq_mat_clear(A);
fmpq_mat_clear(B);
acb_mat_clear(a);
acb_mat_clear(b);
acb_mat_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("solve_dixon....");
fflush(stdout);
/* Solve nonsingular systems */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpq_mat_t A, B, X, AX;
fmpq_t d;
int success;
slong n, m, bits;
n = n_randint(state, 10);
m = n_randint(state, 10);
bits = 1 + n_randint(state, 100);
fmpq_mat_init(A, n, n);
fmpq_mat_init(B, n, m);
fmpq_mat_init(X, n, m);
fmpq_mat_init(AX, n, m);
fmpq_init(d);
/* XXX: replace with a randtest function */
do {
fmpq_mat_randtest(A, state, bits);
fmpq_mat_det(d, A);
} while (fmpq_is_zero(d));
fmpq_clear(d);
fmpq_mat_randtest(B, state, bits);
success = fmpq_mat_solve_dixon(X, A, B);
fmpq_mat_mul(AX, A, X);
if (!fmpq_mat_equal(AX, B) || !success)
{
flint_printf("FAIL!\n");
flint_printf("success: %d\n", success);
flint_printf("A:\n");
fmpq_mat_print(A);
flint_printf("B:\n");
fmpq_mat_print(B);
flint_printf("X:\n");
fmpq_mat_print(X);
flint_printf("AX:\n");
fmpq_mat_print(AX);
abort();
}
fmpq_mat_clear(A);
fmpq_mat_clear(B);
fmpq_mat_clear(X);
fmpq_mat_clear(AX);
}
/* Check singular systems */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpq_mat_t A, B, X;
fmpz_mat_t M;
fmpz_t den;
slong n, m, bits;
int success;
n = 1 + n_randint(state, 10);
m = 1 + n_randint(state, 10);
bits = 1 + n_randint(state, 100);
fmpz_init(den);
fmpz_mat_init(M, n, n);
fmpz_mat_randrank(M, state, n_randint(state, n), bits);
if (i % 2)
fmpz_mat_randops(M, state, n_randint(state, 2*m*n + 1));
fmpz_randtest_not_zero(den, state, bits);
fmpq_mat_init(A, n, n);
fmpq_mat_set_fmpz_mat_div_fmpz(A, M, den);
fmpq_mat_init(B, n, m);
fmpq_mat_randtest(B, state, bits);
fmpq_mat_init(X, n, m);
success = fmpq_mat_solve_dixon(X, A, B);
if (success != 0)
{
flint_printf("FAIL!\n");
flint_printf("Expected success = 0\n");
fmpq_mat_print(A);
flint_printf("\n");
abort();
}
fmpq_mat_clear(A);
fmpq_mat_clear(B);
fmpq_mat_clear(X);
fmpz_mat_clear(M);
fmpz_clear(den);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
long i;
flint_rand_t state;
printf("trace....");
fflush(stdout);
flint_randinit(state);
/* Test trace(AB) = trace(BA) */
for (i = 0; i < 1000; i++)
{
fmpq_mat_t A, B, AB, BA;
fmpq_t trab, trba;
long m, n;
m = n_randint(state, 10);
n = n_randint(state, 10);
fmpq_mat_init(A, m, n);
fmpq_mat_init(B, n, m);
fmpq_mat_init(AB, m, m);
fmpq_mat_init(BA, n, n);
fmpq_init(trab);
fmpq_init(trba);
fmpq_mat_randtest(A, state, 1 + n_randint(state, 100));
fmpq_mat_randtest(B, state, 1 + n_randint(state, 100));
fmpq_mat_mul(AB, A, B);
fmpq_mat_mul(BA, B, A);
fmpq_mat_trace(trab, AB);
fmpq_mat_trace(trba, BA);
if (!fmpq_equal(trab, trba))
{
printf("FAIL:\n");
fmpq_mat_print(A), printf("\n");
fmpq_mat_print(B), printf("\n");
fmpq_mat_print(AB), printf("\n");
fmpq_mat_print(BA), printf("\n");
printf("tr(AB): "), fmpq_print(trab), printf("\n");
printf("tr(BA): "), fmpq_print(trba), printf("\n");
abort();
}
fmpq_mat_clear(A);
fmpq_mat_clear(B);
fmpq_mat_clear(AB);
fmpq_mat_clear(BA);
fmpq_clear(trab);
fmpq_clear(trba);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
