稠密矩阵¶

sympy.matrices.dense.Matrix[源代码]¶: MutableDenseMatrix 的别名

class sympy.matrices.dense.DenseMatrix[源代码][源代码]¶

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

属性:

C: 逐元素共轭
D: 返回Dirac共轭（如果 self.rows == 4）。
H: 返回厄米共轭。
T: 矩阵转置
cols
free_symbols: 返回矩阵中的自由符号。
is_Identity
is_echelon: 如果矩阵是阶梯形式，则返回 $True$。
is_hermitian: 检查矩阵是否为厄米矩阵。
is_indefinite: 找出矩阵的确定性。
is_lower: 检查矩阵是否为下三角矩阵。
is_lower_hessenberg: 检查矩阵是否为下Hessenberg形式。
is_negative_definite: 找出矩阵的确定性。
is_negative_semidefinite: 找出矩阵的确定性。
is_positive_definite: 找出矩阵的确定性。
is_positive_semidefinite: 找出矩阵的确定性。
is_square: 检查矩阵是否为方阵。
is_strongly_diagonally_dominant: 测试矩阵是否为行强对角占优。
is_upper: 检查矩阵是否为上三角矩阵。
is_upper_hessenberg: 检查矩阵是否为上Hessenberg形式。
is_weakly_diagonally_dominant: 测试矩阵是否为行弱对角占优。
is_zero_matrix: 检查一个矩阵是否为零矩阵。
种类
行
shape: 矩阵的形状（维度）作为 2 元组 (行数, 列数)。

方法

`LDLdecomposition`([hermitian])	返回矩阵 A 的 LDL 分解 (L, D)，使得如果 hermitian 标志为 True，则 L * D * L.H == A，或者如果 hermitian 为 False，则 L * D * L.T == A。
`LDLsolve`(rhs)	使用LDL分解求解 `Ax = B`，适用于一般的方阵和非奇异矩阵。
`LUdecomposition`([iszerofunc, simpfunc, ...])	返回 (L, U, perm)，其中 L 是一个对角线为单位矩阵的下三角矩阵，U 是一个上三角矩阵，perm 是一个行交换索引对的列表。
`LUdecompositionFF`()	计算一个无分数的LU分解。
`LUdecomposition_Simple`([iszerofunc, ...])	计算矩阵的 PLU 分解。
`LUsolve`(rhs[, iszerofunc])	求解线性系统 `Ax = rhs` 中的 `x`，其中 `A = M`。
`QRdecomposition`()	返回一个QR分解。
`QRsolve`(b)	求解线性系统 `Ax = b`。
`add`(b)	返回 self + b。
`adjoint`()	共轭转置或厄米共轭。
`adjugate`([method])	返回矩阵的伴随矩阵，或经典伴随矩阵。
`analytic_func`(f, x)	计算 f(A)，其中 A 是一个方阵，f 是一个解析函数。
`applyfunc`(f)	对矩阵的每个元素应用一个函数。
`as_immutable`()	返回此矩阵的不可变版本
`as_mutable`()	返回此矩阵的可变版本
`as_real_imag`([deep])	返回一个包含矩阵的（实部，虚部）部分的元组。
`atoms`(*types)	返回构成当前对象的原子。
`berkowitz_det`()	使用Berkowitz方法计算行列式。
`berkowitz_eigenvals`(**flags)	使用Berkowitz方法计算矩阵的特征值。
`berkowitz_minors`()	使用Berkowitz方法计算主子式。
`bidiagonal_decomposition`([upper])	返回 $(U,B,V.H)$ 用于
`bidiagonalize`([upper])	返回 $B$，即输入矩阵的双对角化形式。
`charpoly`([x, simplify])	计算特征多项式 det(x*I - M)，其中 I 是单位矩阵。
`cholesky`([hermitian])	返回矩阵 A 的 Cholesky 类型分解 L，使得如果 hermitian 标志为 True，则 L * L.H == A，或者如果 hermitian 为 False，则 L * L.T == A。
`cholesky_solve`(rhs)	使用 Cholesky 分解求解 `Ax = B`，适用于一般的非奇异方阵。
`cofactor`(i, j[, method])	计算元素的余子式。
`cofactor_matrix`([method])	返回一个包含每个元素的余子式的矩阵。
`col`(j)	基本列选择器。
`col_del`(col)	删除指定的列。
`col_insert`(pos, other)	在给定的列位置插入一列或多列。
`col_join`(other)	将两个矩阵沿着自身的最后一行和另一个矩阵的第一行进行连接。
`columnspace`([simplify])	返回一个向量列表（矩阵对象），这些向量跨越 `M` 的列空间
`companion`(poly)	返回多项式的伴随矩阵。
`condition_number`()	返回矩阵的条件数。
`conjugate`()	返回按元素的共轭。
`connected_components`()	当一个方阵被视为加权图时，返回图中连接顶点的列表。
`connected_components_decomposition`()	仅使用排列将一个方阵分解为块对角形式。
`copy`()
`cramer_solve`(rhs[, det_method])	使用克莱姆法则求解线性方程组。
`cross`(b)	返回 `self` 和 `b` 的叉积，放松兼容维度的条件：如果每个都有3个元素，将返回与 `self` 相同类型和形状的矩阵。
`det`([method, iszerofunc])	如果 `M` 是一个具体的矩阵对象，则计算其行列式；否则，如果 `M` 是一个 `MatrixSymbol` 或其他表达式，则返回表达式 `Determinant(M)`。
`det_LU_decomposition`()	使用LU分解计算矩阵行列式。
`diag`(*args[, strict, unpack, rows, cols])	返回具有指定对角线的矩阵。
`diagonal`([k])	返回自身的第 k 个对角线。
`diagonal_solve`(rhs)	高效求解 `Ax = B`，其中 A 是一个对角矩阵，且对角元素非零。
`diagonalize`([reals_only, sort, normalize])	返回 (P, D)，其中 D 是对角矩阵。
`diff`(*args[, evaluate])	计算矩阵中每个元素的导数。
`dot`(b[, hermitian, conjugate_convention])	返回两个长度相等的向量的点积或内积。
`dual`()	返回矩阵的对偶。
`echelon_form`([iszerofunc, simplify, with_pivots])	返回一个与 `M` 行等价的矩阵，该矩阵为阶梯形式。
`eigenvals`([error_when_incomplete])	计算矩阵的特征值。
`eigenvects`([error_when_incomplete, iszerofunc])	计算矩阵的特征向量。
`elementary_col_op`([op, col, k, col1, col2])	执行基本列操作 $op$。
`elementary_row_op`([op, row, k, row1, row2])	执行基本行操作 $op$。
`equals`(other[, failing_expression])	对矩阵的对应元素应用 `equals` ，试图证明这些元素是等价的，如果它们是等价的则返回 True ，如果有任何一对不等价则返回 False ，如果无法确定表达式是否等价，则返回 None （或者如果 failing_expression 为 True ，则返回第一个失败的表达式）。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	对 self 的每个元素应用 evalf()。
`exp`()	返回一个方阵的指数。
`expand`([deep, modulus, power_base, ...])	对矩阵的每个条目应用 core.function.expand。
`extract`(rowsList, colsList)	通过指定行和列的列表返回一个子矩阵。
`eye`(rows[, cols])	返回一个单位矩阵。
`flat`()
`from_dok`(rows, cols, dok)	从键的字典创建一个矩阵。
`gauss_jordan_solve`(B[, freevar])	使用高斯-约旦消元法求解 `Ax = B`。
`get_diag_blocks`()	获取方阵主对角线上的子方阵。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`hat`()	返回表示叉积的反对称矩阵，使得 `self.hat() * b` 等价于 `self.cross(b)`。
`hstack`(*args)	返回一个矩阵，该矩阵通过水平连接参数（即通过重复应用 row_join）形成。
`integrate`(args, *kwargs)	积分矩阵的每个元素。
`inv`([method, iszerofunc, try_block_diag])	使用指定方法返回矩阵的逆。
`inv_mod`(m)	返回整数矩阵 `M` 模 `m` 的逆。
`inverse_ADJ`([iszerofunc])	使用伴随矩阵和行列式计算逆矩阵。
`inverse_BLOCK`([iszerofunc])	使用块状逆运算计算逆矩阵。
`inverse_CH`([iszerofunc])	使用 Cholesky 分解计算逆矩阵。
`inverse_GE`([iszerofunc])	使用高斯消去法计算逆矩阵。
`inverse_LDL`([iszerofunc])	使用 LDL 分解计算逆矩阵。
`inverse_LU`([iszerofunc])	使用LU分解计算逆矩阵。
`inverse_QR`([iszerofunc])	使用QR分解计算逆矩阵。
`irregular`(ntop, matrices, *kwargs)	返回一个矩阵，该矩阵由给定的矩阵填充，这些矩阵按从左到右、从上到下的顺序依次出现，与它们在矩阵中首次出现的位置一致。
`is_anti_symmetric`([simplify])	检查矩阵 M 是否为反对称矩阵，即，M 是一个方阵，且所有 M[i, j] == -M[j, i]。
`is_diagonal`()	检查矩阵是否为对角矩阵，即主对角线以外的所有元素均为零的矩阵。
`is_diagonalizable`([reals_only])	如果矩阵可对角化，则返回 `True`。
`is_nilpotent`()	检查矩阵是否为幂零矩阵。
`is_symbolic`()	检查是否有元素包含符号。
`is_symmetric`([simplify])	检查矩阵是否为对称矩阵，即方阵且等于其转置矩阵。
`iter_items`()	遍历非零项的索引和值。
`iter_values`()	遍历 self 的非零值
`jacobian`(X)	计算雅可比矩阵（向量值函数的导数）。
`jordan_block`([size, eigenvalue, band])	返回一个 Jordan 块
`jordan_form`([calc_transform])	返回 $(P, J)$，其中 $J$ 是一个约旦块矩阵，$P$ 是一个矩阵，使得 $M = P J P^{-1}$
`key2bounds`(keys)	将一个可能包含混合类型键（整数和切片）的键转换为范围元组，如果任何索引超出 `self` 的范围，则引发错误。
`key2ij`(key)	将键转换为规范形式，将整数或可索引项转换为 `self` 范围内的有效整数，或者返回切片不变。
`left_eigenvects`(**flags)	返回左特征向量和特征值。
`limit`(*args)	计算矩阵中每个元素的极限。
`lll`([delta])	LLL-约化基用于整数矩阵行空间的基。
`lll_transform`([delta])	LLL-约化基和变换矩阵。
`log`([simplify])	返回一个方阵的对数。
`lower_triangular`([k])	返回矩阵中第k条对角线及其以下的元素。
`lower_triangular_solve`(rhs)	求解 `Ax = B`，其中 A 是一个下三角矩阵。
`minor`(i, j[, method])	返回 `M` 的 (i,j) 子式。
`minor_submatrix`(i, j)	返回通过从 `M` 中移除第 $i$ 行和第 $j$ 列得到的子矩阵（适用于Python风格的负索引）。
`multiply`(other[, dotprodsimp])	与 __mul__() 相同，但带有可选的简化。
`multiply_elementwise`(other)	返回 A 和 B 的哈达玛积（逐元素乘积）
`n`(args, *kwargs)	对 self 的每个元素应用 evalf()。
`norm`([ord])	返回矩阵或向量的范数。
`normalized`([iszerofunc])	返回 `self` 的规范化版本。
`nullspace`([simplify, iszerofunc])	返回一个向量列表（矩阵对象），这些向量跨越 `M` 的零空间
`ones`(rows[, cols])	返回一个全为1的矩阵。
`orthogonalize`(vecs, *kwargs)	对 `vecs` 中的向量应用格拉姆-施密特正交化过程。
`per`()	返回矩阵的永久值。
`permute`(perm[, orientation, direction])	通过给定的交换列表置换矩阵的行或列。
`permuteBkwd`(perm)	使用给定的排列逆序置换矩阵的行。
`permuteFwd`(perm)	使用给定的排列来置换矩阵的行。
`permute_cols`(swaps[, direction])	`self.permute(swaps, orientation='cols', direction=direction)` 的别名
`permute_rows`(swaps[, direction])	`self.permute(swaps, orientation='rows', direction=direction)` 的别名
`pinv`([method])	计算矩阵的 Moore-Penrose 伪逆。
`pinv_solve`(B[, arbitrary_matrix])	使用 Moore-Penrose 伪逆求解 `Ax = B`。
`pow`(exp[, method])	返回 self**exp，其中 exp 可以是标量或符号。
`print_nonzero`([symb])	显示非零条目的位置以快速查找形状。
`project`(v)	返回 `self` 在包含 `v` 的直线上的投影。
`rank`([iszerofunc, simplify])	返回矩阵的秩。
`rank_decomposition`([iszerofunc, simplify])	返回一对矩阵 ($C$, $F$)，它们具有匹配的秩，使得 $A = C F$。
`refine`([assumptions])	对矩阵的每个元素应用细化。
`replace`(F, G[, map, simultaneous, exact])	将矩阵条目中的函数 F 替换为函数 G。
`reshape`(rows, cols)	重塑矩阵。
`rmultiply`(other[, dotprodsimp])	与 __rmul__() 相同，但带有可选的简化功能。
`rot90`([k])	将矩阵旋转90度
`row`(i)	基本行选择器。
`row_del`(row)	删除指定的行。
`row_insert`(pos, other)	在给定的行位置插入一行或多行。
`row_join`(other)	将两个矩阵沿着自身的最后一列和rhs的第一列进行连接
`rowspace`([simplify])	返回一个向量列表，这些向量跨越 `M` 的行空间。
`rref`([iszerofunc, simplify, pivots, ...])	返回矩阵的简化行阶梯形式和主元变量的索引。
`rref_rhs`(rhs)	返回矩阵的简化行阶梯形式，显示简化步骤后的右侧矩阵。
`simplify`(**kwargs)	对矩阵的每个元素应用简化。
`singular_value_decomposition`()	返回一个压缩的奇异值分解。
`singular_values`()	计算矩阵的奇异值
`solve`(rhs[, method])	求解存在唯一解的线性方程。
`solve_least_squares`(rhs[, method])	返回对数据的最小二乘拟合。
`strongly_connected_components`()	当一个方阵被视为加权图时，返回图中强连通顶点的列表。
`strongly_connected_components_decomposition`([lower])	仅使用排列将一个方阵分解为块三角形式。
`subs`(args, *kwargs)	返回一个新的矩阵，其中每个条目都应用了 subs。
`table`(printer[, rowstart, rowend, rowsep, ...])	以表格形式表示的矩阵字符串。
`to_DM`([domain])	转换为 `DomainMatrix`。
`todod`()	返回矩阵为包含非零元素的字典的字典
`todok`()	返回矩阵作为键的字典。
`tolist`()	返回矩阵作为嵌套的 Python 列表。
`trace`()	返回一个方阵的迹，即对角元素之和。
`transpose`()	返回矩阵的转置。
`upper_hessenberg_decomposition`()	将一个矩阵转换为Hessenberg矩阵H。
`upper_triangular`([k])	返回矩阵中第 k 条对角线及其以上的元素。
`upper_triangular_solve`(rhs)	求解 `Ax = B`，其中 A 是一个上三角矩阵。
`values`()	返回 self 的非零值。
`vec`()	通过堆叠列将矩阵转换为单列矩阵
`vech`([diagonal, check_symmetry])	通过堆叠下三角中的元素，将矩阵重塑为列向量。
`vee`()	从表示叉积的反对称矩阵返回一个3x1的向量，使得 `self * b` 等价于 `self.vee().cross(b)`。
`vstack`(*args)	返回一个矩阵，该矩阵是通过垂直连接参数（即通过重复应用 col_join）形成的。
`wilkinson`(n, **kwargs)	返回两个大小为 2*n + 1 的平方 Wilkinson 矩阵 $W_{2n + 1}^-, W_{2n + 1}^+ =$ Wilkinson(n)
`xreplace`(rule)	返回一个新的矩阵，其中每个条目都应用了 xreplace。
`zeros`(rows[, cols])	返回一个全零矩阵。

berkowitz
berkowitz_charpoly
cofactorMatrix
det_bareis
执行
jordan_cell
jordan_cells
minorEntry
minorMatrix

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 必须是 Hermitian 正定矩阵，否则 A 必须是对称矩阵。

参见

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

示例

>>> 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

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 必须是一个厄米正定矩阵；如果为 False，A 必须是一个对称矩阵。

参见

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

示例

>>> 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]])

非厄米特 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

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)[源代码][源代码]¶

属性:

C: 逐元素共轭
D: 返回Dirac共轭（如果 self.rows == 4）。
H: 返回厄米共轭。
T: 矩阵转置
cols
free_symbols: 返回矩阵中的自由符号。
is_Identity
is_echelon: 如果矩阵是阶梯形式，则返回 $True$。
is_hermitian: 检查矩阵是否为厄米矩阵。
is_indefinite: 找出矩阵的确定性。
is_lower: 检查矩阵是否为下三角矩阵。
is_lower_hessenberg: 检查矩阵是否为下Hessenberg形式。
is_negative_definite: 找出矩阵的确定性。
is_negative_semidefinite: 找出矩阵的确定性。
is_positive_definite: 找出矩阵的确定性。
is_positive_semidefinite: 找出矩阵的确定性。
is_square: 检查矩阵是否为方阵。
is_strongly_diagonally_dominant: 测试矩阵是否为行强对角占优。
is_upper: 检查矩阵是否为上三角矩阵。
is_upper_hessenberg: 检查矩阵是否为上Hessenberg形式。
is_weakly_diagonally_dominant: 测试矩阵是否为行弱对角占优。
is_zero_matrix: 检查一个矩阵是否为零矩阵。
种类
行
shape: 矩阵的形状（维度）作为 2 元组 (行数, 列数)。

方法

`LDLdecomposition`([hermitian])	返回矩阵 A 的 LDL 分解 (L, D)，使得如果 hermitian 标志为 True，则 L * D * L.H == A，或者如果 hermitian 为 False，则 L * D * L.T == A。
`LDLsolve`(rhs)	使用LDL分解求解 `Ax = B`，适用于一般的方阵和非奇异矩阵。
`LUdecomposition`([iszerofunc, simpfunc, ...])	返回 (L, U, perm)，其中 L 是一个对角线为单位矩阵的下三角矩阵，U 是一个上三角矩阵，perm 是一个行交换索引对的列表。
`LUdecompositionFF`()	计算一个无分数的LU分解。
`LUdecomposition_Simple`([iszerofunc, ...])	计算矩阵的 PLU 分解。
`LUsolve`(rhs[, iszerofunc])	求解线性系统 `Ax = rhs` 中的 `x`，其中 `A = M`。
`QRdecomposition`()	返回一个QR分解。
`QRsolve`(b)	求解线性系统 `Ax = b`。
`add`(b)	返回 self + b。
`adjoint`()	共轭转置或厄米共轭。
`adjugate`([method])	返回矩阵的伴随矩阵，或经典伴随矩阵。
`analytic_func`(f, x)	计算 f(A)，其中 A 是一个方阵，f 是一个解析函数。
`applyfunc`(f)	对矩阵的每个元素应用一个函数。
`as_immutable`()	返回此矩阵的不可变版本
`as_mutable`()	返回此矩阵的可变版本
`as_real_imag`([deep])	返回一个包含矩阵的（实部，虚部）部分的元组。
`atoms`(*types)	返回构成当前对象的原子。
`berkowitz_det`()	使用Berkowitz方法计算行列式。
`berkowitz_eigenvals`(**flags)	使用Berkowitz方法计算矩阵的特征值。
`berkowitz_minors`()	使用Berkowitz方法计算主子式。
`bidiagonal_decomposition`([upper])	返回 $(U,B,V.H)$ 用于
`bidiagonalize`([upper])	返回 $B$，即输入矩阵的双对角化形式。
`charpoly`([x, simplify])	计算特征多项式 det(x*I - M)，其中 I 是单位矩阵。
`cholesky`([hermitian])	返回矩阵 A 的 Cholesky 类型分解 L，使得如果 hermitian 标志为 True，则 L * L.H == A，或者如果 hermitian 为 False，则 L * L.T == A。
`cholesky_solve`(rhs)	使用 Cholesky 分解求解 `Ax = B`，适用于一般的非奇异方阵。
`cofactor`(i, j[, method])	计算元素的余子式。
`cofactor_matrix`([method])	返回一个包含每个元素的余子式的矩阵。
`col`(j)	基本列选择器。
`col_del`(col)	删除指定的列。
`col_insert`(pos, other)	在给定的列位置插入一列或多列。
`col_join`(other)	将两个矩阵沿着自身的最后一行和另一个矩阵的第一行进行连接。
`col_op`(j, f)	在列 j 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], i)。
`col_swap`(i, j)	就地交换矩阵中的两个给定列。
`columnspace`([simplify])	返回一个向量列表（矩阵对象），这些向量跨越 `M` 的列空间
`companion`(poly)	返回多项式的伴随矩阵。
`condition_number`()	返回矩阵的条件数。
`conjugate`()	返回按元素的共轭。
`connected_components`()	当一个方阵被视为加权图时，返回图中连接顶点的列表。
`connected_components_decomposition`()	仅使用排列将一个方阵分解为块对角形式。
`copy`()
`copyin_list`(key, value)	从列表中复制元素。
`copyin_matrix`(key, value)	将矩阵中的值复制到给定的边界内。
`cramer_solve`(rhs[, det_method])	使用克莱姆法则求解线性方程组。
`cross`(b)	返回 `self` 和 `b` 的叉积，放松兼容维度的条件：如果每个都有3个元素，将返回与 `self` 相同类型和形状的矩阵。
`det`([method, iszerofunc])	如果 `M` 是一个具体的矩阵对象，则计算其行列式；否则，如果 `M` 是一个 `MatrixSymbol` 或其他表达式，则返回表达式 `Determinant(M)`。
`det_LU_decomposition`()	使用LU分解计算矩阵行列式。
`diag`(*args[, strict, unpack, rows, cols])	返回具有指定对角线的矩阵。
`diagonal`([k])	返回自身的第 k 个对角线。
`diagonal_solve`(rhs)	高效求解 `Ax = B`，其中 A 是一个对角矩阵，且对角元素非零。
`diagonalize`([reals_only, sort, normalize])	返回 (P, D)，其中 D 是对角矩阵。
`diff`(*args[, evaluate])	计算矩阵中每个元素的导数。
`dot`(b[, hermitian, conjugate_convention])	返回两个长度相等的向量的点积或内积。
`dual`()	返回矩阵的对偶。
`echelon_form`([iszerofunc, simplify, with_pivots])	返回一个与 `M` 行等价的矩阵，该矩阵为阶梯形式。
`eigenvals`([error_when_incomplete])	计算矩阵的特征值。
`eigenvects`([error_when_incomplete, iszerofunc])	计算矩阵的特征向量。
`elementary_col_op`([op, col, k, col1, col2])	执行基本列操作 $op$。
`elementary_row_op`([op, row, k, row1, row2])	执行基本行操作 $op$。
`equals`(other[, failing_expression])	对矩阵的对应元素应用 `equals` ，试图证明这些元素是等价的，如果它们是等价的则返回 True ，如果有任何一对不等价则返回 False ，如果无法确定表达式是否等价，则返回 None （或者如果 failing_expression 为 True ，则返回第一个失败的表达式）。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	对 self 的每个元素应用 evalf()。
`exp`()	返回一个方阵的指数。
`expand`([deep, modulus, power_base, ...])	对矩阵的每个条目应用 core.function.expand。
`extract`(rowsList, colsList)	通过指定行和列的列表返回一个子矩阵。
`eye`(rows[, cols])	返回一个单位矩阵。
`fill`(value)	用给定的值填充自身。
`flat`()
`from_dok`(rows, cols, dok)	从键的字典创建一个矩阵。
`gauss_jordan_solve`(B[, freevar])	使用高斯-约旦消元法求解 `Ax = B`。
`get_diag_blocks`()	获取方阵主对角线上的子方阵。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`hat`()	返回表示叉积的反对称矩阵，使得 `self.hat() * b` 等价于 `self.cross(b)`。
`hstack`(*args)	返回一个矩阵，该矩阵通过水平连接参数（即通过重复应用 row_join）形成。
`integrate`(args, *kwargs)	积分矩阵的每个元素。
`inv`([method, iszerofunc, try_block_diag])	使用指定方法返回矩阵的逆。
`inv_mod`(m)	返回整数矩阵 `M` 模 `m` 的逆。
`inverse_ADJ`([iszerofunc])	使用伴随矩阵和行列式计算逆矩阵。
`inverse_BLOCK`([iszerofunc])	使用块状逆运算计算逆矩阵。
`inverse_CH`([iszerofunc])	使用 Cholesky 分解计算逆矩阵。
`inverse_GE`([iszerofunc])	使用高斯消去法计算逆矩阵。
`inverse_LDL`([iszerofunc])	使用 LDL 分解计算逆矩阵。
`inverse_LU`([iszerofunc])	使用LU分解计算逆矩阵。
`inverse_QR`([iszerofunc])	使用QR分解计算逆矩阵。
`irregular`(ntop, matrices, *kwargs)	返回一个矩阵，该矩阵由给定的矩阵填充，这些矩阵按从左到右、从上到下的顺序依次出现，与它们在矩阵中首次出现的位置一致。
`is_anti_symmetric`([simplify])	检查矩阵 M 是否为反对称矩阵，即，M 是一个方阵，且所有 M[i, j] == -M[j, i]。
`is_diagonal`()	检查矩阵是否为对角矩阵，即主对角线以外的所有元素均为零的矩阵。
`is_diagonalizable`([reals_only])	如果矩阵可对角化，则返回 `True`。
`is_nilpotent`()	检查矩阵是否为幂零矩阵。
`is_symbolic`()	检查是否有元素包含符号。
`is_symmetric`([simplify])	检查矩阵是否为对称矩阵，即方阵且等于其转置矩阵。
`iter_items`()	遍历非零项的索引和值。
`iter_values`()	遍历 self 的非零值
`jacobian`(X)	计算雅可比矩阵（向量值函数的导数）。
`jordan_block`([size, eigenvalue, band])	返回一个 Jordan 块
`jordan_form`([calc_transform])	返回 $(P, J)$，其中 $J$ 是一个约旦块矩阵，$P$ 是一个矩阵，使得 $M = P J P^{-1}$
`key2bounds`(keys)	将一个可能包含混合类型键（整数和切片）的键转换为范围元组，如果任何索引超出 `self` 的范围，则引发错误。
`key2ij`(key)	将键转换为规范形式，将整数或可索引项转换为 `self` 范围内的有效整数，或者返回切片不变。
`left_eigenvects`(**flags)	返回左特征向量和特征值。
`limit`(*args)	计算矩阵中每个元素的极限。
`lll`([delta])	LLL-约化基用于整数矩阵行空间的基。
`lll_transform`([delta])	LLL-约化基和变换矩阵。
`log`([simplify])	返回一个方阵的对数。
`lower_triangular`([k])	返回矩阵中第k条对角线及其以下的元素。
`lower_triangular_solve`(rhs)	求解 `Ax = B`，其中 A 是一个下三角矩阵。
`minor`(i, j[, method])	返回 `M` 的 (i,j) 子式。
`minor_submatrix`(i, j)	返回通过从 `M` 中移除第 $i$ 行和第 $j$ 列得到的子矩阵（适用于Python风格的负索引）。
`multiply`(other[, dotprodsimp])	与 __mul__() 相同，但带有可选的简化。
`multiply_elementwise`(other)	返回 A 和 B 的哈达玛积（逐元素乘积）
`n`(args, *kwargs)	对 self 的每个元素应用 evalf()。
`norm`([ord])	返回矩阵或向量的范数。
`normalized`([iszerofunc])	返回 `self` 的规范化版本。
`nullspace`([simplify, iszerofunc])	返回一个向量列表（矩阵对象），这些向量跨越 `M` 的零空间
`ones`(rows[, cols])	返回一个全为1的矩阵。
`orthogonalize`(vecs, *kwargs)	对 `vecs` 中的向量应用格拉姆-施密特正交化过程。
`per`()	返回矩阵的永久值。
`permute`(perm[, orientation, direction])	通过给定的交换列表置换矩阵的行或列。
`permuteBkwd`(perm)	使用给定的排列逆序置换矩阵的行。
`permuteFwd`(perm)	使用给定的排列来置换矩阵的行。
`permute_cols`(swaps[, direction])	`self.permute(swaps, orientation='cols', direction=direction)` 的别名
`permute_rows`(swaps[, direction])	`self.permute(swaps, orientation='rows', direction=direction)` 的别名
`pinv`([method])	计算矩阵的 Moore-Penrose 伪逆。
`pinv_solve`(B[, arbitrary_matrix])	使用 Moore-Penrose 伪逆求解 `Ax = B`。
`pow`(exp[, method])	返回 self**exp，其中 exp 可以是标量或符号。
`print_nonzero`([symb])	显示非零条目的位置以快速查找形状。
`project`(v)	返回 `self` 在包含 `v` 的直线上的投影。
`rank`([iszerofunc, simplify])	返回矩阵的秩。
`rank_decomposition`([iszerofunc, simplify])	返回一对矩阵 ($C$, $F$)，它们具有匹配的秩，使得 $A = C F$。
`refine`([assumptions])	对矩阵的每个元素应用细化。
`replace`(F, G[, map, simultaneous, exact])	将矩阵条目中的函数 F 替换为函数 G。
`reshape`(rows, cols)	重塑矩阵。
`rmultiply`(other[, dotprodsimp])	与 __rmul__() 相同，但带有可选的简化功能。
`rot90`([k])	将矩阵旋转90度
`row`(i)	基本行选择器。
`row_add`(s, t, k)	将行 s（源）的 k 倍加到行 t（目标）上，原地操作。
`row_del`(row)	删除指定的行。
`row_insert`(pos, other)	在给定的行位置插入一行或多行。
`row_join`(other)	将两个矩阵沿着自身的最后一列和rhs的第一列进行连接
`row_mult`(i, factor)	将给定的行按给定的因子就地乘以。
`row_op`(i, f)	在行 `i` 上进行原地操作，使用双参数仿函数，其参数被解释为 `(self[i, j], j)`。
`row_swap`(i, j)	在原地交换矩阵的两行。
`rowspace`([simplify])	返回一个向量列表，这些向量跨越 `M` 的行空间。
`rref`([iszerofunc, simplify, pivots, ...])	返回矩阵的简化行阶梯形式和主元变量的索引。
`rref_rhs`(rhs)	返回矩阵的简化行阶梯形式，显示简化步骤后的右侧矩阵。
`simplify`(**kwargs)	对矩阵的元素就地应用简化。
`singular_value_decomposition`()	返回一个压缩的奇异值分解。
`singular_values`()	计算矩阵的奇异值
`solve`(rhs[, method])	求解存在唯一解的线性方程。
`solve_least_squares`(rhs[, method])	返回对数据的最小二乘拟合。
`strongly_connected_components`()	当一个方阵被视为加权图时，返回图中强连通顶点的列表。
`strongly_connected_components_decomposition`([lower])	仅使用排列将一个方阵分解为块三角形式。
`subs`(args, *kwargs)	返回一个新的矩阵，其中每个条目都应用了 subs。
`table`(printer[, rowstart, rowend, rowsep, ...])	以表格形式表示的矩阵字符串。
`to_DM`([domain])	转换为 `DomainMatrix`。
`todod`()	返回矩阵为包含非零元素的字典的字典
`todok`()	返回矩阵作为键的字典。
`tolist`()	返回矩阵作为嵌套的 Python 列表。
`trace`()	返回一个方阵的迹，即对角元素之和。
`transpose`()	返回矩阵的转置。
`upper_hessenberg_decomposition`()	将一个矩阵转换为Hessenberg矩阵H。
`upper_triangular`([k])	返回矩阵中第 k 条对角线及其以上的元素。
`upper_triangular_solve`(rhs)	求解 `Ax = B`，其中 A 是一个上三角矩阵。
`values`()	返回 self 的非零值。
`vec`()	通过堆叠列将矩阵转换为单列矩阵
`vech`([diagonal, check_symmetry])	通过堆叠下三角中的元素，将矩阵重塑为列向量。
`vee`()	从表示叉积的反对称矩阵返回一个3x1的向量，使得 `self * b` 等价于 `self.vee().cross(b)`。
`vstack`(*args)	返回一个矩阵，该矩阵是通过垂直连接参数（即通过重复应用 col_join）形成的。
`wilkinson`(n, **kwargs)	返回两个大小为 2*n + 1 的平方 Wilkinson 矩阵 $W_{2n + 1}^-, W_{2n + 1}^+ =$ Wilkinson(n)
`xreplace`(rule)	返回一个新的矩阵，其中每个条目都应用了 xreplace。
`zeros`(rows[, cols])	返回一个全零矩阵。
`zip_row_op`(i, k, f)	使用双参数仿函数对行 `i` 进行就地操作，其参数被解释为 `(self[i, j], self[k, j])`。

berkowitz
berkowitz_charpoly
cofactorMatrix
det_bareis
执行
jordan_cell
jordan_cells
minorEntry
minorMatrix

simplify(**kwargs)[源代码][源代码]¶

对矩阵的元素就地应用简化。

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

参见

sympy.simplify.simplify.simplify

class sympy.matrices.immutable.ImmutableDenseMatrix(*args, **kwargs)[源代码][源代码]

创建矩阵的不可变版本。

属性:

C: 逐元素共轭
D: 返回Dirac共轭（如果 self.rows == 4）。
H: 返回厄米共轭。
我
T: 矩阵转置
args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 $type$ 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
cols
expr_free_symbols: 类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。
free_symbols: 返回矩阵中的自由符号。
func: 表达式中的顶级函数。
is_Identity
is_antihermitian
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_echelon: 如果矩阵是阶梯形式，则返回 $True$。
is_finite
is_hermitian: 检查矩阵是否为厄米矩阵。
is_indefinite: 找出矩阵的确定性。
is_infinite
is_lower: 检查矩阵是否为下三角矩阵。
is_lower_hessenberg: 检查矩阵是否为下Hessenberg形式。
is_negative_definite: 找出矩阵的确定性。
is_negative_semidefinite: 找出矩阵的确定性。
is_polar
is_positive_definite: 找出矩阵的确定性。
is_positive_semidefinite: 找出矩阵的确定性。
is_square: 检查矩阵是否为方阵。
is_strongly_diagonally_dominant: 测试矩阵是否为行强对角占优。
is_upper: 检查矩阵是否为上三角矩阵。
is_upper_hessenberg: 检查矩阵是否为上Hessenberg形式。
is_weakly_diagonally_dominant: 测试矩阵是否为行弱对角占优。
is_zero_matrix: 检查一个矩阵是否为零矩阵。
种类
行
shape: 矩阵的形状（维度）作为 2 元组 (行数, 列数)。

方法

`LDLdecomposition`([hermitian])	返回矩阵 A 的 LDL 分解 (L, D)，使得如果 hermitian 标志为 True，则 L * D * L.H == A，或者如果 hermitian 为 False，则 L * D * L.T == A。
`LDLsolve`(rhs)	使用LDL分解求解 `Ax = B`，适用于一般的方阵和非奇异矩阵。
`LUdecomposition`([iszerofunc, simpfunc, ...])	返回 (L, U, perm)，其中 L 是一个对角线为单位矩阵的下三角矩阵，U 是一个上三角矩阵，perm 是一个行交换索引对的列表。
`LUdecompositionFF`()	计算一个无分数的LU分解。
`LUdecomposition_Simple`([iszerofunc, ...])	计算矩阵的 PLU 分解。
`LUsolve`(rhs[, iszerofunc])	求解线性系统 `Ax = rhs` 中的 `x`，其中 `A = M`。
`QRdecomposition`()	返回一个QR分解。
`QRsolve`(b)	求解线性系统 `Ax = b`。
`add`(b)	返回 self + b。
`adjoint`()	共轭转置或厄米共轭。
`adjugate`([method])	返回矩阵的伴随矩阵，或经典伴随矩阵。
`analytic_func`(f, x)
`apart`([x])	请参阅 sympy.polys 中的 apart 函数。
`applyfunc`(f)	对矩阵的每个元素应用一个函数。
`args_cnc`([cset, warn, split_1])	返回 [交换因子, 非交换因子] 的自身。
`as_coeff_Add`([rational])	高效地提取求和的系数。
`as_coeff_Mul`([rational])	高效地提取乘积的系数。
`as_coeff_add`(*deps)	返回元组 (c, args)，其中 self 被写成一个 Add，`a`。
`as_coeff_exponent`(x)	`cx*e -> c,e` 其中 x 可以是任何符号表达式。
`as_coeff_mul`(deps, *kwargs)	返回元组 (c, args)，其中 self 被写成一个 Mul，`m`。
`as_coefficient`(expr)	提取给定表达式中的符号系数。
`as_coefficients_dict`(*syms)	返回一个字典，将术语映射到它们的 Rational 系数。
`as_content_primitive`([radical, clear])	此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`as_explicit`()	返回一个元素明确表示的密集矩阵
`as_expr`(*gens)	将多项式转换为 SymPy 表达式。
`as_immutable`()	返回此矩阵的不可变版本
`as_independent`(deps, *hint)	将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
`as_leading_term`(*symbols[, logx, cdir])	返回自身级数展开的主导（非零）项。
`as_mutable`()	返回此矩阵的可变版本
`as_numer_denom`()	返回一个表达式的分子和分母。
`as_ordered_factors`([order])	返回有序因子列表（如果是 Mul），否则返回 [self]。
`as_ordered_terms`([order, data])	将表达式转换为有序的项列表。
`as_poly`(gens, *args)	将 `self` 转换为多项式，或返回 `None`。
`as_powers_dict`()	将自身作为一个因子的字典返回，每个因子都被视为一个幂。
`as_real_imag`([deep])	返回一个包含矩阵的（实部，虚部）部分的元组。
`as_terms`()	将一个表达式转换为项的列表。
`aseries`([x, n, bound, hir])	自变量的渐近级数展开
`atoms`(*types)	返回构成当前对象的原子。
`berkowitz_det`()	使用Berkowitz方法计算行列式。
`berkowitz_eigenvals`(**flags)	使用Berkowitz方法计算矩阵的特征值。
`berkowitz_minors`()	使用Berkowitz方法计算主子式。
`bidiagonal_decomposition`([upper])	返回 $(U,B,V.H)$ 用于
`bidiagonalize`([upper])	返回 $B$，即输入矩阵的双对角化形式。
`cancel`(gens, *args)	参见 sympy.polys 中的取消函数
`charpoly`([x, simplify])	计算特征多项式 det(x*I - M)，其中 I 是单位矩阵。
`cholesky`([hermitian])	返回矩阵 A 的 Cholesky 类型分解 L，使得如果 hermitian 标志为 True，则 L * L.H == A，或者如果 hermitian 为 False，则 L * L.T == A。
`cholesky_solve`(rhs)	使用 Cholesky 分解求解 `Ax = B`，适用于一般的非奇异方阵。
`class_key`()	类的好顺序。
`coeff`(x[, n, right, _first])	返回包含 `x**n` 的项中的系数。
`cofactor`(i, j[, method])	计算元素的余子式。
`cofactor_matrix`([method])	返回一个包含每个元素的余子式的矩阵。
`col`(j)	基本列选择器。
`col_del`(col)	删除指定的列。
`col_insert`(pos, other)	在给定的列位置插入一列或多列。
`col_join`(other)	将两个矩阵沿着自身的最后一行和另一个矩阵的第一行进行连接。
`collect`(syms[, func, evaluate, exact, ...])	请参阅 sympy.simplify 中的 collect 函数。
`columnspace`([simplify])	返回一个向量列表（矩阵对象），这些向量跨越 `M` 的列空间
`combsimp`()	请参阅 sympy.simplify 中的 combsimp 函数。
`companion`(poly)	返回多项式的伴随矩阵。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`compute_leading_term`(x[, logx])	已弃用的函数，用于计算级数的首项。
`condition_number`()	返回矩阵的条件数。
`conjugate`()	返回按元素的共轭。
`connected_components`()	当一个方阵被视为加权图时，返回图中连接顶点的列表。
`connected_components_decomposition`()	仅使用排列将一个方阵分解为块对角形式。
`copy`()
`could_extract_minus_sign`()	如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])
`cramer_solve`(rhs[, det_method])	使用克莱姆法则求解线性方程组。
`cross`(b)	返回 `self` 和 `b` 的叉积，放松兼容维度的条件：如果每个都有3个元素，将返回与 `self` 相同类型和形状的矩阵。
`det`([method, iszerofunc])	如果 `M` 是一个具体的矩阵对象，则计算其行列式；否则，如果 `M` 是一个 `MatrixSymbol` 或其他表达式，则返回表达式 `Determinant(M)`。
`det_LU_decomposition`()	使用LU分解计算矩阵行列式。
`diag`(*args[, strict, unpack, rows, cols])	返回具有指定对角线的矩阵。
`diagonal`([k])	返回自身的第 k 个对角线。
`diagonal_solve`(rhs)	高效求解 `Ax = B`，其中 A 是一个对角矩阵，且对角元素非零。
`diagonalize`([reals_only, sort, normalize])	返回 (P, D)，其中 D 是对角矩阵。
`diff`(*args[, evaluate])	计算矩阵中每个元素的导数。
`dot`(b[, hermitian, conjugate_convention])	返回两个长度相等的向量的点积或内积。
`dual`()	返回矩阵的对偶。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`echelon_form`([iszerofunc, simplify, with_pivots])	返回一个与 `M` 行等价的矩阵，该矩阵为阶梯形式。
`eigenvals`([error_when_incomplete])	计算矩阵的特征值。
`eigenvects`([error_when_incomplete, iszerofunc])	计算矩阵的特征向量。
`elementary_col_op`([op, col, k, col1, col2])	执行基本列操作 $op$。
`elementary_row_op`([op, row, k, row1, row2])	执行基本行操作 $op$。
`equals`(other[, failing_expression])	对矩阵的对应元素应用 `equals` ，试图证明这些元素是等价的，如果它们是等价的则返回 True ，如果有任何一对不等价则返回 False ，如果无法确定表达式是否等价，则返回 None （或者如果 failing_expression 为 True ，则返回第一个失败的表达式）。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	对 self 的每个元素应用 evalf()。
`exp`()	返回一个方阵的指数。
`expand`([deep, modulus, power_base, ...])	对矩阵的每个条目应用 core.function.expand。
`extract`(rowsList, colsList)	通过指定行和列的列表返回一个子矩阵。
`extract_additively`(c)	如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
`extract_branch_factor`([allow_half])	尝试以 `exp_polar(2piIn)z` 的方式优雅地表达自身。
`extract_multiplicatively`(c)	如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
`eye`(rows[, cols])	返回一个单位矩阵。
`factor`(gens, *args)	参见 sympy.polys.polytools 中的 factor() 函数
`find`(query[, group])	查找所有匹配查询的子表达式。
`flat`()
`fourier_series`([limits])	计算自身的傅里叶正弦/余弦级数。
`fps`([x, x0, dir, hyper, order, rational, full])	计算自身的形式幂级数。
`from_dok`(rows, cols, dok)	从键的字典创建一个矩阵。
`from_index_summation`(expr[, first_index, ...])	如果可能，将显式求和指标的矩阵表达式解析为无指标的矩阵表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`gammasimp`()	参见 sympy.simplify 中的 gammasimp 函数
`gauss_jordan_solve`(B[, freevar])	使用高斯-约旦消元法求解 `Ax = B`。
`getO`()	如果有加法 O(..) 符号，则返回该符号，否则返回 None。
`get_diag_blocks`()	获取方阵主对角线上的子方阵。
`getn`()	返回表达式的顺序。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`hat`()	返回表示叉积的反对称矩阵，使得 `self.hat() * b` 等价于 `self.cross(b)`。
`hstack`(*args)	返回一个矩阵，该矩阵通过水平连接参数（即通过重复应用 row_join）形成。
`integrate`(args, *kwargs)	积分矩阵的每个元素。
`inv`([method, iszerofunc, try_block_diag])	使用指定方法返回矩阵的逆。
`inv_mod`(m)	返回整数矩阵 `M` 模 `m` 的逆。
`inverse_ADJ`([iszerofunc])	使用伴随矩阵和行列式计算逆矩阵。
`inverse_BLOCK`([iszerofunc])	使用块状逆运算计算逆矩阵。
`inverse_CH`([iszerofunc])	使用 Cholesky 分解计算逆矩阵。
`inverse_GE`([iszerofunc])	使用高斯消去法计算逆矩阵。
`inverse_LDL`([iszerofunc])	使用 LDL 分解计算逆矩阵。
`inverse_LU`([iszerofunc])	使用LU分解计算逆矩阵。
`inverse_QR`([iszerofunc])	使用QR分解计算逆矩阵。
`invert`(g, gens, *args)	返回 `self` 对 `g` 的乘法逆元，其中 self``（和 ``g）可以是符号表达式。
`irregular`(ntop, matrices, *kwargs)	返回一个矩阵，该矩阵由给定的矩阵填充，这些矩阵按从左到右、从上到下的顺序依次出现，与它们在矩阵中首次出现的位置一致。
`is_algebraic_expr`(*syms)	此测试给定的表达式是否在给定的符号 syms 中是代数的。
`is_anti_symmetric`([simplify])	检查矩阵 M 是否为反对称矩阵，即，M 是一个方阵，且所有 M[i, j] == -M[j, i]。
`is_constant`(wrt, *flags)	如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
`is_diagonal`()	检查矩阵是否为对角矩阵，即主对角线以外的所有元素均为零的矩阵。
`is_diagonalizable`([reals_only])	如果矩阵可对角化，则返回 `True`。
`is_meromorphic`(x, a)	此测试表达式是否作为给定符号 `x` 的函数在点 `a` 处是亚纯的。
`is_nilpotent`()	检查矩阵是否为幂零矩阵。
`is_polynomial`(*syms)	如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
`is_rational_function`(*syms)	测试函数是否是给定符号 syms 中的两个多项式的比率。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_symbolic`()	检查是否有元素包含符号。
`is_symmetric`([simplify])	检查矩阵是否为对称矩阵，即方阵且等于其转置矩阵。
`iter_items`()	遍历非零项的索引和值。
`iter_values`()	遍历 self 的非零值
`jacobian`(X)	计算雅可比矩阵（向量值函数的导数）。
`jordan_block`([size, eigenvalue, band])	返回一个 Jordan 块
`jordan_form`([calc_transform])	返回 $(P, J)$，其中 $J$ 是一个约旦块矩阵，$P$ 是一个矩阵，使得 $M = P J P^{-1}$
`key2bounds`(keys)	将一个可能包含混合类型键（整数和切片）的键转换为范围元组，如果任何索引超出 `self` 的范围，则引发错误。
`key2ij`(key)	将键转换为规范形式，将整数或可索引项转换为 `self` 范围内的有效整数，或者返回切片不变。
`leadterm`(x[, logx, cdir])	返回前导项 ax*b 作为元组 (a, b)。
`left_eigenvects`(**flags)	返回左特征向量和特征值。
`limit`(*args)	计算矩阵中每个元素的极限。
`lll`([delta])	LLL-约化基用于整数矩阵行空间的基。
`lll_transform`([delta])	LLL-约化基和变换矩阵。
`log`([simplify])	返回一个方阵的对数。
`lower_triangular`([k])	返回矩阵中第k条对角线及其以下的元素。
`lower_triangular_solve`(rhs)	求解 `Ax = B`，其中 A 是一个下三角矩阵。
`lseries`([x, x0, dir, logx, cdir])	用于生成序列项的迭代器的包装器。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`minor`(i, j[, method])	返回 `M` 的 (i,j) 子式。
`minor_submatrix`(i, j)	返回通过从 `M` 中移除第 $i$ 行和第 $j$ 列得到的子矩阵（适用于Python风格的负索引）。
`multiply`(other[, dotprodsimp])	与 __mul__() 相同，但带有可选的简化。
`multiply_elementwise`(other)	返回 A 和 B 的哈达玛积（逐元素乘积）
`n`(args, *kwargs)	对 self 的每个元素应用 evalf()。
`norm`([ord])	返回矩阵或向量的范数。
`normal`()	返回表达式为分数形式。
`normalized`([iszerofunc])	返回 `self` 的规范化版本。
`nseries`([x, x0, n, dir, logx, cdir])	如果假设允许，则包装到 _eval_nseries，否则包装到 series。
`nsimplify`([constants, tolerance, full])	参见 sympy.simplify 中的 nsimplify 函数
`nullspace`([simplify, iszerofunc])	返回一个向量列表（矩阵对象），这些向量跨越 `M` 的零空间
`ones`(rows[, cols])	返回一个全为1的矩阵。
`orthogonalize`(vecs, *kwargs)	对 `vecs` 中的向量应用格拉姆-施密特正交化过程。
`per`()	返回矩阵的永久值。
`permute`(perm[, orientation, direction])	通过给定的交换列表置换矩阵的行或列。
`permuteBkwd`(perm)	使用给定的排列逆序置换矩阵的行。
`permuteFwd`(perm)	使用给定的排列来置换矩阵的行。
`permute_cols`(swaps[, direction])	`self.permute(swaps, orientation='cols', direction=direction)` 的别名
`permute_rows`(swaps[, direction])	`self.permute(swaps, orientation='rows', direction=direction)` 的别名
`pinv`([method])	计算矩阵的 Moore-Penrose 伪逆。
`pinv_solve`(B[, arbitrary_matrix])	使用 Moore-Penrose 伪逆求解 `Ax = B`。
`pow`(exp[, method])	返回 self**exp，其中 exp 可以是标量或符号。
`powsimp`(args, *kwargs)	请参阅 sympy.simplify 中的 powsimp 函数
`primitive`()	返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
`print_nonzero`([symb])	显示非零条目的位置以快速查找形状。
`project`(v)	返回 `self` 在包含 `v` 的直线上的投影。
`radsimp`(**kwargs)	参见 sympy.simplify 中的 radsimp 函数
`rank`([iszerofunc, simplify])	返回矩阵的秩。
`rank_decomposition`([iszerofunc, simplify])	返回一对矩阵 ($C$, $F$)，它们具有匹配的秩，使得 $A = C F$。
`ratsimp`()	参见 sympy.simplify 中的 ratsimp 函数。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumptions])	对矩阵的每个元素应用细化。
`removeO`()	如果存在，移除加性的 O(..) 符号
`replace`(F, G[, map, simultaneous, exact])	将矩阵条目中的函数 F 替换为函数 G。
`reshape`(rows, cols)	重塑矩阵。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`rmultiply`(other[, dotprodsimp])	与 __rmul__() 相同，但带有可选的简化功能。
`rot90`([k])	将矩阵旋转90度
`round`([n])	返回 x 四舍五入到给定的十进制位数。
`row`(i)	基本行选择器。
`row_del`(row)	删除指定的行。
`row_insert`(pos, other)	在给定的行位置插入一行或多行。
`row_join`(other)	将两个矩阵沿着自身的最后一列和rhs的第一列进行连接
`rowspace`([simplify])	返回一个向量列表，这些向量跨越 `M` 的行空间。
`rref`([iszerofunc, simplify, pivots, ...])	返回矩阵的简化行阶梯形式和主元变量的索引。
`rref_rhs`(rhs)	返回矩阵的简化行阶梯形式，显示简化步骤后的右侧矩阵。
`separate`([deep, force])	参见 sympy.simplify 中的单独函数
`series`([x, x0, n, dir, logx, cdir])	在 `x = x0` 附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。
`simplify`(**kwargs)	对矩阵的每个元素应用简化。
`singular_value_decomposition`()	返回一个压缩的奇异值分解。
`singular_values`()	计算矩阵的奇异值
`solve`(rhs[, method])	求解存在唯一解的线性方程。
`solve_least_squares`(rhs[, method])	返回对数据的最小二乘拟合。
`sort_key`([order])
`strongly_connected_components`()	当一个方阵被视为加权图时，返回图中强连通顶点的列表。
`strongly_connected_components_decomposition`([lower])	仅使用排列将一个方阵分解为块三角形式。
`subs`(args, *kwargs)	返回一个新的矩阵，其中每个条目都应用了 subs。
`table`(printer[, rowstart, rowend, rowsep, ...])	以表格形式表示的矩阵字符串。
`taylor_term`(n, x, *previous_terms)	泰勒项的一般方法。
`to_DM`([domain])	转换为 `DomainMatrix`。
`todod`()	返回矩阵为包含非零元素的字典的字典
`todok`()	返回矩阵作为键的字典。
`together`(args, *kwargs)	请参阅 sympy.polys 中的 together 函数。
`tolist`()	返回矩阵作为嵌套的 Python 列表。
`trace`()	返回一个方阵的迹，即对角元素之和。
`transpose`()	返回矩阵的转置。
`trigsimp`(**args)	参见 sympy.simplify 中的 trigsimp 函数
`upper_hessenberg_decomposition`()	将一个矩阵转换为Hessenberg矩阵H。
`upper_triangular`([k])	返回矩阵中第 k 条对角线及其以上的元素。
`upper_triangular_solve`(rhs)	求解 `Ax = B`，其中 A 是一个上三角矩阵。
`values`()	返回 self 的非零值。
`vec`()	通过堆叠列将矩阵转换为单列矩阵
`vech`([diagonal, check_symmetry])	通过堆叠下三角中的元素，将矩阵重塑为列向量。
`vee`()	从表示叉积的反对称矩阵返回一个3x1的向量，使得 `self * b` 等价于 `self.vee().cross(b)`。
`vstack`(*args)	返回一个矩阵，该矩阵是通过垂直连接参数（即通过重复应用 col_join）形成的。
`wilkinson`(n, **kwargs)	返回两个大小为 2*n + 1 的平方 Wilkinson 矩阵 $W_{2n + 1}^-, W_{2n + 1}^+ =$ Wilkinson(n)
`xreplace`(rule)	返回一个新的矩阵，其中每个条目都应用了 xreplace。
`zeros`(rows[, cols])	返回一个全零矩阵。

as_base_exp
as_coeff_mmul
berkowitz
berkowitz_charpoly
规范化
cofactorMatrix
det_bareis
目录
执行
反向
is_hypergeometric
jordan_cell
jordan_cells
minorEntry
minorMatrix
有效索引

示例

>>> 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