SymPy 1.13 中文文档（二十四·二）

发现矩阵的定性。

解释

一个实方阵 (A) 是：

• 如果对所有非零实向量 (x)，有 (x^T A x > 0)，则 (A) 是正定矩阵。

• 如果对所有非零实向量 (x)，有 (x^T A x \geq 0)，则 (A) 是正半定矩阵。

• 对于所有非零实向量 ( x )，如果 ( x^T A x < 0 )，则矩阵 ( A ) 是负定的。

• 对于所有非零实向量 ( x )，如果 ( x^T A x \leq 0 )，则矩阵是负半定的。

• 如果存在非零实向量 ( x, y )，使得 ( x^T A x > 0 > y^T A y )，则矩阵是不定的。

一个复方阵 ( A ) 是：

• 对于所有非零复向量 ( x )，如果 (\text{re}(x^H A x) > 0)，则矩阵是正定的。

• 对于所有非零复向量 ( x )，如果 (\text{re}(x^H A x) \geq 0)，则矩阵是正半定的。

• 对于所有非零复向量 ( x )，如果 (\text{re}(x^H A x) < 0)，则矩阵是负定的。

• 对于所有非零复向量 ( x )，如果 (\text{re}(x^H A x) \leq 0)，则矩阵是负半定的。

• 如果存在非零复向量 ( x, y )，使得 (\text{re}(x^H A x) > 0 > \text{re}(y^H A y))，则矩阵是不定的。

矩阵不需要对称或厄米才能是正定的。

• 对于实非对称矩阵 ( A )，如果且仅如果 (\frac{A + A^T}{2}) 是正定的，它才是正定的。

• 对于复非厄米矩阵，如果且仅如果 (\frac{A + A^H}{2}) 是正定的，那么它是正定的。

并且这种扩展可以适用于上述所有定义。

然而，对于复杂情况，你可以将 (\text{re}(x^H A x) > 0) 的定义限制为 ( x^H A x > 0 )，并要求矩阵是厄米的。但我们不在计算中呈现这个限制，因为你可以独立检查 M.is_hermitian，并使用相同的过程。

例子

对称正定矩阵的一个例子：

>>> from sympy import Matrix, symbols
>>> from sympy.plotting import plot3d
>>> a, b = symbols('a b')
>>> x = Matrix([a, b]) 

>>> A = Matrix([[1, 0], [0, 1]])
>>> A.is_positive_definite
True
>>> A.is_positive_semidefinite
True 

>>> p = plot3d((x.T*A*x)[0, 0], (a, -1, 1), (b, -1, 1)) 

(png, hires.png, pdf)

对称正半定矩阵的一个例子：

>>> A = Matrix([[1, -1], [-1, 1]])
>>> A.is_positive_definite
False
>>> A.is_positive_semidefinite
True 

>>> p = plot3d((x.T*A*x)[0, 0], (a, -1, 1), (b, -1, 1)) 

(png, hires.png, pdf)

对称负定矩阵的一个例子：

>>> A = Matrix([[-1, 0], [0, -1]])
>>> A.is_negative_definite
True
>>> A.is_negative_semidefinite
True
>>> A.is_indefinite
False 

>>> p = plot3d((x.T*A*x)[0, 0], (a, -1, 1), (b, -1, 1)) 

(png, hires.png, pdf)

对称不定矩阵的一个例子：

>>> A = Matrix([[1, 2], [2, -1]])
>>> A.is_indefinite
True 

>>> p = plot3d((x.T*A*x)[0, 0], (a, -1, 1), (b, -1, 1)) 

(png, hires.png, pdf)

一个非对称的正定矩阵的例子。

>>> A = Matrix([[1, 2], [-2, 1]])
>>> A.is_positive_definite
True
>>> A.is_positive_semidefinite
True 

>>> p = plot3d((x.T*A*x)[0, 0], (a, -1, 1), (b, -1, 1)) 

(png, hires.png, pdf)

注意事项

尽管有些人将正定矩阵的定义仅限于对称或埃尔米特矩阵，这种限制是不正确的，因为它不能从定义(x^T A x > 0)或(\text{re}(x^H A x) > 0)对所有正定矩阵的实例进行分类。

例如，上述示例中呈现的Matrix([[1, 2], [-2, 1]])是一个非对称的实正定矩阵的示例。

然而，因为以下公式成立；

[\text{re}(x^H A x) > 0 \iff \text{re}(x^H \frac{A + A^H}{2} x) > 0]

我们可以通过将矩阵转换为(\frac{A + A^T}{2})或(\frac{A + A^H}{2})（保证始终为实对称或复共轭埃尔米特）来分类所有可能或不可能为对称或埃尔米特正定矩阵，并且我们可以将大部分研究推迟到对称或埃尔米特正定矩阵。

但是，对于乔列斯基分解的存在性，这是一个不同的问题。因为即使非对称或非埃尔米特矩阵可能是正定的，乔列斯基或 LDL 分解也不存在，因为这些分解需要矩阵是对称或埃尔米特的。

参考文献

[R629]

en.wikipedia.org/wiki/Definiteness_of_a_matrix#Eigenvalues

[R630]

mathworld.wolfram.com/PositiveDefiniteMatrix.html

[R631]

Johnson, C. R. “Positive Definite Matrices.” Amer. Math. Monthly 77, 259-264 1970.

property is_square

检查矩阵是否为方阵。

如果行数等于列数，则矩阵是方阵。根据定义，空矩阵是方阵，因为行数和列数都为零。

示例

>>> from sympy import Matrix
>>> a = Matrix([[1, 2, 3], [4, 5, 6]])
>>> b = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> c = Matrix([])
>>> a.is_square
False
>>> b.is_square
True
>>> c.is_square
True 

property is_strongly_diagonally_dominant

测试矩阵是否在行上强对角占优。

解释

若(A)是一个(n, n)矩阵，则在行上强对角占优。

[\left|A_{i, i}\right| > \sum_{j = 0, j \neq i}^{n-1} \left|A_{i, j}\right| \quad {\text{for all }} i \in { 0, …, n-1 }]

示例

>>> from sympy import Matrix
>>> A = Matrix([[3, -2, 1], [1, -3, 2], [-1, 2, 4]])
>>> A.is_strongly_diagonally_dominant
False 

>>> A = Matrix([[-2, 2, 1], [1, 3, 2], [1, -2, 0]])
>>> A.is_strongly_diagonally_dominant
False 

>>> A = Matrix([[-4, 2, 1], [1, 6, 2], [1, -2, 5]])
>>> A.is_strongly_diagonally_dominant
True 

注意事项

如果要测试矩阵是否列对角占优，则可以在转置矩阵后应用该测试。

is_symbolic()

检查是否有任何元素包含符号。

示例

>>> from sympy import Matrix
>>> from sympy.abc import x, y
>>> M = Matrix([[x, y], [1, 0]])
>>> M.is_symbolic()
True 

is_symmetric(simplify=True)

检查矩阵是否对称矩阵，即方阵且等于其转置。

默认情况下，在测试对称性之前会进行简化。可以使用’simplify=False’跳过这一步；虽然可以加快速度，但可能会导致假阴性。

示例

>>> from sympy import Matrix
>>> m = Matrix(2, 2, [0, 1, 1, 2])
>>> m
Matrix([
[0, 1],
[1, 2]])
>>> m.is_symmetric()
True 

>>> m = Matrix(2, 2, [0, 1, 2, 0])
>>> m
Matrix([
[0, 1],
[2, 0]])
>>> m.is_symmetric()
False 

>>> m = Matrix(2, 3, [0, 0, 0, 0, 0, 0])
>>> m
Matrix([
[0, 0, 0],
[0, 0, 0]])
>>> m.is_symmetric()
False 

>>> from sympy.abc import x, y
>>> m = Matrix(3, 3, [1, x**2 + 2*x + 1, y, (x + 1)**2, 2, 0, y, 0, 3])
>>> m
Matrix([
[         1, x**2 + 2*x + 1, y],
[(x + 1)**2,              2, 0],
[         y,              0, 3]])
>>> m.is_symmetric()
True 

如果矩阵已经简化，则可以通过使用’simplify=False’来加速 is_symmetric()测试。

>>> bool(m.is_symmetric(simplify=False))
False
>>> m1 = m.expand()
>>> m1.is_symmetric(simplify=False)
True 

property is_upper

检查矩阵是否为上三角矩阵。 即使矩阵不是方阵，也可以返回 True。

示例

>>> from sympy import Matrix
>>> m = Matrix(2, 2, [1, 0, 0, 1])
>>> m
Matrix([
[1, 0],
[0, 1]])
>>> m.is_upper
True 

>>> m = Matrix(4, 3, [5, 1, 9, 0, 4, 6, 0, 0, 5, 0, 0, 0])
>>> m
Matrix([
[5, 1, 9],
[0, 4, 6],
[0, 0, 5],
[0, 0, 0]])
>>> m.is_upper
True 

>>> m = Matrix(2, 3, [4, 2, 5, 6, 1, 1])
>>> m
Matrix([
[4, 2, 5],
[6, 1, 1]])
>>> m.is_upper
False 

另请参阅

is_lower, is_diagonal, is_upper_hessenberg

property is_upper_hessenberg

检查矩阵是否为上 Hessenberg 形式。

上 Hessenberg 矩阵在第一个次对角线以下有零条目。

示例

>>> from sympy import Matrix
>>> a = Matrix([[1, 4, 2, 3], [3, 4, 1, 7], [0, 2, 3, 4], [0, 0, 1, 3]])
>>> a
Matrix([
[1, 4, 2, 3],
[3, 4, 1, 7],
[0, 2, 3, 4],
[0, 0, 1, 3]])
>>> a.is_upper_hessenberg
True 

另请参阅

is_lower_hessenberg, is_upper

property is_weakly_diagonally_dominant

检验矩阵是否行弱对角线占优。

说明

一个 (n, n) 矩阵 (A) 如果满足行弱对角线占优条件，则为行弱对角线占优。

[\left|A_{i, i}\right| \ge \sum_{j = 0, j \neq i}^{n-1} \left|A_{i, j}\right| \quad {\text{对于所有 }} i \in { 0, …, n-1 }]

示例

>>> from sympy import Matrix
>>> A = Matrix([[3, -2, 1], [1, -3, 2], [-1, 2, 4]])
>>> A.is_weakly_diagonally_dominant
True 

>>> A = Matrix([[-2, 2, 1], [1, 3, 2], [1, -2, 0]])
>>> A.is_weakly_diagonally_dominant
False 

>>> A = Matrix([[-4, 2, 1], [1, 6, 2], [1, -2, 5]])
>>> A.is_weakly_diagonally_dominant
True 

注意

如果您想测试一个矩阵是否是列对角占优的，可以在转置矩阵后应用测试。

property is_zero_matrix

检查矩阵是否为零矩阵。

如果每个元素都是零，则矩阵为零。 即使矩阵不是方阵，也可以认为是零矩阵。 空矩阵由虚假真理原则为零。 对于可能是零的矩阵（例如包含符号的矩阵），这将为 None

示例

>>> from sympy import Matrix, zeros
>>> from sympy.abc import x
>>> a = Matrix([[0, 0], [0, 0]])
>>> b = zeros(3, 4)
>>> c = Matrix([[0, 1], [0, 0]])
>>> d = Matrix([])
>>> e = Matrix([[x, 0], [0, 0]])
>>> a.is_zero_matrix
True
>>> b.is_zero_matrix
True
>>> c.is_zero_matrix
False
>>> d.is_zero_matrix
True
>>> e.is_zero_matrix 

iter_items()

遍历非零项的索引和值。

示例

>>> from sympy import Matrix
>>> m = Matrix([[0, 1], [2, 3]])
>>> list(m.iter_items())
[((0, 1), 1), ((1, 0), 2), ((1, 1), 3)] 

另请参阅

iter_values, todok

iter_values()

遍历自身非零值。

示例

>>> from sympy import Matrix
>>> m = Matrix([[0, 1], [2, 3]])
>>> list(m.iter_values())
[1, 2, 3] 

另请参阅

values

jacobian(X)

计算雅可比矩阵（向量值函数的导数）。

参数：

self：表示函数 f_i(x_1, …, x_n) 的表达式向量。

X：按顺序排列的 x_i 集合，可以是列表或矩阵

self 和 X 可以以任意顺序为行或列矩阵

（即，jacobian() 应始终可用）。

示例

>>> from sympy import sin, cos, Matrix
>>> from sympy.abc import rho, phi
>>> X = Matrix([rho*cos(phi), rho*sin(phi), rho**2])
>>> Y = Matrix([rho, phi])
>>> X.jacobian(Y)
Matrix([
[cos(phi), -rho*sin(phi)],
[sin(phi),  rho*cos(phi)],
[   2*rho,             0]])
>>> X = Matrix([rho*cos(phi), rho*sin(phi)])
>>> X.jacobian(Y)
Matrix([
[cos(phi), -rho*sin(phi)],
[sin(phi),  rho*cos(phi)]]) 

另请参阅

hessian, wronskian

classmethod jordan_block(size=None, eigenvalue=None, *, band='upper', **kwargs)

返回一个 Jordan 块

参数：

大小：整数，可选

指定 Jordan 块矩阵的形状。

特征值：数或符号

指定矩阵的主对角线的值。

注意

关键字 eigenval 也被指定为该关键字的别名，但不建议使用。

我们可能在后续版本中弃用该别名。

带宽：‘上’或‘下’，可选

指定非对角线上的位置以放置 (1)。

cls : Matrix, optional

指定输出形式的矩阵类。

如果未指定，则将在执行方法的类类型返回。

返回：

矩阵

约旦块矩阵。

引发：

ValueError：数值错误

如果矩阵大小规格给定的参数不足，或者没有给出特征值。

示例

创建默认的约旦块：

>>> from sympy import Matrix
>>> from sympy.abc import x
>>> Matrix.jordan_block(4, x)
Matrix([
[x, 1, 0, 0],
[0, x, 1, 0],
[0, 0, x, 1],
[0, 0, 0, x]]) 

创建具有关键字参数的备选约旦块矩阵，其中 (1) 在对角线以下：

>>> Matrix.jordan_block(4, x, band='lower')
Matrix([
[x, 0, 0, 0],
[1, x, 0, 0],
[0, 1, x, 0],
[0, 0, 1, x]]) 

使用关键字参数创建约旦块矩阵

>>> Matrix.jordan_block(size=4, eigenvalue=x)
Matrix([
[x, 1, 0, 0],
[0, x, 1, 0],
[0, 0, x, 1],
[0, 0, 0, x]]) 

参考文献

[R632]

en.wikipedia.org/wiki/Jordan_matrix

jordan_form(calc_transform=True, **kwargs)

返回 ((P, J))，其中 (J) 是约旦块矩阵，(P) 是使得 (M = P J P^{-1}) 的矩阵。

参数：

calc_transform : bool

如果为False，则仅返回 (J)。

chop : bool

在计算特征值和特征向量时，所有矩阵都转换为精确类型。因此，可能存在近似误差。如果 chop==True，则这些错误将被截断。

示例

>>> from sympy import Matrix
>>> M = Matrix([[ 6,  5, -2, -3], [-3, -1,  3,  3], [ 2,  1, -2, -3], [-1,  1,  5,  5]])
>>> P, J = M.jordan_form()
>>> J
Matrix([
[2, 1, 0, 0],
[0, 2, 0, 0],
[0, 0, 2, 1],
[0, 0, 0, 2]]) 

另见

jordan_block

key2bounds(keys)

将具有潜在混合键类型（整数和切片）的键转换为范围的元组，并在任何索引超出self范围时引发错误。

另见

key2ij

key2ij(key)

将键转换为规范形式，将整数或可索引项转换为self范围内的有效整数，或不改变切片。

另见

key2bounds

left_eigenvects(**flags)

返回左特征向量和特征值。

此函数返回左特征向量的三元组列表（特征值，重数，基）。选项与 eigenvects() 相同，即 **flags 参数直接传递给 eigenvects()。

示例

>>> from sympy import Matrix
>>> M = Matrix([[0, 1, 1], [1, 0, 0], [1, 1, 1]])
>>> M.eigenvects()
[(-1, 1, [Matrix([
[-1],
[ 1],
[ 0]])]), (0, 1, [Matrix([
[ 0],
[-1],
[ 1]])]), (2, 1, [Matrix([
[2/3],
[1/3],
[  1]])])]
>>> M.left_eigenvects()
[(-1, 1, [Matrix([[-2, 1, 1]])]), (0, 1, [Matrix([[-1, -1, 1]])]), (2,
1, [Matrix([[1, 1, 1]])])] 

limit(*args)

计算矩阵中每个元素的极限。args 将传递给 limit 函数。

示例

>>> from sympy import Matrix
>>> from sympy.abc import x, y
>>> M = Matrix([[x, y], [1, 0]])
>>> M.limit(x, 2)
Matrix([
[2, y],
[1, 0]]) 

另见

integrate, diff

log(simplify=<function cancel>)

返回方阵的对数。

参数：

simplify : function, bool

用于简化结果的函数。

默认为cancel，对于减少符号矩阵的取倒和求逆的表达式增长有效。

示例

>>> from sympy import S, Matrix 

正定矩阵的示例：

>>> m = Matrix([[1, 1], [0, 1]])
>>> m.log()
Matrix([
[0, 1],
[0, 0]]) 

>>> m = Matrix([[S(5)/4, S(3)/4], [S(3)/4, S(5)/4]])
>>> m.log()
Matrix([
[     0, log(2)],
[log(2),      0]]) 

非正定矩阵示例：

>>> m = Matrix([[S(3)/4, S(5)/4], [S(5)/4, S(3)/4]])
>>> m.log()
Matrix([
[         I*pi/2, log(2) - I*pi/2],
[log(2) - I*pi/2,          I*pi/2]]) 

>>> m = Matrix(
...     [[0, 0, 0, 1],
...      [0, 0, 1, 0],
...      [0, 1, 0, 0],
...      [1, 0, 0, 0]])
>>> m.log()
Matrix([
[ I*pi/2,       0,       0, -I*pi/2],
[      0,  I*pi/2, -I*pi/2,       0],
[      0, -I*pi/2,  I*pi/2,       0],
[-I*pi/2,       0,       0,  I*pi/2]]) 

lower_triangular(k=0)

返回矩阵的第 k 条对角线及其下元素。如果未指定 k，则简单返回矩阵的下三角部分。

示例

>>> from sympy import ones
>>> A = ones(4)
>>> A.lower_triangular()
Matrix([
[1, 0, 0, 0],
[1, 1, 0, 0],
[1, 1, 1, 0],
[1, 1, 1, 1]]) 

>>> A.lower_triangular(-2)
Matrix([
[0, 0, 0, 0],
[0, 0, 0, 0],
[1, 0, 0, 0],
[1, 1, 0, 0]]) 

>>> A.lower_triangular(1)
Matrix([
[1, 1, 0, 0],
[1, 1, 1, 0],
[1, 1, 1, 1],
[1, 1, 1, 1]]) 

lower_triangular_solve(rhs)

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

另见

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

minor(i, j, method='berkowitz')

返回矩阵 M 的(i,j)次小项。即返回通过从 M 中删除第 i 行和第 j 列而获得的矩阵的行列式。

参数：

i, j : 整数

获取子矩阵时排除的行和列。

method : 字符串，可选

用于查找子矩阵行列式的方法，可以是“bareiss”、“berkowitz”、“bird”、“laplace”或“lu”。

示例

>>> from sympy import Matrix
>>> M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> M.minor(1, 1)
-12 

另见

minor_submatrix, cofactor, det

minor_submatrix(i, j)

返回通过从 M 中删除第 i 行和第 j 列获得的子矩阵（支持 Pythonic 负索引）。

参数：

i, j : 整数

获取子矩阵时排除的行和列。

示例

>>> from sympy import Matrix
>>> M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> M.minor_submatrix(1, 1)
Matrix([
[1, 3],
[7, 9]]) 

另见

minor, cofactor

multiply(other, dotprodsimp=None)

与 mul()相同，但具有可选的简化。

参数：

dotprodsimp : 布尔值，可选

指定是否在矩阵乘法过程中使用中间项的代数化简来控制表达式膨胀，从而加快计算速度。默认为关闭。

multiply_elementwise(other)

返回矩阵 A 和 B 的 Hadamard 乘积（逐元素乘积）。

示例

>>> from sympy import Matrix
>>> A = Matrix([[0, 1, 2], [3, 4, 5]])
>>> B = Matrix([[1, 10, 100], [100, 10, 1]])
>>> A.multiply_elementwise(B)
Matrix([
[  0, 10, 200],
[300, 40,   5]]) 

另见

sympy.matrices.matrixbase.MatrixBase.cross, sympy.matrices.matrixbase.MatrixBase.dot, multiply

n(*args, **kwargs)

对 self 的每个元素应用 evalf()。

norm(ord=None)

返回矩阵或向量的范数。

在最简单的情况下，这是向量的几何大小。其他规范可以通过 ord 参数指定。

ord	矩阵的规范	向量的规范
None	弗罗贝尼乌斯范数	2-范数
‘fro’	弗罗贝尼乌斯范数

• 不存在

|

inf	最大行和	max(abs(x))
-inf	–	min(abs(x))
1	最大列和	如下
-1	–	如下
2	2-范数（最大奇异值）	如下
-2	最小奇异值	如下
other

• 不存在

sum(abs(x)ord)(1./ord)

示例

>>> from sympy import Matrix, Symbol, trigsimp, cos, sin, oo
>>> x = Symbol('x', real=True)
>>> v = Matrix([cos(x), sin(x)])
>>> trigsimp( v.norm() )
1
>>> v.norm(10)
(sin(x)**10 + cos(x)**10)**(1/10)
>>> A = Matrix([[1, 1], [1, 1]])
>>> A.norm(1) # maximum sum of absolute values of A is 2
2
>>> A.norm(2) # Spectral norm (max of |Ax|/|x| under 2-vector-norm)
2
>>> A.norm(-2) # Inverse spectral norm (smallest singular value)
0
>>> A.norm() # Frobenius Norm
2
>>> A.norm(oo) # Infinity Norm
2
>>> Matrix([1, -2]).norm(oo)
2
>>> Matrix([-1, 2]).norm(-oo)
1 

另见

normalized

normalized(iszerofunc=<function _iszero>)

返回self的归一化版本。

参数：

iszerofunc : 函数，可选

一个函数，用于确定self是否为零向量。默认的_iszero测试每个元素是否完全为零。

返回：

矩阵

self的归一化向量形式。它与单位向量具有相同长度。然而，对于模为 0 的向量将返回零向量。

引发：

ShapeError

如果矩阵不是向量形式。

另见

norm

nullspace(simplify=False, iszerofunc=<function _iszero>)

返回矩阵的零空间生成的向量列表（Matrix 对象）。

示例

>>> from sympy import Matrix
>>> M = Matrix(3, 3, [1, 3, 0, -2, -6, 0, 3, 9, 6])
>>> M
Matrix([
[ 1,  3, 0],
[-2, -6, 0],
[ 3,  9, 6]])
>>> M.nullspace()
[Matrix([
[-3],
[ 1],
[ 0]])] 

另见

columnspace, rowspace

classmethod ones(rows, cols=None, **kwargs)

返回一个全为 1 的矩阵。

参数：

rows : 矩阵的行

cols : 矩阵的列（如果为 None，则 cols=rows）

关键字参数

cls：返回矩阵的类

classmethod orthogonalize(*vecs, **kwargs)

对提供的vecs应用 Gram-Schmidt 正交化过程。

参数：

vecs

要正交化的向量

normalize : bool

如果为True，则返回标准正交基。

rankcheck : bool

如果True，则在遇到线性相关向量时计算不会停止。

如果False，则在发现任何零或线性相关向量时会引发ValueError。

返回：

列表

正交（或标准正交）基向量列表。

示例

>>> from sympy import I, Matrix
>>> v = [Matrix([1, I]), Matrix([1, -I])]
>>> Matrix.orthogonalize(*v)
[Matrix([
[1],
[I]]), Matrix([
[ 1],
[-I]])] 

另见

MatrixBase.QR 分解

参考文献

[R633]

zh.wikipedia.org/wiki/格拉姆-施密特正交化过程

per()

返回矩阵的永久值。与行列式不同，永久值对于方阵和非方阵都有定义。

对于一个 m x n 矩阵，其中 m 小于等于 n，它被定义为大小不超过 m 的排列 s 上[1, 2, … n]的乘积的和，从 i = 1 到 m 的 M[i, s[i]]。取转置不会影响永久值。

对于方阵而言，这与行列式的置换定义相同，但不考虑置换的符号。使用此定义计算永久效率低下，因此这里使用了莱瑟公式。

示例

>>> from sympy import Matrix
>>> M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> M.per()
450
>>> M = Matrix([1, 5, 7])
>>> M.per()
13 

参考

[R634]

弗兰克·本教授的笔记：math.berkeley.edu/~bernd/ban275.pdf

[R635]

永久的维基百科文章：en.wikipedia.org/wiki/Permanent_%28mathematics%29

[R636]

reference.wolfram.com/language/ref/Permanent.html

[R637]

矩阵的永久：arxiv.org/pdf/0904.3251.pdf

permute(perm, orientation='rows', direction='forward')

通过给定的交换列表置换矩阵的行或列。

参数：

perm : 置换、列表或列表的列表

置换的表示。

如果是 Permutation，直接与矩阵大小有关地进行一些调整使用。

如果指定为列表的列表（例如 [[0, 1], [0, 2]]），则通过应用循环积的乘积形成置换。如何应用循环积的方向在下文描述。

如果指定为列表形式，则列表应表示一个置换的数组形式（例如 [1, 2, 0]），该列表会形成交换函数 (0 \mapsto 1, 1 \mapsto 2, 2\mapsto 0)。

orientation : ‘rows’, ‘cols’

控制标志，决定是置换行还是列。

direction : ‘forward’, ‘backward’

控制标志，决定是先从列表的起始处还是末尾处应用置换。

例如，如果置换规范是 [[0, 1], [0, 2]]，

如果标志设置为 'forward'，循环将形成为 (0 \mapsto 2, 2 \mapsto 1, 1 \mapsto 0)。

如果标志设置为 'backward'，循环将形成为 (0 \mapsto 1, 1 \mapsto 2, 2 \mapsto 0)。

如果参数 perm 不是列表的列表形式，则此标志不起作用。

示例

>>> from sympy import eye
>>> M = eye(3)
>>> M.permute([[0, 1], [0, 2]], orientation='rows', direction='forward')
Matrix([
[0, 0, 1],
[1, 0, 0],
[0, 1, 0]]) 

>>> from sympy import eye
>>> M = eye(3)
>>> M.permute([[0, 1], [0, 2]], orientation='rows', direction='backward')
Matrix([
[0, 1, 0],
[0, 0, 1],
[1, 0, 0]]) 

注释

如果一个双射函数 (\sigma : \mathbb{N}_0 \rightarrow \mathbb{N}_0) 表示置换。

如果矩阵 (A) 是待置换的矩阵，表示为向量的水平或垂直堆叠：

[\begin{split}A = \begin{bmatrix} a_0 \ a_1 \ \vdots \ a_{n-1} \end{bmatrix} = \begin{bmatrix} \alpha_0 & \alpha_1 & \cdots & \alpha_{n-1} \end{bmatrix}\end{split}]

如果矩阵 (B) 是结果，则矩阵行的置换定义如下：

[\begin{split}B := \begin{bmatrix} a_{\sigma(0)} \ a_{\sigma(1)} \ \vdots \ a_{\sigma(n-1)} \end{bmatrix}\end{split}]

并且矩阵列的置换定义为：

[B := \begin{bmatrix} \alpha_{\sigma(0)} & \alpha_{\sigma(1)} & \cdots & \alpha_{\sigma(n-1)} \end{bmatrix}]

permuteBkwd(perm)

通过给定置换的逆置换矩阵的行。

permuteFwd(perm)

使用给定的排列置换矩阵的行。

permute_cols(swaps, direction='forward')

self.permute(swaps, orientation='cols', direction=direction)的别名

另请参阅

permute

permute_rows(swaps, direction='forward')

self.permute(swaps, orientation='rows', direction=direction)的别名

另请参阅

permute

pinv(method='RD')

计算矩阵的 Moore-Penrose 伪逆。

对于任何矩阵，Moore-Penrose 伪逆都存在且唯一。如果矩阵可逆，则伪逆与逆矩阵相同。

参数：

method：字符串，可选

指定计算伪逆的方法。

如果为'RD'，将使用秩分解。

如果为'ED'，将使用对角化。

示例

通过秩分解计算伪逆：

>>> from sympy import Matrix
>>> A = Matrix([[1, 2, 3], [4, 5, 6]])
>>> A.pinv()
Matrix([
[-17/18,  4/9],
[  -1/9,  1/9],
[ 13/18, -2/9]]) 

通过对角化计算伪逆：

>>> B = A.pinv(method='ED')
>>> B.simplify()
>>> B
Matrix([
[-17/18,  4/9],
[  -1/9,  1/9],
[ 13/18, -2/9]]) 

另请参阅

inv, pinv_solve

参考文献

[R638]

en.wikipedia.org/wiki/Moore-Penrose_pseudoinverse

pinv_solve(B, arbitrary_matrix=None)

使用 Moore-Penrose 伪逆解决Ax = B。

可能存在零、一或无限解。如果存在一解，则返回该解。如果存在无限解，则基于任意矩阵的值返回一个解。如果不存在解，则返回最小二乘解。

参数：

B：矩阵

要解的方程的右手边。必须具有与矩阵 A 相同的行数。

arbitrary_matrix：矩阵

如果系统欠定（例如 A 的列数多于行数），可能存在无限解，即任意矩阵。此参数可以设置为特定矩阵，用于此目的；如果设置，其形状必须与 x 相同，行数与矩阵 A 的列数相同，列数与矩阵 B 相同。如果设置为 None，则将使用包含以wn_m形式的虚拟符号的适当矩阵，其中 n 和 m 分别是每个符号的行和列位置。

返回：

x：矩阵

将满足Ax = B的矩阵。将具有与矩阵 A 的列数相同的行数，并且与矩阵 B 具有相同的列数。

示例

>>> from sympy import Matrix
>>> A = Matrix([[1, 2, 3], [4, 5, 6]])
>>> B = Matrix([7, 8])
>>> A.pinv_solve(B)
Matrix([
[ _w0_0/6 - _w1_0/3 + _w2_0/6 - 55/18],
[-_w0_0/3 + 2*_w1_0/3 - _w2_0/3 + 1/9],
[ _w0_0/6 - _w1_0/3 + _w2_0/6 + 59/18]])
>>> A.pinv_solve(B, arbitrary_matrix=Matrix([0, 0, 0]))
Matrix([
[-55/18],
[   1/9],
[ 59/18]]) 

注：

这可能返回精确解或最小二乘解。要确定哪种解，请检查A * A.pinv() * B == B。如果精确解存在，则为 True；如果仅存在最小二乘解，则为 False。请注意，该方程的左侧可能需要简化才能正确与右侧比较。

另请参阅

sympy.matrices.dense.DenseMatrix.lower_triangular_solve, sympy.matrices.dense.DenseMatrix.upper_triangular_solve, gauss_jordan_solve, cholesky_solve, diagonal_solve, LDLsolve, LUsolve, QRsolve, pinv

参考文献

[R639]

en.wikipedia.org/wiki/Moore-Penrose_pseudoinverse#Obtaining_all_solutions_of_a_linear_system

pow(exp, method=None)

返回自我**exp 标量或符号。

参数：

方法 ：乘法，mulsimp，乔丹，卡莱

如果乘以，则使用递归返回指数。如果乔丹，则使用乔丹形式的指数。如果 cayley，则使用 Cayley-Hamilton 定理进行指数计算。如果 mulsimp，则使用递归与 dotprodsimp 进行指数计算。这指定是否在朴素矩阵幂中使用中间项代数简化以控制表达式膨胀，从而加快计算速度。如果为 None，则启发式地决定使用哪种方法。

print_nonzero(symb='X')

显示非零条目的位置，以便快速查找形状。

示例

>>> from sympy import Matrix, eye
>>> m = Matrix(2, 3, lambda i, j: i*3+j)
>>> m
Matrix([
[0, 1, 2],
[3, 4, 5]])
>>> m.print_nonzero()
[ XX]
[XXX]
>>> m = eye(4)
>>> m.print_nonzero("x")
[x   ]
[ x  ]
[  x ]
[   x] 

project(v)

返回 self 在包含 v 的线上的投影。

示例

>>> from sympy import Matrix, S, sqrt
>>> V = Matrix([sqrt(3)/2, S.Half])
>>> x = Matrix([[1, 0]])
>>> V.project(x)
Matrix([[sqrt(3)/2, 0]])
>>> V.project(-x)
Matrix([[sqrt(3)/2, 0]]) 

rank(iszerofunc=<function _iszero>, simplify=False)

返回矩阵的秩。

示例

>>> from sympy import Matrix
>>> from sympy.abc import x
>>> m = Matrix([[1, 2], [x, 1 - 1/x]])
>>> m.rank()
2
>>> n = Matrix(3, 3, range(1, 10))
>>> n.rank()
2 

rank_decomposition(iszerofunc=<function _iszero>, simplify=False)

返回一对矩阵（(C)，(F)），它们具有相同的秩，使得 (A = C F)。

参数：

iszerofunc ：函数，可选

用于检测元素是否可以作为枢轴的函数。默认情况下使用lambda x: x.is_zero。

简化 ：布尔或函数，可选

用于在寻找枢轴时简化元素的函数。默认情况下使用 SymPy 的simplify。

返回：

(C, F) ：矩阵

(C) 和 (F) 是秩与 (A) 相同的全秩矩阵，它们的乘积给出 (A)。

有关附加数学细节，请参见注释。

示例

>>> from sympy import Matrix
>>> A = Matrix([
...     [1, 3, 1, 4],
...     [2, 7, 3, 9],
...     [1, 5, 3, 1],
...     [1, 2, 0, 8]
... ])
>>> C, F = A.rank_decomposition()
>>> C
Matrix([
[1, 3, 4],
[2, 7, 9],
[1, 5, 1],
[1, 2, 8]])
>>> F
Matrix([
[1, 0, -2, 0],
[0, 1,  1, 0],
[0, 0,  0, 1]])
>>> C * F == A
True 

注释

获得 (F)，(A) 的 RREF，相当于创建一个产品

[E_n E_{n-1} … E_1 A = F]

其中 (E_n, E_{n-1}, \dots, E_1) 是消元矩阵或等效于每个行约简步骤的排列矩阵。

相同消元矩阵的逆矩阵给出 (C)：

[C = \left(E_n E_{n-1} \dots E_1\right)^{-1}]

不需要实际计算逆矩阵：(C)的列与(F)的主元列的列索引相同。

另见

sympy.matrices.matrixbase.MatrixBase.rref

参考文献

[R640]

en.wikipedia.org/wiki/Rank_factorization

[R641]

Piziak, R.; Odell, P. L. (1999 年 6 月 1 日). “矩阵的满秩分解”. 数学杂志. 72 (3): 193. doi:10.2307/2690882

refine(assumptions=True)

对矩阵的每个元素应用精化。

示例

>>> from sympy import Symbol, Matrix, Abs, sqrt, Q
>>> x = Symbol('x')
>>> Matrix([[Abs(x)**2, sqrt(x**2)],[sqrt(x**2), Abs(x)**2]])
Matrix([
[ Abs(x)**2, sqrt(x**2)],
[sqrt(x**2),  Abs(x)**2]])
>>> _.refine(Q.real(x))
Matrix([
[  x**2, Abs(x)],
[Abs(x),   x**2]]) 

replace(F, G, map=False, simultaneous=True, exact=None)

用函数 G 替换矩阵条目中的函数 F。

示例

>>> from sympy import symbols, Function, Matrix
>>> F, G = symbols('F, G', cls=Function)
>>> M = Matrix(2, 2, lambda i, j: F(i+j)) ; M
Matrix([
[F(0), F(1)],
[F(1), F(2)]])
>>> N = M.replace(F,G)
>>> N
Matrix([
[G(0), G(1)],
[G(1), G(2)]]) 

reshape(rows, cols)

重塑矩阵。元素总数必须保持不变。

示例

>>> from sympy import Matrix
>>> m = Matrix(2, 3, lambda i, j: 1)
>>> m
Matrix([
[1, 1, 1],
[1, 1, 1]])
>>> m.reshape(1, 6)
Matrix([[1, 1, 1, 1, 1, 1]])
>>> m.reshape(3, 2)
Matrix([
[1, 1],
[1, 1],
[1, 1]]) 

rmultiply(other, dotprodsimp=None)

与 rmul()相同，但具有可选的简化。

参数：

dotprodsimp：bool，可选

指定在矩阵乘法期间是否使用中间项代数化简来控制表达式膨胀，从而加快计算速度。默认关闭。

rot90(k=1)

将矩阵逆时针旋转 90 度

参数：

k：整数

指定矩阵顺时针旋转的次数（正数时为顺时针，负数时为逆时针）。

示例

>>> from sympy import Matrix, symbols
>>> A = Matrix(2, 2, symbols('a:d'))
>>> A
Matrix([
[a, b],
[c, d]]) 

将矩阵顺时针旋转一次：

>>> A.rot90(1)
Matrix([
[c, a],
[d, b]]) 

将矩阵逆时针旋转两次：

>>> A.rot90(-2)
Matrix([
[d, c],
[b, a]]) 

row(i)

行选择器。

示例

>>> from sympy import eye
>>> eye(2).row(0)
Matrix([[1, 0]]) 

另见

col, row_del, row_join, row_insert

row_del(row)

删除指定行。

row_insert(pos, other)

在给定的行位置插入一行或多行。

示例

>>> from sympy import zeros, ones
>>> M = zeros(3)
>>> V = ones(1, 3)
>>> M.row_insert(1, V)
Matrix([
[0, 0, 0],
[1, 1, 1],
[0, 0, 0],
[0, 0, 0]]) 

另见

row, col_insert

row_join(other)

连接两个矩阵，沿着 self 的最后一列和 rhs 的第一列

示例

>>> from sympy import zeros, ones
>>> M = zeros(3)
>>> V = ones(3, 1)
>>> M.row_join(V)
Matrix([
[0, 0, 0, 1],
[0, 0, 0, 1],
[0, 0, 0, 1]]) 

另见

row, col_join

rowspace(simplify=False)

返回一个生成矩阵行空间的向量列表。

示例

>>> from sympy import Matrix
>>> M = Matrix(3, 3, [1, 3, 0, -2, -6, 0, 3, 9, 6])
>>> M
Matrix([
[ 1,  3, 0],
[-2, -6, 0],
[ 3,  9, 6]])
>>> M.rowspace()
[Matrix([[1, 3, 0]]), Matrix([[0, 0, 6]])] 

rref(iszerofunc=<function _iszero>, simplify=False, pivots=True, normalize_last=True)

返回矩阵的行阶梯形式和主元变量的索引。

参数：

iszerofunc：函数

用于检测元素是否可以作为主元的函数。默认使用lambda x: x.is_zero。

simplify：函数

用于在查找主元时简化元素的函数。默认使用 SymPy 的simplify。

pivots：是或否

如果为True，则返回一个元组，其中包含行减少矩阵和一个主轴列的元组。如果为False，则仅返回行减少矩阵。

normalize_last：是或否

如果为True，直到所有每个主轴上下的条目都被归零之前，没有主轴被标准化为(1)。这意味着行减少算法在最后一步之前是无分数的。如果为False，则使用简单的行减少过程，在使用行操作将主轴上下归零之前，将每个主轴标准化为(1)。

例子

>>> from sympy import Matrix
>>> from sympy.abc import x
>>> m = Matrix([[1, 2], [x, 1 - 1/x]])
>>> m.rref()
(Matrix([
[1, 0],
[0, 1]]), (0, 1))
>>> rref_matrix, rref_pivots = m.rref()
>>> rref_matrix
Matrix([
[1, 0],
[0, 1]])
>>> rref_pivots
(0, 1) 

iszerofunc可以在具有浮点值的矩阵中纠正舍入误差。在以下示例中，调用rref()会导致浮点错误，错误地行减少矩阵。iszerofunc= lambda x: abs(x) < 1e-9将足够小的数字设置为零，从而避免此错误。

>>> m = Matrix([[0.9, -0.1, -0.2, 0], [-0.8, 0.9, -0.4, 0], [-0.1, -0.8, 0.6, 0]])
>>> m.rref()
(Matrix([
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0]]), (0, 1, 2))
>>> m.rref(iszerofunc=lambda x:abs(x)<1e-9)
(Matrix([
[1, 0, -0.301369863013699, 0],
[0, 1, -0.712328767123288, 0],
[0, 0,         0,          0]]), (0, 1)) 

注意事项

normalize_last=True的默认值可以显著加快行减少的速度，特别是在具有符号的矩阵上。然而，如果你依赖于行减少算法留下矩阵的形式条目，请设置normalize_last=False。

rref_rhs(rhs)

返回矩阵的简化行阶梯形式，显示减少步骤后的右手边矩阵。rhs必须与self具有相同的行数。

例子

>>> from sympy import Matrix, symbols
>>> r1, r2 = symbols('r1 r2')
>>> Matrix([[1, 1], [2, 1]]).rref_rhs(Matrix([r1, r2]))
(Matrix([
[1, 0],
[0, 1]]), Matrix([
[ -r1 + r2],
[2*r1 - r2]])) 

property shape

矩阵的形状（维度）作为 2 元组（行数，列数）。

例子

>>> from sympy import zeros
>>> M = zeros(2, 3)
>>> M.shape
(2, 3)
>>> M.rows
2
>>> M.cols
3 

simplify(**kwargs)

将矩阵的每个元素应用简化。

例子

>>> from sympy.abc import x, y
>>> from sympy import SparseMatrix, sin, cos
>>> SparseMatrix(1, 1, [x*sin(y)**2 + x*cos(y)**2])
Matrix([[x*sin(y)**2 + x*cos(y)**2]])
>>> _.simplify()
Matrix([[x]]) 

singular_value_decomposition()

返回一个压缩的奇异值分解。

解释

奇异值分解是形式为(A = U \Sigma V^H)的分解，其中

• (U, V)是列正交矩阵。

• (\Sigma) 是一个对角矩阵，主对角线上包含矩阵 A 的奇异值。

一个列正交矩阵满足(\mathbb{I} = U^H U)，而一个完整的正交矩阵满足关系(\mathbb{I} = U U^H = U^H U)，其中(\mathbb{I})是具有相同维度的单位矩阵。

对于不是方阵或秩不足的矩阵，返回一个列正交矩阵就足够了，因为扩展它们可能会引入冗余计算。在压缩的奇异值分解中，我们只返回列正交矩阵，因为这个原因。

如果你想要扩展结果以返回一个完整的正交分解，你应该使用以下步骤。

• 用与每个其他列正交的列扩展(U, V)矩阵，并使其变成方阵。

• 用零行扩展(\Sigma)矩阵，使其形状与原矩阵相同。

过程将在示例部分说明。

例子

我们首先取一个满秩矩阵：

>>> from sympy import Matrix
>>> A = Matrix([[1, 2],[2,1]])
>>> U, S, V = A.singular_value_decomposition()
>>> U
Matrix([
[ sqrt(2)/2, sqrt(2)/2],
[-sqrt(2)/2, sqrt(2)/2]])
>>> S
Matrix([
[1, 0],
[0, 3]])
>>> V
Matrix([
[-sqrt(2)/2, sqrt(2)/2],
[ sqrt(2)/2, sqrt(2)/2]]) 

如果一个矩阵是方阵且满秩，那么 U，V 在两个方向上都是正交的。

>>> U * U.H
Matrix([
[1, 0],
[0, 1]])
>>> U.H * U
Matrix([
[1, 0],
[0, 1]]) 

>>> V * V.H
Matrix([
[1, 0],
[0, 1]])
>>> V.H * V
Matrix([
[1, 0],
[0, 1]])
>>> A == U * S * V.H
True 

>>> C = Matrix([
...         [1, 0, 0, 0, 2],
...         [0, 0, 3, 0, 0],
...         [0, 0, 0, 0, 0],
...         [0, 2, 0, 0, 0],
...     ])
>>> U, S, V = C.singular_value_decomposition() 

>>> V.H * V
Matrix([
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
>>> V * V.H
Matrix([
[1/5, 0, 0, 0, 2/5],
[  0, 1, 0, 0,   0],
[  0, 0, 1, 0,   0],
[  0, 0, 0, 0,   0],
[2/5, 0, 0, 0, 4/5]]) 

如果你想要扩展结果为一个完整的正交分解，你应该用另一个正交列扩展(V)。

可以向每个其他列附加一个任意的标准基，这些基是线性独立的，并且你可以运行 Gram-Schmidt 过程使它们增强为正交基。

>>> V_aug = V.row_join(Matrix([[0,0,0,0,1],
... [0,0,0,1,0]]).H)
>>> V_aug = V_aug.QRdecomposition()[0]
>>> V_aug
Matrix([
[0,   sqrt(5)/5, 0, -2*sqrt(5)/5, 0],
[1,           0, 0,            0, 0],
[0,           0, 1,            0, 0],
[0,           0, 0,            0, 1],
[0, 2*sqrt(5)/5, 0,    sqrt(5)/5, 0]])
>>> V_aug.H * V_aug
Matrix([
[1, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 1, 0],
[0, 0, 0, 0, 1]])
>>> V_aug * V_aug.H
Matrix([
[1, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 1, 0],
[0, 0, 0, 0, 1]]) 

同样地，我们扩展 U

>>> U_aug = U.row_join(Matrix([0,0,1,0]))
>>> U_aug = U_aug.QRdecomposition()[0]
>>> U_aug
Matrix([
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1],
[1, 0, 0, 0]]) 

>>> U_aug.H * U_aug
Matrix([
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])
>>> U_aug * U_aug.H
Matrix([
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]) 

我们向 S 添加了 2 列零和一行

>>> S_aug = S.col_join(Matrix([[0,0,0]]))
>>> S_aug = S_aug.row_join(Matrix([[0,0,0,0],
... [0,0,0,0]]).H)
>>> S_aug
Matrix([
[2,       0, 0, 0, 0],
[0, sqrt(5), 0, 0, 0],
[0,       0, 3, 0, 0],
[0,       0, 0, 0, 0]]) 

>>> U_aug * S_aug * V_aug.H == C
True 

singular_values()

计算矩阵的奇异值

示例

>>> from sympy import Matrix, Symbol
>>> x = Symbol('x', real=True)
>>> M = Matrix([[0, 1, 0], [0, x, 0], [-1, 0, 0]])
>>> M.singular_values()
[sqrt(x**2 + 1), 1, 0] 

另请参阅

condition_number

solve(rhs, method='GJ')

解决存在唯一解的线性方程。

参数：

rhs ：矩阵

表示线性方程右侧的向量。

method ：字符串，可选

如果设为 'GJ' 或 'GE'，将使用高斯-约当消元法，该方法已在 gauss_jordan_solve 程序中实现。

如果设为 'LU'，将使用 LUsolve 程序。

如果设为 'QR'，将使用 QRsolve 程序。

如果设为 'PINV'，将使用 pinv_solve 程序。

如果设为 'CRAMER'，将使用 cramer_solve 程序。

它还支持特殊线性系统的可用方法

对于正定系统：

如果设为 'CH'，将使用 cholesky_solve 程序。

如果设为 'LDL'，将使用 LDLsolve 程序。

要使用不同的方法并通过求逆计算解决方案，请使用 .inv() 文档字符串中定义的方法。

返回：

solutions ：矩阵

表示解决方案的向量。

引发：

ValueError

如果不存在唯一解，则会引发 ValueError。

如果 M 不是方阵，则建议将引发 ValueError 并建议使用不同的解决系统程序。

solve_least_squares(rhs, method='CH')

返回数据的最小二乘拟合。

参数：

rhs ：矩阵

表示线性方程右侧的向量。

method ：字符串或布尔值，可选

如果设为 'CH'，将使用 cholesky_solve 程序。

如果设为 'LDL'，将使用 LDLsolve 程序。

如果设为 'QR'，将使用 QRsolve 程序。

如果设为 'PINV'，将使用 pinv_solve 程序。

否则，将使用 M 的共轭来创建传递给 solve 的方程组，同时还将使用 method 定义的提示。

返回：

solutions ：矩阵

表示解决方案的向量。

示例

>>> from sympy import Matrix, ones
>>> A = Matrix([1, 2, 3])
>>> B = Matrix([2, 3, 4])
>>> S = Matrix(A.row_join(B))
>>> S
Matrix([
[1, 2],
[2, 3],
[3, 4]]) 

如果 S 的每行表示 Ax + By 的系数，而 x 和 y 分别为 [2, 3]，则 S*xy 为：

>>> r = S*Matrix([2, 3]); r
Matrix([
[ 8],
[13],
[18]]) 

但让我们在中间值上加 1，然后求解 xy 的最小二乘值：

>>> xy = S.solve_least_squares(Matrix([8, 14, 18])); xy
Matrix([
[ 5/3],
[10/3]]) 

错误由 S*xy - r 给出：

>>> S*xy - r
Matrix([
[1/3],
[1/3],
[1/3]])
>>> _.norm().n(2)
0.58 

如果使用不同的 xy，则范数会更高：

>>> xy += ones(2, 1)/10
>>> (S*xy - r).norm().n(2)
1.5 

strongly_connected_components()

返回将方阵视为加权图时的强连通顶点列表。

示例

>>> from sympy import Matrix
>>> A = Matrix([
...     [44, 0, 0, 0, 43, 0, 45, 0, 0],
...     [0, 66, 62, 61, 0, 68, 0, 60, 67],
...     [0, 0, 22, 21, 0, 0, 0, 20, 0],
...     [0, 0, 12, 11, 0, 0, 0, 10, 0],
...     [34, 0, 0, 0, 33, 0, 35, 0, 0],
...     [0, 86, 82, 81, 0, 88, 0, 80, 87],
...     [54, 0, 0, 0, 53, 0, 55, 0, 0],
...     [0, 0, 2, 1, 0, 0, 0, 0, 0],
...     [0, 76, 72, 71, 0, 78, 0, 70, 77]])
>>> A.strongly_connected_components()
[[0, 4, 6], [2, 3, 7], [1, 5, 8]] 

strongly_connected_components_decomposition(lower=True)

将方阵分解为仅使用置换的块三角形式。

参数：

lower ：布尔值

当 True 时，使 (B) 成为下块三角形。否则，使 (B) 成为上块三角形。

返回：

P, B ：置换矩阵，块矩阵

P 是类似于解释中相似变换的置换矩阵。而 B 是置换结果的块三角形矩阵。

解释

分解的形式为 (A = P^{-1} B P)，其中 (P) 是置换矩阵，(B) 是块对角线矩阵。

示例

>>> from sympy import Matrix, pprint
>>> A = Matrix([
...     [44, 0, 0, 0, 43, 0, 45, 0, 0],
...     [0, 66, 62, 61, 0, 68, 0, 60, 67],
...     [0, 0, 22, 21, 0, 0, 0, 20, 0],
...     [0, 0, 12, 11, 0, 0, 0, 10, 0],
...     [34, 0, 0, 0, 33, 0, 35, 0, 0],
...     [0, 86, 82, 81, 0, 88, 0, 80, 87],
...     [54, 0, 0, 0, 53, 0, 55, 0, 0],
...     [0, 0, 2, 1, 0, 0, 0, 0, 0],
...     [0, 76, 72, 71, 0, 78, 0, 70, 77]]) 

一个下三角分解：

>>> P, B = A.strongly_connected_components_decomposition()
>>> pprint(P)
PermutationMatrix((8)(1 4 3 2 6)(5 7))
>>> pprint(B)
[[44  43  45]   [0  0  0]     [0  0  0]  ]
[[          ]   [       ]     [       ]  ]
[[34  33  35]   [0  0  0]     [0  0  0]  ]
[[          ]   [       ]     [       ]  ]
[[54  53  55]   [0  0  0]     [0  0  0]  ]
[                                        ]
[ [0  0  0]    [22  21  20]   [0  0  0]  ]
[ [       ]    [          ]   [       ]  ]
[ [0  0  0]    [12  11  10]   [0  0  0]  ]
[ [       ]    [          ]   [       ]  ]
[ [0  0  0]    [2   1   0 ]   [0  0  0]  ]
[                                        ]
[ [0  0  0]    [62  61  60]  [66  68  67]]
[ [       ]    [          ]  [          ]]
[ [0  0  0]    [82  81  80]  [86  88  87]]
[ [       ]    [          ]  [          ]]
[ [0  0  0]    [72  71  70]  [76  78  77]] 

>>> P = P.as_explicit()
>>> B = B.as_explicit()
>>> P.T * B * P == A
True 

一个上块三角形分解：

>>> P, B = A.strongly_connected_components_decomposition(lower=False)
>>> pprint(P)
PermutationMatrix((0 1 5 7 4 3 2 8 6))
>>> pprint(B)
[[66  68  67]  [62  61  60]   [0  0  0]  ]
[[          ]  [          ]   [       ]  ]
[[86  88  87]  [82  81  80]   [0  0  0]  ]
[[          ]  [          ]   [       ]  ]
[[76  78  77]  [72  71  70]   [0  0  0]  ]
[                                        ]
[ [0  0  0]    [22  21  20]   [0  0  0]  ]
[ [       ]    [          ]   [       ]  ]
[ [0  0  0]    [12  11  10]   [0  0  0]  ]
[ [       ]    [          ]   [       ]  ]
[ [0  0  0]    [2   1   0 ]   [0  0  0]  ]
[                                        ]
[ [0  0  0]     [0  0  0]    [44  43  45]]
[ [       ]     [       ]    [          ]]
[ [0  0  0]     [0  0  0]    [34  33  35]]
[ [       ]     [       ]    [          ]]
[ [0  0  0]     [0  0  0]    [54  53  55]] 

>>> P = P.as_explicit()
>>> B = B.as_explicit()
>>> P.T * B * P == A
True 

subs(*args, **kwargs)

返回应用到每个条目的子项后的新矩阵。

例子

>>> from sympy.abc import x, y
>>> from sympy import SparseMatrix, Matrix
>>> SparseMatrix(1, 1, [x])
Matrix([[x]])
>>> _.subs(x, y)
Matrix([[y]])
>>> Matrix(_).subs(y, x)
Matrix([[x]]) 

table(printer, rowstart='[', rowend=']', rowsep='\n', colsep=', ', align='right')

矩阵的表格形式的字符串。

printer 是用于元素的打印机（通常类似于 StrPrinter()）。

rowstart 是用于开始每一行的字符串（默认为‘[’）。

rowend 是用于结束每一行的字符串（默认为‘]’）。

rowsep 是用于分隔行的字符串（默认为换行符）。

colsep 是用于分隔列的字符串（默认为‘, ’）。

align 定义了元素的对齐方式。必须是‘left’、‘right’或‘center’之一。您还可以使用‘<’、‘>’和‘^’分别表示相同的意思。

这由矩阵的字符串打印机使用。

例子

>>> from sympy import Matrix, StrPrinter
>>> M = Matrix([[1, 2], [-33, 4]])
>>> printer = StrPrinter()
>>> M.table(printer)
'[  1, 2]\n[-33, 4]'
>>> print(M.table(printer))
[  1, 2]
[-33, 4]
>>> print(M.table(printer, rowsep=',\n'))
[  1, 2],
[-33, 4]
>>> print('[%s]' % M.table(printer, rowsep=',\n'))
[[  1, 2],
[-33, 4]]
>>> print(M.table(printer, colsep=' '))
[  1 2]
[-33 4]
>>> print(M.table(printer, align='center'))
[ 1 , 2]
[-33, 4]
>>> print(M.table(printer, rowstart='{', rowend='}'))
{  1, 2}
{-33, 4} 

todod()

返回包含矩阵非零元素的字典字典形式的矩阵。

例子

>>> from sympy import Matrix
>>> A = Matrix([[0, 1],[0, 3]])
>>> A
Matrix([
[0, 1],
[0, 3]])
>>> A.todod()
{0: {1: 1}, 1: {1: 3}} 

todok()

返回以键为字典的矩阵。

例子

>>> from sympy import Matrix
>>> M = Matrix.eye(3)
>>> M.todok()
{(0, 0): 1, (1, 1): 1, (2, 2): 1} 

tolist()

返回嵌套的 Python 列表形式的矩阵。

例子

>>> from sympy import Matrix, ones
>>> m = Matrix(3, 3, range(9))
>>> m
Matrix([
[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> m.tolist()
[[0, 1, 2], [3, 4, 5], [6, 7, 8]]
>>> ones(3, 0).tolist()
[[], [], []] 

当没有行时，将无法确定原始矩阵有多少列：

>>> ones(0, 3).tolist()
[] 

trace()

返回方阵的迹，即对角元素的和。

例子

>>> from sympy import Matrix
>>> A = Matrix(2, 2, [1, 2, 3, 4])
>>> A.trace()
5 

transpose()

返回矩阵的转置。

例子

>>> from sympy import Matrix
>>> A = Matrix(2, 2, [1, 2, 3, 4])
>>> A.transpose()
Matrix([
[1, 3],
[2, 4]]) 

>>> from sympy import Matrix, I
>>> m=Matrix(((1, 2+I), (3, 4)))
>>> m
Matrix([
[1, 2 + I],
[3,     4]])
>>> m.transpose()
Matrix([
[    1, 3],
[2 + I, 4]])
>>> m.T == m.transpose()
True 

另请参阅

conjugate

按元素共轭

upper_hessenberg_decomposition()

将矩阵转换为 Hessenberg 矩阵 H。

返回 2 个矩阵 H、P，使得 (P H P^{T} = A)，其中 H 是上 Hessenberg 矩阵，P 是正交矩阵

例子

>>> from sympy import Matrix
>>> A = Matrix([
...     [1,2,3],
...     [-3,5,6],
...     [4,-8,9],
... ])
>>> H, P = A.upper_hessenberg_decomposition()
>>> H
Matrix([
[1,    6/5,    17/5],
[5, 213/25, -134/25],
[0, 216/25,  137/25]])
>>> P
Matrix([
[1,    0,   0],
[0, -3/5, 4/5],
[0,  4/5, 3/5]])
>>> P * H * P.H == A
True 

参考

upper_triangular(k=0)

返回矩阵第 k 条对角线及其以上的元素。如果未指定 k，则简单返回矩阵的上三角部分。

例子

>>> from sympy import ones
>>> A = ones(4)
>>> A.upper_triangular()
Matrix([
[1, 1, 1, 1],
[0, 1, 1, 1],
[0, 0, 1, 1],
[0, 0, 0, 1]]) 

>>> A.upper_triangular(2)
Matrix([
[0, 0, 1, 1],
[0, 0, 0, 1],
[0, 0, 0, 0],
[0, 0, 0, 0]]) 

>>> A.upper_triangular(-1)
Matrix([
[1, 1, 1, 1],
[1, 1, 1, 1],
[0, 1, 1, 1],
[0, 0, 1, 1]]) 

upper_triangular_solve(rhs)

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

另请参阅

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

values()

返回 self 的非零值。

例子

>>> from sympy import Matrix
>>> m = Matrix([[0, 1], [2, 3]])
>>> m.values()
[1, 2, 3] 

另请参阅

iter_values, tolist, flat

vec()

返回通过堆叠列将矩阵转换为单列矩阵

示例

>>> from sympy import Matrix
>>> m=Matrix([[1, 3], [2, 4]])
>>> m
Matrix([
[1, 3],
[2, 4]])
>>> m.vec()
Matrix([
[1],
[2],
[3],
[4]]) 

另请参阅

vech

vech(diagonal=True, check_symmetry=True)

将矩阵重新形状为列向量，通过堆叠下三角中的元素。

参数：

diagonal : bool, optional

如果为 True，则包含对角元素。

check_symmetry : bool, optional

如果为 True，则检查矩阵是否对称。

示例

>>> from sympy import Matrix
>>> m=Matrix([[1, 2], [2, 3]])
>>> m
Matrix([
[1, 2],
[2, 3]])
>>> m.vech()
Matrix([
[1],
[2],
[3]])
>>> m.vech(diagonal=False)
Matrix([[2]]) 

注意事项

这对于对称矩阵应该有效，并且 vech 可以用比 vec 更小的尺寸表示向量形式的对称矩阵。

另请参阅

vec

vee()

从表示叉乘的反对称矩阵中返回一个 3x1 向量，以便 self * b 等价于 self.vee().cross(b)。

示例

调用 vee 可以从反对称矩阵创建向量：

>>> from sympy import Matrix
>>> A = Matrix([[0, -3, 2], [3, 0, -1], [-2, 1, 0]])
>>> a = A.vee()
>>> a
Matrix([
[1],
[2],
[3]]) 

计算原矩阵与向量的矩阵乘积相当于叉乘：

>>> b = Matrix([3, 2, 1])
>>> A * b
Matrix([
[-4],
[ 8],
[-4]]) 

>>> a.cross(b)
Matrix([
[-4],
[ 8],
[-4]]) 

vee 也可用于检索角速度表达式。定义旋转矩阵：

>>> from sympy import rot_ccw_axis3, trigsimp
>>> from sympy.physics.mechanics import dynamicsymbols
>>> theta = dynamicsymbols('theta')
>>> R = rot_ccw_axis3(theta)
>>> R
Matrix([
[cos(theta(t)), -sin(theta(t)), 0],
[sin(theta(t)),  cos(theta(t)), 0],
[            0,              0, 1]]) 

我们可以检索角速度：

>>> Omega = R.T * R.diff()
>>> Omega = trigsimp(Omega)
>>> Omega.vee()
Matrix([
[                      0],
[                      0],
[Derivative(theta(t), t)]]) 

另请参阅

dot, cross, hat, multiply, multiply_elementwise

classmethod vstack(*args)

返回通过垂直连接参数形成的矩阵（即重复应用 col_join）。

示例

>>> from sympy import Matrix, eye
>>> Matrix.vstack(eye(2), 2*eye(2))
Matrix([
[1, 0],
[0, 1],
[2, 0],
[0, 2]]) 

classmethod wilkinson(n, **kwargs)

返回大小为 2*n + 1 的两个平方 Wilkinson 矩阵 (W_{2n + 1}^-, W_{2n + 1}^+ =) Wilkinson(n)

示例

>>> from sympy import Matrix
>>> wminus, wplus = Matrix.wilkinson(3)
>>> wminus
Matrix([
[-3,  1,  0, 0, 0, 0, 0],
[ 1, -2,  1, 0, 0, 0, 0],
[ 0,  1, -1, 1, 0, 0, 0],
[ 0,  0,  1, 0, 1, 0, 0],
[ 0,  0,  0, 1, 1, 1, 0],
[ 0,  0,  0, 0, 1, 2, 1],
[ 0,  0,  0, 0, 0, 1, 3]])
>>> wplus
Matrix([
[3, 1, 0, 0, 0, 0, 0],
[1, 2, 1, 0, 0, 0, 0],
[0, 1, 1, 1, 0, 0, 0],
[0, 0, 1, 0, 1, 0, 0],
[0, 0, 0, 1, 1, 1, 0],
[0, 0, 0, 0, 1, 2, 1],
[0, 0, 0, 0, 0, 1, 3]]) 

参考文献

[R642]

blogs.mathworks.com/cleve/2013/04/15/wilkinsons-matrices-2/

[R643]

1. 1. Wilkinson，The Algebraic Eigenvalue Problem，Claredon Press，Oxford，1965，662 页。

xreplace(rule)

返回应用于每个条目的 xreplace 后的新矩阵。

示例

>>> from sympy.abc import x, y
>>> from sympy import SparseMatrix, Matrix
>>> SparseMatrix(1, 1, [x])
Matrix([[x]])
>>> _.xreplace({x: y})
Matrix([[y]])
>>> Matrix(_).xreplace({y: x})
Matrix([[x]]) 

classmethod zeros(rows, cols=None, **kwargs)

返回一个零矩阵。

参数：

rows : 矩阵的行数

cols : 矩阵的列数（如果为 None，则 cols=rows）

Kwargs

cls：返回矩阵的类

矩阵异常

class sympy.matrices.matrixbase.MatrixError

class sympy.matrices.matrixbase.ShapeError

错误的矩阵形状

class sympy.matrices.matrixbase.NonSquareMatrixError

矩阵函数

sympy.matrices.dense.matrix_multiply_elementwise(A, B)

返回矩阵 A 和 B 的 Hadamard 积（逐元素乘积）

>>> from sympy import Matrix, matrix_multiply_elementwise
>>> A = Matrix([[0, 1, 2], [3, 4, 5]])
>>> B = Matrix([[1, 10, 100], [100, 10, 1]])
>>> matrix_multiply_elementwise(A, B)
Matrix([
[  0, 10, 200],
[300, 40,   5]]) 

另请参阅

sympy.matrices.matrixbase.MatrixBase.__mul__

sympy.matrices.dense.zeros(*args, **kwargs)

返回一个具有rows行和cols列的零矩阵；如果省略cols，则返回一个方阵。

参见

ones, eye, diag

sympy.matrices.dense.ones(*args, **kwargs)

返回一个具有rows行和cols列的全为 1 的矩阵；如果省略cols，则返回一个方阵。

参见

zeros, eye, diag

sympy.matrices.dense.eye(*args, **kwargs)

创建 n x n 的方阵单位矩阵

参见

diag, zeros, ones

sympy.matrices.dense.diag(*values, strict=True, unpack=False, **kwargs)

返回一个将提供的值放置在对角线上的矩阵。如果包括非方阵，则将产生一个分块对角矩阵。

示例

这个版本的 diag 是对 Matrix.diag 的一个轻量级封装，不同之处在于它将所有列表视为矩阵 - 即使只给出一个列表也是如此。如果不希望这样做，请在列表前面加上(*)或设置(unpack=True)。

>>> from sympy import diag 

>>> diag([1, 2, 3], unpack=True)  # = diag(1,2,3) or diag(*[1,2,3])
Matrix([
[1, 0, 0],
[0, 2, 0],
[0, 0, 3]]) 

>>> diag([1, 2, 3])  # a column vector
Matrix([
[1],
[2],
[3]]) 

参见

matrixbase.MatrixBase.eye, matrixbase.MatrixBase.diagonal, expressions.blockmatrix.BlockMatrix

sympy.matrices.dense.jordan_cell(eigenval, n)

创建一个 Jordan 块：

示例

>>> from sympy import jordan_cell
>>> from sympy.abc import x
>>> jordan_cell(x, 4)
Matrix([
[x, 1, 0, 0],
[0, x, 1, 0],
[0, 0, x, 1],
[0, 0, 0, x]]) 

sympy.matrices.dense.hessian(f, varlist, constraints=())

计算函数 f 关于参数 varlist 的 Hessian 矩阵，varlist 可以作为一个序列或行/列向量给出。可选地给出约束条件列表。

示例

>>> from sympy import Function, hessian, pprint
>>> from sympy.abc import x, y
>>> f = Function('f')(x, y)
>>> g1 = Function('g')(x, y)
>>> g2 = x**2 + 3*y
>>> pprint(hessian(f, (x, y), [g1, g2]))
[                   d               d            ]
[     0        0    --(g(x, y))     --(g(x, y))  ]
[                   dx              dy           ]
[                                                ]
[     0        0        2*x              3       ]
[                                                ]
[                     2               2          ]
[d                   d               d           ]
[--(g(x, y))  2*x   ---(f(x, y))   -----(f(x, y))]
[dx                   2            dy dx         ]
[                   dx                           ]
[                                                ]
[                     2               2          ]
[d                   d               d           ]
[--(g(x, y))   3   -----(f(x, y))   ---(f(x, y)) ]
[dy                dy dx              2          ]
[                                   dy           ] 

参见

sympy.matrices.matrixbase.MatrixBase.jacobian, wronskian

参考文献

[R644]

zh.wikipedia.org/wiki/海森矩阵

sympy.matrices.dense.GramSchmidt(vlist, orthonormal=False)

对一组向量应用 Gram-Schmidt 过程。

参数：

vlist：矩阵列表

要进行正交化的向量。

orthonormal：布尔值，可选

如果为真，则返回一个正交归一基。

返回：

vlist：矩阵列表

正交化向量

注意事项

这个例程主要是从Matrix.orthogonalize复制过来的，除了一些不同之处，当线性相关向量被发现时，这个例程总是会引发错误，而关键字normalize在这个函数中被命名为orthonormal。

参见

matrixbase.MatrixBase.orthogonalize

参考文献

[R645]

en.wikipedia.org/wiki/Gram%E2%80%93Schmidt_process

sympy.matrices.dense.wronskian(functions, var, method='bareiss')

计算空函数组 [] 的 Wronskian

 | f1       f2        ...   fn      |
                 | f1'      f2'       ...   fn'     |
                 |  .        .        .      .      |
W(f1, ..., fn) = |  .        .         .     .      |
                 |  .        .          .    .      |
                 |  (n)      (n)            (n)     |
                 | D   (f1) D   (f2)  ...  D   (fn) | 

参见：en.wikipedia.org/wiki/Wronskian

另请参阅

sympy.matrices.matrixbase.MatrixBase.jacobian, hessian

sympy.matrices.dense.casoratian(seqs, n, zero=True)

给定阶数为 ‘k’ 的线性差分算子 L 和齐次方程 Ly = 0，我们希望计算 L 的核，即一组 ‘k’ 个序列：a(n), b(n), … z(n)。

L 的解线性独立当且仅当它们的 Casoratian，表示为 C(a, b, …, z)，在 n = 0 时不为零。

Casoratian 是由 k x k 行列式定义的：

+  a(n)     b(n)     . . . z(n)     +
|  a(n+1)   b(n+1)   . . . z(n+1)   |
|    .         .     .        .     |
|    .         .       .      .     |
|    .         .         .    .     |
+  a(n+k-1) b(n+k-1) . . . z(n+k-1) + 

在 rsolve_hyper() 中非常有用，用于将递归的生成集合中的线性相关解因子化并返回一个基础：

>>> from sympy import Symbol, casoratian, factorial
>>> n = Symbol('n', integer=True) 

指数和阶乘是线性独立的：

>>> casoratian([2**n, factorial(n)], n) != 0
True 

sympy.matrices.dense.randMatrix(r, c=None, min=0, max=99, seed=None, symmetric=False, percent=100, prng=None)

创建尺寸为 r x c 的随机矩阵。如果省略 c，则矩阵将是方阵。如果 symmetric 为 True，则矩阵必须是方阵。如果 percent 小于 100，则只有大约给定百分比的元素将非零。

用于生成矩阵的伪随机数生成器的选择方式如下。

• 如果提供了 prng，它将用作随机数生成器。它应该是 random.Random 的实例，或者至少具有相同签名的 randint 和 shuffle 方法。

• 如果未提供 prng 但提供了 seed，则将创建具有给定 seed 的新 random.Random；

• 否则，将使用默认种子创建一个新的 random.Random。

示例

>>> from sympy import randMatrix
>>> randMatrix(3) 
[25, 45, 27]
[44, 54,  9]
[23, 96, 46]
>>> randMatrix(3, 2) 
[87, 29]
[23, 37]
[90, 26]
>>> randMatrix(3, 3, 0, 2) 
[0, 2, 0]
[2, 0, 1]
[0, 0, 1]
>>> randMatrix(3, symmetric=True) 
[85, 26, 29]
[26, 71, 43]
[29, 43, 57]
>>> A = randMatrix(3, seed=1)
>>> B = randMatrix(3, seed=2)
>>> A == B
False
>>> A == randMatrix(3, seed=1)
True
>>> randMatrix(3, symmetric=True, percent=50) 
[77, 70,  0],
[70,  0,  0],
[ 0,  0, 88] 

旋转矩阵

sympy.matrices.dense.rot_givens(i, j, theta, dim=3)

返回一个 Givens 旋转矩阵，一个在由两个坐标轴张成的平面上的旋转。

参数：

i : 整数，范围在 0 到 dim - 1 之间

指代第一个轴

j : 整数，范围在 0 到 dim - 1 之间

指代第二个轴

dim : 大于 1 的整数

维数的数量。默认为 3。

说明

Givens 旋转对应于将旋转矩阵推广到任意维数，由以下给出：

[\begin{split}G(i, j, \theta) = \begin{bmatrix} 1 & \cdots & 0 & \cdots & 0 & \cdots & 0 \ \vdots & \ddots & \vdots & & \vdots & & \vdots \ 0 & \cdots & c & \cdots & -s & \cdots & 0 \ \vdots & & \vdots & \ddots & \vdots & & \vdots \ 0 & \cdots & s & \cdots & c & \cdots & 0 \ \vdots & & \vdots & & \vdots & \ddots & \vdots \ 0 & \cdots & 0 & \cdots & 0 & \cdots & 1 \end{bmatrix}\end{split}]

其中 (c = \cos(\theta)) 和 (s = \sin(\theta)) 出现在第 i 行和第 j 列的交点处。

对于固定的 i > j，Givens 矩阵的非零元素由以下给出：

• (g_{kk} = 1) 对于 (k \ne i,,j)

• (g_{kk} = c) 对于 (k = i,,j)

• (g_{ji} = -g_{ij} = -s)

例子

>>> from sympy import pi, rot_givens 

绕第三轴（z 轴）逆时针旋转 π/3 (60 度)：

>>> rot_givens(1, 0, pi/3)
Matrix([
[      1/2, -sqrt(3)/2, 0],
[sqrt(3)/2,        1/2, 0],
[        0,          0, 1]]) 

如果我们绕 π/2 (90 度) 旋转：

>>> rot_givens(1, 0, pi/2)
Matrix([
[0, -1, 0],
[1,  0, 0],
[0,  0, 1]]) 

这可以推广到任意维度：

>>> rot_givens(1, 0, pi/2, dim=4)
Matrix([
[0, -1, 0, 0],
[1,  0, 0, 0],
[0,  0, 1, 0],
[0,  0, 0, 1]]) 

参见

rot_axis1

返回一个绕第一轴（顺时针绕 x 轴）旋转 theta 弧度的旋转矩阵

rot_axis2

返回一个绕第二轴（顺时针绕 y 轴）旋转 theta 弧度的旋转矩阵

rot_axis3

返回一个绕第三轴（顺时针绕 z 轴）旋转 theta 弧度的旋转矩阵

rot_ccw_axis1

返回一个绕第一轴（逆时针绕 x 轴）旋转 theta 弧度的旋转矩阵

rot_ccw_axis2

返回一个绕第二轴（逆时针绕 y 轴）旋转 theta 弧度的旋转矩阵

rot_ccw_axis3

返回一个绕第三轴（逆时针绕 z 轴）旋转 theta 弧度的旋转矩阵

参考文献

[R646]

en.wikipedia.org/wiki/Givens_rotation

sympy.matrices.dense.rot_axis1(theta)

返回一个绕第一轴（顺时针绕 x 轴）旋转 theta 弧度的旋转矩阵

解释

对于右手坐标系，这对应于绕 (x)-轴的顺时针旋转，如下：

[\begin{split}R = \begin{bmatrix} 1 & 0 & 0 \ 0 & \cos(\theta) & \sin(\theta) \ 0 & -\sin(\theta) & \cos(\theta) \end{bmatrix}\end{split}]

例子

>>> from sympy import pi, rot_axis1 

绕 π/3 (60 度) 旋转：

>>> theta = pi/3
>>> rot_axis1(theta)
Matrix([
[1,          0,         0],
[0,        1/2, sqrt(3)/2],
[0, -sqrt(3)/2,       1/2]]) 

如果我们绕 π/2 (90 度) 旋转：

>>> rot_axis1(pi/2)
Matrix([
[1,  0, 0],
[0,  0, 1],
[0, -1, 0]]) 

参见

rot_givens

返回一个 Givens 旋转矩阵（任意维度的广义旋转）

rot_ccw_axis1

返回一个绕第一轴（逆时针绕 x 轴）旋转 theta 弧度的旋转矩阵

rot_axis2

返回一个绕第二轴（顺时针绕 y 轴）旋转 theta 弧度的旋转矩阵

rot_axis3

返回一个绕第三轴（顺时针绕 z 轴）旋转 theta 弧度的旋转矩阵

sympy.matrices.dense.rot_axis2(theta)

返回一个绕第二轴（顺时针绕 y 轴）旋转 theta 弧度的旋转矩阵

解释

对于右手坐标系，这对应于绕 (y)-轴的顺时针旋转，如下：

[\begin{split}R = \begin{bmatrix} \cos(\theta) & 0 & -\sin(\theta) \ 0 & 1 & 0 \ \sin(\theta) & 0 & \cos(\theta) \end{bmatrix}\end{split}]

示例

>>> from sympy import pi, rot_axis2 

旋转π/3（60 度）：

>>> theta = pi/3
>>> rot_axis2(theta)
Matrix([
[      1/2, 0, -sqrt(3)/2],
[        0, 1,          0],
[sqrt(3)/2, 0,        1/2]]) 

如果我们旋转π/2（90 度）：

>>> rot_axis2(pi/2)
Matrix([
[0, 0, -1],
[0, 1,  0],
[1, 0,  0]]) 

另见

rot_givens

返回一个 Givens 旋转矩阵（任意维度的广义旋转）

rot_ccw_axis2

返回一个绕着 2 轴（顺时针绕 y 轴）旋转θ（弧度）的旋转矩阵

rot_axis1

返回一个绕着 1 轴（逆时针绕 x 轴）旋转θ（弧度）的旋转矩阵

rot_axis3

返回一个绕着 3 轴（逆时针绕 z 轴）旋转θ（弧度）的旋转矩阵

sympy.matrices.dense.rot_axis3(theta)

返回一个绕着 3 轴旋转θ（弧度）的旋转矩阵。

解释

对于右手坐标系，这对应于绕 (z)-轴顺时针旋转，如下所示：

[\begin{split}R = \begin{bmatrix} \cos(\theta) & \sin(\theta) & 0 \ -\sin(\theta) & \cos(\theta) & 0 \ 0 & 0 & 1 \end{bmatrix}\end{split}]

示例

>>> from sympy import pi, rot_axis3 

旋转π/3（60 度）：

>>> theta = pi/3
>>> rot_axis3(theta)
Matrix([
[       1/2, sqrt(3)/2, 0],
[-sqrt(3)/2,       1/2, 0],
[         0,         0, 1]]) 

如果我们旋转π/2（90 度）：

>>> rot_axis3(pi/2)
Matrix([
[ 0, 1, 0],
[-1, 0, 0],
[ 0, 0, 1]]) 

另见

rot_givens

返回一个 Givens 旋转矩阵（任意维度的广义旋转）

rot_ccw_axis3

返回一个绕着 3 轴（逆时针绕 z 轴）旋转θ（弧度）的旋转矩阵

rot_axis1

返回一个绕着 1 轴（顺时针绕 x 轴）旋转θ（弧度）的旋转矩阵

rot_axis2

返回一个绕着 2 轴（顺时针绕 y 轴）旋转θ（弧度）的旋转矩阵

sympy.matrices.dense.rot_ccw_axis1(theta)

返回一个绕着 1 轴旋转θ（弧度）的旋转矩阵。

解释

对于右手坐标系，这对应于绕 (x)-轴逆时针旋转，如下所示：

[\begin{split}R = \begin{bmatrix} 1 & 0 & 0 \ 0 & \cos(\theta) & -\sin(\theta) \ 0 & \sin(\theta) & \cos(\theta) \end{bmatrix}\end{split}]

示例

>>> from sympy import pi, rot_ccw_axis1 

旋转π/3（60 度）：

>>> theta = pi/3
>>> rot_ccw_axis1(theta)
Matrix([
[1,         0,          0],
[0,       1/2, -sqrt(3)/2],
[0, sqrt(3)/2,        1/2]]) 

如果我们旋转π/2（90 度）：

>>> rot_ccw_axis1(pi/2)
Matrix([
[1, 0,  0],
[0, 0, -1],
[0, 1,  0]]) 

另见

rot_givens

返回一个 Givens 旋转矩阵（任意维度的广义旋转）

rot_axis1

返回一个绕着 1 轴（顺时针绕 x 轴）旋转θ（弧度）的旋转矩阵

rot_ccw_axis2

返回绕 2 轴（顺时针绕 y 轴）旋转θ（弧度）的旋转矩阵。

rot_ccw_axis3

返回绕 3 轴（顺时针绕 z 轴）旋转θ（弧度）的旋转矩阵。

sympy.matrices.dense.rot_ccw_axis2(theta)

返回绕 2 轴旋转θ（弧度）的旋转矩阵。

解释

对于右手坐标系，这对应于绕(y)-轴的逆时针旋转，表示为：

[\begin{split}R = \begin{bmatrix} \cos(\theta) & 0 & \sin(\theta) \ 0 & 1 & 0 \ -\sin(\theta) & 0 & \cos(\theta) \end{bmatrix}\end{split}]

示例

>>> from sympy import pi, rot_ccw_axis2 

旋转π/3（60 度）：

>>> theta = pi/3
>>> rot_ccw_axis2(theta)
Matrix([
[       1/2, 0, sqrt(3)/2],
[         0, 1,         0],
[-sqrt(3)/2, 0,       1/2]]) 

如果我们旋转π/2（90 度）：

>>> rot_ccw_axis2(pi/2)
Matrix([
[ 0,  0,  1],
[ 0,  1,  0],
[-1,  0,  0]]) 

参见

rot_givens

返回 Givens 旋转矩阵（任意维度的广义旋转）

rot_axis2

返回绕 2 轴（顺时针绕 y 轴）旋转θ（弧度）的旋转矩阵。

rot_ccw_axis1

返回绕 1 轴（顺时针绕 x 轴）旋转θ（弧度）的旋转矩阵。

rot_ccw_axis3

返回绕 3 轴（顺时针绕 z 轴）旋转θ（弧度）的旋转矩阵。

sympy.matrices.dense.rot_ccw_axis3(theta)

返回绕 3 轴（顺时针绕 z 轴）旋转θ（弧度）的旋转矩阵。

解释

对于右手坐标系，这对应于绕(z)-轴的逆时针旋转，表示为：

[\begin{split}R = \begin{bmatrix} \cos(\theta) & -\sin(\theta) & 0 \ \sin(\theta) & \cos(\theta) & 0 \ 0 & 0 & 1 \end{bmatrix}\end{split}]

示例

>>> from sympy import pi, rot_ccw_axis3 

旋转π/3（60 度）：

>>> theta = pi/3
>>> rot_ccw_axis3(theta)
Matrix([
[      1/2, -sqrt(3)/2, 0],
[sqrt(3)/2,        1/2, 0],
[        0,          0, 1]]) 

如果我们旋转π/2（90 度）：

>>> rot_ccw_axis3(pi/2)
Matrix([
[0, -1, 0],
[1,  0, 0],
[0,  0, 1]]) 

参见

rot_givens

返回 Givens 旋转矩阵（任意维度的广义旋转）

rot_axis3

返回绕 3 轴（逆时针绕 z 轴）旋转θ（弧度）的旋转矩阵。

rot_ccw_axis1

返回绕 1 轴（顺时针绕 x 轴）旋转θ（弧度）的旋转矩阵。

rot_ccw_axis2

返回绕 2 轴（顺时针绕 y 轴）旋转θ（弧度）的旋转矩阵。

NumPy 实用函数

sympy.matrices.dense.list2numpy(l, dtype=<class 'object'>)

将 SymPy 表达式的 Python 列表转换为 NumPy 数组。

参见

matrix2numpy

sympy.matrices.dense.matrix2numpy(m, dtype=<class 'object'>)

将 SymPy 的矩阵转换为 NumPy 数组。

另请参阅

list2numpy

sympy.matrices.dense.symarray(prefix, shape, **kwargs)

创建一个符号的 numpy ndarray（作为对象数组）。

创建的符号命名为prefix_i1_i2_… 因此，如果您希望您的符号对于不同的输出数组是唯一的，请提供一个非空前缀，因为 SymPy 中具有相同名称的符号是相同的对象。

参数：

prefix : 字符串

附加到每个符号名称前面的前缀。

shape : 整数或元组

创建的数组的形状。如果是整数，则数组是一维的；对于多于一个维度，形状必须是一个元组。

**kwargs : 字典

传递给 Symbol 的关键字参数

示例

这些 doctest 需要 numpy。

>>> from sympy import symarray
>>> symarray('', 3)
[_0 _1 _2] 

如果您希望多个 symarray 包含不同的符号，必须提供唯一的前缀：

>>> a = symarray('', 3)
>>> b = symarray('', 3)
>>> a[0] == b[0]
True
>>> a = symarray('a', 3)
>>> b = symarray('b', 3)
>>> a[0] == b[0]
False 

使用前缀创建 symarrays：

>>> symarray('a', 3)
[a_0 a_1 a_2] 

对于多于一个维度，形状必须以元组形式给出：

>>> symarray('a', (2, 3))
[[a_0_0 a_0_1 a_0_2]
 [a_1_0 a_1_1 a_1_2]]
>>> symarray('a', (2, 3, 2))
[[[a_0_0_0 a_0_0_1]
 [a_0_1_0 a_0_1_1]
 [a_0_2_0 a_0_2_1]]

 [[a_1_0_0 a_1_0_1]
 [a_1_1_0 a_1_1_1]
 [a_1_2_0 a_1_2_1]]] 

用于设置基础符号假设的关键字参数：

>>> [s.is_real for s in symarray('a', 2, real=True)]
[True, True] 

sympy.matrices.matrixbase.a2idx(j, n=None)

在进行正数验证后返回 n 的整数。
\ddots & \vdots & & \vdots \ 0 & \cdots & s & \cdots & c & \cdots & 0 \ \vdots & & \vdots & & \vdots & \ddots & \vdots \ 0 & \cdots & 0 & \cdots & 0 & \cdots & 1 \end{bmatrix}\end{split}]

其中 (c = \cos(\theta)) 和 (s = \sin(\theta)) 出现在第 i 行和第 j 列的交点处。

对于固定的 i > j，Givens 矩阵的非零元素由以下给出：

• (g_{kk} = 1) 对于 (k \ne i,,j)

• (g_{kk} = c) 对于 (k = i,,j)

• (g_{ji} = -g_{ij} = -s)

例子

>>> from sympy import pi, rot_givens 

绕第三轴（z 轴）逆时针旋转 π/3 (60 度)：

>>> rot_givens(1, 0, pi/3)
Matrix([
[      1/2, -sqrt(3)/2, 0],
[sqrt(3)/2,        1/2, 0],
[        0,          0, 1]]) 

如果我们绕 π/2 (90 度) 旋转：

>>> rot_givens(1, 0, pi/2)
Matrix([
[0, -1, 0],
[1,  0, 0],
[0,  0, 1]]) 

这可以推广到任意维度：

>>> rot_givens(1, 0, pi/2, dim=4)
Matrix([
[0, -1, 0, 0],
[1,  0, 0, 0],
[0,  0, 1, 0],
[0,  0, 0, 1]]) 

参见

rot_axis1

返回一个绕第一轴（顺时针绕 x 轴）旋转 theta 弧度的旋转矩阵

rot_axis2

返回一个绕第二轴（顺时针绕 y 轴）旋转 theta 弧度的旋转矩阵

rot_axis3

返回一个绕第三轴（顺时针绕 z 轴）旋转 theta 弧度的旋转矩阵

rot_ccw_axis1

返回一个绕第一轴（逆时针绕 x 轴）旋转 theta 弧度的旋转矩阵

rot_ccw_axis2

返回一个绕第二轴（逆时针绕 y 轴）旋转 theta 弧度的旋转矩阵

rot_ccw_axis3

返回一个绕第三轴（逆时针绕 z 轴）旋转 theta 弧度的旋转矩阵

参考文献

[R646]

en.wikipedia.org/wiki/Givens_rotation

sympy.matrices.dense.rot_axis1(theta)

返回一个绕第一轴（顺时针绕 x 轴）旋转 theta 弧度的旋转矩阵

解释

对于右手坐标系，这对应于绕 (x)-轴的顺时针旋转，如下：

[\begin{split}R = \begin{bmatrix} 1 & 0 & 0 \ 0 & \cos(\theta) & \sin(\theta) \ 0 & -\sin(\theta) & \cos(\theta) \end{bmatrix}\end{split}]

例子

>>> from sympy import pi, rot_axis1 

绕 π/3 (60 度) 旋转：

>>> theta = pi/3
>>> rot_axis1(theta)
Matrix([
[1,          0,         0],
[0,        1/2, sqrt(3)/2],
[0, -sqrt(3)/2,       1/2]]) 

如果我们绕 π/2 (90 度) 旋转：

>>> rot_axis1(pi/2)
Matrix([
[1,  0, 0],
[0,  0, 1],
[0, -1, 0]]) 

参见

rot_givens

返回一个 Givens 旋转矩阵（任意维度的广义旋转）

rot_ccw_axis1

返回一个绕第一轴（逆时针绕 x 轴）旋转 theta 弧度的旋转矩阵

rot_axis2

返回一个绕第二轴（顺时针绕 y 轴）旋转 theta 弧度的旋转矩阵

rot_axis3

返回一个绕第三轴（顺时针绕 z 轴）旋转 theta 弧度的旋转矩阵

sympy.matrices.dense.rot_axis2(theta)

返回一个绕第二轴（顺时针绕 y 轴）旋转 theta 弧度的旋转矩阵

解释

对于右手坐标系，这对应于绕 (y)-轴的顺时针旋转，如下：

[\begin{split}R = \begin{bmatrix} \cos(\theta) & 0 & -\sin(\theta) \ 0 & 1 & 0 \ \sin(\theta) & 0 & \cos(\theta) \end{bmatrix}\end{split}]

示例

>>> from sympy import pi, rot_axis2 

旋转π/3（60 度）：

>>> theta = pi/3
>>> rot_axis2(theta)
Matrix([
[      1/2, 0, -sqrt(3)/2],
[        0, 1,          0],
[sqrt(3)/2, 0,        1/2]]) 

如果我们旋转π/2（90 度）：

>>> rot_axis2(pi/2)
Matrix([
[0, 0, -1],
[0, 1,  0],
[1, 0,  0]]) 

另见

rot_givens

返回一个 Givens 旋转矩阵（任意维度的广义旋转）

rot_ccw_axis2

返回一个绕着 2 轴（顺时针绕 y 轴）旋转θ（弧度）的旋转矩阵

rot_axis1

返回一个绕着 1 轴（逆时针绕 x 轴）旋转θ（弧度）的旋转矩阵

rot_axis3

返回一个绕着 3 轴（逆时针绕 z 轴）旋转θ（弧度）的旋转矩阵

sympy.matrices.dense.rot_axis3(theta)

返回一个绕着 3 轴旋转θ（弧度）的旋转矩阵。

解释

对于右手坐标系，这对应于绕 (z)-轴顺时针旋转，如下所示：

[\begin{split}R = \begin{bmatrix} \cos(\theta) & \sin(\theta) & 0 \ -\sin(\theta) & \cos(\theta) & 0 \ 0 & 0 & 1 \end{bmatrix}\end{split}]

示例

>>> from sympy import pi, rot_axis3 

旋转π/3（60 度）：

>>> theta = pi/3
>>> rot_axis3(theta)
Matrix([
[       1/2, sqrt(3)/2, 0],
[-sqrt(3)/2,       1/2, 0],
[         0,         0, 1]]) 

如果我们旋转π/2（90 度）：

>>> rot_axis3(pi/2)
Matrix([
[ 0, 1, 0],
[-1, 0, 0],
[ 0, 0, 1]]) 

另见

rot_givens

返回一个 Givens 旋转矩阵（任意维度的广义旋转）

rot_ccw_axis3

返回一个绕着 3 轴（逆时针绕 z 轴）旋转θ（弧度）的旋转矩阵

rot_axis1

返回一个绕着 1 轴（顺时针绕 x 轴）旋转θ（弧度）的旋转矩阵

rot_axis2

返回一个绕着 2 轴（顺时针绕 y 轴）旋转θ（弧度）的旋转矩阵

sympy.matrices.dense.rot_ccw_axis1(theta)

返回一个绕着 1 轴旋转θ（弧度）的旋转矩阵。

解释

对于右手坐标系，这对应于绕 (x)-轴逆时针旋转，如下所示：

[\begin{split}R = \begin{bmatrix} 1 & 0 & 0 \ 0 & \cos(\theta) & -\sin(\theta) \ 0 & \sin(\theta) & \cos(\theta) \end{bmatrix}\end{split}]

示例

>>> from sympy import pi, rot_ccw_axis1 

旋转π/3（60 度）：

>>> theta = pi/3
>>> rot_ccw_axis1(theta)
Matrix([
[1,         0,          0],
[0,       1/2, -sqrt(3)/2],
[0, sqrt(3)/2,        1/2]]) 

如果我们旋转π/2（90 度）：

>>> rot_ccw_axis1(pi/2)
Matrix([
[1, 0,  0],
[0, 0, -1],
[0, 1,  0]]) 

另见

rot_givens

返回一个 Givens 旋转矩阵（任意维度的广义旋转）

rot_axis1

返回一个绕着 1 轴（顺时针绕 x 轴）旋转θ（弧度）的旋转矩阵

rot_ccw_axis2

返回绕 2 轴（顺时针绕 y 轴）旋转θ（弧度）的旋转矩阵。

rot_ccw_axis3

返回绕 3 轴（顺时针绕 z 轴）旋转θ（弧度）的旋转矩阵。

sympy.matrices.dense.rot_ccw_axis2(theta)

返回绕 2 轴旋转θ（弧度）的旋转矩阵。

解释

对于右手坐标系，这对应于绕(y)-轴的逆时针旋转，表示为：

[\begin{split}R = \begin{bmatrix} \cos(\theta) & 0 & \sin(\theta) \ 0 & 1 & 0 \ -\sin(\theta) & 0 & \cos(\theta) \end{bmatrix}\end{split}]

示例

>>> from sympy import pi, rot_ccw_axis2 

旋转π/3（60 度）：

>>> theta = pi/3
>>> rot_ccw_axis2(theta)
Matrix([
[       1/2, 0, sqrt(3)/2],
[         0, 1,         0],
[-sqrt(3)/2, 0,       1/2]]) 

如果我们旋转π/2（90 度）：

>>> rot_ccw_axis2(pi/2)
Matrix([
[ 0,  0,  1],
[ 0,  1,  0],
[-1,  0,  0]]) 

参见

rot_givens

返回 Givens 旋转矩阵（任意维度的广义旋转）

rot_axis2

返回绕 2 轴（顺时针绕 y 轴）旋转θ（弧度）的旋转矩阵。

rot_ccw_axis1

返回绕 1 轴（顺时针绕 x 轴）旋转θ（弧度）的旋转矩阵。

rot_ccw_axis3

返回绕 3 轴（顺时针绕 z 轴）旋转θ（弧度）的旋转矩阵。

sympy.matrices.dense.rot_ccw_axis3(theta)

返回绕 3 轴（顺时针绕 z 轴）旋转θ（弧度）的旋转矩阵。

解释

对于右手坐标系，这对应于绕(z)-轴的逆时针旋转，表示为：

[\begin{split}R = \begin{bmatrix} \cos(\theta) & -\sin(\theta) & 0 \ \sin(\theta) & \cos(\theta) & 0 \ 0 & 0 & 1 \end{bmatrix}\end{split}]

示例

>>> from sympy import pi, rot_ccw_axis3 

旋转π/3（60 度）：

>>> theta = pi/3
>>> rot_ccw_axis3(theta)
Matrix([
[      1/2, -sqrt(3)/2, 0],
[sqrt(3)/2,        1/2, 0],
[        0,          0, 1]]) 

如果我们旋转π/2（90 度）：

>>> rot_ccw_axis3(pi/2)
Matrix([
[0, -1, 0],
[1,  0, 0],
[0,  0, 1]]) 

参见

rot_givens

返回 Givens 旋转矩阵（任意维度的广义旋转）

rot_axis3

返回绕 3 轴（逆时针绕 z 轴）旋转θ（弧度）的旋转矩阵。

rot_ccw_axis1

返回绕 1 轴（顺时针绕 x 轴）旋转θ（弧度）的旋转矩阵。

rot_ccw_axis2

返回绕 2 轴（顺时针绕 y 轴）旋转θ（弧度）的旋转矩阵。

NumPy 实用函数

sympy.matrices.dense.list2numpy(l, dtype=<class 'object'>)

将 SymPy 表达式的 Python 列表转换为 NumPy 数组。

参见

matrix2numpy

sympy.matrices.dense.matrix2numpy(m, dtype=<class 'object'>)

将 SymPy 的矩阵转换为 NumPy 数组。

另请参阅

list2numpy

sympy.matrices.dense.symarray(prefix, shape, **kwargs)

创建一个符号的 numpy ndarray（作为对象数组）。

创建的符号命名为prefix_i1_i2_… 因此，如果您希望您的符号对于不同的输出数组是唯一的，请提供一个非空前缀，因为 SymPy 中具有相同名称的符号是相同的对象。

参数：

prefix : 字符串

附加到每个符号名称前面的前缀。

shape : 整数或元组

创建的数组的形状。如果是整数，则数组是一维的；对于多于一个维度，形状必须是一个元组。

**kwargs : 字典

传递给 Symbol 的关键字参数

示例

这些 doctest 需要 numpy。

>>> from sympy import symarray
>>> symarray('', 3)
[_0 _1 _2] 

如果您希望多个 symarray 包含不同的符号，必须提供唯一的前缀：

>>> a = symarray('', 3)
>>> b = symarray('', 3)
>>> a[0] == b[0]
True
>>> a = symarray('a', 3)
>>> b = symarray('b', 3)
>>> a[0] == b[0]
False 

使用前缀创建 symarrays：

>>> symarray('a', 3)
[a_0 a_1 a_2] 

对于多于一个维度，形状必须以元组形式给出：

>>> symarray('a', (2, 3))
[[a_0_0 a_0_1 a_0_2]
 [a_1_0 a_1_1 a_1_2]]
>>> symarray('a', (2, 3, 2))
[[[a_0_0_0 a_0_0_1]
 [a_0_1_0 a_0_1_1]
 [a_0_2_0 a_0_2_1]]

 [[a_1_0_0 a_1_0_1]
 [a_1_1_0 a_1_1_1]
 [a_1_2_0 a_1_2_1]]] 

用于设置基础符号假设的关键字参数：

>>> [s.is_real for s in symarray('a', 2, real=True)]
[True, True] 

sympy.matrices.matrixbase.a2idx(j, n=None)

在进行正数验证后返回 n 的整数。