blocks|key|181598|text|你不能直接做它，但是你总是可以计算它，使用一个稀疏的求解器。其思想是求解A*X=I，其中我是恒等矩阵。如果有解，X将是你的逆矩阵。The+eigen+documentation有一个关于稀疏求解器和如何使用它们的页面，但是基本步骤如下：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|181599|SolverClassName<SparseMatrix<double>+>+solver;
solver.compute(A);
SparseMatrix<double>+I(n,n);
I.setIdentity();
auto+A_inv+=+solver.solve(I);|code-block|syntax|javascript|181600|entityMap|0|LINK|mutability|MUTABLE|url|http://eigen.tuxfamily.org/dox-devel/group__TopicSparseSystems.html^0|10|5|1T|N|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

You cannot do it directly, but you can always calculate it, using one of the sparse solvers. The idea is to solve <code>A*X=I</code>, where I is the identity matrix. If there is a solution, X will be your inverse matrix.
<a href="http://eigen.tuxfamily.org/dox-devel/group__TopicSparseSystems.html">The eigen documentation</a> has a page about sparse solvers and how to use them, but the basic steps are as follows:

<pre><code>SolverClassName&lt;SparseMatrix&lt;double&gt; &gt; solver;
solver.compute(A);
SparseMatrix&lt;double&gt; I(n,n);
I.setIdentity();
auto A_inv = solver.solve(I);
</code></pre>

blocks|key|230145|text|这在数学上没有意义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|230146|稀疏矩阵不一定具有稀疏逆。|230147|这就是为什么这个方法不可用的原因。|230148|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

It's not mathematically meaningful.

A sparse matrix does not necessarily have a sparse inverse.

That's why the method is not available.

blocks|key|5295278|text|关于@Soheib和@MatthiasB的答案的一个小扩展，如果您使用Eigen::SparseMatrix<float>，最好使用SparseLU而不是SimplicialLLT或SimplicialLDLT，它们在浮点矩阵上给出了错误的答案。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5295279|entityMap^0|Z|Q|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

A small extension on @Soheib and @MatthiasB's answers, if you're using <code>Eigen::SparseMatrix&lt;float&gt;</code> it's better to use SparseLU rather than SimplicialLLT or SimplicialLDLT, they produced wrong answers with me on float matrices

blocks|key|5295293|text|请注意，稀疏矩阵的逆不一定是稀疏的，所以如果您正在处理大型矩阵(如果使用稀疏表示，这很可能)，那么这将是非常昂贵的。仔细考虑你是否真的需要实际的矩阵逆。如果你要用矩阵逆来求解方程组，那么你就不需要实际计算矩阵逆并把它乘以(使用通常命名为solve的方法，并提供方程的右边)。如果你需要协方差的Fisher矩阵的逆，试着近似。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5295294|entityMap^0|3A|5|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Be warned that the inverse of a sparse matrix is not necessarily sparse, so if you're working with large matrices (which is likely, if you're using sparse representations) then this is going to be expensive. Think carefully about whether you really need the actual matrix inverse. If you're going to use the matrix inverse to solve a system of equations, then you don't need to actually compute the matrix inverse and multiply it out (use the method typically named <code>solve</code> and supply the right-hand-side of the equation). If you need the inverse of the Fisher matrix for covariances, try to approximate.

blocks|key|5295234|text|你可以找到一个关于稀疏复矩阵的逆的例子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5295235|我用的是SimplicialLLT，|5295236|你可以从贝娄找到其他的课程。|5295237|TopicSparseSystems.html|offset|length|5295238|此页面可以帮助您为您的工作提供适当的类名(矩阵的规格、准确性和模糊)。|5295239|//////////////////////+++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%2B%2B)+{
++++++for+(int+j=0;+j<4;+j%2B%2B)+{
+++++++++A.coeffRef(i,+i)+=+i%2Bj;
++++++}
+++}
++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;
+}|code-block|syntax|javascript|5295240|entityMap|0|LINK|mutability|MUTABLE|url|http://eigen.tuxfamily.org/dox-devel/group__TopicSparseSystems.html^0|0|0|0|0|N|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@$H|12|I|13|1|14]]|A|$]]|$1|J|3|K|5|6|7|15|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|16|8|@]|9|@]|A|$O|P]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

You can find a example about inverse of Sparse Complex Matrix

I used of SimplicialLLT class,

you can find other class from bellow 

<a href="http://eigen.tuxfamily.org/dox-devel/group__TopicSparseSystems.html" rel="nofollow">http://eigen.tuxfamily.org/dox-devel/group__TopicSparseSystems.html</a>

This page can help you with proper class name for your work (spead, accuracy and dimmenssion of your Matrix)

<pre><code>////////////////////// In His Name \\\\\\\\\\\\\\\\\\\\\\\\\\\
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;Eigen/Dense&gt;
#include &lt;Eigen/Sparse&gt;

using namespace std;
using namespace Eigen;

int main()
 {
 SparseMatrix&lt; complex&lt;float&gt; &gt; A(4,4);

 for (int i=0; i&lt;4; i++) {
 for (int j=0; j&lt;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&lt;SparseMatrix&lt;complex&lt;float&gt; &gt; &gt; solverA;
 A.makeCompressed();
 solverA.compute(A);

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

 SparseMatrix&lt;float&gt; eye(4,4);
 eye.setIdentity();

 SparseMatrix&lt;complex&lt;float&gt; &gt; inv_A = solverA.solve(eye);

 cout &lt;&lt; "A:\n" &lt;&lt; A &lt;&lt; endl;
 cout &lt;&lt; "inv_A\n" &lt;&lt; inv_A &lt;&lt; endl;
 }
</code></pre>

I have a question about Eigen library in C++. Actually, I want to calculate inverse matrix of sparse matrix. 
When I used Dense matrix in Eigen, I can use .inverse() operation to calculate inverse of dense matrix. 
But in Sparse matrix, I cannot find inverse operation anywhere. Does anyone who know to calculate inverse of sparse matrix? help me.

How can I calculate inverse of sparse matrix in Eigen library

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我有一个关于C++的特征库的问题。实际上，我想要计算稀疏矩阵的逆矩阵。当我在本征中使用稠密矩阵时，可以使用.inverse()运算来计算稠密矩阵的逆。但是在稀疏矩阵中，我在任何地方都找不到逆运算。谁知道如何计算稀疏矩阵的逆？帮帮我。

问如何计算特征库中稀疏矩阵的逆
EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何计算特征库中稀疏矩阵的逆EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何计算特征库中稀疏矩阵的逆
EN