python 中的矩阵矩阵

Question

嘿，我正在编写这段代码以进行材料分析。我为材料的每一层生成了一个矩阵，我想将每个矩阵保存为自己的元素。我这样做的方法是将其保存到字典中。然后，我通过对字典的所有值求和来形成一个矩阵。现在，我针对三种不同的条件执行此操作，从而得到 3 个矩阵：A、B 和 D。我想创建所有这些矩阵，使其看起来像：

    | AB |
    | BD |

但是我无法让它正确打印，因为它总是说矩阵：然后是矩阵之一，例如A。它在第三行打印第二个矩阵B，其中A结束而不是在A旁边。我还需要在这个庞大的矩阵上执行未来的操作，所以我想知道最好的方法是什么。这是我的代码的一部分：

    Qbars = {}
    for i in plies:

    Qbar11 = Q11 * math.cos(float(thetas[j]))**4 + Q22        *math.sin(float(thetas[j]))**4 + \
        2 * (Q12 + 2 * Q66) * math.sin(float(thetas[j]))**2 * math.cos(float(thetas[j]))**2
        Qbar22 = Q11 * math.sin(float(thetas[j]))**4 + Q22 *math.cos(float(thetas[j]))**4 + \
        2 * (Q12 + 2 * Q66) * math.sin(float(thetas[j]))**2 * math.cos(float(thetas[j]))**2
        Qbar12 = (Q11 + Q22 - 4 * Q66) * math.sin(float(thetas[j]))**2 * \
        math.cos(float(thetas[j]))**2 + Q12 * (math.cos(float(thetas[j]))**4 + \
        math.sin(float(thetas[j]))**4)
        Qbar66 = (Q11 + Q22 - 2 * Q12 - 2 * Q66) * math.sin(float(thetas[j]))**2 * \
        math.cos(float(thetas[j])) **2 + Q66 * (math.sin(float(thetas[j]))**4 + \
        math.cos(float(thetas[j]))**4)
        Qbar16 = (Q11 - Q12 - 2 * Q66) * math.cos(float(thetas[j]))**3 * \
        math.sin(float(thetas[j])) - (Q22 - Q12 - 2 * Q66) * math.cos(float(thetas[j])) * \
        math.sin(float(thetas[j]))**3
        Qbar26 = (Q11 - Q12 - 2 * Q66) * math.cos(float(thetas[j])) * \
        math.sin(float(thetas[j]))**3 - (Q22 - Q12 - 2 * Q66) * \
        math.cos(float(thetas[j]))**3 * math.sin(float(thetas[j]))

        Qbar = np.matrix ([[Qbar11, Qbar12, Qbar16], [Qbar12, Qbar22, Qbar26], \
        [Qbar16, Qbar26, Qbar66]])

        Qbars[i] = Qbar

        if len(thetas) == 1:
            j = 0
        else:
            j = j + 1

    k=0
    Alist = {}
    for i in plies:
        Alist[i] = Qbars[i].dot(h[k])
        if len(h) == 1:
            k = 0
        else:
            k = k + 1
    A = sum(Alist.values())

    ABD = ([A, B],[B, D])
    print ABD

我打算执行的接下来的操作之一是将矩阵乘以 6x1 数组，如下所示：

    | NX | | 啊啊啊|
    | 纽约 | | 啊啊啊|
    | Nxy| | 啊啊啊|
    ------ * ----------------
    | MX | | BBBDDD |
    | 我的| | BBBDDD |
    | MXy| | BBBDDD |

这样做的最佳方法是什么？

编辑：我制作了这个较短的代码来重现我正在处理的内容，我想不出如何使其更小。

import os
import numpy as np
import math
os.system('cls')
ang = raw_input("ENTER 0 (SPACE) 45 ")
thetas = [int(i) for i in ang.split()]
x = 40
h = [3, 5]
y = [1,2]
j = 0
Qbars = {}
for i in y:
    theta = [thetas[j] * math.pi / 180]
    Q = math.sin(float(thetas[j]))
    Qbar = np.matrix ([[Q, Q, Q], [Q, Q, Q], [Q, Q, Q]])

    Qbars[i] = Qbar

    if len(thetas) == 1:
        j = 0
    else:
        j = j + 1

print Qbars
k=0
Alist = {}
for i in y:
    Alist[i] = Qbars[i].dot(h[k])
    if len(h) == 1:
        k = 0
    else:
        k = k + 1
A = sum(Alist.values())

AAAA = ([A, A], [A, A])
print AAAA
test = raw_input("Press ENTER to close")

Answer 1

正如其他人所指出的，矩阵类现在几乎已被弃用。它们比ndarrays 更受限制，几乎没有附加功能。人们更喜欢使用 numpy 矩阵的主要原因是线性代数（特别是矩阵乘法）对于矩阵来说更自然。

但是，据我所知，您首先使用的np.dot是类的重载算术运算符matrix，所以您不会看到使用时出现任何功能损失np.array。此外，如果您要切换到 python 3.5 或更高版本，您可以使用@矩阵乘法运算符，它可以让您编写诸如

Alist[i] = Qbars[i] @ h[k]

由于上述原因，下面我将使用类ndarray而不是类。matrix

因此，您的问题有两个主要部分：创建块矩阵并将结果与​​向量相乘。我建议使用最新的 numpy 版本，因为有numpy.block引入了。这很方便地完成您想要它做的事情：

>>> import numpy as np
>>> A,B,C = (np.full((3,3),k) for k in range(3))
>>> A
array([[0, 0, 0],
       [0, 0, 0],
       [0, 0, 0]])
>>> B
array([[1, 1, 1],
       [1, 1, 1],
       [1, 1, 1]])
>>> C
array([[2, 2, 2],
       [2, 2, 2],
       [2, 2, 2]])
>>> np.block([[A,B],[B,C]])
array([[0, 0, 0, 1, 1, 1],
       [0, 0, 0, 1, 1, 1],
       [0, 0, 0, 1, 1, 1],
       [1, 1, 1, 2, 2, 2],
       [1, 1, 1, 2, 2, 2],
       [1, 1, 1, 2, 2, 2]])

np.concatenate同样，您可以使用一种堆叠方法连接两个 3 长度向量（这些方法在旧版本中也可用）。

现在，问题是你不能将 shape 矩阵(6,1)与 shape 矩阵相乘(6,6)，所以问题是你真正想要在这里做什么。如果您想将矩阵的每个元素与向量的相应行相乘，您只需将数组（类np.ndarray！）相乘并利用数组广播：

>>> Q = np.block([[A,B],[B,C]])    # (6,6)-shape array
>>> v = np.arange(6).reshape(-1,1) # (6,1)-shape array
>>> v * Q
array([[ 0,  0,  0,  0,  0,  0],
       [ 0,  0,  0,  1,  1,  1],
       [ 0,  0,  0,  2,  2,  2],
       [ 3,  3,  3,  6,  6,  6],
       [ 4,  4,  4,  8,  8,  8],
       [ 5,  5,  5, 10, 10, 10]])

另一种选择是您想要进行矩阵向量乘法，但是您必须转置向量（以便将其与右侧的矩阵相乘）或交换矩阵和向量的顺序（将向量相乘）与左侧的矩阵）。前者的示例：

>>> v.T @ Q  # python 3.5 and up
array([[12, 12, 12, 27, 27, 27]])

>>> v.T.dot(Q)
array([[12, 12, 12, 27, 27, 27]])

数组（而不是矩阵）的另一个好处是数组可以是多维的。您可以定义一个 3d 数组（沿第三轴的 2d 数组的集合），然后沿第三个维度求和，而不是将 numpy 数组放入字典中并以这种方式求和。numpy 的一大好处是其高效的内存需求和性能，如果您在整个代码中使用 numpy 对象和方法，这些方面将是最强的。混合本机 Python 对象（例如 dict、zip、循环）通常会降低性能。