int
arb_mat_inv(arb_mat_t X, const arb_mat_t A, slong prec)
{
if (X == A)
{
int r;
arb_mat_t T;
arb_mat_init(T, arb_mat_nrows(A), arb_mat_ncols(A));
r = arb_mat_inv(T, A, prec);
arb_mat_swap(T, X);
arb_mat_clear(T);
return r;
}
arb_mat_one(X);
return arb_mat_solve(X, A, X, prec);
}
int arb_mat_generalized_eigenproblem_symmetric_positive_definite(arb_mat_t D, arb_mat_t P, const arb_mat_t A, const arb_mat_t B, slong prec) {
// solve the generalized eigenvalue problem Ax = lambda * Bx, where B
// is symmetric positive definite and A is symmetric.
//
// Returns 0 on success.
//
// If there is a problem inverting the Cholesky factorization of B, returns -1.
// If the eigenvalues are not distinct (or cannot be certified as distinct),
// returns 1. In this case the returned eigenvalues will be correct, but
// some eigenvectors will be nonsense, or will be accurate eigenvectors but with
// infinite radius, or something like that.
int dim = arb_mat_nrows(B);
arb_mat_t L;
arb_mat_t X;
arb_mat_init(L, dim, dim);
arb_mat_init(X, dim, dim);
arb_mat_cholesky(L, B, prec);
int result = arb_mat_inv(L, L, prec);
if(!result) {
arb_mat_clear(L);
arb_mat_clear(X);
return -1;
}
arb_mat_mul(X, L, A, prec);
arb_mat_transpose(L, L);
arb_mat_mul(X, X, L, prec);
result = arb_mat_jacobi(D, P, X, prec);
arb_mat_mul(P, L, P, prec);
//arb_mat_transpose(P, P);
arb_mat_clear(L);
arb_mat_clear(X);
return result;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("inv....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000 * 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(Q, state, qbits);
q_invertible = fmpq_mat_inv(Qinv, Q);
if (!q_invertible)
{
arb_mat_set_fmpq_mat(A, Q, prec);
r_invertible = arb_mat_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 = arb_mat_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 = arb_mat_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;
}
