blocks|key|5643849|text|默认情况下，MATLAB的lu总是执行旋转。例如，当您尝试执行常规LU分解算法时，如果您的对角系数等于0，则它将不起作用，因为在执行高斯消元法以创建上三角矩阵U时，需要使用对角系数，因此您将得到除以零的错误。需要旋转以确保分解是稳定的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5643850|然而，如果你能保证你的矩阵的对角系数是非零的，这是非常简单的，但你必须自己写。你所要做的就是对矩阵进行高斯消元，并将矩阵简化为简化的梯形。得到的降阶梯形矩阵为U，而高斯消元法中去除L下三角部分所需的系数将被放置在下三角半部分中，从而得到U。|5643851|假设您的矩阵存储在A中，则可以使用类似的方法。请记住，我在这里假设了一个方阵。非旋转LU分解算法的实现放在名为lu_nopivot的MATLAB函数文件中|5643852|function+[L,+U]+=+lu_nopivot(A)

n+=+size(A,+1);+%25+Obtain+number+of+rows+(should+equal+number+of+columns)
L+=+eye(n);+%25+Start+L+off+as+identity+and+populate+the+lower+triangular+half+slowly
for+k+=+1+:+n
++++%25+For+each+row+k,+access+columns+from+k%2B1+to+the+end+and+divide+by
++++%25+the+diagonal+coefficient+at+A(k+,k)
++++L(k+%2B+1+:+n,+k)+=+A(k+%2B+1+:+n,+k)+/+A(k,+k);

++++%25+For+each+row+k%2B1+to+the+end,+perform+Gaussian+elimination
++++%25+In+the+end,+A+will+contain+U
++++for+l+=+k+%2B+1+:+n
++++++++A(l,+:)+=+A(l,+:)+-+L(l,+k)+*+A(k,+:);
++++end
end
U+=+A;

end|code-block|syntax|javascript|5643853|作为一个运行示例，假设我们有以下3+x+3矩阵：|5643854|>>+rng(123)
>>+A+=+randi(10,+3,+3)

A+=

+++++7+++++6++++10
+++++3+++++8+++++7
+++++3+++++5+++++5|5643855|运行该算法可以得到以下结果：|5643856|>>+[L,U]+=+lu_nopivot(A)

L+=

++++1.0000+++++++++0+++++++++0
++++0.4286++++1.0000+++++++++0
++++0.4286++++0.4474++++1.0000+++

U+=

++++7.0000++++6.0000+++10.0000
+++++++++0++++5.4286++++2.7143
+++++++++0+++++++++0+++-0.5000|5643857|将L和U相乘可实现：|5643858|>>+L*U

ans+=

+++++7+++++6++++10
+++++3+++++8+++++7
+++++3+++++5+++++5|5643859|..。这是原始矩阵A。|5643860|entityMap^0|D|2|27|1|0|27|1|2I|1|3A|1|0|9|1|1J|A|0|0|0|0|0|0|1|1|3|1|0|0|9|1|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1G|8|@$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|1L|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1M|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1N|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|1O|8|@]|D|@]|E|$]]|$1|U|3|V|5|L|7|1P|8|@]|D|@]|E|$M|N]]|$1|W|3|X|5|6|7|1Q|8|@$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|L|7|1V|8|@]|D|@]|E|$M|N]]|$1|10|3|11|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|12|3|-4|5|6|7|1Z|8|@]|D|@]|E|$]]]|13|$]]

MATLAB's <code>lu</code> always performs pivoting by default. If you had for example a diagonal coefficient that was equal to 0 when you tried to do the conventional LU decomposition algorithm, it will not work as the diagonal coefficients are required when performing the Gaussian elimination to create the upper triangular matrix <code>U</code> so you would get a divide by zero error. Pivoting is required to ensure that the decomposition is stable. 

However, if you can guarantee that the diagonal coefficients of your matrix are non-zero, it is very simple but you will have to write this on your own. All you have to do is perform Gaussian elimination on the matrix and reduce the matrix into reduced echelon form. The result reduced echelon form matrix is <code>U</code> while the coefficients required to remove the lower triangular part of <code>L</code> in Gaussian elimination would be placed in the lower triangular half to make <code>U</code>.

Something like this could work, assuming your matrix is stored in <code>A</code>. Remember that I'm assuming a square matrix here. The implementation of the non-pivoting LU decomposition algorithm is placed in a MATLAB function file called <code>lu_nopivot</code>:

<pre><code>function [L, U] = lu_nopivot(A)

n = size(A, 1); % Obtain number of rows (should equal number of columns)
L = eye(n); % Start L off as identity and populate the lower triangular half slowly
for k = 1 : n
 % For each row k, access columns from k+1 to the end and divide by
 % the diagonal coefficient at A(k ,k)
 L(k + 1 : n, k) = A(k + 1 : n, k) / A(k, k);

 % For each row k+1 to the end, perform Gaussian elimination
 % In the end, A will contain U
 for l = k + 1 : n
 A(l, :) = A(l, :) - L(l, k) * A(k, :);
 end
end
U = A;

end
</code></pre>

As a running example, suppose we have the following 3 x 3 matrix:

<pre><code>&gt;&gt; rng(123)
&gt;&gt; A = randi(10, 3, 3)

A =

 7 6 10
 3 8 7
 3 5 5
</code></pre>

Running the algorithm gives us:

<pre><code>&gt;&gt; [L,U] = lu_nopivot(A)

L =

 1.0000 0 0
 0.4286 1.0000 0
 0.4286 0.4474 1.0000 

U =

 7.0000 6.0000 10.0000
 0 5.4286 2.7143
 0 0 -0.5000
</code></pre>

Multiplying <code>L</code> and <code>U</code> together gives:

<pre><code>&gt;&gt; L*U

ans =

 7 6 10
 3 8 7
 3 5 5
</code></pre>

... which is the original matrix <code>A</code>.

blocks|key|1065795|text|你可以使用这个技巧(尽管如前所述，你可能会失去数值稳定性)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1065796|[L,+U]+=+lu(sparse(A),+0)|code-block|syntax|javascript|1065797|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You could use this hack (though as already mentioned, you might lose numerical stability):

<pre><code>[L, U] = lu(sparse(A), 0)
</code></pre>

blocks|key|3324942|text|您可能想要考虑进行LDU分解，而不是未旋转的LU。看，没有旋转的LU在数字上是不稳定的-即使对于满秩和可逆的矩阵也是如此。上面提供的简单算法说明了原因-有除以涉及的矩阵的每个对角元素。因此，如果对角线上的任何地方都有零，分解就会失败，即使矩阵可能仍然是非奇异的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3324943|Wikipedia在这里谈了一点LDU分解：|3324944|https://en.wikipedia.org/wiki/LU_decomposition#LDU_decomposition|offset|length|3324945|而不引用算法。它引用了以下教科书作为存在的证明：|3324946|罗杰·霍恩；约翰逊·查尔斯·R.+(1985年)，矩阵分析，剑桥大学出版社，ISBN+978-0-521-38632-6。请参见第3.5节。|3324947|LDU被保证存在(至少对于可逆矩阵)，它在数值上是稳定的，并且它也是唯一的(假设L和U都被约束为在对角线上具有单位元素)。|3324948|然后，如果由于任何原因"D“挡住了你的路，你可以将对角矩阵D吸收到L+(L:=L_D)或U+(U:=D_U)中，或者在L和U之间对称地分割它(比如L:=L*sqrt(D)和U:=sqrt(D)*U)，或者你想怎么做都行。有无数种方法可以将LDU拆分成LU，这就是为什么LU分解不是唯一的。|3324949|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|1S|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$F|Z|G|10|1|11]]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|13|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|14|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|15|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|E]]]]

You might want to consider doing LDU decomposition instead of unpivoted LU. See, LU without pivoting is numerically unstable - even for matrices that are full rank and invertible. The simple algorithm provided above shows why - there is division by each diagonal element of the matrix involved. Thus, if there is a zero anywhere on the diagonal, decomposition fails, even though the matrix could still be non-singular.

Wikipedia talks a little about LDU decomposition here:

<a href="https://en.wikipedia.org/wiki/LU_decomposition#LDU_decomposition" rel="nofollow noreferrer">https://en.wikipedia.org/wiki/LU_decomposition#LDU_decomposition</a>

without citing an algorithm. It cites the following textbook for proof of existence:

Horn, Roger A.; Johnson, Charles R. (1985), Matrix Analysis, Cambridge University Press, ISBN 978-0-521-38632-6. See Section 3.5.

LDU is guaranteed to exist (at least for an invertible matrix), it is numerically stable, and it is also unique (provided that both L and U are constrained to have unit elements on the diagonal). 

Then, if for any reason "D" gets in your way, you can absorb the diagonal matrix D into either L (L:=LD) or U (U:=DU), or split it symmetrically between L and U (such as L:=L*sqrt(D) and U:=sqrt(D)*U), or however you want to do it. There is an infinite number of ways to split LDU into LU, and this is why LU decomposition is not unique.

How can I implement the function <code>lu(A)</code> in MATLAB so that <code>L*U</code> is directly <code>A</code> and I also get the real <code>L</code> matrix?

When I use <code>[L,U] = lu(A)</code>, MATLAB doesn't give me the right <code>L</code> matrix. When I use <code>[L,U,P]</code> = lu(A), I need to implement <code>P*A = L*U</code>, but I only want to multiply <code>L*U</code> to receive A.

Perform LU decomposition without pivoting in MATLAB

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

如何在MATLAB中实现函数lu(A)，使L*U直接为A，同时也得到真实的L矩阵？当我使用[L,U] = lu(A)时，MATLAB没有给出正确的L矩阵。当我使用[L,U,P] = lu( A )时，我需要实现P*A = L*U，但我只想将L*U相乘以接收A。

问在MATLAB中执行不旋转的LU分解
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在MATLAB中执行不旋转的LU分解EN