If 循环在 for 循环中起作用

Question

这段代码：

K = 3
N = 3
E = [np.reshape(np.array(i), (K, N)) for i in itertools.product([0, 1, -1], repeat = K*N)]

print 'E = ', E

生成所有可能的 E 矩阵（维度 3x3），由 2 个整数组成：0 和 2，例如：

...
array([[0, 2, 2],
       [0, 0, 0],
       [2, 0, 0]]), array([[0, 2, 2],
       [0, 0, 0],
       [2, 0, 2]]), array([[0, 2, 2],
       [0, 0, 0],
       [2, 2, 0]])
...

给出这个矩阵方程：

A_SC = E * A     # Eqn. 1

其中：

1）*代表标准matrix multiplication（行，列）

2) A_SC, E 和 A 是 3x3 矩阵,

3) E是上述代码生成的所有可能的整数矩阵

4) A 是已知矩阵：

A =np.array([[   0.288155519353E+01,   0.000000000000E+00,   0.568733333333E+01],
             [  -0.144077759676E+01,   0.249550000000E+01,   0.568733333333E+01],
             [  -0.144077759676E+01,  -0.249550000000E+01,   0.568733333333E+01]])

A_SC 矩阵可以表示为 3 行向量：a1_SC、a2_SC 和 a3_SC：

       |a1_SC|
A_SC = |a2_SC|
       |a3_SC|

对于给定的E矩阵，存在一个A_SC矩阵。

以下代码：

1) 遍历所有可能的 E 矩阵，

2) 计算A_SC矩阵，

3) 计算a1_SC、a2_SC和a3_SC、

的范数

4) 并在该次迭代中计算 E 矩阵的行列式：

for indx_E in E:
      A_SC = np.dot(indx_E,A)
      a1_SC = np.linalg.norm(A_SC[0])
      a2_SC = np.linalg.norm(A_SC[1])
      a3_SC = np.linalg.norm(A_SC[2])

      det_indx_E = np.linalg.det(indx_E)
      print 'a1_SC = ', a1_SC
      print 'a2_SC = ', a2_SC
      print 'a3_SC = ', a3_SC
      print 'det_indx_E = ', det_indx_E

目标是获得所有这些 A_SC 和 E 矩阵（等式 1），其中这 3 行向量的范数相同且大于 10，

norm(a1_SC) = norm(a2_SC) = norm(a3_SC) > 10

同时，E的行列式必须大于0.0。这个条件可以这样表达：就在这个for循环之后，我们可以写一个if循环：

tol_1 = 10
tol_2 = 0

for indx_E in E:

      A_SC = np.dot(indx_E,A)
      a1_SC = np.linalg.norm(A_SC[0])
      a2_SC = np.linalg.norm(A_SC[1])
      a3_SC = np.linalg.norm(A_SC[2])

      det_indx_E = np.linalg.det(indx_E)
      print 'a1_SC = ', a1_SC
      print 'a2_SC = ', a2_SC
      print 'a3_SC = ', a3_SC
      print 'det_indx_E = ', det_indx_E

      if  a1_SC > tol_1\
          and a2_SC > tol_1\
          and a3_SC > tol_1\
          and abs(a1_SC - a2_SC) == tol_2\
          and abs(a1_SC - a3_SC) == tol_2\
          and abs(a2_SC - a3_SC) == tol_2\
          and det_indx_E > 0.0:
             print 'A_SC = ', A_SC

             print 'a1_SC = ', a1_SC
             print 'a2_SC = ', a2_SC
             print 'a3_SC = ', a3_SC
             print 'det_indx_E = ', det_indx_E

             # Now, which is the `E` matrix for this `A_SC` ?
             #      A_SC = E * A     # Eqn. 1
             #      A_SC * inv(A) = E * A * inv(A)  # Eqn. 2
             #
             #      ------------------------------
             #     | A_SC * inv(A) = E  # Eqn. 3  |
             #      ------------------------------
             E_sol = np.dot(A_SC, np.linalg.inv(A))
             print 'E_sol = ', E_sol

为了清楚起见，这是完整的代码：

A =np.array([[   0.288155519353E+01,   0.000000000000E+00,   0.568733333333E+01],
                 [  -0.144077759676E+01,   0.249550000000E+01,   0.568733333333E+01],
                 [  -0.144077759676E+01,  -0.249550000000E+01,   0.568733333333E+01]])

K = 3
N = 3
E = [np.reshape(np.array(i), (K, N)) for i in itertools.product([0, 1, -1], repeat = K*N)]

print 'type(E) = ', type(E)
print 'E = ', E
print 'len(E) = ', len(E)

tol_1 = 10
tol_2 = 0

for indx_E in E:

      A_SC = np.dot(indx_E,A)
      a1_SC = np.linalg.norm(A_SC[0])
      a2_SC = np.linalg.norm(A_SC[1])
      a3_SC = np.linalg.norm(A_SC[2])

      det_indx_E = np.linalg.det(indx_E)
      print 'a1_SC = ', a1_SC
      print 'a2_SC = ', a2_SC
      print 'a3_SC = ', a3_SC
      print 'det_indx_E = ', det_indx_E

      if  a1_SC > tol_1\
          and a2_SC > tol_1\
          and a3_SC > tol_1\
          and abs(a1_SC - a2_SC) == tol_2\
          and abs(a1_SC - a3_SC) == tol_2\
          and abs(a2_SC - a3_SC) == tol_2\
          and det_indx_E > 0.0:
             print 'A_SC = ', A_SC

             print 'a1_SC = ', a1_SC
             print 'a2_SC = ', a2_SC
             print 'a3_SC = ', a3_SC
             print 'det_indx_E = ', det_indx_E

             # Now, which is the `E` matrix for this `A_SC` ?
             #      A_SC = E * A     # Eqn. 1
             #      A_SC * inv(A) = E * A * inv(A)  # Eqn. 2
             #
             #      ------------------------------
             #     | A_SC * inv(A) = E  # Eqn. 3  |
             #      ------------------------------
             E_sol = np.dot(A_SC, np.linalg.inv(A))
             print 'E_sol = ', E_sol

问题是没有打印 A_SC（因此没有 E_sol）。如果您运行此代码，则每次迭代都会打印所有范数和行列式，例如以下内容：

a1_SC =  12.7513326014
a2_SC =  12.7513326014
a3_SC =  12.7513326014
det_indx_E =  8.0

这将是一个完美的候选者，因为它满足

a1_SC = a2_SC = a3_SC = 12.7513326014 > 10.0

和

determinant > 0.0

但是，没有 A_SC（因此也没有 E_sol）被打印...为什么会这样？

例如，这个 E 矩阵：

        2 0 0
  E =   0 2 0
        0 0 2

有det = 8.0，并且是候选人，因为它有：

a1_SC = a2_SC = a3_SC = 12.7513326014 > 10.0

Answer 1

简单的答案是不要将双重输出误认为是具有真正基础精度的字符串。最简单的更改：

tol_2 = 1e-8

并将tol_2相关条件改为限制：

        and abs(a1_SC - a2_SC) <= tol_2\
        and abs(a1_SC - a3_SC) <= tol_2\
        and abs(a2_SC - a3_SC) <= tol_2\

这应该可以解决您的问题。

记住当你没有明确地在计算机上使用符号计算时，即使在最简单的例子中，你也应该随时准备好出现数字错误

如果您需要检查 STRICT、数学等式 - 您必须使用符号数学包和相关机制.

如果所需的相等性更像是一种 'physical' 的感觉（例如，什么力足以拉动那个盒子）——那么我描述的方法就可以了，因为一些 'error' 是始终存在于物理世界中，您只需说明所需的公差（在这种情况下我们使用 tol_2）

If 循环在 for 循环中起作用

If loop acting inside a for loop

python

arrays

numpy

matrix

linear-algebra