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;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("inv_ldl_precomp....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
fmpq_mat_t Q, Qinv;
arb_mat_t A, Ainv;
slong n, qbits, prec;
int q_invertible, r_invertible, r_invertible2;
n = n_randint(state, 8);
qbits = 1 + n_randint(state, 30);
prec = 2 + n_randint(state, 200);
fmpq_mat_init(Q, n, n);
fmpq_mat_init(Qinv, n, n);
arb_mat_init(A, n, n);
arb_mat_init(Ainv, n, n);
_fmpq_mat_randtest_positive_semidefinite(Q, state, qbits);
q_invertible = fmpq_mat_inv(Qinv, Q);
if (!q_invertible)
{
arb_mat_set_fmpq_mat(A, Q, prec);
r_invertible = _spd_inv(Ainv, A, prec);
if (r_invertible)
{
flint_printf("FAIL: matrix is singular over Q but not over R\n");
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("\n");
flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n");
flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("Ainv = \n"); arb_mat_printd(Ainv, 15); flint_printf("\n\n");
abort();
}
}
else
{
/* now this must converge */
while (1)
{
arb_mat_set_fmpq_mat(A, Q, prec);
r_invertible = _spd_inv(Ainv, A, prec);
if (r_invertible)
{
break;
}
else
{
if (prec > 10000)
{
flint_printf("FAIL: failed to converge at 10000 bits\n");
flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n");
flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n");
abort();
}
prec *= 2;
}
}
if (!arb_mat_contains_fmpq_mat(Ainv, Qinv))
{
flint_printf("FAIL (containment, iter = %wd)\n", iter);
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("\n");
flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n");
flint_printf("Qinv = \n"); fmpq_mat_print(Qinv); flint_printf("\n\n");
flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("Ainv = \n"); arb_mat_printd(Ainv, 15); flint_printf("\n\n");
abort();
}
/* test aliasing */
r_invertible2 = _spd_inv(A, A, prec);
if (!arb_mat_equal(A, Ainv) || r_invertible != r_invertible2)
{
flint_printf("FAIL (aliasing)\n");
flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("Ainv = \n"); arb_mat_printd(Ainv, 15); flint_printf("\n\n");
abort();
}
}
fmpq_mat_clear(Q);
fmpq_mat_clear(Qinv);
arb_mat_clear(A);
arb_mat_clear(Ainv);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("lu....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
fmpq_mat_t Q;
acb_mat_t A, LU, P, L, U, T;
slong i, j, n, qbits, prec, *perm;
int q_invertible, r_invertible;
n = n_randint(state, 8);
qbits = 1 + n_randint(state, 100);
prec = 2 + n_randint(state, 202);
fmpq_mat_init(Q, n, n);
acb_mat_init(A, n, n);
acb_mat_init(LU, n, n);
acb_mat_init(P, n, n);
acb_mat_init(L, n, n);
acb_mat_init(U, n, n);
acb_mat_init(T, n, n);
perm = _perm_init(n);
fmpq_mat_randtest(Q, state, qbits);
q_invertible = fmpq_mat_is_invertible(Q);
if (!q_invertible)
{
acb_mat_set_fmpq_mat(A, Q, prec);
r_invertible = acb_mat_lu(perm, LU, A, prec);
if (r_invertible)
{
flint_printf("FAIL: matrix is singular over Q but not over R\n");
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("\n");
flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n");
flint_printf("A = \n"); acb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("LU = \n"); acb_mat_printd(LU, 15); flint_printf("\n\n");
}
}
else
{
/* now this must converge */
while (1)
{
acb_mat_set_fmpq_mat(A, Q, prec);
r_invertible = acb_mat_lu(perm, LU, A, prec);
if (r_invertible)
{
break;
}
else
{
if (prec > 10000)
{
flint_printf("FAIL: failed to converge at 10000 bits\n");
abort();
}
prec *= 2;
}
}
acb_mat_one(L);
for (i = 0; i < n; i++)
for (j = 0; j < i; j++)
acb_set(acb_mat_entry(L, i, j),
acb_mat_entry(LU, i, j));
for (i = 0; i < n; i++)
for (j = i; j < n; j++)
acb_set(acb_mat_entry(U, i, j),
acb_mat_entry(LU, i, j));
for (i = 0; i < n; i++)
acb_one(acb_mat_entry(P, perm[i], i));
acb_mat_mul(T, P, L, prec);
acb_mat_mul(T, T, U, prec);
if (!acb_mat_contains_fmpq_mat(T, Q))
{
flint_printf("FAIL (containment, iter = %wd)\n", iter);
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("\n");
flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n");
flint_printf("A = \n"); acb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("LU = \n"); acb_mat_printd(LU, 15); flint_printf("\n\n");
flint_printf("L = \n"); acb_mat_printd(L, 15); flint_printf("\n\n");
flint_printf("U = \n"); acb_mat_printd(U, 15); flint_printf("\n\n");
flint_printf("P*L*U = \n"); acb_mat_printd(T, 15); flint_printf("\n\n");
abort();
}
}
fmpq_mat_clear(Q);
acb_mat_clear(A);
acb_mat_clear(LU);
acb_mat_clear(P);
acb_mat_clear(L);
acb_mat_clear(U);
acb_mat_clear(T);
_perm_clear(perm);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("spd_solve....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
fmpq_mat_t Q, QX, QB;
arb_mat_t A, X, B;
slong n, m, qbits, prec;
int q_invertible, r_invertible, r_invertible2;
n = n_randint(state, 8);
m = n_randint(state, 8);
qbits = 1 + n_randint(state, 30);
prec = 2 + n_randint(state, 200);
fmpq_mat_init(Q, n, n);
fmpq_mat_init(QX, n, m);
fmpq_mat_init(QB, n, m);
arb_mat_init(A, n, n);
arb_mat_init(X, n, m);
arb_mat_init(B, n, m);
_fmpq_mat_randtest_positive_semidefinite(Q, state, qbits);
fmpq_mat_randtest(QB, state, qbits);
q_invertible = fmpq_mat_solve_fraction_free(QX, Q, QB);
if (!q_invertible)
{
arb_mat_set_fmpq_mat(A, Q, prec);
r_invertible = arb_mat_spd_solve(X, A, B, prec);
if (r_invertible)
{
flint_printf("FAIL: matrix is singular over Q but not over R\n");
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("\n");
flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n");
flint_printf("QX = \n"); fmpq_mat_print(QX); flint_printf("\n\n");
flint_printf("QB = \n"); fmpq_mat_print(QB); flint_printf("\n\n");
flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n");
abort();
}
}
else
{
/* now this must converge */
while (1)
{
arb_mat_set_fmpq_mat(A, Q, prec);
arb_mat_set_fmpq_mat(B, QB, prec);
r_invertible = arb_mat_spd_solve(X, A, B, prec);
if (r_invertible)
{
break;
}
else
{
if (prec > 10000)
{
flint_printf("FAIL: failed to converge at 10000 bits\n");
flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n");
flint_printf("QX = \n"); fmpq_mat_print(QX); flint_printf("\n\n");
flint_printf("QB = \n"); fmpq_mat_print(QB); flint_printf("\n\n");
flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n");
abort();
}
prec *= 2;
}
}
if (!arb_mat_contains_fmpq_mat(X, QX))
{
flint_printf("FAIL (containment, iter = %wd)\n", iter);
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("\n");
flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n");
flint_printf("QB = \n"); fmpq_mat_print(QB); flint_printf("\n\n");
flint_printf("QX = \n"); fmpq_mat_print(QX); flint_printf("\n\n");
flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("B = \n"); arb_mat_printd(B, 15); flint_printf("\n\n");
flint_printf("X = \n"); arb_mat_printd(X, 15); flint_printf("\n\n");
abort();
}
/* test aliasing */
r_invertible2 = arb_mat_spd_solve(B, A, B, prec);
if (!arb_mat_equal(X, B) || r_invertible != r_invertible2)
{
flint_printf("FAIL (aliasing)\n");
flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("B = \n"); arb_mat_printd(B, 15); flint_printf("\n\n");
flint_printf("X = \n"); arb_mat_printd(X, 15); flint_printf("\n\n");
abort();
}
}
fmpq_mat_clear(Q);
fmpq_mat_clear(QB);
fmpq_mat_clear(QX);
arb_mat_clear(A);
arb_mat_clear(B);
arb_mat_clear(X);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("ldl....");
fflush(stdout);
flint_randinit(state);
/* check special matrices */
{
slong n;
for (n = 1; n < 10; n++)
{
slong lprec;
arb_mat_t L, A;
arb_mat_init(L, n, n);
arb_mat_init(A, n, n);
for (lprec = 2; lprec < 10; lprec++)
{
int result;
slong prec;
prec = 1 << lprec;
/* zero */
arb_mat_zero(A);
result = arb_mat_ldl(L, A, prec);
if (result)
{
flint_printf("FAIL (zero):\n");
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("L = \n"); arb_mat_printd(L, 15);
flint_printf("\n\n");
}
/* negative identity */
arb_mat_one(A);
arb_mat_neg(A, A);
result = arb_mat_ldl(L, A, prec);
if (result)
{
flint_printf("FAIL (negative identity):\n");
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("L = \n"); arb_mat_printd(L, 15);
flint_printf("\n\n");
}
/* identity */
arb_mat_one(A);
result = arb_mat_ldl(L, A, prec);
if (!result || !arb_mat_equal(L, A))
{
flint_printf("FAIL (identity):\n");
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("L = \n"); arb_mat_printd(L, 15);
flint_printf("\n\n");
}
}
arb_mat_clear(L);
arb_mat_clear(A);
}
}
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
fmpq_mat_t Q;
arb_mat_t A, L, D, U, T;
slong n, qbits, prec;
int q_invertible, r_invertible;
n = n_randint(state, 8);
qbits = 1 + n_randint(state, 100);
prec = 2 + n_randint(state, 202);
fmpq_mat_init(Q, n, n);
arb_mat_init(A, n, n);
arb_mat_init(L, n, n);
arb_mat_init(D, n, n);
arb_mat_init(U, n, n);
arb_mat_init(T, n, n);
_fmpq_mat_randtest_positive_semidefinite(Q, state, qbits);
q_invertible = fmpq_mat_is_invertible(Q);
if (!q_invertible)
{
arb_mat_set_fmpq_mat(A, Q, prec);
r_invertible = arb_mat_ldl(L, A, prec);
if (r_invertible)
{
flint_printf("FAIL: matrix is singular over Q but not over R\n");
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("\n");
flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n");
flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("L = \n"); arb_mat_printd(L, 15); flint_printf("\n\n");
}
}
else
{
/* now this must converge */
while (1)
{
arb_mat_set_fmpq_mat(A, Q, prec);
r_invertible = arb_mat_ldl(L, A, prec);
if (r_invertible)
{
break;
}
else
{
if (prec > 10000)
{
flint_printf("FAIL: failed to converge at 10000 bits\n");
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n");
flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n");
abort();
}
prec *= 2;
}
}
/* multiply out the decomposition */
{
slong i;
arb_mat_zero(D);
arb_mat_transpose(U, L);
for (i = 0; i < n; i++)
{
arb_set(arb_mat_entry(D, i, i), arb_mat_entry(L, i, i));
arb_one(arb_mat_entry(L, i, i));
arb_one(arb_mat_entry(U, i, i));
}
arb_mat_mul(T, L, D, prec);
arb_mat_mul(T, T, U, prec);
}
if (!arb_mat_contains_fmpq_mat(T, Q))
{
flint_printf("FAIL (containment, iter = %wd)\n", iter);
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("\n");
flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n");
flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("L = \n"); arb_mat_printd(L, 15); flint_printf("\n\n");
flint_printf("U = \n"); arb_mat_printd(U, 15); flint_printf("\n\n");
flint_printf("L*U = \n"); arb_mat_printd(T, 15); flint_printf("\n\n");
abort();
}
}
fmpq_mat_clear(Q);
arb_mat_clear(A);
arb_mat_clear(L);
arb_mat_clear(D);
arb_mat_clear(U);
arb_mat_clear(T);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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("det....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
fmpq_mat_t Q;
fmpq_t Qdet;
arb_mat_t A;
arb_t Adet;
slong n, qbits, prec;
n = n_randint(state, 8);
qbits = 1 + n_randint(state, 100);
prec = 2 + n_randint(state, 200);
fmpq_mat_init(Q, n, n);
fmpq_init(Qdet);
arb_mat_init(A, n, n);
arb_init(Adet);
fmpq_mat_randtest(Q, state, qbits);
fmpq_mat_det(Qdet, Q);
arb_mat_set_fmpq_mat(A, Q, prec);
arb_mat_det(Adet, A, prec);
if (!arb_contains_fmpq(Adet, Qdet))
{
flint_printf("FAIL (containment, iter = %wd)\n", iter);
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("\n");
flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n");
flint_printf("Qdet = \n"); fmpq_print(Qdet); flint_printf("\n\n");
flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("Adet = \n"); arb_printd(Adet, 15); flint_printf("\n\n");
flint_printf("Adet = \n"); arb_print(Adet); flint_printf("\n\n");
abort();
}
fmpq_mat_clear(Q);
fmpq_clear(Qdet);
arb_mat_clear(A);
arb_clear(Adet);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]) {
if(argc < 2) {
printf("Compute Genz-Keister quadrature rule\n");
printf("Syntax: genzkeister [-dc D] [-dp D] [-pn] [-pw] [-pge] [-pwf] -K K [n1 n2 n3 ...nk]\n");
printf("Options:\n");
printf(" -dc Compute nodes and weights up to this number of decimal digits\n");
printf(" -dp Print this number of decimal digits\n");
printf(" -pn Do not print the nodes\n");
printf(" -pw Do not print the weights\n");
printf(" -pge Print the generators\n");
printf(" -pmo Print the moments\n");
printf(" -pai Print the a_i values\n");
printf(" -pwf Print the weight factors\n");
printf(" -pzs Print the Z-sequence\n");
printf(" -K Set the level of the rule\n");
printf(" Further optional parameters n1 ... nk define the Kronrod extension used\n");
return EXIT_FAILURE;
}
unsigned int K = 1;
int target_prec = 53;
int nrprintdigits = 20;
std::vector<int> levels;
bool print_nodes = true;
bool print_weights = true;
bool print_generators = false;
bool print_moments = false;
bool print_avalues = false;
bool print_weightfactors = false;
bool print_zsequence = false;
for(int i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-dc")) {
/* 'digits' is in base 10 and log(10)/log(2) = 3.32193 */
target_prec = 3.32193 * atoi(argv[i+1]);
i++;
} else if (!strcmp(argv[i], "-dp")) {
nrprintdigits = atoi(argv[i+1]);
i++;
} else if (!strcmp(argv[i], "-pn")) {
print_nodes = false;
} else if (!strcmp(argv[i], "-pw")) {
print_weights = false;
} else if (!strcmp(argv[i], "-pge")) {
print_generators = true;
} else if (!strcmp(argv[i], "-pmo")) {
print_moments = true;
} else if (!strcmp(argv[i], "-pai")) {
print_avalues = true;
} else if (!strcmp(argv[i], "-pwf")) {
print_weightfactors = true;
} else if (!strcmp(argv[i], "-pzs")) {
print_zsequence = true;
} else if (!strcmp(argv[i], "-K")) {
K = atoi(argv[i+1]);
i++;
} else {
levels.push_back(atoi(argv[i]));
}
}
/* Dimension of the quadrature rule */
const unsigned int D = DIMENSION;
// Note K is shifted by 1 wrt the original paper
// This makes K=3 equal to the Gauss Rule of 3 points.
K--;
/* Default rule definition */
if(levels.size() == 0) {
#ifdef LEGENDRE
levels = {1, 2, 4, 8, 16, 32};//, 64};
#endif
#ifdef HERMITEPRO
levels = {1, 2, 6, 10, 16};//, 68};
#endif
#ifdef HERMITE
levels = {1, 2, 6, 10, 16};//, 68};
#endif
#ifdef CHEBYSHEVT
levels = {1, 2, 4, 6, 12, 24};//, 48};
#endif
#ifdef CHEBYSHEVU
levels = {1, 2, 4, 8, 16, 32};//, 64};
#endif
}
std::cout << "Kronrod extension: ";
for(auto it=levels.begin(); it != levels.end(); it++) {
std::cout << *it << " ";
}
std::cout << "\n==================================================" << std::endl;
/* Iteratively compute quadrature nodes and weights */
generators_t G;
tables_t T;
nodes_t<D> nodes;
weights_t weights;
rule_t<D> rule;
for(unsigned int working_prec = target_prec; ; working_prec *= 2) {
std::cout << "--------------------------------------------------\n";
std::cout << "Working precision (bits): " << working_prec << std::endl;
/* Compute data tables */
// TODO: Assert generator g_0 = 0
G = compute_generators(levels, 2*working_prec);
T = compute_tables(G, 2*working_prec);
if(K >= G.size()) {
std::cout << "***********************************\n";
std::cout << "*** not enough generators found ***\n";
std::cout << "***********************************\n";
break;
}
/* Compute a Genz-Keister quadrature rule */
rule = genz_keister_construction<D>(K, G, T, working_prec);
nodes = rule.first;
weights = rule.second;
/* Accuracy goal reached? */
if(check_accuracy<D>(nodes, weights, target_prec)) {
break;
}
}
/* Print nodes and weights */
std::cout << "==================================================\n";
std::cout << "DIMENSION: " << D << std::endl;
std::cout << "LEVEL: " << K+1 << std::endl;
std::cout << "NUMBER NODES: " << nodes.size() << std::endl;
if(print_generators) {
std::cout << "==================================================\n";
std::cout << "GENERATORS" << std::endl;
for(auto it=G.begin(); it != G.end(); it++) {
std::cout << "| ";
arb_printd(&(*it), nrprintdigits);
std::cout << std::endl;
}
}
if(print_moments) {
std::cout << "==================================================\n";
std::cout << "MOMENTS" << std::endl;
moments_t M = std::get<0>(T);
fmpq_mat_print(&M);
std::cout << std::endl;
}
if(print_avalues) {
std::cout << "==================================================\n";
std::cout << "A-VALUES" << std::endl;
ai_t A = std::get<1>(T);
arb_mat_printd(&A, nrprintdigits);
}
if(print_weightfactors) {
std::cout << "==================================================\n";
std::cout << "WEIGHTFACTORS" << std::endl;
wft_t WF = std::get<2>(T);
arb_mat_printd(&WF, nrprintdigits);
}
if(print_zsequence) {
std::cout << "==================================================\n";
std::cout << "Z-SEQUENCE" << std::endl;
z_t Z = std::get<3>(T);
std::cout << "Z = [ ";
for(auto it=Z.begin(); it != Z.end(); it++) {
std::cout << (*it) << " ";
}
std::cout << "]" << std::endl;
}
if(print_nodes) {
std::cout << "==================================================\n";
std::cout << "NODES" << std::endl;
for(auto it=nodes.begin(); it != nodes.end(); it++) {
std::cout << "| ";
for(unsigned int d=0; d < D; d++) {
arb_printd(&((*it)[d]), nrprintdigits);
std::cout << ",\t\t";
}
std::cout << std::endl;
}
}
if(print_weights) {
std::cout << "==================================================\n";
std::cout << "WEIGHTS" << std::endl;
for(auto it=weights.begin(); it != weights.end(); it++) {
std::cout << "| ";
arb_printd(&(*it), nrprintdigits);
std::cout << std::endl;
}
}
std::cout << "==================================================\n";
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("frobenius_norm....");
fflush(stdout);
flint_randinit(state);
/* compare to the exact rational norm */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
fmpq_mat_t Q;
fmpq_t q;
arb_mat_t A;
slong n, qbits, prec;
n = n_randint(state, 8);
qbits = 1 + n_randint(state, 100);
prec = 2 + n_randint(state, 200);
fmpq_mat_init(Q, n, n);
fmpq_init(q);
arb_mat_init(A, n, n);
fmpq_mat_randtest(Q, state, qbits);
_fmpq_mat_sum_of_squares(q, Q);
arb_mat_set_fmpq_mat(A, Q, prec);
/* check that the arb interval contains the exact value */
{
arb_t a;
arb_init(a);
arb_mat_frobenius_norm(a, A, prec);
arb_mul(a, a, a, prec);
if (!arb_contains_fmpq(a, q))
{
flint_printf("FAIL (containment, iter = %wd)\n", iter);
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("\n");
flint_printf("Q = \n");
fmpq_mat_print(Q);
flint_printf("\n\n");
flint_printf("frobenius_norm(Q)^2 = \n");
fmpq_print(q);
flint_printf("\n\n");
flint_printf("A = \n");
arb_mat_printd(A, 15);
flint_printf("\n\n");
flint_printf("frobenius_norm(A)^2 = \n");
arb_printd(a, 15);
flint_printf("\n\n");
flint_printf("frobenius_norm(A)^2 = \n");
arb_print(a);
flint_printf("\n\n");
abort();
}
arb_clear(a);
}
/* check that the upper bound is not less than the exact value */
{
mag_t b;
fmpq_t y;
mag_init(b);
fmpq_init(y);
arb_mat_bound_frobenius_norm(b, A);
mag_mul(b, b, b);
mag_get_fmpq(y, b);
if (fmpq_cmp(q, y) > 0)
{
flint_printf("FAIL (bound, iter = %wd)\n", iter);
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("\n");
flint_printf("Q = \n");
fmpq_mat_print(Q);
flint_printf("\n\n");
flint_printf("frobenius_norm(Q)^2 = \n");
fmpq_print(q);
flint_printf("\n\n");
flint_printf("A = \n");
arb_mat_printd(A, 15);
flint_printf("\n\n");
flint_printf("bound_frobenius_norm(A)^2 = \n");
mag_printd(b, 15);
flint_printf("\n\n");
flint_printf("bound_frobenius_norm(A)^2 = \n");
mag_print(b);
flint_printf("\n\n");
abort();
}
mag_clear(b);
fmpq_clear(y);
}
fmpq_mat_clear(Q);
fmpq_clear(q);
arb_mat_clear(A);
}
/* check trace(A^T A) = frobenius_norm(A)^2 */
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
slong m, n, prec;
arb_mat_t A, AT, ATA;
arb_t t;
prec = 2 + n_randint(state, 200);
m = n_randint(state, 10);
n = n_randint(state, 10);
arb_mat_init(A, m, n);
arb_mat_init(AT, n, m);
arb_mat_init(ATA, n, n);
arb_init(t);
arb_mat_randtest(A, state, 2 + n_randint(state, 100), 10);
arb_mat_transpose(AT, A);
arb_mat_mul(ATA, AT, A, prec);
arb_mat_trace(t, ATA, prec);
arb_sqrt(t, t, prec);
/* check the norm bound */
{
mag_t low, frobenius;
mag_init(low);
arb_get_mag_lower(low, t);
mag_init(frobenius);
arb_mat_bound_frobenius_norm(frobenius, A);
if (mag_cmp(low, frobenius) > 0)
{
flint_printf("FAIL (bound)\n", iter);
flint_printf("m = %wd, n = %wd, prec = %wd\n", m, n, prec);
flint_printf("\n");
flint_printf("A = \n");
arb_mat_printd(A, 15);
flint_printf("\n\n");
flint_printf("lower(sqrt(trace(A^T A))) = \n");
mag_printd(low, 15);
flint_printf("\n\n");
flint_printf("bound_frobenius_norm(A) = \n");
mag_printd(frobenius, 15);
flint_printf("\n\n");
abort();
}
mag_clear(low);
mag_clear(frobenius);
}
/* check the norm interval */
{
arb_t frobenius;
arb_init(frobenius);
arb_mat_frobenius_norm(frobenius, A, prec);
if (!arb_overlaps(t, frobenius))
{
flint_printf("FAIL (overlap)\n", iter);
flint_printf("m = %wd, n = %wd, prec = %wd\n", m, n, prec);
flint_printf("\n");
flint_printf("A = \n");
arb_mat_printd(A, 15);
flint_printf("\n\n");
flint_printf("sqrt(trace(A^T A)) = \n");
arb_printd(t, 15);
flint_printf("\n\n");
flint_printf("frobenius_norm(A) = \n");
arb_printd(frobenius, 15);
flint_printf("\n\n");
abort();
}
arb_clear(frobenius);
}
arb_mat_clear(A);
arb_mat_clear(AT);
arb_mat_clear(ATA);
arb_clear(t);
}
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()
{
long iter;
flint_rand_t state;
printf("det....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
fmpq_mat_t Q;
fmpq_t Qdet;
acb_mat_t A;
acb_t Adet, imagunit;
long n, qbits, prec;
int imaginary;
n = n_randint(state, 8);
qbits = 1 + n_randint(state, 100);
prec = 2 + n_randint(state, 200);
imaginary = n_randint(state, 2);
fmpq_mat_init(Q, n, n);
fmpq_init(Qdet);
acb_mat_init(A, n, n);
acb_init(Adet);
acb_init(imagunit);
fmpq_mat_randtest(Q, state, qbits);
fmpq_mat_det(Qdet, Q);
acb_mat_set_fmpq_mat(A, Q, prec);
if (imaginary)
{
acb_onei(imagunit);
acb_mat_scalar_mul_acb(A, A, imagunit, prec);
}
acb_mat_det(Adet, A, prec);
if (imaginary)
{
acb_onei(imagunit);
acb_inv(imagunit, imagunit, prec);
acb_pow_ui(imagunit, imagunit, n, prec);
acb_mul(Adet, Adet, imagunit, prec);
}
if (!acb_contains_fmpq(Adet, Qdet))
{
printf("FAIL (containment, iter = %ld)\n", iter);
printf("n = %ld, prec = %ld\n", n, prec);
printf("\n");
printf("Q = \n"); fmpq_mat_print(Q); printf("\n\n");
printf("Qdet = \n"); fmpq_print(Qdet); printf("\n\n");
printf("A = \n"); acb_mat_printd(A, 15); printf("\n\n");
printf("Adet = \n"); acb_printd(Adet, 15); printf("\n\n");
printf("Adet = \n"); acb_print(Adet); printf("\n\n");
abort();
}
fmpq_mat_clear(Q);
fmpq_clear(Qdet);
acb_mat_clear(A);
acb_clear(Adet);
acb_clear(imagunit);
}
flint_randclear(state);
flint_cleanup();
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()
{
slong iter;
flint_rand_t state;
flint_printf("trace....");
fflush(stdout);
flint_randinit(state);
/* check that the acb trace contains the fmpq trace */
for (iter = 0; iter < 10000; iter++)
{
fmpq_mat_t Q;
fmpq_t Qtrace;
acb_mat_t A;
acb_t Atrace;
slong n, qbits, prec;
n = n_randint(state, 8);
qbits = 1 + n_randint(state, 100);
prec = 2 + n_randint(state, 200);
fmpq_mat_init(Q, n, n);
fmpq_init(Qtrace);
acb_mat_init(A, n, n);
acb_init(Atrace);
fmpq_mat_randtest(Q, state, qbits);
fmpq_mat_trace(Qtrace, Q);
acb_mat_set_fmpq_mat(A, Q, prec);
acb_mat_trace(Atrace, A, prec);
if (!acb_contains_fmpq(Atrace, Qtrace))
{
flint_printf("FAIL (containment, iter = %wd)\n", iter);
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("\n");
flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n");
flint_printf("Qtrace = \n"); fmpq_print(Qtrace); flint_printf("\n\n");
flint_printf("A = \n"); acb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("Atrace = \n"); acb_printd(Atrace, 15); flint_printf("\n\n");
flint_printf("Atrace = \n"); acb_print(Atrace); flint_printf("\n\n");
abort();
}
fmpq_mat_clear(Q);
fmpq_clear(Qtrace);
acb_mat_clear(A);
acb_clear(Atrace);
}
/* check trace(A*B) = trace(B*A) */
for (iter = 0; iter < 10000; iter++)
{
slong m, n, prec;
acb_mat_t a, b, ab, ba;
acb_t trab, trba;
prec = 2 + n_randint(state, 200);
m = n_randint(state, 10);
n = n_randint(state, 10);
acb_mat_init(a, m, n);
acb_mat_init(b, n, m);
acb_mat_init(ab, m, m);
acb_mat_init(ba, n, n);
acb_init(trab);
acb_init(trba);
acb_mat_randtest(a, state, 2 + n_randint(state, 100), 10);
acb_mat_randtest(b, state, 2 + n_randint(state, 100), 10);
acb_mat_mul(ab, a, b, prec);
acb_mat_mul(ba, b, a, prec);
acb_mat_trace(trab, ab, prec);
acb_mat_trace(trba, ba, prec);
if (!acb_overlaps(trab, trba))
{
flint_printf("FAIL (overlap, iter = %wd)\n", iter);
flint_printf("m = %wd, n = %wd, prec = %wd\n", m, n, prec);
flint_printf("\n");
flint_printf("a = \n"); acb_mat_printd(a, 15); flint_printf("\n\n");
flint_printf("b = \n"); acb_mat_printd(b, 15); flint_printf("\n\n");
flint_printf("ab = \n"); acb_mat_printd(ab, 15); flint_printf("\n\n");
flint_printf("ba = \n"); acb_mat_printd(ba, 15); flint_printf("\n\n");
flint_printf("trace(ab) = \n"); acb_printd(trab, 15); flint_printf("\n\n");
flint_printf("trace(ba) = \n"); acb_printd(trba, 15); flint_printf("\n\n");
}
acb_clear(trab);
acb_clear(trba);
acb_mat_clear(a);
acb_mat_clear(b);
acb_mat_clear(ab);
acb_mat_clear(ba);
}
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;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("scalar_div_fmpz....");
fflush(stdout);
/* Aliasing */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpq_mat_t A, B;
fmpz_t x;
slong m, n, bits;
m = n_randint(state, 10);
n = n_randint(state, 10);
bits = 1 + n_randint(state, 100);
fmpq_mat_init(A, m, n);
fmpq_mat_init(B, m, n);
fmpz_init(x);
fmpq_mat_randtest(B, state, bits);
fmpz_randtest_not_zero(x, state, bits);
fmpq_mat_scalar_div_fmpz(A, B, x);
fmpq_mat_scalar_div_fmpz(B, B, x);
result = fmpq_mat_equal(A, B);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("A:\n"), fmpq_mat_print(A);
flint_printf("B:\n"), fmpq_mat_print(B);
abort();
}
fmpq_mat_clear(A);
fmpq_mat_clear(B);
fmpz_clear(x);
}
/* (A + B) / x == A / x + B / x */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpq_mat_t A, B, C, D;
fmpz_t x;
slong m, n, bits;
m = n_randint(state, 10);
n = n_randint(state, 10);
bits = 1 + n_randint(state, 100);
fmpq_mat_init(A, m, n);
fmpq_mat_init(B, m, n);
fmpq_mat_init(C, m, n);
fmpq_mat_init(D, m, n);
fmpz_init(x);
fmpq_mat_randtest(A, state, bits);
fmpq_mat_randtest(B, state, bits);
fmpz_randtest_not_zero(x, state, bits);
fmpq_mat_scalar_div_fmpz(C, A, x);
fmpq_mat_scalar_div_fmpz(D, B, x);
fmpq_mat_add(D, C, D);
fmpq_mat_add(C, A, B);
fmpq_mat_scalar_div_fmpz(C, C, x);
result = fmpq_mat_equal(C, D);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("A:\n"), fmpq_mat_print(A);
flint_printf("B:\n"), fmpq_mat_print(B);
abort();
}
fmpq_mat_clear(A);
fmpq_mat_clear(B);
fmpq_mat_clear(C);
fmpq_mat_clear(D);
fmpz_clear(x);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}