SymPy 1.13 中文文档（二十五）

原文：docs.sympy.org/latest/index.html

矩阵类别

原文链接：docs.sympy.org/latest/modules/matrices/kind.html

class sympy.matrices.kind.MatrixKind(element_kind=NumberKind)

SymPy 中所有矩阵的类别。

此类的基本类是MatrixBase和MatrixExpr，但任何表示矩阵的表达式都可以具有这种类别。

参数：

元素类别：类别

元素类型。默认是sympy.core.kind.NumberKind，表示矩阵只包含数字。

示例

任何矩阵类的实例均具有MatrixKind类别：

>>> from sympy import MatrixSymbol
>>> A = MatrixSymbol('A', 2, 2)
>>> A.kind
MatrixKind(NumberKind) 

表示矩阵的表达式可能不是 Matrix 类的实例，但它将具有MatrixKind类别：

>>> from sympy import MatrixExpr, Integral
>>> from sympy.abc import x
>>> intM = Integral(A, x)
>>> isinstance(intM, MatrixExpr)
False
>>> intM.kind
MatrixKind(NumberKind) 

使用isinstance()检查是否为MatrixKind，无需指定元素类型。使用is来检查包括元素类型的类别：

>>> from sympy import Matrix
>>> from sympy.core import NumberKind
>>> from sympy.matrices import MatrixKind
>>> M = Matrix([1, 2])
>>> isinstance(M.kind, MatrixKind)
True
>>> M.kind is MatrixKind(NumberKind)
True 

另请参见

sympy.core.kind.NumberKind，sympy.core.kind.UndefinedKind，sympy.core.containers.TupleKind，sympy.sets.sets.SetKind

__weakref__

对对象的弱引用列表

密集矩阵

原文链接：docs.sympy.org/latest/modules/matrices/dense.html

sympy.matrices.dense.Matrix

别名 MutableDenseMatrix

class sympy.matrices.dense.DenseMatrix

基于 DomainMatrix 的矩阵实现作为内部表示

LDLdecomposition(hermitian=True)

返回矩阵 A 的 LDL 分解 (L, D)，使得当 hermitian 标志为 True 时，L * D * L.H == A；当 hermitian 为 False 时，L * D * L.T == A。此方法消除了平方根的使用。此外，确保 L 的所有对角线条目都为 1。如果 hermitian 为 True，则 A 必须是 Hermite 正定矩阵；否则必须是对称矩阵。

示例

>>> from sympy import Matrix, eye
>>> A = Matrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11)))
>>> L, D = A.LDLdecomposition()
>>> L
Matrix([
[   1,   0, 0],
[ 3/5,   1, 0],
[-1/5, 1/3, 1]])
>>> D
Matrix([
[25, 0, 0],
[ 0, 9, 0],
[ 0, 0, 9]])
>>> L * D * L.T * A.inv() == eye(A.rows)
True 

矩阵可以有复数条目：

>>> from sympy import I
>>> A = Matrix(((9, 3*I), (-3*I, 5)))
>>> L, D = A.LDLdecomposition()
>>> L
Matrix([
[   1, 0],
[-I/3, 1]])
>>> D
Matrix([
[9, 0],
[0, 4]])
>>> L*D*L.H == A
True 

另请参阅

sympy.matrices.dense.DenseMatrix.cholesky，sympy.matrices.matrixbase.MatrixBase.LUdecomposition，QRdecomposition

as_immutable()

返回此矩阵的不可变版本

as_mutable()

返回此矩阵的可变版本

示例

>>> from sympy import ImmutableMatrix
>>> X = ImmutableMatrix([[1, 2], [3, 4]])
>>> Y = X.as_mutable()
>>> Y[1, 1] = 5 # Can set values in Y
>>> Y
Matrix([
[1, 2],
[3, 5]]) 

cholesky(hermitian=True)

返回矩阵 A 的 Cholesky 分解 L，使得当 hermitian 标志为 True 时，L * L.H == A；当 hermitian 为 False 时，L * L.T == A。

如果 hermitian 为 True，则 A 必须是 Hermite 正定矩阵；如果为 False，则必须是对称矩阵。

示例

>>> from sympy import Matrix
>>> A = Matrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11)))
>>> A.cholesky()
Matrix([
[ 5, 0, 0],
[ 3, 3, 0],
[-1, 1, 3]])
>>> A.cholesky() * A.cholesky().T
Matrix([
[25, 15, -5],
[15, 18,  0],
[-5,  0, 11]]) 

矩阵可以有复数条目：

>>> from sympy import I
>>> A = Matrix(((9, 3*I), (-3*I, 5)))
>>> A.cholesky()
Matrix([
[ 3, 0],
[-I, 2]])
>>> A.cholesky() * A.cholesky().H
Matrix([
[   9, 3*I],
[-3*I,   5]]) 

当矩阵非正定时，非 Hermite Cholesky 分解可能是有用的。

>>> A = Matrix([[1, 2], [2, 1]])
>>> L = A.cholesky(hermitian=False)
>>> L
Matrix([
[1,         0],
[2, sqrt(3)*I]])
>>> L*L.T == A
True 

另请参阅

sympy.matrices.dense.DenseMatrix.LDLdecomposition，sympy.matrices.matrixbase.MatrixBase.LUdecomposition，QRdecomposition

lower_triangular_solve(rhs)

解决 Ax = B，其中 A 是一个下三角矩阵。

另请参阅

upper_triangular_solve, gauss_jordan_solve, cholesky_solve, diagonal_solve, LDLsolve, LUsolve, QRsolve, pinv_solve, cramer_solve

upper_triangular_solve(rhs)

解决Ax = B，其中 A 是上三角矩阵。

另见

lower_triangular_solve, gauss_jordan_solve, cholesky_solve, diagonal_solve, LDLsolve, LUsolve, QRsolve, pinv_solve, cramer_solve

class sympy.matrices.dense.MutableDenseMatrix(*args, **kwargs)

simplify(**kwargs)

对矩阵元素应用简化操作。

这是一个 M.applyfunc(lambda x: simplify(x, ratio, measure))的快捷方式。

另见

sympy.simplify.simplify.simplify

class sympy.matrices.immutable.ImmutableDenseMatrix(*args, **kwargs)

创建矩阵的不可变版本。

示例

>>> from sympy import eye, ImmutableMatrix
>>> ImmutableMatrix(eye(3))
Matrix([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
>>> _[0, 0] = 42
Traceback (most recent call last):
...
TypeError: Cannot set values of ImmutableDenseMatrix 

稀疏矩阵

原文：docs.sympy.org/latest/modules/matrices/sparse.html

稀疏矩阵类参考文档

sympy.matrices.sparse.SparseMatrix

别名为MutableSparseMatrix

class sympy.matrices.sparse.MutableSparseMatrix(*args, **kwargs)

不可变稀疏矩阵类参考文档

class sympy.matrices.immutable.ImmutableSparseMatrix(*args, **kwargs)

创建不可变版本的稀疏矩阵。

示例

>>> from sympy import eye, ImmutableSparseMatrix
>>> ImmutableSparseMatrix(1, 1, {})
Matrix([[0]])
>>> ImmutableSparseMatrix(eye(3))
Matrix([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
>>> _[0, 0] = 42
Traceback (most recent call last):
...
TypeError: Cannot set values of ImmutableSparseMatrix
>>> _.shape
(3, 3) 

稀疏工具

原文链接：docs.sympy.org/latest/modules/matrices/sparsetools.html

sympy.matrices.sparsetools._doktocsr()

将稀疏矩阵转换为压缩稀疏行（CSR）格式。

参数：

A：按键（行，列）排序的非零元素

JA：JA[i] 是与 A[i]对应的列

IA：IA[i] 包含 A 中第一个非零元素的索引

对于行[i]的非零元素数。因此，IA[i+1] - IA[i] 给出行[i]的非零元素数。IA 的长度始终比矩阵中的行数多 1。

示例

>>> from sympy.matrices.sparsetools import _doktocsr
>>> from sympy import SparseMatrix, diag
>>> m = SparseMatrix(diag(1, 2, 3))
>>> m[2, 0] = -1
>>> _doktocsr(m)
[[1, 2, -1, 3], [0, 1, 0, 2], [0, 1, 2, 4], [3, 3]] 

sympy.matrices.sparsetools._csrtodok()

将 CSR 表示转换为 DOK 表示。

示例

>>> from sympy.matrices.sparsetools import _csrtodok
>>> _csrtodok([[5, 8, 3, 6], [0, 1, 2, 1], [0, 0, 2, 3, 4], [4, 3]])
Matrix([
[0, 0, 0],
[5, 8, 0],
[0, 0, 3],
[0, 6, 0]]) 

sympy.matrices.sparsetools.banded(**kwargs)

从描述矩阵对角线的给定字典返回稀疏矩阵。键为正值表示上对角线，负值表示主对角线以下。值可以是：

• 表达式或单参数函数，

• 值的列表或元组，

• 矩阵

如果没有给出尺寸，则返回的矩阵大小将足够大，以包含提供的最大非零值。

Kwargs

矩阵的对角线；如果计算

未给出。

矩阵的列数；如果计算

未给出。

示例

>>> from sympy import banded, ones, Matrix
>>> from sympy.abc import x 

如果元组中给出了显式值，则矩阵将自动调整大小以包含所有值，否则将单个值填充到整个对角线上：

>>> banded({1: (1, 2, 3), -1: (4, 5, 6), 0: x})
Matrix([
[x, 1, 0, 0],
[4, x, 2, 0],
[0, 5, x, 3],
[0, 0, 6, x]]) 

接受单个参数的函数可用于根据对角线索引（从 0 开始）填充对角线。必须提供矩阵的大小（或形状）以获得超过 1x1 的矩阵：

>>> s = lambda d: (1 + d)**2
>>> banded(5, {0: s, 2: s, -2: 2})
Matrix([
[1, 0, 1,  0,  0],
[0, 4, 0,  4,  0],
[2, 0, 9,  0,  9],
[0, 2, 0, 16,  0],
[0, 0, 2,  0, 25]]) 

放置在对角线上的矩阵的对角线将与指定的对角线重合：

>>> vert = Matrix([1, 2, 3])
>>> banded({0: vert}, cols=3)
Matrix([
[1, 0, 0],
[2, 1, 0],
[3, 2, 1],
[0, 3, 2],
[0, 0, 3]]) 

>>> banded(4, {0: ones(2)})
Matrix([
[1, 1, 0, 0],
[1, 1, 0, 0],
[0, 0, 1, 1],
[0, 0, 1, 1]]) 

如果指定的大小无法容纳所有值的整数倍，则会引发错误。这里，行被指定为奇数（但需要偶数才能容纳对角线上的 2x2 非对角线元素）：

>>> banded({0: 2, 1: ones(2)}, rows=5)
Traceback (most recent call last):
...
ValueError:
sequence does not fit an integral number of times in the matrix 

在这里，提供了偶数行…但是正方形矩阵也有偶数列。正如我们在上一个示例中看到的，需要奇数行：

>>> banded(4, {0: 2, 1: ones(2)})  # trying to make 4x4 and cols must be odd
Traceback (most recent call last):
...
ValueError:
sequence does not fit an integral number of times in the matrix 

避免计算行数的方法是将矩阵元素封装在元组中，并指示所需的元素数量放在右边：

>>> banded({0: 2, 2: (ones(2),)*3})
Matrix([
[2, 0, 1, 1, 0, 0, 0, 0],
[0, 2, 1, 1, 0, 0, 0, 0],
[0, 0, 2, 0, 1, 1, 0, 0],
[0, 0, 0, 2, 1, 1, 0, 0],
[0, 0, 0, 0, 2, 0, 1, 1],
[0, 0, 0, 0, 0, 2, 1, 1]]) 

如果给定的条目写入了多个值，将引发错误。这里，如果将它们放置在第一个对角线上，这些 1 将与主对角线重叠：

>>> banded({0: (2,)*5, 1: (ones(2),)*3})
Traceback (most recent call last):
...
ValueError: collision at (1, 1) 

通过在全一的 2x2 矩阵左下角放置 0，可以避免碰撞：

>>> u2 = Matrix([
... [1, 1],
... [0, 1]])
>>> banded({0: [2]*5, 1: [u2]*3})
Matrix([
[2, 1, 1, 0, 0, 0, 0],
[0, 2, 1, 0, 0, 0, 0],
[0, 0, 2, 1, 1, 0, 0],
[0, 0, 0, 2, 1, 0, 0],
[0, 0, 0, 0, 2, 1, 1],
[0, 0, 0, 0, 0, 0, 1]]) 

不可变矩阵

原文链接：docs.sympy.org/latest/modules/matrices/immutablematrices.html

在 SymPy 中，标准的Matrix类是可变的。出于性能考虑这一点非常重要，但这也意味着标准矩阵不能很好地与 SymPy 的其他部分交互。这是因为大多数 SymPy 类继承自不可变的Basic对象。

ImmutableDenseMatrix 类的使命是解决性能/可变性与安全性/不可变性之间的张力。不可变矩阵几乎可以完成普通矩阵的所有功能，但它们继承自Basic，因此可以更自然地与 SymPy 的其他部分交互。ImmutableMatrix 还继承自MatrixExpr，允许它与 SymPy 的矩阵表达式模块自由交互。

通过调用构造函数，您可以将任何类似于矩阵的对象转换为ImmutableMatrix。

>>> from sympy import Matrix, ImmutableMatrix
>>> M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> M[1, 1] = 0
>>> IM = ImmutableMatrix(M)
>>> IM
Matrix([
[1, 2, 3],
[4, 0, 6],
[7, 8, 9]])
>>> IM[1, 1] = 5
Traceback (most recent call last):
...
TypeError: Can not set values in Immutable Matrix. Use Matrix instead. 

ImmutableMatrix 类参考

sympy.matrices.immutable.ImmutableMatrix

是 ImmutableDenseMatrix 的别名。

class sympy.matrices.immutable.ImmutableDenseMatrix(*args, **kwargs)

创建一个矩阵的不可变版本。

示例

>>> from sympy import eye, ImmutableMatrix
>>> ImmutableMatrix(eye(3))
Matrix([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
>>> _[0, 0] = 42
Traceback (most recent call last):
...
TypeError: Cannot set values of ImmutableDenseMatrix 

矩阵表达式

原文：docs.sympy.org/latest/modules/matrices/expressions.html

矩阵表达式模块允许用户编写如下语句

>>> from sympy import MatrixSymbol, Matrix
>>> X = MatrixSymbol('X', 3, 3)
>>> Y = MatrixSymbol('Y', 3, 3)
>>> (X.T*X).I*Y
X**(-1)*X.T**(-1)*Y 

>>> Matrix(X)
Matrix([
[X[0, 0], X[0, 1], X[0, 2]],
[X[1, 0], X[1, 1], X[1, 2]],
[X[2, 0], X[2, 1], X[2, 2]]]) 

>>> (X*Y)[1, 2]
X[1, 0]*Y[0, 2] + X[1, 1]*Y[1, 2] + X[1, 2]*Y[2, 2] 

其中X和Y是MatrixSymbol，而不是标量符号。

支持矩阵表达式的导数。一个矩阵关于另一个矩阵的导数通常是一个四维数组，但如果一些维度是平凡的或对角的，导数算法将尝试将结果表示为矩阵表达式：

>>> a = MatrixSymbol("a", 3, 1)
>>> b = MatrixSymbol("b", 3, 1)
>>> (a.T*X**2*b).diff(X)
a*b.T*X.T + X.T*a*b.T 

>>> X.diff(X)
PermuteDims(ArrayTensorProduct(I, I), (3)(1 2)) 

最后的输出是一个数组表达式，因为返回的符号是四维的。

矩阵表达式核心参考

class sympy.matrices.expressions.MatrixExpr(*args, **kwargs)

矩阵表达式的超类

MatrixExprs 表示在特定基础内表示的抽象矩阵，线性变换。

示例

>>> from sympy import MatrixSymbol
>>> A = MatrixSymbol('A', 3, 3)
>>> y = MatrixSymbol('y', 3, 1)
>>> x = (A.T*A).I * A * y 

参见

MatrixSymbol，MatAdd，MatMul，Transpose，Inverse

property T

矩阵转置

as_coeff_Mul(rational=False)

高效提取乘积的系数。

as_explicit()

返回一个明确表示元素的密集矩阵

返回一个类型为 ImmutableDenseMatrix 的对象。

示例

>>> from sympy import Identity
>>> I = Identity(3)
>>> I
I
>>> I.as_explicit()
Matrix([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]]) 

参见

as_mutable

返回可变矩阵类型

as_mutable()

返回一个密集的可变矩阵，其元素明确表示

示例

>>> from sympy import Identity
>>> I = Identity(3)
>>> I
I
>>> I.shape
(3, 3)
>>> I.as_mutable()
Matrix([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]]) 

参见

as_explicit

返回 ImmutableDenseMatrix

equals(other)

测试矩阵之间的逐元素相等性，可能是不同类型的矩阵

>>> from sympy import Identity, eye
>>> Identity(3).equals(eye(3))
True 

static from_index_summation(expr, first_index=None, last_index=None, dimensions=None)

将具有明确求和索引的矩阵表达式解析为没有索引的矩阵表达式，如果可能的话。

此转换以数学符号表示：

(\sum_{j=0}^{N-1} A_{i,j} B_{j,k} \Longrightarrow \mathbf{A}\cdot \mathbf{B})

可选参数first_index：指定用作表达式起始的自由索引。

示例

>>> from sympy import MatrixSymbol, MatrixExpr, Sum
>>> from sympy.abc import i, j, k, l, N
>>> A = MatrixSymbol("A", N, N)
>>> B = MatrixSymbol("B", N, N)
>>> expr = Sum(A[i, j]*B[j, k], (j, 0, N-1))
>>> MatrixExpr.from_index_summation(expr)
A*B 

检测到转置：

>>> expr = Sum(A[j, i]*B[j, k], (j, 0, N-1))
>>> MatrixExpr.from_index_summation(expr)
A.T*B 

检测迹：

>>> expr = Sum(A[i, i], (i, 0, N-1))
>>> MatrixExpr.from_index_summation(expr)
Trace(A) 

更复杂的表达式：

>>> expr = Sum(A[i, j]*B[k, j]*A[l, k], (j, 0, N-1), (k, 0, N-1))
>>> MatrixExpr.from_index_summation(expr)
A*B.T*A.T 

class sympy.matrices.expressions.MatrixSymbol(name, n, m)

矩阵对象的符号表示

创建一个 SymPy 符号来表示一个矩阵。此矩阵具有形状，并可包含在矩阵表达式中

示例

>>> from sympy import MatrixSymbol, Identity
>>> A = MatrixSymbol('A', 3, 4) # A 3 by 4 Matrix
>>> B = MatrixSymbol('B', 4, 3) # A 4 by 3 Matrix
>>> A.shape
(3, 4)
>>> 2*A*B + Identity(3)
I + 2*A*B 

class sympy.matrices.expressions.MatAdd(*args, evaluate=False, check=None, _sympify=True)

矩阵表达式的和

MatAdd 继承自并像 SymPy Add 操作

示例

>>> from sympy import MatAdd, MatrixSymbol
>>> A = MatrixSymbol('A', 5, 5)
>>> B = MatrixSymbol('B', 5, 5)
>>> C = MatrixSymbol('C', 5, 5)
>>> MatAdd(A, B, C)
A + B + C 

class sympy.matrices.expressions.MatMul(*args, evaluate=False, check=None, _sympify=True)

矩阵表达式的乘积

示例

>>> from sympy import MatMul, MatrixSymbol
>>> A = MatrixSymbol('A', 5, 4)
>>> B = MatrixSymbol('B', 4, 3)
>>> C = MatrixSymbol('C', 3, 6)
>>> MatMul(A, B, C)
A*B*C 

class sympy.matrices.expressions.MatPow(base, exp, evaluate=False, **options)

sympy.matrices.expressions.hadamard_product(*matrices)

返回矩阵的逐元素（又名 Hadamard）乘积。

示例

>>> from sympy import hadamard_product, MatrixSymbol
>>> A = MatrixSymbol('A', 2, 3)
>>> B = MatrixSymbol('B', 2, 3)
>>> hadamard_product(A)
A
>>> hadamard_product(A, B)
HadamardProduct(A, B)
>>> hadamard_product(A, B)[0, 1]
A[0, 1]*B[0, 1] 

class sympy.matrices.expressions.HadamardProduct(*args, evaluate=False, check=None)

矩阵表达式的逐元素乘积

示例

矩阵符号的 Hadamard 乘积：

>>> from sympy import hadamard_product, HadamardProduct, MatrixSymbol
>>> A = MatrixSymbol('A', 5, 5)
>>> B = MatrixSymbol('B', 5, 5)
>>> isinstance(hadamard_product(A, B), HadamardProduct)
True 

注意

这是一个简单存储其参数而不进行评估的符号对象。要实际计算乘积，请使用函数 hadamard_product() 或 HadamardProduct.doit

class sympy.matrices.expressions.HadamardPower(base, exp)

矩阵表达式的逐元素乘幂

参数：

base：标量或矩阵

exp：标量或矩阵

注意事项

有四种可用的哈达玛乘方的定义。让我们将 (A, B) 视为 ((m, n)) 矩阵，(a, b) 视为标量。

矩阵的标量乘方：

[\begin{split}A^{\circ b} = \begin{bmatrix} A_{0, 0}^b & A_{0, 1}^b & \cdots & A_{0, n-1}^b \ A_{1, 0}^b & A_{1, 1}^b & \cdots & A_{1, n-1}^b \ \vdots & \vdots & \ddots & \vdots \ A_{m-1, 0}^b & A_{m-1, 1}^b & \cdots & A_{m-1, n-1}^b \end{bmatrix}\end{split}]

矩阵的标量乘方：

[\begin{split}a^{\circ B} = \begin{bmatrix} a^{B_{0, 0}} & a^{B_{0, 1}} & \cdots & a^{B_{0, n-1}} \ a^{B_{1, 0}} & a^{B_{1, 1}} & \cdots & a^{B_{1, n-1}} \ \vdots & \vdots & \ddots & \vdots \ a^{B_{m-1, 0}} & a^{B_{m-1, 1}} & \cdots & a^{B_{m-1, n-1}} \end{bmatrix}\end{split}]

矩阵的矩阵乘方：

[\begin{split}A^{\circ B} = \begin{bmatrix} A_{0, 0}^{B_{0, 0}} & A_{0, 1}^{B_{0, 1}} & \cdots & A_{0, n-1}^{B_{0, n-1}} \ A_{1, 0}^{B_{1, 0}} & A_{1, 1}^{B_{1, 1}} & \cdots & A_{1, n-1}^{B_{1, n-1}} \ \vdots & \vdots & \ddots & \vdots \ A_{m-1, 0}^{B_{m-1, 0}} & A_{m-1, 1}^{B_{m-1, 1}} & \cdots & A_{m-1, n-1}^{B_{m-1, n-1}} \end{bmatrix}\end{split}]

标量的标量乘方：

[a^{\circ b} = a^b]

class sympy.matrices.expressions.Inverse(mat, exp=-1)

矩阵表达式的乘法逆

这是一个简单存储其参数而不进行评估的符号对象。要实际计算逆矩阵，请使用矩阵的 .inverse() 方法。

示例

>>> from sympy import MatrixSymbol, Inverse
>>> A = MatrixSymbol('A', 3, 3)
>>> B = MatrixSymbol('B', 3, 3)
>>> Inverse(A)
A**(-1)
>>> A.inverse() == Inverse(A)
True
>>> (A*B).inverse()
B**(-1)*A**(-1)
>>> Inverse(A*B)
(A*B)**(-1) 

class sympy.matrices.expressions.Transpose(*args, **kwargs)

矩阵表达式的转置。

这是一个简单存储其参数而不进行评估的符号对象。要实际计算转置，请使用 transpose() 函数或矩阵的 .T 属性。

示例

>>> from sympy import MatrixSymbol, Transpose, transpose
>>> A = MatrixSymbol('A', 3, 5)
>>> B = MatrixSymbol('B', 5, 3)
>>> Transpose(A)
A.T
>>> A.T == transpose(A) == Transpose(A)
True
>>> Transpose(A*B)
(A*B).T
>>> transpose(A*B)
B.T*A.T 

class sympy.matrices.expressions.Trace(mat)

矩阵迹

表示矩阵表达式的迹。

示例

>>> from sympy import MatrixSymbol, Trace, eye
>>> A = MatrixSymbol('A', 3, 3)
>>> Trace(A)
Trace(A)
>>> Trace(eye(3))
Trace(Matrix([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]]))
>>> Trace(eye(3)).simplify()
3 

class sympy.matrices.expressions.FunctionMatrix(rows, cols, lamda)

使用一个函数（Lambda）表示矩阵，该函数根据每个矩阵条目的坐标给出输出。

参数：

rows：非负整数。可以是符号。

cols：非负整数。可以是符号。

lamda：函数、Lambda 或字符串

如果它是 SymPy 的 Function 或 Lambda 实例，则应能接受表示矩阵坐标的两个参数。

如果它是一个纯粹包含 Python lambda 语义的字符串，则由 SymPy 解析器解释，并转换为 SymPy 的 Lambda 实例。

示例

从 Lambda 创建 FunctionMatrix：

>>> from sympy import FunctionMatrix, symbols, Lambda, MatPow
>>> i, j, n, m = symbols('i,j,n,m')
>>> FunctionMatrix(n, m, Lambda((i, j), i + j))
FunctionMatrix(n, m, Lambda((i, j), i + j)) 

从 SymPy 函数创建 FunctionMatrix：

>>> from sympy import KroneckerDelta
>>> X = FunctionMatrix(3, 3, KroneckerDelta)
>>> X.as_explicit()
Matrix([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]]) 

从 SymPy 未定义函数创建 FunctionMatrix：

>>> from sympy import Function
>>> f = Function('f')
>>> X = FunctionMatrix(3, 3, f)
>>> X.as_explicit()
Matrix([
[f(0, 0), f(0, 1), f(0, 2)],
[f(1, 0), f(1, 1), f(1, 2)],
[f(2, 0), f(2, 1), f(2, 2)]]) 

从 Python lambda 创建 FunctionMatrix：

>>> FunctionMatrix(n, m, 'lambda i, j: i + j')
FunctionMatrix(n, m, Lambda((i, j), i + j)) 

矩阵乘积的惰性求值示例：

>>> Y = FunctionMatrix(1000, 1000, Lambda((i, j), i + j))
>>> isinstance(Y*Y, MatPow) # this is an expression object
True
>>> (Y**2)[10,10] # So this is evaluated lazily
342923500 

注意事项

该类提供了一种用最稀疏方式表示序列形式的极度密集矩阵的替代方法。

class sympy.matrices.expressions.PermutationMatrix(perm)

一个置换矩阵

参数：

perm：置换

矩阵使用的置换。

置换确定矩阵大小的大小。

参阅sympy.combinatorics.permutations.Permutation文档，了解如何创建置换对象的详细信息。

示例

>>> from sympy import Matrix, PermutationMatrix
>>> from sympy.combinatorics import Permutation 

创建置换矩阵：

>>> p = Permutation(1, 2, 0)
>>> P = PermutationMatrix(p)
>>> P = P.as_explicit()
>>> P
Matrix([
[0, 1, 0],
[0, 0, 1],
[1, 0, 0]]) 

置换矩阵的行和列：

>>> M = Matrix([0, 1, 2])
>>> Matrix(P*M)
Matrix([
[1],
[2],
[0]]) 

>>> Matrix(M.T*P)
Matrix([[2, 0, 1]]) 

另请参阅

sympy.combinatorics.permutations.Permutation

class sympy.matrices.expressions.MatrixPermute(mat, perm, axis=0)

用于置换矩阵行或列的符号表示。

参数：

perm：置换，置换矩阵

用于置换矩阵的置换。置换可以调整为合适的大小，

axis：0 或 1

要与之一起置换的轴。如果为(0)，它将置换矩阵行。如果为(1)，它将置换矩阵列。

注意事项

这遵循与sympy.matrices.matrixbase.MatrixBase.permute()中使用的相同符号。

示例

>>> from sympy import Matrix, MatrixPermute
>>> from sympy.combinatorics import Permutation 

置换矩阵的行：

>>> p = Permutation(1, 2, 0)
>>> A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> B = MatrixPermute(A, p, axis=0)
>>> B.as_explicit()
Matrix([
[4, 5, 6],
[7, 8, 9],
[1, 2, 3]]) 

置换矩阵的列：

>>> B = MatrixPermute(A, p, axis=1)
>>> B.as_explicit()
Matrix([
[2, 3, 1],
[5, 6, 4],
[8, 9, 7]]) 

另请参阅

sympy.matrices.matrixbase.MatrixBase.permute

class sympy.matrices.expressions.Identity(n)

矩阵单位矩阵 I - 乘法单位元素

示例

>>> from sympy import Identity, MatrixSymbol
>>> A = MatrixSymbol('A', 3, 5)
>>> I = Identity(3)
>>> I*A
A 

class sympy.matrices.expressions.ZeroMatrix(m, n)

矩阵零 0 - 加法单位元素

示例

>>> from sympy import MatrixSymbol, ZeroMatrix
>>> A = MatrixSymbol('A', 3, 5)
>>> Z = ZeroMatrix(3, 5)
>>> A + Z
A
>>> Z*A.T
0 

class sympy.matrices.expressions.CompanionMatrix(poly)

多项式的符号伴随矩阵。

示例

>>> from sympy import Poly, Symbol, symbols
>>> from sympy.matrices.expressions import CompanionMatrix
>>> x = Symbol('x')
>>> c0, c1, c2, c3, c4 = symbols('c0:5')
>>> p = Poly(c0 + c1*x + c2*x**2 + c3*x**3 + c4*x**4 + x**5, x)
>>> CompanionMatrix(p)
CompanionMatrix(Poly(x**5 + c4*x**4 + c3*x**3 + c2*x**2 + c1*x + c0,
x, domain='ZZ[c0,c1,c2,c3,c4]')) 

class sympy.matrices.expressions.MatrixSet(n, m, set)

MatrixSet 表示形状为(n, m)的矩阵集合。

示例

>>> from sympy.matrices import MatrixSet
>>> from sympy import S, I, Matrix
>>> M = MatrixSet(2, 2, set=S.Reals)
>>> X = Matrix([[1, 2], [3, 4]])
>>> X in M
True
>>> X = Matrix([[1, 2], [I, 4]])
>>> X in M
False 

块矩阵

块矩阵允许您使用较小的子块构建较大的矩阵。它们可以与MatrixExpr或ImmutableMatrix对象一起使用。

class sympy.matrices.expressions.blockmatrix.BlockMatrix(*args, **kwargs)

块矩阵是由其他矩阵组成的矩阵。

子矩阵存储在 SymPy 矩阵对象中，但作为矩阵表达式的一部分访问。

>>> from sympy import (MatrixSymbol, BlockMatrix, symbols,
...     Identity, ZeroMatrix, block_collapse)
>>> n,m,l = symbols('n m l')
>>> X = MatrixSymbol('X', n, n)
>>> Y = MatrixSymbol('Y', m, m)
>>> Z = MatrixSymbol('Z', n, m)
>>> B = BlockMatrix([[X, Z], [ZeroMatrix(m,n), Y]])
>>> print(B)
Matrix([
[X, Z],
[0, Y]]) 

>>> C = BlockMatrix([[Identity(n), Z]])
>>> print(C)
Matrix([[I, Z]]) 

>>> print(block_collapse(C*B))
Matrix([[X, Z + Z*Y]]) 

一些矩阵可能由块的行组成，每行中的矩阵具有相同的高度，并且所有行具有相同的总列数，但在每行中的每个矩阵中不具有相同数量的列。在这种情况下，矩阵不是块矩阵，并且应通过 Matrix 进行实例化。

>>> from sympy import ones, Matrix
>>> dat = [
... [ones(3,2), ones(3,3)*2],
... [ones(2,3)*3, ones(2,2)*4]]
...
>>> BlockMatrix(dat)
Traceback (most recent call last):
...
ValueError:
Although this matrix is comprised of blocks, the blocks do not fill
the matrix in a size-symmetric fashion. To create a full matrix from
these arguments, pass them directly to Matrix.
>>> Matrix(dat)
Matrix([
[1, 1, 2, 2, 2],
[1, 1, 2, 2, 2],
[1, 1, 2, 2, 2],
[3, 3, 3, 4, 4],
[3, 3, 3, 4, 4]]) 

另请参阅

sympy.matrices.matrixbase.MatrixBase.irregular

LDUdecomposition()

返回一个 2x2 块矩阵的块 LDU 分解。

返回：

(L, D, U)：矩阵

L：下三角矩阵 D：对角矩阵 U：上三角矩阵

引发：

ShapeError

如果块矩阵不是 2x2 矩阵

NonInvertibleMatrixError

如果矩阵“A”是不可逆的

示例

>>> from sympy import symbols, MatrixSymbol, BlockMatrix, block_collapse
>>> m, n = symbols('m n')
>>> A = MatrixSymbol('A', n, n)
>>> B = MatrixSymbol('B', n, m)
>>> C = MatrixSymbol('C', m, n)
>>> D = MatrixSymbol('D', m, m)
>>> X = BlockMatrix([[A, B], [C, D]])
>>> L, D, U = X.LDUdecomposition()
>>> block_collapse(L*D*U)
Matrix([
[A, B],
[C, D]]) 

另请参阅

sympy.matrices.expressions.blockmatrix.BlockMatrix.UDLdecomposition, sympy.matrices.expressions.blockmatrix.BlockMatrix.LUdecomposition

LUdecomposition()

返回 2x2 块矩阵的块 LU 分解

返回：

(L, U)：矩阵

L：下对角矩阵 U：上对角矩阵

抛出：

ShapeError

如果块矩阵不是 2x2 矩阵

NonInvertibleMatrixError

如果矩阵“A”是非可逆的

示例

>>> from sympy import symbols, MatrixSymbol, BlockMatrix, block_collapse
>>> m, n = symbols('m n')
>>> A = MatrixSymbol('A', n, n)
>>> B = MatrixSymbol('B', n, m)
>>> C = MatrixSymbol('C', m, n)
>>> D = MatrixSymbol('D', m, m)
>>> X = BlockMatrix([[A, B], [C, D]])
>>> L, U = X.LUdecomposition()
>>> block_collapse(L*U)
Matrix([
[A, B],
[C, D]]) 

参见

sympy.matrices.expressions.blockmatrix.BlockMatrix.UDLdecomposition, sympy.matrices.expressions.blockmatrix.BlockMatrix.LDUdecomposition

UDLdecomposition()

返回 2x2 块矩阵的块 UDL 分解

返回：

(U, D, L)：矩阵

U：上对角矩阵 D：对角矩阵 L：下对角矩阵

抛出：

ShapeError

如果块矩阵不是 2x2 矩阵

NonInvertibleMatrixError

如果矩阵“D”是非可逆的

示例

>>> from sympy import symbols, MatrixSymbol, BlockMatrix, block_collapse
>>> m, n = symbols('m n')
>>> A = MatrixSymbol('A', n, n)
>>> B = MatrixSymbol('B', n, m)
>>> C = MatrixSymbol('C', m, n)
>>> D = MatrixSymbol('D', m, m)
>>> X = BlockMatrix([[A, B], [C, D]])
>>> U, D, L = X.UDLdecomposition()
>>> block_collapse(U*D*L)
Matrix([
[A, B],
[C, D]]) 

参见

sympy.matrices.expressions.blockmatrix.BlockMatrix.LDUdecomposition, sympy.matrices.expressions.blockmatrix.BlockMatrix.LUdecomposition

schur(mat='A', generalized=False)

返回 2x2 块矩阵的舒尔补

参数：

mat：字符串，可选

用于计算舒尔补的矩阵。“默认情况下使用“A”

generalized：布尔值，可选

如果为 True，则返回使用摩尔-彭罗斯逆的广义舒尔补

返回：

M：矩阵

舒尔补矩阵

抛出：

ShapeError

如果块矩阵不是 2x2 矩阵

NonInvertibleMatrixError

如果给定的矩阵是非可逆的

示例

>>> from sympy import symbols, MatrixSymbol, BlockMatrix
>>> m, n = symbols('m n')
>>> A = MatrixSymbol('A', n, n)
>>> B = MatrixSymbol('B', n, m)
>>> C = MatrixSymbol('C', m, n)
>>> D = MatrixSymbol('D', m, m)
>>> X = BlockMatrix([[A, B], [C, D]]) 

默认的舒尔补是使用“A”进行评估的

>>> X.schur()
-C*A**(-1)*B + D
>>> X.schur('D')
A - B*D**(-1)*C 

非可逆矩阵的舒尔补没有定义。相反，可以计算使用摩尔-彭罗斯逆的广义舒尔补。为此，必须将 generalized 设置为 True。

>>> X.schur('B', generalized=True)
C - D*(B.T*B)**(-1)*B.T*A
>>> X.schur('C', generalized=True)
-A*(C.T*C)**(-1)*C.T*D + B 

参见

sympy.matrices.matrixbase.MatrixBase.pinv

参考文献

[R608]

维基百科关于舒尔补的文章

transpose()

返回矩阵的转置。

示例

>>> from sympy import MatrixSymbol, BlockMatrix, ZeroMatrix
>>> from sympy.abc import m, n
>>> X = MatrixSymbol('X', n, n)
>>> Y = MatrixSymbol('Y', m, m)
>>> Z = MatrixSymbol('Z', n, m)
>>> B = BlockMatrix([[X, Z], [ZeroMatrix(m,n), Y]])
>>> B.transpose()
Matrix([
[X.T,  0],
[Z.T, Y.T]])
>>> _.transpose()
Matrix([
[X, Z],
[0, Y]]) 

class sympy.matrices.expressions.blockmatrix.BlockDiagMatrix(*mats)

一个带有块矩阵的稀疏矩阵

示例

>>> from sympy import MatrixSymbol, BlockDiagMatrix, symbols
>>> n, m, l = symbols('n m l')
>>> X = MatrixSymbol('X', n, n)
>>> Y = MatrixSymbol('Y', m, m)
>>> BlockDiagMatrix(X, Y)
Matrix([
[X, 0],
[0, Y]]) 

注意事项

如果您想获取单独的对角块，请使用 get_diag_blocks()。

参见

sympy.matrices.dense.diag

get_diag_blocks()

返回矩阵的对角块列表。

示例

>>> from sympy import BlockDiagMatrix, Matrix 

>>> A = Matrix([[1, 2], [3, 4]])
>>> B = Matrix([[5, 6], [7, 8]])
>>> M = BlockDiagMatrix(A, B) 

如何从块对角矩阵获取对角块：

>>> diag_blocks = M.get_diag_blocks()
>>> diag_blocks[0]
Matrix([
[1, 2],
[3, 4]])
>>> diag_blocks[1]
Matrix([
[5, 6],
[7, 8]]) 

sympy.matrices.expressions.blockmatrix.block_collapse(expr)

评估块矩阵表达式

>>> from sympy import MatrixSymbol, BlockMatrix, symbols, Identity, ZeroMatrix, block_collapse
>>> n,m,l = symbols('n m l')
>>> X = MatrixSymbol('X', n, n)
>>> Y = MatrixSymbol('Y', m, m)
>>> Z = MatrixSymbol('Z', n, m)
>>> B = BlockMatrix([[X, Z], [ZeroMatrix(m, n), Y]])
>>> print(B)
Matrix([
[X, Z],
[0, Y]]) 

>>> C = BlockMatrix([[Identity(n), Z]])
>>> print(C)
Matrix([[I, Z]]) 

>>> print(block_collapse(C*B))
Matrix([[X, Z + Z*Y]]) 

矩阵正则形式

原文链接：docs.sympy.org/latest/modules/matrices/normalforms.html

sympy.matrices.normalforms.smith_normal_form(m, domain=None)

返回矩阵 (m) 在环 (domain) 上的 Smith 正则形式。这只适用于环是主理想域的情况。

示例

>>> from sympy import Matrix, ZZ
>>> from sympy.matrices.normalforms import smith_normal_form
>>> m = Matrix([[12, 6, 4], [3, 9, 6], [2, 16, 14]])
>>> print(smith_normal_form(m, domain=ZZ))
Matrix([[1, 0, 0], [0, 10, 0], [0, 0, -30]]) 

sympy.matrices.normalforms.hermite_normal_form(A, *, D=None, check_rank=False)

计算整数矩阵 A 的 Hermite 正则形式。

参数：

A : (m \times n) 整数 Matrix。

D : int, 可选

假设 (W) 是 A 的 HNF。如果事先已知，可提供正整数 D，它是 (\det(W)) 的任意倍数。在这种情况下，如果 A 的秩也是 (m)，那么我们可以使用另一种算法，该算法在 mod D 下工作，以防止系数膨胀。

check_rank : 布尔值, 可选 (默认为 False)

基本假设是，如果您传递了 D 的值，则已相信 A 的秩是 (m)，因此我们不会浪费时间为您检查它。如果您希望进行检查（并且如果检查失败，则使用普通的非模 D 算法），则将 check_rank 设置为 True。

返回：

Matrix

矩阵 A 的 Hermite 正则形式。

引发：

DMDomainError

如果矩阵的域不是 ZZ。

DMShapeError

如果使用 mod D 算法但矩阵的行数多于列数。

示例

>>> from sympy import Matrix
>>> from sympy.matrices.normalforms import hermite_normal_form
>>> m = Matrix([[12, 6, 4], [3, 9, 6], [2, 16, 14]])
>>> print(hermite_normal_form(m))
Matrix([[10, 0, 2], [0, 15, 3], [0, 0, 2]]) 

参考文献

[R647]

Cohen, H. 计算代数数论课程. (见算法 2.4.5 和 2.4.8。)

张量

原文链接：docs.sympy.org/latest/modules/tensor/index.html

一个用于处理包括张量在内的带有指数的符号对象的模块。

内容

• N 维数组

• N 维数组表达式

• 索引对象

• 方法

• 张量

• 张量运算符

N 维数组

原文链接：docs.sympy.org/latest/modules/tensor/array.html

SymPy 的 N 维数组模块。

提供了四个类来处理 N 维数组，根据稠密/稀疏（即是否将所有元素或仅非零元素存储在内存中）和可变/不可变的组合（不可变类是 SymPy 对象，但在创建后不能更改）。

示例

以下示例展示了Array的使用。这是ImmutableDenseNDimArray的缩写，即一个不可变的稠密 N 维数组，其他类似。

可以检测嵌套列表和元组的形状来构造数组

>>> from sympy import Array
>>> a1 = Array([[1, 2], [3, 4], [5, 6]])
>>> a1
[[1, 2], [3, 4], [5, 6]]
>>> a1.shape
(3, 2)
>>> a1.rank()
2
>>> from sympy.abc import x, y, z
>>> a2 = Array([[[x, y], [z, x*z]], [[1, x*y], [1/x, x/y]]])
>>> a2
[[[x, y], [z, x*z]], [[1, x*y], [1/x, x/y]]]
>>> a2.shape
(2, 2, 2)
>>> a2.rank()
3 

或者可以传递一个 1 维数组，然后是一个形状元组：

>>> m1 = Array(range(12), (3, 4))
>>> m1
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]
>>> m2 = Array(range(12), (3, 2, 2))
>>> m2
[[[0, 1], [2, 3]], [[4, 5], [6, 7]], [[8, 9], [10, 11]]]
>>> m2[1,1,1]
7
>>> m2.reshape(4, 3)
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]] 

切片支持：

>>> m2[:, 1, 1]
[3, 7, 11] 

按元素求导：

>>> from sympy.abc import x, y, z
>>> m3 = Array([x**3, x*y, z])
>>> m3.diff(x)
[3*x**2, y, 0]
>>> m3.diff(z)
[0, 0, 1] 

与其他 SymPy 表达式的乘法是按元素应用的：

>>> (1+x)*m3
[x**3*(x + 1), x*y*(x + 1), z*(x + 1)] 

若要对 N 维数组的每个元素应用函数，请使用applyfunc：

>>> m3.applyfunc(lambda x: x/2)
[x**3/2, x*y/2, z/2] 

N 维数组可以通过tolist()方法转换为嵌套列表：

>>> m2.tolist()
[[[0, 1], [2, 3]], [[4, 5], [6, 7]], [[8, 9], [10, 11]]]
>>> isinstance(m2.tolist(), list)
True 

如果秩为 2，可以用tomatrix()将它们转换为矩阵：

>>> m1.tomatrix()
Matrix([
[0, 1,  2,  3],
[4, 5,  6,  7],
[8, 9, 10, 11]]) 

乘积和收缩

数组(A_{i_1,\ldots,i_n})和(B_{j_1,\ldots,j_m})之间的张量积创建定义为组合数组(P = A \otimes B)的张量积，定义为

(P_{i_1,\ldots,i_n,j_1,\ldots,j_m} := A_{i_1,\ldots,i_n}\cdot B_{j_1,\ldots,j_m}.)

可通过tensorproduct(...)获得：

>>> from sympy import Array, tensorproduct
>>> from sympy.abc import x,y,z,t
>>> A = Array([x, y, z, t])
>>> B = Array([1, 2, 3, 4])
>>> tensorproduct(A, B)
[[x, 2*x, 3*x, 4*x], [y, 2*y, 3*y, 4*y], [z, 2*z, 3*z, 4*z], [t, 2*t, 3*t, 4*t]] 

如果不想立即计算张量积，可以使用ArrayTensorProduct，它创建一个未评估的张量积表达式：

>>> from sympy.tensor.array.expressions import ArrayTensorProduct
>>> ArrayTensorProduct(A, B)
ArrayTensorProduct([x, y, z, t], [1, 2, 3, 4]) 

在ArrayTensorProduct上调用.as_explicit()相当于直接调用tensorproduct(...)：

>>> ArrayTensorProduct(A, B).as_explicit()
[[x, 2*x, 3*x, 4*x], [y, 2*y, 3*y, 4*y], [z, 2*z, 3*z, 4*z], [t, 2*t, 3*t, 4*t]] 

秩为 1 的数组与矩阵的张量积创建一个秩为 3 的数组：

>>> from sympy import eye
>>> p1 = tensorproduct(A, eye(4))
>>> p1
[[[x, 0, 0, 0], [0, x, 0, 0], [0, 0, x, 0], [0, 0, 0, x]], [[y, 0, 0, 0], [0, y, 0, 0], [0, 0, y, 0], [0, 0, 0, y]], [[z, 0, 0, 0], [0, z, 0, 0], [0, 0, z, 0], [0, 0, 0, z]], [[t, 0, 0, 0], [0, t, 0, 0], [0, 0, t, 0], [0, 0, 0, t]]] 

现在，要获取(A_0 \otimes \mathbf{1})，可以通过切片访问(p_{0,m,n})：

>>> p1[0,:,:]
[[x, 0, 0, 0], [0, x, 0, 0], [0, 0, x, 0], [0, 0, 0, x]] 

张量收缩对指定的轴求和，例如收缩位置(a)和(b)意味着

(A_{i_1,\ldots,i_a,\ldots,i_b,\ldots,i_n} \implies \sum_k A_{i_1,\ldots,k,\ldots,k,\ldots,i_n})

请记住，Python 索引从零开始，因此要收缩第 a 和第 b 个轴，需要指定(a-1)和(b-1)

>>> from sympy import tensorcontraction
>>> C = Array([[x, y], [z, t]]) 

矩阵的迹等价于一个秩为 2 的数组的收缩：

(A_{m,n} \implies \sum_k A_{k,k})

>>> tensorcontraction(C, (0, 1))
t + x 

要创建一个表示不立即评估的张量收缩的表达式，请使用ArrayContraction，如果跟随.as_explicit()，则等效于tensorcontraction(...)：

>>> from sympy.tensor.array.expressions import ArrayContraction
>>> ArrayContraction(C, (0, 1))
ArrayContraction([[x, y], [z, t]], (0, 1))
>>> ArrayContraction(C, (0, 1)).as_explicit()
t + x 

矩阵乘积等价于两个秩为 2 的数组的张量积，然后收缩第 2 和第 3 个轴（在 Python 中索引轴号为 1、2）。

(A_{m,n}\cdot B_{i,j} \implies \sum_k A_{m, k}\cdot B_{k, j})

>>> D = Array([[2, 1], [0, -1]])
>>> tensorcontraction(tensorproduct(C, D), (1, 2))
[[2*x, x - y], [2*z, -t + z]] 

可以验证矩阵乘积是等价的：

>>> from sympy import Matrix
>>> Matrix([[x, y], [z, t]])*Matrix([[2, 1], [0, -1]])
Matrix([
[2*x,  x - y],
[2*z, -t + z]]) 

或者等价地

>>> C.tomatrix()*D.tomatrix()
Matrix([
[2*x,  x - y],
[2*z, -t + z]]) 

对角线操作符

tensordiagonal 函数的行为方式与 tensorcontraction 类似，但连接的索引不进行求和，例如对位置 (a) 和 (b) 进行对角化意味着

(A_{i_1,\ldots,i_a,\ldots,i_b,\ldots,i_n} \implies A_{i_1,\ldots,k,\ldots,k,\ldots,i_n} \implies \tilde{A}{i_1,\ldots,i{a-1},i_{a+1},\ldots,i_{b-1},i_{b+1},\ldots,i_n,k})

其中 (\tilde{A}) 是在位置 (a) 和 (b) 移动到最后索引位置的 (A) 的对角化数组等价物。

比较收缩和对角运算符之间的差异：

>>> from sympy import tensordiagonal
>>> from sympy.abc import a, b, c, d
>>> m = Matrix([[a, b], [c, d]])
>>> tensorcontraction(m, [0, 1])
a + d
>>> tensordiagonal(m, [0, 1])
[a, d] 

简而言之，tensordiagonal 不会对加和进行求和。

通过数组导数

常规的导数操作可以扩展到支持对数组进行导数，前提是该数组中的所有元素都是符号或适合导数计算的表达式。

由数组定义的导数如下：给定数组 (A_{i_1, \ldots, i_N}) 和数组 (X_{j_1, \ldots, j_M})，数组的导数将返回由新数组 (B) 定义的新数组

(B_{j_1,\ldots,j_M,i_1,\ldots,i_N} := \frac{\partial A_{i_1,\ldots,i_N}}{\partial X_{j_1,\ldots,j_M}})

函数 derive_by_array 执行这样的操作：

>>> from sympy import derive_by_array
>>> from sympy.abc import x, y, z, t
>>> from sympy import sin, exp 

对标量而言，其行为与普通导数完全相同：

>>> derive_by_array(sin(x*y), x)
y*cos(x*y) 

标量由数组基础推导：

>>> derive_by_array(sin(x*y), [x, y, z])
[y*cos(x*y), x*cos(x*y), 0] 

通过数组基础进行的导数：(B^{nm} := \frac{\partial A^m}{\partial x^n})

>>> basis = [x, y, z]
>>> ax = derive_by_array([exp(x), sin(y*z), t], basis)
>>> ax
[[exp(x), 0, 0], [0, z*cos(y*z), 0], [0, y*cos(y*z), 0]] 

收缩结果数组：(\sum_m \frac{\partial A^m}{\partial x^m})

>>> tensorcontraction(ax, (0, 1))
z*cos(y*z) + exp(x) 

类：

class sympy.tensor.array.ImmutableDenseNDimArray(iterable, shape=None, **kwargs)

class sympy.tensor.array.ImmutableSparseNDimArray(iterable=None, shape=None, **kwargs)

class sympy.tensor.array.MutableDenseNDimArray(iterable=None, shape=None, **kwargs)

class sympy.tensor.array.MutableSparseNDimArray(iterable=None, shape=None, **kwargs)

函数：

sympy.tensor.array.derive_by_array(expr, dx)

由数组导数。支持数组和标量。

数组表达式的等价运算符是 array_derive。

解释

给定数组 (A_{i_1, \ldots, i_N}) 和数组 (X_{j_1, \ldots, j_M})，此函数将返回由新数组 (B) 定义的新数组

(B_{j_1,\ldots,j_M,i_1,\ldots,i_N} := \frac{\partial A_{i_1,\ldots,i_N}}{\partial X_{j_1,\ldots,j_M}})

示例：

>>> from sympy import derive_by_array
>>> from sympy.abc import x, y, z, t
>>> from sympy import cos
>>> derive_by_array(cos(x*t), x)
-t*sin(t*x)
>>> derive_by_array(cos(x*t), [x, y, z, t])
[-t*sin(t*x), 0, 0, -x*sin(t*x)]
>>> derive_by_array([x, y**2*z], [[x, y], [z, t]])
[[[1, 0], [0, 2*y*z]], [[0, y**2], [0, 0]]] 

sympy.tensor.array.permutedims(expr, perm=None, index_order_old=None, index_order_new=None)

对数组的索引进行排列。

参数指定索引的排列。

数组表达式的等价运算符是 PermuteDims，可用于保持表达式不被求值。

示例：

>>> from sympy.abc import x, y, z, t
>>> from sympy import sin
>>> from sympy import Array, permutedims
>>> a = Array([[x, y, z], [t, sin(x), 0]])
>>> a
[[x, y, z], [t, sin(x), 0]]
>>> permutedims(a, (1, 0))
[[x, t], [y, sin(x)], [z, 0]] 

如果数组是二阶的，可以使用 transpose：

>>> from sympy import transpose
>>> transpose(a)
[[x, t], [y, sin(x)], [z, 0]] 

高维度的示例：

>>> b = Array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
>>> permutedims(b, (2, 1, 0))
[[[1, 5], [3, 7]], [[2, 6], [4, 8]]]
>>> permutedims(b, (1, 2, 0))
[[[1, 5], [2, 6]], [[3, 7], [4, 8]]] 

指定与前几行相同排列的另一种方法是将旧和新索引作为列表或字符串传递：

>>> permutedims(b, index_order_old="cba", index_order_new="abc")
[[[1, 5], [3, 7]], [[2, 6], [4, 8]]]
>>> permutedims(b, index_order_old="cab", index_order_new="abc")
[[[1, 5], [2, 6]], [[3, 7], [4, 8]]] 

Permutation 对象也是允许的：

>>> from sympy.combinatorics import Permutation
>>> permutedims(b, Permutation([1, 2, 0]))
[[[1, 5], [2, 6]], [[3, 7], [4, 8]]] 

另请参阅：

sympy.tensor.array.expressions.array_expressions.PermuteDims

sympy.tensor.array.tensorcontraction(array, *contraction_axes)

在指定轴上收缩类似数组对象。

数组表达式的等价运算符是 ArrayContraction，可用于保持表达式不被求值。

示例：

>>> from sympy import Array, tensorcontraction
>>> from sympy import Matrix, eye
>>> tensorcontraction(eye(3), (0, 1))
3
>>> A = Array(range(18), (3, 2, 3))
>>> A
[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16, 17]]]
>>> tensorcontraction(A, (0, 2))
[21, 30] 

可以通过适当的 tensorcontraction 和 tensorproduct 组合来模拟矩阵乘法

>>> from sympy import tensorproduct
>>> from sympy.abc import a,b,c,d,e,f,g,h
>>> m1 = Matrix([[a, b], [c, d]])
>>> m2 = Matrix([[e, f], [g, h]])
>>> p = tensorproduct(m1, m2)
>>> p
[[[[a*e, a*f], [a*g, a*h]], [[b*e, b*f], [b*g, b*h]]], [[[c*e, c*f], [c*g, c*h]], [[d*e, d*f], [d*g, d*h]]]]
>>> tensorcontraction(p, (1, 2))
[[a*e + b*g, a*f + b*h], [c*e + d*g, c*f + d*h]]
>>> m1*m2
Matrix([
[a*e + b*g, a*f + b*h],
[c*e + d*g, c*f + d*h]]) 

另请参阅：

sympy.tensor.array.expressions.array_expressions.ArrayContraction

sympy.tensor.array.tensorproduct(*args)

标量或类数组对象之间的张量积。

数组表达式的等效运算符是ArrayTensorProduct，可以用来保持表达式不求值。

示例

>>> from sympy.tensor.array import tensorproduct, Array
>>> from sympy.abc import x, y, z, t
>>> A = Array([[1, 2], [3, 4]])
>>> B = Array([x, y])
>>> tensorproduct(A, B)
[[[x, y], [2*x, 2*y]], [[3*x, 3*y], [4*x, 4*y]]]
>>> tensorproduct(A, x)
[[x, 2*x], [3*x, 4*x]]
>>> tensorproduct(A, B, B)
[[[[x**2, x*y], [x*y, y**2]], [[2*x**2, 2*x*y], [2*x*y, 2*y**2]]], [[[3*x**2, 3*x*y], [3*x*y, 3*y**2]], [[4*x**2, 4*x*y], [4*x*y, 4*y**2]]]] 

在两个矩阵上应用此函数将导致一个秩为 4 的数组。

>>> from sympy import Matrix, eye
>>> m = Matrix([[x, y], [z, t]])
>>> p = tensorproduct(eye(3), m)
>>> p
[[[[x, y], [z, t]], [[0, 0], [0, 0]], [[0, 0], [0, 0]]], [[[0, 0], [0, 0]], [[x, y], [z, t]], [[0, 0], [0, 0]]], [[[0, 0], [0, 0]], [[0, 0], [0, 0]], [[x, y], [z, t]]]] 

参见

sympy.tensor.array.expressions.array_expressions.ArrayTensorProduct

sympy.tensor.array.tensordiagonal(array, *diagonal_axes)

对指定轴上的类数组对象进行对角化。

这相当于将表达式乘以克罗内克三角形单位化的轴。

对角线索引被放在轴的末尾。

数组表达式的等效运算符是ArrayDiagonal，可以用来保持表达式不求值。

示例

tensordiagonal对二维数组的轴 0 和 1 的作用等效于矩阵的对角线：

>>> from sympy import Array, tensordiagonal
>>> from sympy import Matrix, eye
>>> tensordiagonal(eye(3), (0, 1))
[1, 1, 1] 

>>> from sympy.abc import a,b,c,d
>>> m1 = Matrix([[a, b], [c, d]])
>>> tensordiagonal(m1, [0, 1])
[a, d] 

对于高维数组，被对角化的维度将被追加移除，并作为最后的单一维度追加：

>>> A = Array(range(18), (3, 2, 3))
>>> A
[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16, 17]]]
>>> tensordiagonal(A, (0, 2))
[[0, 7, 14], [3, 10, 17]]
>>> from sympy import permutedims
>>> tensordiagonal(A, (0, 2)) == permutedims(Array([A[0, :, 0], A[1, :, 1], A[2, :, 2]]), [1, 0])
True 

参见

sympy.tensor.array.expressions.array_expressions.ArrayDiagonal