Come calcolare l'inversa della matrice sparsa nella libreria Eigen

Question

Ho una domanda sulla libreria Eigen in C++. In realtà, voglio calcolare la matrice inversa della matrice sparsa. Quando ho usato la matrice densa in Eigen, posso usare l'operazione .inverse() per calcolare l'inverso della matrice densa. Ma in Sparse matrix, non riesco a trovare l'operazione inversa da nessuna parte. Qualcuno che sa calcolare l'inversa della matrice sparsa? aiutami.

Answer 1

Non è possibile farlo direttamente, ma è sempre possibile calcolarlo utilizzando uno dei risolutori sparsi. L'idea è di risolvere A*X=I, dove I è la matrice di identità. Se c'è una soluzione, X sarà la tua matrice inversa. The eigen documentation ha una pagina su risolutori sparse e come usarli, ma i passaggi fondamentali sono i seguenti:

SolverClassName<SparseMatrix<double> > solver; 
solver.compute(A); 
SparseMatrix<double> I(n,n); 
I.setIdentity(); 
auto A_inv = solver.solve(I); 

Answer 2

Non è matematicamente significativo.

Una matrice sparsa non ha necessariamente un inverso sparse.

Ecco perché il metodo non è disponibile.

Answer 3

Si può trovare un esempio su inverso della matrice complessa Sparse

ho usato di classe SimplicialLLT,

si possono trovare altra classe da muggito

http://eigen.tuxfamily.org/dox-devel/group__TopicSparseSystems.html

Questa pagina può aiutare con una corretta nome di classe per il vostro lavoro (spead, accuratezza e dimmenssion del vostro Matrix)

////////////////////// In His Name \\\\\\\\\\\\\\\\\\\\\\\\\\\ 
#include <iostream> 
#include <vector> 
#include <Eigen/Dense> 
#include <Eigen/Sparse> 

using namespace std; 
using namespace Eigen; 

int main() 
{ 
    SparseMatrix< complex<float> > A(4,4); 

    for (int i=0; i<4; i++) { 
     for (int j=0; j<4; j++) { 
     A.coeffRef(i, i) = i+j; 
     } 
    } 
    A.insert(2,1) = {2,1}; 
    A.insert(3,0) = {0,0}; 
    A.insert(3,1) = {2.5,1}; 
    A.insert(1,3) = {2.5,1}; 

    SimplicialLLT<SparseMatrix<complex<float> > > solverA; 
    A.makeCompressed(); 
    solverA.compute(A); 

    if(solverA.info()!=Success) { 
    cout << "Oh: Very bad" << endl; 
    } 

    SparseMatrix<float> eye(4,4); 
    eye.setIdentity(); 

    SparseMatrix<complex<float> > inv_A = solverA.solve(eye); 

    cout << "A:\n" << A << endl; 
    cout << "inv_A\n" << inv_A << endl; 
} 

Answer 4

Una piccola estensione @Soheib e @ risposte di MatthiasB, se si sta utilizzando Eigen::SparseMatrix<float> è meglio utilizzare SparseLU anziché SimplicialLLT o SimplicialLDLT, hanno prodotto risposte errate con me su matrici float