Python numpy，相同的计算结果不同

我要计算。
我认为结果是A。
因此，我使用numpy编写了一个python代码。
但根据计算顺序，结果不是A。
这是怎么回事

import numpy as np
from numpy import *
from numpy.random import *
import decimal

#generate matrix A
A = randn(180,240)
A = np.array(A, dtype = decimal.Decimal )

#generate matrix P
h,w=A.shape
P = randn(0.9*h,h)
P = np.array(P, dtype = decimal.Decimal )

#it's OK. IA = A
PP = dot(P.T,P)
PPinv = np.linalg.inv(PP)
PPinvPP = dot(PPinv,PP)
PPinvPPinv = np.linalg.inv(PPinvPP)
I = dot(PPinvPPinv,PPinvPP)
IA = dot(I, A)

#I think IA2 must be A. but not A. Why?
PA = dot(P,A)
PPA = dot(P.T,PA)
PPinvPPA = dot(PPinv,PPA)
IA2 = dot(PPinvPPinv, PPinvPPA)

#print result
print "A;%0.2f" % A[0,0]
print "IA:%0.2f" % IA[0,0]
print "IA2:%0.2f" % IA2[0,0]

---

主要原因是当您使用非方矩阵p时，高度小于宽度，PP的行列式总是有一个零值，但由于计算误差，它是！=0因此，在这之后，不可能计算出真实的PPIV，任何前进的步骤都是毫无意义的

P = randn(2,3)
P = np.array(P, dtype = decimal.Decimal )

PP = dot(P.T,P)
np.linalg.det(PP) #-5.2536080570332981e-34

那么为什么IA==A呢

我认为这是一种错误给你正常结果的情况

如何解决

不要将Python用于理论问题：）

将P=randn（0.9*h，h）更改为P=randn（1.1*h，h）

---

主要原因是当您使用非方矩阵p时，高度小于宽度，PP的行列式总是有一个零值，但由于计算误差，它是！=0因此，在这之后，不可能计算出真实的PPIV，任何前进的步骤都是毫无意义的

P = randn(2,3)
P = np.array(P, dtype = decimal.Decimal )

PP = dot(P.T,P)
np.linalg.det(PP) #-5.2536080570332981e-34

那么为什么IA==A呢

我认为这是一种错误给你正常结果的情况

如何解决

不要将Python用于理论问题：）

将P=randn（0.9*h，h）更改为P=randn（1.1*h，h）

---

这里发生的事情很有趣：

通常，只有当

PP

为非单数时，您的公式才是正确的

那么为什么

AI==A

PP = dot(P.T,P)
PPinv = np.linalg.inv(PP)
PPinvPP = dot(PPinv,PP)
PPinvPPinv = np.linalg.inv(PPinvPP)
I = dot(PPinvPPinv,PPinvPP)
IA = dot(I, A)

这里有几点需要注意：

• PP=dot（P.T，P）

  是单数
• =>

  PPinv

  不是一个真正的倒数
• 但是

  PPinvPP

  是可逆的，因此

  I

  确实是单位矩阵

注意：由于您对术语的特殊求值顺序，您只能得到

AI==A

---

在

IA2

项的第二次计算中，您没有这个特殊的评估顺序，因此，

A

。

这里发生的事情非常有趣：

通常，只有当

PP

为非单数时，您的公式才是正确的

那么为什么

AI==A

PP = dot(P.T,P)
PPinv = np.linalg.inv(PP)
PPinvPP = dot(PPinv,PP)
PPinvPPinv = np.linalg.inv(PPinvPP)
I = dot(PPinvPPinv,PPinvPP)
IA = dot(I, A)

这里有几点需要注意：

• PP=dot（P.T，P）

  是单数
• =>

  PPinv

  不是一个真正的倒数
• 但是

  PPinvPP

  是可逆的，因此

  I

  确实是单位矩阵

注意：由于您对术语的特殊求值顺序，您只能得到

AI==A

---

在对

IA2

术语的第二次计算中，您没有这个特殊的评估顺序，因此，

A

。

不是对您的问题的直接回答，但您可以使用它来解决此类问题：

from IPython.display import display
import sympy as sy


sy.init_printing()  # For LaTeX-like pretty printing in IPython

n = 5
A = sy.MatrixSymbol('A', 162, 240)  # dimension 162x240
P = sy.MatrixSymbol('P', 162, 180)  # dimensions 162x180

PTP = P*P.T
ex1 = (PTP.inverse() * PTP).inverse() * PTP.inverse() * PTP * A
display(ex1)  # displays: A

---

不是对您的问题的直接回答，但您可以使用以下方法解决此类问题：

from IPython.display import display
import sympy as sy


sy.init_printing()  # For LaTeX-like pretty printing in IPython

n = 5
A = sy.MatrixSymbol('A', 162, 240)  # dimension 162x240
P = sy.MatrixSymbol('P', 162, 180)  # dimensions 162x180

PTP = P*P.T
ex1 = (PTP.inverse() * PTP).inverse() * PTP.inverse() * PTP * A
display(ex1)  # displays: A

---

我只能猜测，但我要说的是——欢迎来到离散数字的奇妙世界，

（a*b）*c！=a*（b*c）

是现实。你可能需要用一个ε来定义相等，以便进行比较。你的数组中没有一个是相等的，我只能猜测，但我要说的是-欢迎来到离散数字的奇妙世界，在这里

（a*b）*c！=a*（b*c）

是现实。你可能需要用一个ε来定义相等，以便进行比较。你的数组中没有一个是相等的。我有一个问题要问你（但我仍然不能在你的答案下进行评论）：det（AAT）（其中a.shape==（n，n-1），所以AAT.shape==（n，n））总是==0，还是只在大多数情况下是相等的？主要思想是我们无法获得更多信息（例如。（n，n-1）->（n，n））而不使用它的线性组合。好吧，我们知道

Rank（AB）我有一个问题要问你（但我仍然不能在你的答案下评论）：det（AAT）（其中a.shape==（n，n-1），所以AAT.shape==（n，n））总是==0，或者只是大多数时候？主要的想法是我们无法获得更多的信息（例如，（n，n-1）->（n，n））不使用它的线性组合。我们知道，
Rank（AB）