介绍 poly 模块的 domainmatrix¶

本页介绍了 domainmatrix 的概念，该概念用于 SymPy 的 sympy.polys 模块中。这是一个相对高级的主题，因此建议阅读有关 Domain 和 DDM 以及 sympy.matrices 模块的内容以更好地理解。

什么是 domainmatrix？¶

这是一种将 Matrix 与 Domain 关联的方式。

domainmatrix 表示一个元素属于特定域的矩阵。每个 domainmatrix 内部封装了一个 DDM，用于低级操作。其思想是 domainmatrix 类提供了在 Expr 和多项式域之间转换的便利程序，以及统一具有不同域的矩阵。

通常，我们表示一个矩阵而不考虑 Domain 为：

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

用于 DomainMatrix 类的模块。

DomainMatrix 表示一个矩阵，其元素属于特定的域。每个 DomainMatrix 内部封装了一个 DDM，用于低级操作。其思想是 DomainMatrix 类提供了在 Expr 和多项式域之间转换以及统一不同域矩阵的便利程序。

sympy.polys.matrices.domainmatrix.DM(rows, domain)[源代码][源代码]¶

DomainMatrix.from_list 的便捷别名

参见

DomainMatrix.from_list

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DM
>>> DM([[1, 2], [3, 4]], ZZ)
DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)

class sympy.polys.matrices.domainmatrix.DomainMatrix(rows, shape, domain, *, fmt=None)[源代码][源代码]¶

将矩阵与 Domain 关联

属性:

is_diagonal: 如果矩阵是对角矩阵，则为真。
is_lower: 指示此矩阵是否为下三角矩阵。
is_square: 如果矩阵是方阵，则为真。
is_upper: 指示此矩阵是否为上三角矩阵。
is_zero_matrix

方法

`add`(B)	添加两个相同域的 DomainMatrix 矩阵
`adj_det`()	方阵 `DomainMatrix` 的伴随矩阵和行列式。
`adj_poly_det`([cp])	返回多项式 $p$ 使得 $p(A) = adj(A)$ 并且也返回 $A$ 的行列式。
`adjugate`()	方阵 `DomainMatrix` 的伴随矩阵。
`cancel_denom`(denom)	取消矩阵和分母之间的因子。
`cancel_denom_elementwise`(denom)	取消矩阵元素与分母之间的因子。
`charpoly`()	方阵的特征多项式。
`charpoly_base`()	块分解后 `charpoly_factor_blocks()` 的基本情况。
`charpoly_berk`()	使用 Berkowitz 算法计算特征多项式。
`charpoly_factor_blocks`()	特征多项式的部分因式分解。
`charpoly_factor_list`()	特征多项式的完全因式分解。
`choose_domain`(**opts)	转换为由 `construct_domain()` 找到的域。
`clear_denoms`([convert])	清除分母，但保持域不变。
`clear_denoms_rowwise`([convert])	清除矩阵每一行的分母。
`columnspace`()	返回 DomainMatrix 的列空间
`content`()	返回矩阵元素的最大公约数。
`convert_to`(K)	将 DomainMatrix 的域更改为所需的域或字段
`det`()	返回一个方阵 `DomainMatrix` 的行列式。
`diag`(diagonal, domain[, shape])	返回一个对角矩阵，其对角线元素来自 `diagonal`。
`diagonal`()	获取矩阵的对角线元素作为列表。
`eval_poly`(p)	计算矩阵 $p(A)$ 的多项式函数。
`eval_poly_mul`(p, B)	计算多项式矩阵乘积 $p(A) imes B$。
`eye`(shape, domain)	返回大小为 n 或形状为 (m, n) 的单位矩阵。
`from_Matrix`(M[, fmt])	将矩阵转换为 DomainMatrix
`from_dict_sympy`(nrows, ncols, elemsdict, ...)
`from_dod`(dod, shape, domain)	从字典的字典（dod）格式创建稀疏的 `DomainMatrix`。
`from_dod_like`(dod[, domain])	从字典的字典（dod）格式创建 `DomainMatrix`，类似于 `self`。
`from_dok`(dok, shape, domain)	从键值字典（dok）格式创建 `DomainMatrix`。
`from_flat_nz`(elements, data, domain)	调用 `to_flat_nz()` 后重建 `DomainMatrix`。
`from_list`(rows, domain)	将一个列表的列表转换为 DomainMatrix
`from_list_flat`(elements, shape, domain)	从扁平列表创建 `DomainMatrix`。
`from_list_sympy`(nrows, ncols, rows, **kwargs)	将 Expr 的列表列表转换为使用 construct_domain 的 DomainMatrix
`from_rep`(rep)	从 DDM/SDM 高效创建一个新的 DomainMatrix。
`hstack`(*B)	水平堆叠给定的矩阵。
`inv`()	如果存在，找到 DomainMatrix 的逆矩阵
`inv_den`([method])	返回一个带有分母的 `DomainMatrix` 作为逆矩阵。
`iter_items`()	遍历矩阵中非零元素的索引和值。
`iter_values`()	遍历矩阵中的非零元素。
`lll`([delta])	执行 Lenstra–Lenstra–Lovász (LLL) 基底约简算法。
`lll_transform`([delta])	执行 Lenstra–Lenstra–Lovász (LLL) 基底约简算法，并返回约简后的基底和变换矩阵。
`lu`()	返回 DomainMatrix 的上下分解
`lu_solve`(rhs)	用于求解域矩阵 x 的求解器，在 A*x = B 中
`matmul`(B)	对两个 DomainMatrix 矩阵执行矩阵乘法
`mul`(b)	对第二个 DomainMatrix 相对于第一个 DomainMatrix 执行逐项乘法。
`neg`()	返回 DomainMatrix 的负值
`nnz`()	矩阵中非零元素的数量。
`nullspace`([divide_last])	返回 DomainMatrix 的零空间
`nullspace_from_rref`([pivots])	从简化行阶梯形矩阵和主元计算零空间。
`ones`(shape, domain)	返回一个指定域中大小为 shape 的全 1 的 DomainMatrix
`pow`(n)	计算 A**n
`primitive`()	提取矩阵元素的最大公约数。
`rowspace`()	返回 DomainMatrix 的行空间
`rref`(*[, method])	返回简化行阶梯形式（RREF）和主元列表。
`rref_den`(*[, method, keep_domain])	返回简化行阶梯形式，带有分母和主元列表。
`scc`()	计算 DomainMatrix 的强连通分量
`solve_den`(b[, method])	在基础域中不使用分数求解矩阵方程 $Ax = b$。
`solve_den_charpoly`(b[, cp, check])	使用特征多项式求解矩阵方程 $Ax = b$。
`solve_den_rref`(b)	使用无分数的简化行阶梯形式（RREF）求解矩阵方程 $Ax = b$
`sub`(B)	减去两个相同域的 DomainMatrix 矩阵
`to_Matrix`()	将 DomainMatrix 转换为 Matrix
`to_ddm`()	返回 self 的 `DDM` 表示。
`to_dense`()	返回 self 的密集 DomainMatrix 表示。
`to_dfm`()	返回 self 的 `DFM` 表示。
`to_dfm_or_ddm`()	返回 self 的 `DFM` 或 `DDM` 表示。
`to_dod`()	将 `DomainMatrix` 转换为字典的字典（dod）格式。
`to_dok`()	将 `DomainMatrix` 转换为键值字典 (dok) 格式。
`to_field`()	返回一个具有适当域的 DomainMatrix
`to_flat_nz`()	将 `DomainMatrix` 转换为非零元素和数据的列表。
`to_list`()	将 `DomainMatrix` 转换为列表的列表。
`to_list_flat`()	将 `DomainMatrix` 转换为扁平列表。
`to_sdm`()	返回 self 的 `SDM` 表示。
`to_sparse`()	返回 self 的稀疏 DomainMatrix 表示。
`transpose`()	`self` 的矩阵转置
`unify`(*others[, fmt])	统一自身和其他矩阵的域和格式。
`vstack`(*B)	垂直堆叠给定的矩阵。
`zeros`(shape, domain, *[, fmt])	返回一个大小为 shape 的零 DomainMatrix，属于指定的域

applyfunc
复制
提取
扁平
get_domain
getitem_sympy
mul_elementwise
等级
rmul
rscalarmul
scalarmul
to_sympy
unify_eq

参见

DDM
SDM
Domain
Poly

示例

从现有的 Matrix 类创建一个 DomainMatrix：

>>> from sympy import Matrix
>>> from sympy.polys.matrices import DomainMatrix
>>> Matrix1 = Matrix([
...    [1, 2],
...    [3, 4]])
>>> A = DomainMatrix.from_Matrix(Matrix1)
>>> A
DomainMatrix({0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}}, (2, 2), ZZ)

直接形成一个 DomainMatrix：

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [ZZ(1), ZZ(2)],
...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> A
DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)

add(B)[源代码][源代码]¶

添加两个相同域的 DomainMatrix 矩阵

参数:

A, B: DomainMatrix: 矩阵相加

返回:

DomainMatrix: 加法后的DomainMatrix

Raises:

DMShapeError: 如果两个 DomainMatrix 的维度不相等
ValueError: 如果两个 DomainMatrix 的域不同

参见

sub, matmul

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [ZZ(1), ZZ(2)],
...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> B = DomainMatrix([
...    [ZZ(4), ZZ(3)],
...    [ZZ(2), ZZ(1)]], (2, 2), ZZ)

>>> A.add(B)
DomainMatrix([[5, 5], [5, 5]], (2, 2), ZZ)

adj_det()[源代码][源代码]¶

方阵 DomainMatrix 的伴随矩阵和行列式。

返回:

(伴随矩阵, 行列式)(域矩阵, 域标量): 这个矩阵的伴随矩阵和行列式。

参见

adjugate: 仅返回伴随矩阵。
det: 仅返回行列式。
inv_den: 返回一个矩阵/分母对，表示逆矩阵，但可能与伴随矩阵和行列式相差一个公因子。

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DM
>>> A = DM([
...     [ZZ(1), ZZ(2)],
...     [ZZ(3), ZZ(4)]], ZZ)
>>> adjA, detA = A.adj_det()
>>> adjA
DomainMatrix([[4, -2], [-3, 1]], (2, 2), ZZ)
>>> detA
-2

adj_poly_det(cp=None)[源代码][源代码]¶

返回多项式 $p$ 使得 $p(A) = adj(A)$ 并且也返回 $A$ 的行列式。

参见

adjugate
eval_poly
adj_det

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices import DM
>>> A = DM([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], QQ)
>>> p, detA = A.adj_poly_det()
>>> p
[-1, 5]
>>> p_A = A.eval_poly(p)
>>> p_A
DomainMatrix([[4, -2], [-3, 1]], (2, 2), QQ)
>>> p[0]*A**1 + p[1]*A**0 == p_A
True
>>> p_A == A.adjugate()
True
>>> A * A.adjugate() == detA * A.eye(A.shape, A.domain).to_dense()
True

adjugate()[源代码][源代码]¶

方阵 DomainMatrix 的伴随矩阵。

伴随矩阵是余子矩阵的转置，并且与逆矩阵相关，关系如下:

adj(A) = det(A) * A.inv()

与逆矩阵不同，伴随矩阵可以在不使用基本域中的除法或分数的情况下进行计算和表示。

返回:

DomainMatrix: 此矩阵的伴随矩阵，具有相同的域。

参见

adj_det

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DM
>>> A = DM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], ZZ)
>>> A.adjugate()
DomainMatrix([[4, -2], [-3, 1]], (2, 2), ZZ)

cancel_denom(denom)[源代码][源代码]¶

取消矩阵和分母之间的因子。

返回一个矩阵和最简形式的分子。

需要在基础域中使用 gcd。

像 solve_den()、inv_den() 和 rref_den() 这样的方法返回一个矩阵和分母，但不一定是最简形式。可以通过 cancel_denom() 进行无分数的最简形式化简。

参见

solve_den
inv_den
rref_den
cancel_denom_elementwise

示例

>>> from sympy.polys.matrices import DM
>>> from sympy import ZZ
>>> M = DM([[2, 2, 0],
...         [0, 2, 2],
...         [0, 0, 2]], ZZ)
>>> Minv, den = M.inv_den()
>>> Minv.to_Matrix()
Matrix([
[1, -1,  1],
[0,  1, -1],
[0,  0,  1]])
>>> den
2
>>> Minv_reduced, den_reduced = Minv.cancel_denom(den)
>>> Minv_reduced.to_Matrix()
Matrix([
[1, -1,  1],
[0,  1, -1],
[0,  0,  1]])
>>> den_reduced
2
>>> Minv_reduced.to_field() / den_reduced == Minv.to_field() / den
True

分母相对于单位被规范化了（例如，负分母被转换为正数）：

>>> M = DM([[2, 2, 0]], ZZ)
>>> den = ZZ(-4)
>>> M.cancel_denom(den)
(DomainMatrix([[-1, -1, 0]], (1, 3), ZZ), 2)

任何对 _所有_ 元素都通用的因子将被消去，但矩阵的 _某些_ 元素与分母之间仍可能存在共同的因子。要消去每个元素与分母之间的因子，请使用 cancel_denom_elementwise() 或将其转换为域并使用除法：

>>> M = DM([[4, 6]], ZZ)
>>> den = ZZ(12)
>>> M.cancel_denom(den)
(DomainMatrix([[2, 3]], (1, 2), ZZ), 6)
>>> numers, denoms = M.cancel_denom_elementwise(den)
>>> numers
DomainMatrix([[1, 1]], (1, 2), ZZ)
>>> denoms
DomainMatrix([[3, 2]], (1, 2), ZZ)
>>> M.to_field() / den
DomainMatrix([[1/3, 1/2]], (1, 2), QQ)

cancel_denom_elementwise(denom)[源代码][源代码]¶

取消矩阵元素与分母之间的因子。

返回一个分子矩阵和分母矩阵。

需要在基础域中使用 gcd。

参见

cancel_denom

示例

>>> from sympy.polys.matrices import DM
>>> from sympy import ZZ
>>> M = DM([[2, 3], [4, 12]], ZZ)
>>> denom = ZZ(6)
>>> numers, denoms = M.cancel_denom_elementwise(denom)
>>> numers.to_Matrix()
Matrix([
[1, 1],
[2, 2]])
>>> denoms.to_Matrix()
Matrix([
[3, 2],
[3, 1]])
>>> M_frac = (M.to_field() / denom).to_Matrix()
>>> M_frac
Matrix([
[1/3, 1/2],
[2/3,   2]])
>>> denoms_inverted = denoms.to_Matrix().applyfunc(lambda e: 1/e)
>>> numers.to_Matrix().multiply_elementwise(denoms_inverted) == M_frac
True

使用 cancel_denom() 在保持矩阵形式的同时，消除矩阵和分母之间的因子。

charpoly()[源代码][源代码]¶

方阵的特征多项式。

使用无除法算术以完全展开的形式计算特征多项式。如果需要特征多项式的因式分解，那么调用 charpoly_factor_list() 比先调用 charpoly() 然后对结果进行因式分解更有效。

返回:

列表: DomainElement 的列表: 特征多项式的系数

参见

charpoly_factor_list: 计算特征多项式的因式分解。
charpoly_factor_blocks: 特征多项式的一个部分因式分解，其计算效率高于完全因式分解或完全展开的多项式。

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [ZZ(1), ZZ(2)],
...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)

>>> A.charpoly()
[1, -5, -2]

charpoly_base()[源代码][源代码]¶

块分解后 charpoly_factor_blocks() 的基本情况。

此方法由 charpoly_factor_blocks() 在计算块的特征多项式的基本情况下内部使用。调用 charpoly_factor_blocks()、charpoly() 或 charpoly_factor_list() 比直接调用此方法更有效。

这将根据矩阵的稀疏性使用密集或稀疏实现，并在可能的情况下清除分母，然后调用 charpoly_berk() 使用 Berkowitz 算法计算特征多项式。

参见

charpoly
charpoly_factor_list
charpoly_factor_blocks
charpoly_berk

charpoly_berk()[源代码][源代码]¶

使用 Berkowitz 算法计算特征多项式。

此方法直接调用 Berkowitz 算法的底层实现（sympy.polys.matrices.dense.ddm_berk() 或 sympy.polys.matrices.sdm.sdm_berk()）。

这被 charpoly() 和其他方法用作计算特征多项式的基本情况。然而，这些方法在调用此方法之前会应用其他优化，例如块分解、清除分母以及在密集和稀疏表示之间转换。调用这些方法比调用此方法更有效，但此方法提供了直接访问Berkowitz算法的途径。

参见

charpoly
charpoly_base
charpoly_factor_list
charpoly_factor_blocks
sympy.polys.matrices.dense.ddm_berk
sympy.polys.matrices.sdm.sdm_berk

示例

>>> from sympy.polys.matrices import DM
>>> from sympy import QQ
>>> M = DM([[6, -1, 0, 0],
...         [9, 12, 0, 0],
...         [0,  0, 1, 2],
...         [0,  0, 5, 6]], QQ)
>>> M.charpoly_berk()
[1, -25, 203, -495, -324]

charpoly_factor_blocks()[源代码][源代码]¶

特征多项式的部分因式分解。

这种因式分解源于矩阵（如果有的话）的块结构，因此因子不能保证是不可约的。charpoly_factor_blocks() 方法是获取特征多项式表示的最有效方式，但结果既没有完全展开也没有完全分解。

返回:

list: 成对列表 (因子, 重数): 特征多项式的一个部分因式分解。

参见

charpoly: 计算完全展开的特征多项式。
charpoly_factor_list: 计算特征多项式的完全分解。

示例

>>> from sympy.polys.matrices import DM
>>> from sympy import ZZ
>>> M = DM([[6, -1, 0, 0],
...         [9, 12, 0, 0],
...         [0,  0, 1, 2],
...         [0,  0, 5, 6]], ZZ)

这仅使用矩阵的块结构来计算部分因式分解，以揭示因子：

>>> M.charpoly_factor_blocks()
[([1, -18, 81], 1), ([1, -7, -4], 1)]

这些因素对应于矩阵中的两个对角块：

>>> DM([[6, -1], [9, 12]], ZZ).charpoly()
[1, -18, 81]
>>> DM([[1, 2], [5, 6]], ZZ).charpoly()
[1, -7, -4]

使用 charpoly_factor_list() 获取完全分解为不可约因子的结果：

>>> M.charpoly_factor_list()
[([1, -9], 2), ([1, -7, -4], 1)]

使用 charpoly() 来获取展开的特征多项式：

>>> M.charpoly()
[1, -25, 203, -495, -324]

charpoly_factor_list()[源代码][源代码]¶

特征多项式的完全因式分解。

返回:

list: 成对列表 (因子, 重数): 特征多项式的完全分解。

参见

charpoly: 特征多项式的展开形式。
charpoly_factor_blocks: 特征多项式的部分因式分解，可以更高效地计算。

示例

>>> from sympy.polys.matrices import DM
>>> from sympy import ZZ
>>> M = DM([[6, -1, 0, 0],
...         [9, 12, 0, 0],
...         [0,  0, 1, 2],
...         [0,  0, 5, 6]], ZZ)

计算特征多项式的因式分解：

>>> M.charpoly_factor_list()
[([1, -9], 2), ([1, -7, -4], 1)]

使用 charpoly() 获取未分解的特征多项式：

>>> M.charpoly()
[1, -25, 203, -495, -324]

使用 Matrix 进行相同的计算：

>>> M.to_Matrix().charpoly().as_expr()
lambda**4 - 25*lambda**3 + 203*lambda**2 - 495*lambda - 324
>>> M.to_Matrix().charpoly().as_expr().factor()
(lambda - 9)**2*(lambda**2 - 7*lambda - 4)

choose_domain(**opts)[源代码][源代码]¶

转换为由 construct_domain() 找到的域。

参见

construct_domain
convert_to

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DM
>>> M = DM([[1, 2], [3, 4]], ZZ)
>>> M
DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)
>>> M.choose_domain(field=True)
DomainMatrix([[1, 2], [3, 4]], (2, 2), QQ)

>>> from sympy.abc import x
>>> M = DM([[1, x], [x**2, x**3]], ZZ[x])
>>> M.choose_domain(field=True).domain
ZZ(x)

关键字参数被传递给 construct_domain()。

clear_denoms(convert=False)[源代码][源代码]¶

清除分母，但保持域不变。

参见

sympy.polys.polytools.Poly.clear_denoms
clear_denoms_rowwise

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices import DM
>>> A = DM([[(1,2), (1,3)], [(1,4), (1,5)]], QQ)
>>> den, Anum = A.clear_denoms()
>>> den.to_sympy()
60
>>> Anum.to_Matrix()
Matrix([
[30, 20],
[15, 12]])
>>> den * A == Anum
True

除非将 convert 设置为 True ，否则分子矩阵将与原始矩阵在同一域中：

>>> A.clear_denoms()[1].domain
QQ
>>> A.clear_denoms(convert=True)[1].domain
ZZ

分母始终在相关的环中：

>>> A.clear_denoms()[0].domain
ZZ
>>> A.domain.get_ring()
ZZ

clear_denoms_rowwise(convert=False)[源代码][源代码]¶

清除矩阵每一行的分母。

参见

sympy.polys.polytools.Poly.clear_denoms
clear_denoms

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices import DM
>>> A = DM([[(1,2), (1,3), (1,4)], [(1,5), (1,6), (1,7)]], QQ)
>>> den, Anum = A.clear_denoms_rowwise()
>>> den.to_Matrix()
Matrix([
[12,   0],
[ 0, 210]])
>>> Anum.to_Matrix()
Matrix([
[ 6,  4,  3],
[42, 35, 30]])

分母矩阵是一个对角矩阵，其对角线上是每一行的分母。不变量是：

>>> den * A == Anum
True
>>> A == den.to_field().inv() * Anum
True

除非将 convert 设置为 True ，否则分子矩阵将与原始矩阵在同一域中：

>>> A.clear_denoms_rowwise()[1].domain
QQ
>>> A.clear_denoms_rowwise(convert=True)[1].domain
ZZ

分母矩阵的域是相关的环：

>>> A.clear_denoms_rowwise()[0].domain
ZZ

columnspace()[源代码][源代码]¶

返回 DomainMatrix 的列空间

返回:

DomainMatrix: 这个矩阵的列构成了列空间的基。

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [QQ(1), QQ(-1)],
...    [QQ(2), QQ(-2)]], (2, 2), QQ)
>>> A.columnspace()
DomainMatrix([[1], [2]], (2, 1), QQ)

content()[源代码][源代码]¶

返回矩阵元素的最大公约数。

需要在基础域中使用 gcd。

参见

primitive
cancel_denom

示例

>>> from sympy.polys.matrices import DM
>>> from sympy import ZZ
>>> M = DM([[2, 4], [4, 12]], ZZ)
>>> M.content()
2

convert_to(K)[源代码][源代码]¶

将 DomainMatrix 的域更改为所需的域或字段

参数:

K表示所需的领域或专业。: 或者，可以传递 None，在这种情况下，此方法仅返回此 DomainMatrix 的副本。

返回:

DomainMatrix: 具有所需域或字段的 DomainMatrix

示例

>>> from sympy import ZZ, ZZ_I
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [ZZ(1), ZZ(2)],
...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)

>>> A.convert_to(ZZ_I)
DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ_I)

det()[源代码][源代码]¶

返回一个方阵 DomainMatrix 的行列式。

返回:

determinant: 域元素: 矩阵的行列式。

Raises:

ValueError: 如果 DomainMatrix 的域不是域

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [ZZ(1), ZZ(2)],
...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)

>>> A.det()
-2

classmethod diag(diagonal, domain, shape=None)[源代码][源代码]¶

返回一个对角矩阵，其对角线元素来自 diagonal。

示例

>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy import ZZ
>>> DomainMatrix.diag([ZZ(5), ZZ(6)], ZZ)
DomainMatrix({0: {0: 5}, 1: {1: 6}}, (2, 2), ZZ)

diagonal()[源代码][源代码]¶

获取矩阵的对角线元素作为列表。

参见

is_diagonal
diag

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DM
>>> M = DM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], ZZ)
>>> M.diagonal()
[1, 4]

eval_poly(p)[源代码][源代码]¶

计算矩阵 $p(A)$ 的多项式函数。

参见

eval_poly_mul

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices import DM
>>> A = DM([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], QQ)
>>> p = [QQ(1), QQ(2), QQ(3)]
>>> p_A = A.eval_poly(p)
>>> p_A
DomainMatrix([[12, 14], [21, 33]], (2, 2), QQ)
>>> p_A == p[0]*A**2 + p[1]*A + p[2]*A**0
True

eval_poly_mul(p, B)[源代码][源代码]¶

计算多项式矩阵乘积 $p(A) imes B$。

使用Horner方法计算多项式矩阵乘积 $p(A) imes B$，而不显式创建矩阵 $p(A)$。如果 $B$ 是一个列矩阵，则此方法将仅使用矩阵-向量乘法，而不需要矩阵-矩阵乘法。

如果 $B$ 是方阵或宽矩阵，或者如果 $A$ 可以用比 $B$ 更简单的域表示，那么显式地计算 $p(A)$ （参见 eval_poly()）然后与 $B$ 相乘可能会更快。

参见

eval_poly
solve_den_charpoly

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices import DM
>>> A = DM([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], QQ)
>>> b = DM([[QQ(5)], [QQ(6)]], QQ)
>>> p = [QQ(1), QQ(2), QQ(3)]
>>> p_A_b = A.eval_poly_mul(p, b)
>>> p_A_b
DomainMatrix([[144], [303]], (2, 1), QQ)
>>> p_A_b == p[0]*A**2*b + p[1]*A*b + p[2]*b
True
>>> A.eval_poly_mul(p, b) == A.eval_poly(p)*b
True

classmethod eye(shape, domain)[源代码][源代码]¶

返回大小为 n 或形状为 (m, n) 的单位矩阵。

示例

>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy import QQ
>>> DomainMatrix.eye(3, QQ)
DomainMatrix({0: {0: 1}, 1: {1: 1}, 2: {2: 1}}, (3, 3), QQ)

classmethod from_Matrix(

M,

fmt='sparse',

**kwargs,

)[源代码][源代码]¶

将矩阵转换为 DomainMatrix

参数:

M: 矩阵

返回:

返回一个与 M 元素相同的 DomainMatrix

参见

Matrix

示例

>>> from sympy import Matrix
>>> from sympy.polys.matrices import DomainMatrix
>>> M = Matrix([
...    [1.0, 3.4],
...    [2.4, 1]])
>>> A = DomainMatrix.from_Matrix(M)
>>> A
DomainMatrix({0: {0: 1.0, 1: 3.4}, 1: {0: 2.4, 1: 1.0}}, (2, 2), RR)

我们可以使用 fmt=’dense’ 将内部表示保持为 ddm >>> from sympy import Matrix, QQ >>> from sympy.polys.matrices import DomainMatrix >>> A = DomainMatrix.from_Matrix(Matrix([[QQ(1, 2), QQ(3, 4)], [QQ(0, 1), QQ(0, 1)]]), fmt=’dense’) >>> A.rep [[1/2, 3/4], [0, 0]]

classmethod from_dict_sympy(

nrows,

ncols,

elemsdict,

**kwargs,

)[源代码][源代码]¶

参数:

nrows: 行数
ncols: 列数
elemsdict: 包含 DomainMatrix 非零元素的字典的字典

返回:

包含 elemsdict 元素的 DomainMatrix

参见

from_list_sympy

示例

>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy.abc import x,y,z
>>> elemsdict = {0: {0:x}, 1:{1: y}, 2: {2: z}}
>>> A = DomainMatrix.from_dict_sympy(3, 3, elemsdict)
>>> A
DomainMatrix({0: {0: x}, 1: {1: y}, 2: {2: z}}, (3, 3), ZZ[x,y,z])

classmethod from_dod(dod, shape, domain)[源代码][源代码]¶

从字典的字典（dod）格式创建稀疏的 DomainMatrix。

参见 to_dod() 以获取解释。

参见

to_dod
from_dod_like

from_dod_like(dod, domain=None)[源代码][源代码]¶

从字典的字典（dod）格式创建 DomainMatrix，类似于 self。

参见 to_dod() 以获取解释。

参见

to_dod
from_dod

classmethod from_dok(dok, shape, domain)[源代码][源代码]¶

从键值字典（dok）格式创建 DomainMatrix。

参见 to_dok() 以获取解释。

参见

to_dok

from_flat_nz(elements, data, domain)[源代码][源代码]¶

调用 to_flat_nz() 后重建 DomainMatrix。

参见 to_flat_nz() 以获取解释。

参见

to_flat_nz

classmethod from_list(rows, domain)[源代码][源代码]¶

将一个列表的列表转换为 DomainMatrix

参数:

rows: 列表的列表: 内层列表的每个元素都应该是单个参数或参数元组，这些参数将被传递给域构造函数以形成域的一个元素。请参见示例。

返回:

包含在行中定义的元素的 DomainMatrix

参见

from_list_sympy

示例

>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy import FF, QQ, ZZ
>>> A = DomainMatrix.from_list([[1, 0, 1], [0, 0, 1]], ZZ)
>>> A
DomainMatrix([[1, 0, 1], [0, 0, 1]], (2, 3), ZZ)
>>> B = DomainMatrix.from_list([[1, 0, 1], [0, 0, 1]], FF(7))
>>> B
DomainMatrix([[1 mod 7, 0 mod 7, 1 mod 7], [0 mod 7, 0 mod 7, 1 mod 7]], (2, 3), GF(7))
>>> C = DomainMatrix.from_list([[(1, 2), (3, 1)], [(1, 4), (5, 1)]], QQ)
>>> C
DomainMatrix([[1/2, 3], [1/4, 5]], (2, 2), QQ)

classmethod from_list_flat( elements, shape, domain, )[源代码][源代码]¶

从扁平列表创建 DomainMatrix。

参见

to_list_flat

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> element_list = [ZZ(1), ZZ(2), ZZ(3), ZZ(4)]
>>> A = DomainMatrix.from_list_flat(element_list, (2, 2), ZZ)
>>> A
DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)
>>> A == A.from_list_flat(A.to_list_flat(), A.shape, A.domain)
True

classmethod from_list_sympy(

nrows,

ncols,

rows,

**kwargs,

)[源代码][源代码]¶

将 Expr 的列表列表转换为使用 construct_domain 的 DomainMatrix

参数:

nrows: 行数
ncols: 列数
rows: 列表的列表

返回:

包含行元素的 DomainMatrix

参见

sympy.polys.constructor.construct_domain, from_dict_sympy

示例

>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy.abc import x, y, z
>>> A = DomainMatrix.from_list_sympy(1, 3, [[x, y, z]])
>>> A
DomainMatrix([[x, y, z]], (1, 3), ZZ[x,y,z])

classmethod from_rep(rep)[源代码][源代码]¶

从 DDM/SDM 高效创建一个新的 DomainMatrix。

参数:

rep: SDM 或 DDM: 矩阵的内部稀疏或密集表示。

返回:

DomainMatrix: 一个包装 rep 的 DomainMatrix。

注释

这将接管 rep 作为其内部表示。如果 rep 在其他地方被修改，则应提供一个副本给 from_rep。对 rep 只进行最少的验证或检查，因为这应该是一个高效的内部例程。

示例

创建一个内部表示为 DDM 的 DomainMatrix：

>>> from sympy.polys.domains import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy.polys.matrices.ddm import DDM
>>> drep = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> dM = DomainMatrix.from_rep(drep)
>>> dM
DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)

创建一个内部表示为 SDM 的 DomainMatrix 稀疏矩阵：

>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import ZZ
>>> drep = SDM({0:{1:ZZ(1)},1:{0:ZZ(2)}}, (2, 2), ZZ)
>>> dM = DomainMatrix.from_rep(drep)
>>> dM
DomainMatrix({0: {1: 1}, 1: {0: 2}}, (2, 2), ZZ)

hstack(*B)[源代码][源代码]¶

水平堆叠给定的矩阵。

参数:

B: DomainMatrix: 水平堆叠的矩阵。

返回:

DomainMatrix: 通过水平堆叠的 DomainMatrix。

参见

unify

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix

>>> A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> B = DomainMatrix([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
>>> A.hstack(B)
DomainMatrix([[1, 2, 5, 6], [3, 4, 7, 8]], (2, 4), ZZ)

>>> C = DomainMatrix([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
>>> A.hstack(B, C)
DomainMatrix([[1, 2, 5, 6, 9, 10], [3, 4, 7, 8, 11, 12]], (2, 6), ZZ)

inv()[源代码][源代码]¶

如果存在，找到 DomainMatrix 的逆矩阵

返回:

DomainMatrix: DomainMatrix 求逆后

Raises:

ValueError: 如果 DomainMatrix 的域不是一个域
DMNonSquareMatrixError: 如果 DomainMatrix 不是一个方阵 DomainMatrix

参见

neg

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...     [QQ(2), QQ(-1), QQ(0)],
...     [QQ(-1), QQ(2), QQ(-1)],
...     [QQ(0), QQ(0), QQ(2)]], (3, 3), QQ)
>>> A.inv()
DomainMatrix([[2/3, 1/3, 1/6], [1/3, 2/3, 1/3], [0, 0, 1/2]], (3, 3), QQ)

inv_den(method=None)[源代码][源代码]¶

返回一个带有分母的 DomainMatrix 作为逆矩阵。

参数:

方法str, 可选: 用于计算逆的方法。可以是 None、'rref' 或 'charpoly' 之一。如果为 None，则方法会自动选择（详见 solve_den()）。

返回:

(inv, den)(): 逆矩阵及其分母。
这或多或少等同于 adj_det() ，除了 inv
而 den 并不保证是伴随矩阵和逆矩阵。
比率 inv/den 等同于 adj/det 但有一些因素
可能会在 inv 和 den 之间取消。在简单的情况下，这
可能只是一个减号，因此 (inv, den) == (-adj, -det) 但是
比 -1 更复杂的因子也可以被消去。
取消操作并不保证完全完成，因此 inv 和 den
可能不是最简形式。如果分母 den 为零，则
仅当行列式为零时。
如果需要实际的伴随矩阵和行列式，请使用 adj_det()
反之。如果目的是计算逆矩阵或求解
那么方程组 inv_den() 更高效。

参见

inv
det
adj_det
solve_den

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...     [ZZ(2), ZZ(-1), ZZ(0)],
...     [ZZ(-1), ZZ(2), ZZ(-1)],
...     [ZZ(0), ZZ(0), ZZ(2)]], (3, 3), ZZ)
>>> Ainv, den = A.inv_den()
>>> den
6
>>> Ainv
DomainMatrix([[4, 2, 1], [2, 4, 2], [0, 0, 3]], (3, 3), ZZ)
>>> A * Ainv == den * A.eye(A.shape, A.domain).to_dense()
True

property is_diagonal¶

如果矩阵是对角矩阵，则为真。

可以对非方阵返回真。如果 M[i,j] == 0 在 i != j 时成立，则矩阵是对角矩阵。

参见

is_upper
is_lower
is_square
diagonal

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DM
>>> M = DM([[ZZ(1), ZZ(0)], [ZZ(0), ZZ(1)]], ZZ)
>>> M.is_diagonal
True

property is_lower¶: 指示此矩阵是否为下三角矩阵。即使矩阵不是方阵，也可能返回 True。

property is_square¶: 如果矩阵是方阵，则为真。

property is_upper¶: 指示此矩阵是否为上三角矩阵。即使矩阵不是方阵，也可能返回 True。

iter_items()[源代码][源代码]¶

遍历矩阵中非零元素的索引和值。

参见

iter_values
to_dok
sympy.matrices.matrixbase.MatrixBase.iter_items

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([[ZZ(1), ZZ(0)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> list(A.iter_items())
[((0, 0), 1), ((1, 0), 3), ((1, 1), 4)]

iter_values()[源代码][源代码]¶

遍历矩阵中的非零元素。

参见

iter_items
to_list_flat
sympy.matrices.matrixbase.MatrixBase.iter_values

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([[ZZ(1), ZZ(0)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> list(A.iter_values())
[1, 3, 4]

lll(delta=MPQ(3, 4))[源代码][源代码]¶

执行 Lenstra–Lenstra–Lovász (LLL) 基底约简算法。参见 [1] 和 [2]。

参数:

deltaQQ, 可选: Lovász 参数。必须在区间 (0.25, 1) 内，较大的值会产生更简化的基。出于历史原因，默认值为 0.75。

返回:

作为 ZZ 上的 DomainMatrix 的简化基。

参见

lll_transform

注释

该实现源自 [Rae18cd1d3e50-3]_（第68-69页）中图4.3和4.4给出的Maple代码。它采用了仅在需要时计算状态更新的高效方法。

参考文献

[1]

https://zh.wikipedia.org/wiki/Lenstra-Lenstra-Lovász网格基准缩减算法

[2]

https://web.archive.org/web/20221029115428/https://web.cs.elte.hu/~lovasz/scans/lll.pdf

[3]

Murray R. Bremner, “格基约化：LLL算法及其应用简介”

示例

>>> from sympy.polys.domains import ZZ, QQ
>>> from sympy.polys.matrices import DM
>>> x = DM([[1, 0, 0, 0, -20160],
...         [0, 1, 0, 0, 33768],
...         [0, 0, 1, 0, 39578],
...         [0, 0, 0, 1, 47757]], ZZ)
>>> y = DM([[10, -3, -2, 8, -4],
...         [3, -9, 8, 1, -11],
...         [-3, 13, -9, -3, -9],
...         [-12, -7, -11, 9, -1]], ZZ)
>>> assert x.lll(delta=QQ(5, 6)) == y

lll_transform(delta=MPQ(3, 4))[源代码][源代码]¶

执行 Lenstra–Lenstra–Lovász (LLL) 基底约简算法，并返回约简后的基底和变换矩阵。

参见

lll

示例

>>> from sympy.polys.domains import ZZ, QQ
>>> from sympy.polys.matrices import DM
>>> X = DM([[1, 0, 0, 0, -20160],
...         [0, 1, 0, 0, 33768],
...         [0, 0, 1, 0, 39578],
...         [0, 0, 0, 1, 47757]], ZZ)
>>> B, T = X.lll_transform(delta=QQ(5, 6))
>>> T * X == B
True

lu()[源代码][源代码]¶

返回 DomainMatrix 的上下分解

返回:

(L, U, 交换): L, U 是 DomainMatrix 的低分解和高分解，exchange 是在分解过程中交换的行索引列表。

Raises:

ValueError: 如果 DomainMatrix 的域不是一个域

参见

lu_solve

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [QQ(1), QQ(-1)],
...    [QQ(2), QQ(-2)]], (2, 2), QQ)
>>> L, U, exchange = A.lu()
>>> L
DomainMatrix([[1, 0], [2, 1]], (2, 2), QQ)
>>> U
DomainMatrix([[1, -1], [0, 0]], (2, 2), QQ)
>>> exchange
[]

lu_solve(rhs)[源代码][源代码]¶

用于求解域矩阵 x 的求解器，在 A*x = B 中

参数:

rhs域矩阵 B

返回:

DomainMatrix: x 在 A*x = B 中

Raises:

DMShapeError: 如果 DomainMatrix A 和 rhs 的行数不同
ValueError: 如果 DomainMatrix A 的域不是一个域

参见

lu

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [QQ(1), QQ(2)],
...    [QQ(3), QQ(4)]], (2, 2), QQ)
>>> B = DomainMatrix([
...    [QQ(1), QQ(1)],
...    [QQ(0), QQ(1)]], (2, 2), QQ)

>>> A.lu_solve(B)
DomainMatrix([[-2, -1], [3/2, 1]], (2, 2), QQ)

matmul(B)[源代码][源代码]¶

对两个 DomainMatrix 矩阵执行矩阵乘法

参数:

A, B: DomainMatrix: 乘以

返回:

DomainMatrix: 乘法后的 DomainMatrix

参见

mul, pow, add, sub

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [ZZ(1), ZZ(2)],
...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> B = DomainMatrix([
...    [ZZ(1), ZZ(1)],
...    [ZZ(0), ZZ(1)]], (2, 2), ZZ)

>>> A.matmul(B)
DomainMatrix([[1, 3], [3, 7]], (2, 2), ZZ)

mul(b)[源代码][源代码]¶

对第二个 DomainMatrix 相对于第一个 DomainMatrix 执行逐项乘法。返回一个 DomainMatrix，其行是由逐项乘法创建的 DomainMatrix 矩阵列表。

参数:

A, B: DomainMatrix: 矩阵按项相乘

返回:

DomainMatrix: 逐项乘法后的 DomainMatrix

参见

matmul

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [ZZ(1), ZZ(2)],
...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> b = ZZ(2)

>>> A.mul(b)
DomainMatrix([[2, 4], [6, 8]], (2, 2), ZZ)

neg()[源代码][源代码]¶

返回 DomainMatrix 的负值

参数:

A表示一个 DomainMatrix

返回:

DomainMatrix: 取反后的 DomainMatrix

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [ZZ(1), ZZ(2)],
...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)

>>> A.neg()
DomainMatrix([[-1, -2], [-3, -4]], (2, 2), ZZ)

nnz()[源代码][源代码]¶

矩阵中非零元素的数量。

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DM
>>> A = DM([[1, 0], [0, 4]], ZZ)
>>> A.nnz()
2

nullspace(divide_last=False)[源代码][源代码]¶

返回 DomainMatrix 的零空间

参数:

divide_lastbool, 可选: 如果为 False（默认值），向量不会被归一化，并且使用 rref_den() 计算 RREF，分母会被丢弃。如果为 True，则每一行会除以其最终元素；在这种情况下，域必须是一个域。

返回:

DomainMatrix: 这个矩阵的行构成了零空间的一个基。

参见

nullspace_from_rref
rref
rref_den
rowspace

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices import DM
>>> A = DM([
...    [QQ(2), QQ(-2)],
...    [QQ(4), QQ(-4)]], QQ)
>>> A.nullspace()
DomainMatrix([[1, 1]], (1, 2), QQ)

返回的矩阵是零空间的一个基：

>>> A_null = A.nullspace().transpose()
>>> A * A_null
DomainMatrix([[0], [0]], (2, 1), QQ)
>>> rows, cols = A.shape
>>> nullity = rows - A.rank()
>>> A_null.shape == (cols, nullity)
True

零空间也可以为非域环计算。如果环不是一个域，那么除法就不被使用。在这种情况下，将 divide_last 设置为 True 将会引发错误：

>>> from sympy import ZZ
>>> B = DM([[6, -3],
...         [4, -2]], ZZ)
>>> B.nullspace()
DomainMatrix([[3, 6]], (1, 2), ZZ)
>>> B.nullspace(divide_last=True)
Traceback (most recent call last):
...
DMNotAField: Cannot normalize vectors over a non-field

在一个定义了 gcd 的环上，零空间可以通过 primitive() 方法潜在地减少。

>>> B.nullspace().primitive()
(3, DomainMatrix([[1, 2]], (1, 2), ZZ))

环上的矩阵通常可以通过将其转换为域来进行归一化，但这样做通常是个坏主意：

>>> from sympy.abc import a, b, c
>>> from sympy import Matrix
>>> M = Matrix([[        a*b,       b + c,        c],
...             [      a - b,         b*c,     c**2],
...             [a*b + a - b, b*c + b + c, c**2 + c]])
>>> M.to_DM().domain
ZZ[a,b,c]
>>> M.to_DM().nullspace().to_Matrix().transpose()
Matrix([
[                             c**3],
[            -a*b*c**2 + a*c - b*c],
[a*b**2*c - a*b - a*c + b**2 + b*c]])

这里的未归一化形式比归一化形式更好，归一化形式会在整个矩阵中分散一个大分母：

>>> M.to_DM().to_field().nullspace(divide_last=True).to_Matrix().transpose()
Matrix([
[                   c**3/(a*b**2*c - a*b - a*c + b**2 + b*c)],
[(-a*b*c**2 + a*c - b*c)/(a*b**2*c - a*b - a*c + b**2 + b*c)],
[                                                          1]])

nullspace_from_rref(pivots=None)[源代码][源代码]¶

从简化行阶梯形矩阵和主元计算零空间。

矩阵的域可以是任何域。

矩阵必须已经是简化行阶梯形式。否则结果将会不正确。首先使用 rref() 或 rref_den() 来获取简化行阶梯形式，或者使用 nullspace() 代替。

参见

nullspace
rref
rref_den
sympy.polys.matrices.sdm.SDM.nullspace_from_rref
sympy.polys.matrices.ddm.DDM.nullspace_from_rref

classmethod ones(shape, domain)[源代码][源代码]¶

返回一个指定域中大小为 shape 的全 1 的 DomainMatrix

示例

>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy import QQ
>>> DomainMatrix.ones((2,3), QQ)
DomainMatrix([[1, 1, 1], [1, 1, 1]], (2, 3), QQ)

pow(n)[源代码][源代码]¶

计算 A**n

参数:

ADomainMatrix
nA 的指数

返回:

DomainMatrix: 计算 A**n 上的 DomainMatrix

Raises:

NotImplementedError: 如果 n 是负数。

参见

matmul

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [ZZ(1), ZZ(1)],
...    [ZZ(0), ZZ(1)]], (2, 2), ZZ)

>>> A.pow(2)
DomainMatrix([[1, 2], [0, 1]], (2, 2), ZZ)

primitive()[源代码][源代码]¶

提取矩阵元素的最大公约数。

需要在基础域中使用 gcd。

参见

content
cancel_denom

示例

>>> from sympy.polys.matrices import DM
>>> from sympy import ZZ
>>> M = DM([[2, 4], [4, 12]], ZZ)
>>> content, M_primitive = M.primitive()
>>> content
2
>>> M_primitive
DomainMatrix([[1, 2], [2, 6]], (2, 2), ZZ)
>>> content * M_primitive == M
True
>>> M_primitive.content() == ZZ(1)
True

rowspace()[源代码][源代码]¶

返回 DomainMatrix 的行空间

返回:

DomainMatrix: 这个矩阵的行形成了行空间的基。

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [QQ(1), QQ(-1)],
...    [QQ(2), QQ(-2)]], (2, 2), QQ)
>>> A.rowspace()
DomainMatrix([[1, -1]], (1, 2), QQ)

rref(*, method='auto')[源代码][源代码]¶

返回简化行阶梯形式（RREF）和主元列表。

如果域不是一个字段，那么它将被转换为一个字段。有关返回带有分母的 RREF 的此例程的无分数版本，请参见 rref_den()。

该域必须是字段或有相关的分数域（参见 to_field()）。

参数:

方法str, 可选 (默认: ‘auto’)

用于计算简化行阶梯形矩阵（RREF）的方法。默认是 'auto'，它会尝试选择最快的方法。其他选项有：

A.rref(method='GJ') 使用带除法的Gauss-Jordan消去法。如果域不是域，则首先会通过 to_field() 将其转换为域，然后通过反转每行中的主元来计算RREF。这对于非常稀疏的矩阵或元素具有复杂分母的矩阵最为有效。
A.rref(method='FF') 使用无分数的高斯-约旦消元法。消元过程使用精确除法（exquo）来控制系数的增长。在这种情况下，当前域始终用于消元，但如果该域不是域，则最终会将其转换为域并除以分母。这对于密集矩阵或分母简单的矩阵最为有效。
A.rref(method='CD') 在关联环中使用无分数的高斯-约旦消元法之前清除分母。这对于分母非常简单的稠密矩阵最为有效。
A.rref(method='GJ_dense')、A.rref(method='FF_dense') 和 A.rref(method='CD_dense') 与上述方法相同，只是使用了算法的密集实现。默认情况下，A.rref(method='auto') 通常会选择 RREF 的稀疏实现。

无论使用哪种算法，返回的矩阵将始终与输入具有相同的格式（稀疏或密集），并且其域将始终是输入域的分数域。

返回:

(DomainMatrix, 列表): reduced-row echelon form 和 DomainMatrix 的枢轴列表

参见

rref_den: RREF 带分母
sympy.polys.matrices.sdm.sdm_irref: method='GJ' 的稀疏实现。
sympy.polys.matrices.sdm.sdm_rref_den: method='FF' 和 method='CD' 的稀疏实现。
sympy.polys.matrices.dense.ddm_irref: method='GJ' 的密集实现。
sympy.polys.matrices.dense.ddm_irref_den: method='FF' 和 method='CD' 的密集实现。
clear_denoms: 从矩阵中清除分母，由 method='CD' 和 method='GJ' 使用，当原始域不是域时。

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...     [QQ(2), QQ(-1), QQ(0)],
...     [QQ(-1), QQ(2), QQ(-1)],
...     [QQ(0), QQ(0), QQ(2)]], (3, 3), QQ)

>>> rref_matrix, rref_pivots = A.rref()
>>> rref_matrix
DomainMatrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], (3, 3), QQ)
>>> rref_pivots
(0, 1, 2)

rref_den( *, method='auto', keep_domain=True, )[源代码][源代码]¶

返回简化行阶梯形式，带有分母和主元列表。

需要在基础域中进行精确除法（exquo）。

参数:

方法str, 可选 (默认: ‘auto’)

用于计算简化行阶梯形矩阵（RREF）的方法。默认是 'auto'，它会尝试选择最快的方法。其他选项有：

A.rref(method='FF') 使用无分数的高斯-若尔当消元法。消元过程中使用精确除法（exquo）来控制系数的增长。在这种情况下，当前域始终用于消元，结果始终作为当前域上的矩阵返回。这对于密集矩阵或分母简单的矩阵最为有效。
A.rref(method='CD') 在关联环中使用无分数的高斯-若尔当消元法之前先清除分母。除非传递了 keep_domain=False，否则结果将转换回原始域，在这种情况下，结果将覆盖用于消元的环。这对于分母非常简单的密集矩阵最为有效。
A.rref(method='GJ') 使用带除法的Gauss-Jordan消元法。如果域不是域，则首先通过 to_field() 将其转换为域，并通过反转每行中的主元元素来计算RREF。除非传递了 keep_domain=False，否则结果将通过清除分母转换回原始域，在这种情况下，结果将保留用于消元的域。这对于非常稀疏的矩阵或元素具有复杂分母的矩阵最为有效。
A.rref(method='GJ_dense')、A.rref(method='FF_dense') 和 A.rref(method='CD_dense') 与上述方法相同，只是使用了算法的密集实现。默认情况下，A.rref(method='auto') 通常会选择 RREF 的稀疏实现。

无论使用哪种算法，返回的矩阵将始终与输入具有相同的格式（稀疏或密集），并且如果 keep_domain=True，其域将始终与输入相同。

keep_domainbool, 可选

如果为 True（默认值），返回矩阵和分母的域与输入矩阵的域相同。如果为 False，返回矩阵的域可能会更改为使用不同域的算法所关联的环或域。如果调用者不需要结果在原始域中，这有助于提高效率，例如，它可以避免在 A.rref(method='GJ') 的情况下清除分母。

返回:

(DomainMatrix, 标量, 列表): 简化行阶梯形式，分母和主元索引列表。

参见

rref: 无分母的场域的RREF。
sympy.polys.matrices.sdm.sdm_irref: method='GJ' 的稀疏实现。
sympy.polys.matrices.sdm.sdm_rref_den: method='FF' 和 method='CD' 的稀疏实现。
sympy.polys.matrices.dense.ddm_irref: method='GJ' 的密集实现。
sympy.polys.matrices.dense.ddm_irref_den: method='FF' 和 method='CD' 的密集实现。
clear_denoms: 从矩阵中清除分母，由 method='CD' 使用。

示例

>>> from sympy import ZZ, QQ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...     [ZZ(2), ZZ(-1), ZZ(0)],
...     [ZZ(-1), ZZ(2), ZZ(-1)],
...     [ZZ(0), ZZ(0), ZZ(2)]], (3, 3), ZZ)

>>> A_rref, denom, pivots = A.rref_den()
>>> A_rref
DomainMatrix([[6, 0, 0], [0, 6, 0], [0, 0, 6]], (3, 3), ZZ)
>>> denom
6
>>> pivots
(0, 1, 2)
>>> A_rref.to_field() / denom
DomainMatrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], (3, 3), QQ)
>>> A_rref.to_field() / denom == A.convert_to(QQ).rref()[0]
True

scc()[源代码][源代码]¶

计算 DomainMatrix 的强连通分量

返回:

整数列表的列表: 每个列表代表一个强连通分量。

参见

sympy.matrices.matrixbase.MatrixBase.strongly_connected_components
sympy.utilities.iterables.strongly_connected_components

示例

找到矩阵的强连通分量：

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> M = DomainMatrix([[ZZ(1), ZZ(0), ZZ(2)],
...                   [ZZ(0), ZZ(3), ZZ(0)],
...                   [ZZ(4), ZZ(6), ZZ(5)]], (3, 3), ZZ)
>>> M.scc()
[[1], [0, 2]]

从组件计算行列式：

>>> MM = M.to_Matrix()
>>> MM
Matrix([
[1, 0, 2],
[0, 3, 0],
[4, 6, 5]])
>>> MM[[1], [1]]
Matrix([[3]])
>>> MM[[0, 2], [0, 2]]
Matrix([
[1, 2],
[4, 5]])
>>> MM.det()
-9
>>> MM[[1], [1]].det() * MM[[0, 2], [0, 2]].det()
-9

这些组件按逆拓扑顺序给出，并表示将矩阵转换为块下三角形式的行和列的排列：

>>> MM[[1, 0, 2], [1, 0, 2]]
Matrix([
[3, 0, 0],
[0, 1, 2],
[6, 4, 5]])

solve_den(b, method=None)[源代码][源代码]¶

在基础域中不使用分数求解矩阵方程 $Ax = b$。

参数:

selfDomainMatrix

方程 $Ax = b$ 中的 m x n 矩阵 $A$。不支持欠定系统，因此 m >= n：$A$ 应为方阵或有比列更多的行。

bDomainMatrix

n x m 矩阵 $b$ 用于右端项。

cp : DomainElement 的列表, 可选列表

矩阵 $A$ 的特征多项式。如果未给出，将使用 charpoly() 计算。

方法: str, 可选

用于求解系统的方法。可以是 None、'charpoly' 或 'rref' 之一。如果为 ``None``（默认），则方法将自动选择。

charpoly 方法使用 solve_den_charpoly() 并且只能在矩阵为方阵时使用。此方法无除法操作，可用于任何域。

rref 方法是无分数的，但需要在基础域中进行精确除法（exquo）。这也适用于大多数域。此方法可用于超定系统（方程多于未知数），但不能用于欠定系统，因为寻求的是唯一解。

返回:

(分子, 分母)(域矩阵, 域元素): 方程 $Ax = b$ 的解作为一个由 n x m 矩阵分子 xnum 和标量分母 xden 组成的对。
解 $x$ 由 x = xnum / xden 给出。无除法
不变量是 A * xnum == xden * b。如果 $A$ 是方阵，那么
分母 xden 将是行列式 $det(A)$ 的除数。

Raises:

DMNonInvertibleMatrixError: 如果系统 $Ax = b$ 没有唯一解。

参见

solve_den_charpoly
solve_den_rref
inv_den

示例

在整数范围内求解矩阵方程：

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DM
>>> A = DM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], ZZ)
>>> b = DM([[ZZ(5)], [ZZ(6)]], ZZ)
>>> xnum, xden = A.solve_den(b)
>>> xden
-2
>>> xnum
DomainMatrix([[8], [-9]], (2, 1), ZZ)
>>> A * xnum == xden * b
True

在多项式环上求解矩阵方程：

>>> from sympy import ZZ
>>> from sympy.abc import x, y, z, a, b
>>> R = ZZ[x, y, z, a, b]
>>> M = DM([[x*y, x*z], [y*z, x*z]], R)
>>> b = DM([[a], [b]], R)
>>> M.to_Matrix()
Matrix([
[x*y, x*z],
[y*z, x*z]])
>>> b.to_Matrix()
Matrix([
[a],
[b]])
>>> xnum, xden = M.solve_den(b)
>>> xden
x**2*y*z - x*y*z**2
>>> xnum.to_Matrix()
Matrix([
[ a*x*z - b*x*z],
[-a*y*z + b*x*y]])
>>> M * xnum == xden * b
True

该解可以在一个分数域上表示，这将取消分母和分子元素之间的最大公约数：

>>> xsol = xnum.to_field() / xden
>>> xsol.to_Matrix()
Matrix([
[           (a - b)/(x*y - y*z)],
[(-a*z + b*x)/(x**2*z - x*z**2)]])
>>> (M * xsol).to_Matrix() == b.to_Matrix()
True

在求解一个大型方程组时，这一消去步骤可能比 solve_den() 本身要慢得多。解决方案也可以表示为一个 Matrix，而不尝试在分子和分母之间进行任何多项式消去，从而更快地得到一个不太简化的结果：

>>> xsol_uncancelled = xnum.to_Matrix() / xnum.domain.to_sympy(xden)
>>> xsol_uncancelled
Matrix([
[ (a*x*z - b*x*z)/(x**2*y*z - x*y*z**2)],
[(-a*y*z + b*x*y)/(x**2*y*z - x*y*z**2)]])
>>> from sympy import cancel
>>> cancel(xsol_uncancelled) == xsol.to_Matrix()
True

solve_den_charpoly( b, cp=None, check=True, )[源代码][源代码]¶

使用特征多项式求解矩阵方程 $Ax = b$。

此方法在基础域中没有任何除法或分数的情况下，使用特征多项式求解方阵方程 $Ax = b$ 中的 $x$。

参数:

selfDomainMatrix: 方程 $Ax = b$ 中的 n x n 矩阵 $A$。必须是方阵且可逆。
bDomainMatrix: 用于右端项的 n x m 矩阵 $b$。
cp列表，可选: 如果已知矩阵 $A$ 的特征多项式。如果未给出，将使用 charpoly() 计算。
检查bool, 可选: 如果 True``（默认值），检查行列式是否不为零，如果是零则引发错误。如果 ``False，那么如果行列式为零，返回值将等于 (A.adjugate()*b, 0)。

返回:

(xnum, detA)(域矩阵, 域元素): 方程 $Ax = b$ 的解作为矩阵分子和标量分母对。分母等于 $A$ 的行列式，分子是 adj(A)*b。
解 $x$ 由 x = xnum / detA 给出。无除法
不变式是 A * xnum == detA * b。
如果 b 是单位矩阵，那么 xnum 是伴随矩阵
并且我们有 A * adj(A) == detA * I。

参见

solve_den: 用于求解带分母的矩阵方程的主前端。
solve_den_rref: 使用无分数的简化行阶梯形式（RREF）求解矩阵方程。
inv_den: 使用特征多项式求逆矩阵。

示例

在整数范围内求解矩阵方程：

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DM
>>> A = DM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], ZZ)
>>> b = DM([[ZZ(5)], [ZZ(6)]], ZZ)
>>> xnum, detA = A.solve_den_charpoly(b)
>>> detA
-2
>>> xnum
DomainMatrix([[8], [-9]], (2, 1), ZZ)
>>> A * xnum == detA * b
True

solve_den_rref(b)[源代码][源代码]¶

使用无分数的简化行阶梯形式（RREF）求解矩阵方程 $Ax = b$

求解矩阵方程 $Ax = b$ 中的 $x$，并以分子/分母对的形式返回解。

参见

solve_den
solve_den_charpoly

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DM
>>> A = DM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], ZZ)
>>> b = DM([[ZZ(5)], [ZZ(6)]], ZZ)
>>> xnum, xden = A.solve_den_rref(b)
>>> xden
-2
>>> xnum
DomainMatrix([[8], [-9]], (2, 1), ZZ)
>>> A * xnum == xden * b
True

sub(B)[源代码][源代码]¶

减去两个相同域的 DomainMatrix 矩阵

参数:

A, B: DomainMatrix: 矩阵相减

返回:

DomainMatrix: 减法后的 DomainMatrix

Raises:

DMShapeError: 如果两个 DomainMatrix 的维度不相等
ValueError: 如果两个 DomainMatrix 的域不同

参见

add, matmul

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [ZZ(1), ZZ(2)],
...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> B = DomainMatrix([
...    [ZZ(4), ZZ(3)],
...    [ZZ(2), ZZ(1)]], (2, 2), ZZ)

>>> A.sub(B)
DomainMatrix([[-3, -1], [1, 3]], (2, 2), ZZ)

to_Matrix()[源代码][源代码]¶

将 DomainMatrix 转换为 Matrix

返回:

矩阵: DomainMatrix 的 MutableDenseMatrix

参见

from_Matrix

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [ZZ(1), ZZ(2)],
...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)

>>> A.to_Matrix()
Matrix([
    [1, 2],
    [3, 4]])

to_ddm()[源代码][源代码]¶

返回 self 的 DDM 表示。

参见

to_sdm
to_dense
sympy.polys.matrices.ddm.DDM.to_sdm

示例

>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy import QQ
>>> A = DomainMatrix({0: {0: 1}, 1: {1: 2}}, (2, 2), QQ)
>>> ddm = A.to_ddm()
>>> ddm
[[1, 0], [0, 2]]
>>> type(ddm)
<class 'sympy.polys.matrices.ddm.DDM'>

to_dense()[源代码][源代码]¶

返回 self 的密集 DomainMatrix 表示。

示例

>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy import QQ
>>> A = DomainMatrix({0: {0: 1}, 1: {1: 2}}, (2, 2), QQ)
>>> A.rep
{0: {0: 1}, 1: {1: 2}}
>>> B = A.to_dense()
>>> B.rep
[[1, 0], [0, 2]]

to_dfm()[源代码][源代码]¶

返回 self 的 DFM 表示。

参见

to_ddm
to_dense
DFM

示例

>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy import QQ
>>> A = DomainMatrix([[1, 0],[0, 2]], (2, 2), QQ)
>>> dfm = A.to_dfm()
>>> dfm
[[1, 0], [0, 2]]
>>> type(dfm)
<class 'sympy.polys.matrices._dfm.DFM'>

to_dfm_or_ddm()[源代码][源代码]¶

返回 self 的 DFM 或 DDM 表示。

参见

to_ddm: 始终返回 DDM 表示。
to_dfm: 返回一个 DFM 表示形式，或引发错误。
to_dense: 内部转换为 DFM 或 DDM
DFM: 这是 DFM 密集 FLINT 矩阵表示。
DDM: Python DDM 密集域矩阵表示。

示例

>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy import QQ
>>> A = DomainMatrix([[1, 0],[0, 2]], (2, 2), QQ)
>>> dfm = A.to_dfm_or_ddm()
>>> dfm
[[1, 0], [0, 2]]
>>> type(dfm)  # Depends on the ground domain and ground types
<class 'sympy.polys.matrices._dfm.DFM'>

to_dod()[源代码][源代码]¶

将 DomainMatrix 转换为字典的字典（dod）格式。

参见

from_dod
from_dod_like
to_dok
to_list
to_list_flat
to_flat_nz
sympy.matrices.matrixbase.MatrixBase.todod

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DM
>>> A = DM([[ZZ(1), ZZ(2), ZZ(0)], [ZZ(3), ZZ(0), ZZ(4)]], ZZ)
>>> A.to_dod()
{0: {0: 1, 1: 2}, 1: {0: 3, 2: 4}}
>>> A.to_sparse() == A.from_dod(A.to_dod(), A.shape, A.domain)
True
>>> A == A.from_dod_like(A.to_dod())
True

to_dok()[源代码][源代码]¶

将 DomainMatrix 转换为键值字典 (dok) 格式。

参见

from_dok
to_list
to_list_flat
to_flat_nz

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [ZZ(1), ZZ(0)],
...    [ZZ(0), ZZ(4)]], (2, 2), ZZ)
>>> A.to_dok()
{(0, 0): 1, (1, 1): 4}

可以通过调用 from_dok() 来重建矩阵，尽管重建的矩阵将始终为稀疏格式：

>>> A.to_sparse() == A.from_dok(A.to_dok(), A.shape, A.domain)
True

to_field()[源代码][源代码]¶

返回一个具有适当域的 DomainMatrix

返回:

DomainMatrix: 具有适当域的 DomainMatrix

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [ZZ(1), ZZ(2)],
...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)

>>> A.to_field()
DomainMatrix([[1, 2], [3, 4]], (2, 2), QQ)

to_flat_nz()[源代码][源代码]¶

将 DomainMatrix 转换为非零元素和数据的列表。

参见

from_flat_nz

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([
...    [ZZ(1), ZZ(2)],
...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> elements, data = A.to_flat_nz()
>>> elements
[1, 2, 3, 4]
>>> A == A.from_flat_nz(elements, data, A.domain)
True

创建一个元素翻倍的矩阵：

>>> elements_doubled = [2*x for x in elements]
>>> A2 = A.from_flat_nz(elements_doubled, data, A.domain)
>>> A2 == 2*A
True

to_list()[源代码][源代码]¶

将 DomainMatrix 转换为列表的列表。

参见

from_list
to_list_flat
to_flat_nz
to_dok

to_list_flat()[源代码][源代码]¶

将 DomainMatrix 转换为扁平列表。

参见

from_list_flat
to_list
to_flat_nz
to_dok

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> A.to_list_flat()
[1, 2, 3, 4]

to_sdm()[源代码][源代码]¶

返回 self 的 SDM 表示。

参见

to_ddm
to_sparse
sympy.polys.matrices.sdm.SDM.to_ddm

示例

>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy import QQ
>>> A = DomainMatrix([[1, 0],[0, 2]], (2, 2), QQ)
>>> sdm = A.to_sdm()
>>> sdm
{0: {0: 1}, 1: {1: 2}}
>>> type(sdm)
<class 'sympy.polys.matrices.sdm.SDM'>

to_sparse()[源代码][源代码]¶

返回 self 的稀疏 DomainMatrix 表示。

示例

>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy import QQ
>>> A = DomainMatrix([[1, 0],[0, 2]], (2, 2), QQ)
>>> A.rep
[[1, 0], [0, 2]]
>>> B = A.to_sparse()
>>> B.rep
{0: {0: 1}, 1: {1: 2}}

transpose()[源代码][源代码]¶: self 的矩阵转置

unify(*others, fmt=None)[源代码][源代码]¶

统一自身和其他矩阵的域和格式。

参数:

其他DomainMatrix
fmt: 字符串 ‘dense’, ‘sparse’ 或 `None` (默认): 如果 self 和 other 尚未采用相同格式，则首选转换为的格式。如果为 $None$ 或未指定，则不执行转换。

返回:

Tuple[DomainMatrix]: 具有统一域和格式的矩阵

参见

convert_to, to_dense, to_sparse

示例

统一具有不同域的 DomainMatrix 的域：

>>> from sympy import ZZ, QQ
>>> from sympy.polys.matrices import DomainMatrix
>>> A = DomainMatrix([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
>>> B = DomainMatrix([[QQ(1, 2), QQ(2)]], (1, 2), QQ)
>>> Aq, Bq = A.unify(B)
>>> Aq
DomainMatrix([[1, 2]], (1, 2), QQ)
>>> Bq
DomainMatrix([[1/2, 2]], (1, 2), QQ)

统一格式（密集或稀疏）：

>>> A = DomainMatrix([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
>>> B = DomainMatrix({0:{0: ZZ(1)}}, (2, 2), ZZ)
>>> B.rep
{0: {0: 1}}

>>> A2, B2 = A.unify(B, fmt='dense')
>>> B2.rep
[[1, 0], [0, 0]]

vstack(*B)[源代码][源代码]¶

垂直堆叠给定的矩阵。

参数:

B: DomainMatrix: 垂直堆叠的矩阵。

返回:

DomainMatrix: 通过垂直堆叠形成的 DomainMatrix。

参见

unify

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices import DomainMatrix

>>> A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> B = DomainMatrix([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
>>> A.vstack(B)
DomainMatrix([[1, 2], [3, 4], [5, 6], [7, 8]], (4, 2), ZZ)

>>> C = DomainMatrix([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
>>> A.vstack(B, C)
DomainMatrix([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]], (6, 2), ZZ)

classmethod zeros(shape, domain, *, fmt='sparse')[源代码][源代码]¶

返回一个大小为 shape 的零 DomainMatrix，属于指定的域

示例

>>> from sympy.polys.matrices import DomainMatrix
>>> from sympy import QQ
>>> DomainMatrix.zeros((2, 3), QQ)
DomainMatrix({}, (2, 3), QQ)

用于DDM类的模块。

DDM 类是 DomainMatrix 使用的内部表示。字母 DDM 代表密集域矩阵。DDM 实例使用多项式域（例如 ZZ、QQ 等）中的元素以密集矩阵表示形式表示矩阵。

基本用法：

>>> from sympy import ZZ, QQ
>>> from sympy.polys.matrices.ddm import DDM
>>> A = DDM([[ZZ(0), ZZ(1)], [ZZ(-1), ZZ(0)]], (2, 2), ZZ)
>>> A.shape
(2, 2)
>>> A
[[0, 1], [-1, 0]]
>>> type(A)
<class 'sympy.polys.matrices.ddm.DDM'>
>>> A @ A
[[-1, 0], [0, -1]]

ddm_* 函数被设计为可以操作 DDM 以及普通的列表嵌套列表：

>>> from sympy.polys.matrices.dense import ddm_idet
>>> ddm_idet(A, QQ)
1
>>> ddm_idet([[0, 1], [-1, 0]], QQ)
1
>>> A
[[-1, 0], [0, -1]]

注意 ddm_idet 会就地修改输入矩阵。建议使用 DDM.det 方法作为更友好的接口，它会负责复制矩阵：

>>> B = DDM([[ZZ(0), ZZ(1)], [ZZ(-1), ZZ(0)]], (2, 2), ZZ)
>>> B.det()
1

通常情况下，DDM 不会被直接使用，它只是 DomainMatrix 内部表示的一部分，增加了进一步的功能，例如统一域。

DDM 使用的密集格式是一个元素列表的列表，例如 2x2 单位矩阵类似于 [[1, 0], [0, 1]]。DDM 类本身是列表的子类，其列表项是普通列表。元素可以通过例如 ddm[i][j] 访问，其中 ddm[i] 给出第 i 行，ddm[i][j] 获取该行第 j 列的元素。子类化列表使得例如迭代和索引非常高效。我们没有覆盖 __getitem__，因为那样会失去这个好处。

核心例程由 dense.py 中定义的 ddm_* 函数实现。这些函数旨在能够对矩阵的原始列表表示进行操作，大多数函数在原地操作。DDM 类负责复制等操作，并且还存储与其元素关联的 Domain 对象。这使得可以实现诸如 A + B 的操作，并进行域检查和形状检查，从而使列表表示更加友好。

class sympy.polys.matrices.ddm.DDM(rowslist, shape, domain)[源代码][源代码]¶

基于多项式域元素的稠密矩阵

这是一个列表子类，并且是一个列表的列表的包装器，支持基本的矩阵算术运算 +, -, , *。

方法

`add`(b)	a + b
`append`(object, /)	将对象追加到列表的末尾。
`charpoly`()	特征多项式的系数
`clear`(/)	从列表中移除所有项目。
`copy`()
`count`(value, /)	返回值出现的次数。
`det`()	行列式
`diag`(values, domain)	返回一个对角线上为 values 的方阵。
`diagonal`()	返回矩阵对角线上的元素列表。
`extend`(iterable, /)	通过从可迭代对象中追加元素来扩展列表。
`from_dod`(dod, shape, domain)	从字典的字典（dod）格式创建一个 `DDM`。
`from_dok`(dok, shape, domain)	从键的字典（dok）格式创建一个 `DDM`。
`from_flat_nz`(elements, data, domain)	在调用 `to_flat_nz()` 之后重建 `DDM`。
`from_list`(rowslist, shape, domain)	从列表的列表创建一个 `DDM`。
`from_list_flat`(flat, shape, domain)	从元素的扁平列表创建一个 `DDM`。
`hstack`(*B)	水平堆叠 `DDM` 矩阵。
`index`(value[, start, stop])	返回值的第一个索引。
`insert`(index, object, /)	在索引前插入对象。
`inv`()	一个的逆
`is_diagonal`()	指示此矩阵是否为对角矩阵。
`is_lower`()	指示此矩阵是否为下三角矩阵。
`is_upper`()	指示此矩阵是否为上三角矩阵。
`is_zero_matrix`()	判断此矩阵是否所有元素均为零。
`iter_items`()	遍历矩阵中非零元素的索引和值。
`iter_values`()	遍历矩阵中的非零值。
`lu`()	L, U 分解
`lu_solve`(b)	x 其中 a*x = b
`matmul`(b)	a @ b (矩阵乘积)
`neg`()	-a
`nnz`()	在 `DDM` 矩阵中非零条目的数量。
`nullspace`()	返回 a 的零空间的基础。
`nullspace_from_rref`([pivots])	从矩阵的简化行阶梯形式（rref）计算其零空间。
`pop`([index])	移除并返回索引处的项（默认最后一个）。
`remove`(value, /)	移除首次出现的值。
`reverse`(/)	反向就地。
`rref`()	a 的简化行阶梯形式和主元列表。
`rref_den`()	a 的简化行阶梯形式，带有分母和主元列表
`scc`()	方阵 a 的强连通分量。
`sort`(*[, key, reverse])	将列表按升序排序并返回 None。
`sub`(b)	a - b
`to_ddm`()	转换为 `DDM`。
`to_dfm`()	转换为 `DDM` 到 `DFM`。
`to_dfm_or_ddm`()	如果可能，转换为 `DFM` ，否则返回自身。
`to_dod`()	转换为字典的字典（dod）格式。
`to_dok`()	将 `DDM` 转换为键字典 (dok) 格式。
`to_flat_nz`()	转换为非零元素和数据的扁平列表。
`to_list`()	转换为列表的列表。
`to_list_flat`()	转换为元素的扁平列表。
`to_sdm`()	转换为 `SDM`。
`vstack`(*B)	垂直堆叠 `DDM` 矩阵。

applyfunc
转换为
提取
提取切片
眼睛
扁平
flatiter
from_ddm
getitem
lll
lll_transform
mul
mul_elementwise
ones
特定
rmul
setitem
转置
零

add(b)[源代码][源代码]¶: a + b

charpoly()[源代码][源代码]¶: 特征多项式的系数

det()[源代码][源代码]¶: 行列式

classmethod diag(values, domain)[源代码][源代码]¶

返回一个对角线上为 values 的方阵。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.diag

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.sdm import DDM
>>> DDM.diag([ZZ(1), ZZ(2), ZZ(3)], ZZ)
[[1, 0, 0], [0, 2, 0], [0, 0, 3]]

diagonal()[源代码][源代码]¶: 返回矩阵对角线上的元素列表。

classmethod from_dod(dod, shape, domain)[源代码][源代码]¶

从字典的字典（dod）格式创建一个 DDM。

参见

to_dod
sympy.polys.matrices.sdm.SDM.from_dod
sympy.polys.matrices.domainmatrix.DomainMatrix.from_dod

示例

>>> from sympy.polys.matrices.ddm import DDM
>>> from sympy import QQ
>>> dod = {0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}}
>>> A = DDM.from_dod(dod, (2, 2), QQ)
>>> A
[[1, 2], [3, 4]]

classmethod from_dok(dok, shape, domain)[源代码][源代码]¶

从键的字典（dok）格式创建一个 DDM。

参见

to_dok
sympy.polys.matrices.sdm.SDM.from_dok
sympy.polys.matrices.domainmatrix.DomainMatrix.from_dok

示例

>>> from sympy.polys.matrices.ddm import DDM
>>> from sympy import QQ
>>> dok = {(0, 0): 1, (0, 1): 2, (1, 0): 3, (1, 1): 4}
>>> A = DDM.from_dok(dok, (2, 2), QQ)
>>> A
[[1, 2], [3, 4]]

classmethod from_flat_nz(elements, data, domain)[源代码][源代码]¶

在调用 to_flat_nz() 之后重建 DDM。

参见

to_flat_nz
sympy.polys.matrices.sdm.SDM.from_flat_nz
sympy.polys.matrices.domainmatrix.DomainMatrix.from_flat_nz

示例

>>> from sympy.polys.matrices.ddm import DDM
>>> from sympy import QQ
>>> A = DDM([[1, 2], [3, 4]], (2, 2), QQ)
>>> elements, data = A.to_flat_nz()
>>> elements
[1, 2, 3, 4]
>>> A == DDM.from_flat_nz(elements, data, A.domain)
True

classmethod from_list(rowslist, shape, domain)[源代码][源代码]¶

从列表的列表创建一个 DDM。

参见

from_list_flat

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.ddm import DDM
>>> A = DDM.from_list([[ZZ(0), ZZ(1)], [ZZ(-1), ZZ(0)]], (2, 2), ZZ)
>>> A
[[0, 1], [-1, 0]]
>>> A == DDM([[ZZ(0), ZZ(1)], [ZZ(-1), ZZ(0)]], (2, 2), ZZ)
True

classmethod from_list_flat(flat, shape, domain)[源代码][源代码]¶

从元素的扁平列表创建一个 DDM。

参见

to_list_flat
sympy.polys.matrices.domainmatrix.DomainMatrix.from_list_flat

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices.ddm import DDM
>>> A = DDM.from_list_flat([1, 2, 3, 4], (2, 2), QQ)
>>> A
[[1, 2], [3, 4]]
>>> A == DDM.from_list_flat(A.to_list_flat(), A.shape, A.domain)
True

hstack(*B)[源代码][源代码]¶

水平堆叠 DDM 矩阵。

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.sdm import DDM

>>> A = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> B = DDM([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
>>> A.hstack(B)
[[1, 2, 5, 6], [3, 4, 7, 8]]

>>> C = DDM([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
>>> A.hstack(B, C)
[[1, 2, 5, 6, 9, 10], [3, 4, 7, 8, 11, 12]]

inv()[源代码][源代码]¶: 一个的逆

is_diagonal()[源代码][源代码]¶: 指示此矩阵是否为对角矩阵。即使矩阵不是方阵，也可能返回 True。

is_lower()[源代码][源代码]¶: 指示此矩阵是否为下三角矩阵。即使矩阵不是方阵，也可能返回 True。

is_upper()[源代码][源代码]¶: 指示此矩阵是否为上三角矩阵。即使矩阵不是方阵，也可能返回 True。

is_zero_matrix()[源代码][源代码]¶: 判断此矩阵是否所有元素均为零。

iter_items()[源代码][源代码]¶

遍历矩阵中非零元素的索引和值。

参见

iter_values
to_dok
sympy.polys.matrices.domainmatrix.DomainMatrix.iter_items

示例

>>> from sympy.polys.matrices.ddm import DDM
>>> from sympy import QQ
>>> A = DDM([[QQ(1), QQ(0)], [QQ(3), QQ(4)]], (2, 2), QQ)
>>> list(A.iter_items())
[((0, 0), 1), ((1, 0), 3), ((1, 1), 4)]

iter_values()[源代码][源代码]¶

遍历矩阵中的非零值。

参见

iter_items
to_list_flat
sympy.polys.matrices.domainmatrix.DomainMatrix.iter_values

示例

>>> from sympy.polys.matrices.ddm import DDM
>>> from sympy import QQ
>>> A = DDM([[QQ(1), QQ(0)], [QQ(3), QQ(4)]], (2, 2), QQ)
>>> list(A.iter_values())
[1, 3, 4]

lu()[源代码][源代码]¶: L, U 分解

lu_solve(b)[源代码][源代码]¶: x 其中 a*x = b

matmul(b)[源代码][源代码]¶: a @ b (矩阵乘积)

neg()[源代码][源代码]¶: -a

nnz()[源代码][源代码]¶

在 DDM 矩阵中非零条目的数量。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.nnz

nullspace()[源代码][源代码]¶

返回 a 的零空间的基础。

矩阵的域必须是一个域。

参见

rref
sympy.polys.matrices.domainmatrix.DomainMatrix.nullspace

nullspace_from_rref(pivots=None)[源代码][源代码]¶

从矩阵的简化行阶梯形式（rref）计算其零空间。

矩阵的域可以是任何域。

返回一个元组 (basis, nonpivots)。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.nullspace: 此函数的高级接口。

rref()[源代码][源代码]¶

a 的简化行阶梯形式和主元列表。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.rref: 此函数的高级接口。
sympy.polys.matrices.dense.ddm_irref: 底层算法。

rref_den()[源代码][源代码]¶

a 的简化行阶梯形式，带有分母和主元列表

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.rref_den: 此函数的高级接口。
sympy.polys.matrices.dense.ddm_irref_den: 底层算法。

scc()[源代码][源代码]¶

方阵 a 的强连通分量。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.scc

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.sdm import DDM
>>> A = DDM([[ZZ(1), ZZ(0)], [ZZ(0), ZZ(1)]], (2, 2), ZZ)
>>> A.scc()
[[0], [1]]

sub(b)[源代码][源代码]¶: a - b

to_ddm()[源代码][源代码]¶

转换为 DDM。

这仅仅返回 self ，但存在是为了与其他矩阵类型（如 SDM）中的相应方法保持一致。

参见

to_sdm
to_dfm
to_dfm_or_ddm
sympy.polys.matrices.sdm.SDM.to_ddm
sympy.polys.matrices.domainmatrix.DomainMatrix.to_ddm

to_dfm()[源代码][源代码]¶

转换为 DDM 到 DFM。

参见

DFM
sympy.polys.matrices._dfm.DFM.to_ddm

示例

>>> from sympy.polys.matrices.ddm import DDM
>>> from sympy import QQ
>>> A = DDM([[1, 2], [3, 4]], (2, 2), QQ)
>>> A.to_dfm()
[[1, 2], [3, 4]]
>>> type(A.to_dfm())
<class 'sympy.polys.matrices._dfm.DFM'>

to_dfm_or_ddm()[源代码][源代码]¶

如果可能，转换为 DFM ，否则返回自身。

参见

to_dfm
to_ddm
sympy.polys.matrices.domainmatrix.DomainMatrix.to_dfm_or_ddm

示例

>>> from sympy.polys.matrices.ddm import DDM
>>> from sympy import QQ
>>> A = DDM([[1, 2], [3, 4]], (2, 2), QQ)
>>> A.to_dfm_or_ddm()
[[1, 2], [3, 4]]
>>> type(A.to_dfm_or_ddm())
<class 'sympy.polys.matrices._dfm.DFM'>

to_dod()[源代码][源代码]¶

转换为字典的字典（dod）格式。

参见

from_dod
sympy.polys.matrices.sdm.SDM.to_dod
sympy.polys.matrices.domainmatrix.DomainMatrix.to_dod

示例

>>> from sympy.polys.matrices.ddm import DDM
>>> from sympy import QQ
>>> A = DDM([[1, 2], [3, 4]], (2, 2), QQ)
>>> A.to_dod()
{0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}}

to_dok()[源代码][源代码]¶

将 DDM 转换为键字典 (dok) 格式。

参见

from_dok
sympy.polys.matrices.sdm.SDM.to_dok
sympy.polys.matrices.domainmatrix.DomainMatrix.to_dok

示例

>>> from sympy.polys.matrices.ddm import DDM
>>> from sympy import QQ
>>> A = DDM([[1, 2], [3, 4]], (2, 2), QQ)
>>> A.to_dok()
{(0, 0): 1, (0, 1): 2, (1, 0): 3, (1, 1): 4}

to_flat_nz()[源代码][源代码]¶

转换为非零元素和数据的扁平列表。

参见

from_flat_nz
sympy.polys.matrices.sdm.SDM.to_flat_nz
sympy.polys.matrices.domainmatrix.DomainMatrix.to_flat_nz

示例

>>> from sympy.polys.matrices.ddm import DDM
>>> from sympy import QQ
>>> A = DDM([[1, 2], [3, 4]], (2, 2), QQ)
>>> elements, data = A.to_flat_nz()
>>> elements
[1, 2, 3, 4]
>>> A == DDM.from_flat_nz(elements, data, A.domain)
True

to_list()[源代码][源代码]¶

转换为列表的列表。

参见

to_list_flat
sympy.polys.matrices.domainmatrix.DomainMatrix.to_list

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices.ddm import DDM
>>> A = DDM([[1, 2], [3, 4]], (2, 2), QQ)
>>> A.to_list()
[[1, 2], [3, 4]]

to_list_flat()[源代码][源代码]¶

转换为元素的扁平列表。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.to_list_flat

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices.ddm import DDM
>>> A = DDM([[1, 2], [3, 4]], (2, 2), QQ)
>>> A.to_list_flat()
[1, 2, 3, 4]
>>> A == DDM.from_list_flat(A.to_list_flat(), A.shape, A.domain)
True

to_sdm()[源代码][源代码]¶

转换为 SDM。

参见

SDM
sympy.polys.matrices.sdm.SDM.to_ddm

示例

>>> from sympy.polys.matrices.ddm import DDM
>>> from sympy import QQ
>>> A = DDM([[1, 2], [3, 4]], (2, 2), QQ)
>>> A.to_sdm()
{0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}}
>>> type(A.to_sdm())
<class 'sympy.polys.matrices.sdm.SDM'>

vstack(*B)[源代码][源代码]¶

垂直堆叠 DDM 矩阵。

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.sdm import DDM

>>> A = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> B = DDM([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
>>> A.vstack(B)
[[1, 2], [3, 4], [5, 6], [7, 8]]

>>> C = DDM([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
>>> A.vstack(B, C)
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]]

用于操作列表矩阵表示中矩阵的 ddm_* 例程的模块。

这些例程由 DDM 类在内部使用，该类还为它们提供了一个更友好的接口。这里的想法是以一种可以应用于任何简单列表表示的方式来实现核心矩阵例程，而无需使用任何特定的矩阵类。例如，我们可以计算矩阵的 RREF 如下：

>>> from sympy.polys.matrices.dense import ddm_irref
>>> M = [[1, 2, 3], [4, 5, 6]]
>>> pivots = ddm_irref(M)
>>> M
[[1.0, 0.0, -1.0], [0, 1.0, 2.0]]

这些是较低级别的例程，主要在原地工作。这个级别的例程不需要知道元素的域是什么，但理想情况下应该记录它们将使用哪些操作以及需要提供哪些函数。

下一级是 DDM 类，它使用这些例程，但通过一个处理复制等操作并跟踪矩阵元素域的接口来封装它们：

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.matrices.ddm import DDM
>>> M = DDM([[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)]], (2, 3), QQ)
>>> M
[[1, 2, 3], [4, 5, 6]]
>>> Mrref, pivots = M.rref()
>>> Mrref
[[1, 0, -1], [0, 1, 2]]

sympy.polys.matrices.dense.ddm_berk(M, K)[源代码][源代码]¶

计算特征多项式的Berkowitz算法。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.charpoly: 此函数的高级接口。

参考文献

[1]

https://en.wikipedia.org/wiki/Samuelson%E2%80%93Berkowitz_algorithm

示例

>>> from sympy import Matrix
>>> from sympy.polys.matrices.dense import ddm_berk
>>> from sympy.polys.domains import ZZ
>>> M = [[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]]
>>> ddm_berk(M, ZZ)
[[1], [-5], [-2]]
>>> Matrix(M).charpoly()
PurePoly(lambda**2 - 5*lambda - 2, lambda, domain='ZZ')

sympy.polys.matrices.dense.ddm_iadd( a: list[list[R]], b: Sequence[Sequence[R]], ) → None[源代码][源代码]¶: a += b

sympy.polys.matrices.dense.ddm_idet(a, K)[源代码][源代码]¶

a <– 阶梯化(a); 返回行列式

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.det

参考文献

[1]

https://en.wikipedia.org/wiki/Bareiss_algorithm

[2]

https://www.math.usm.edu/perry/Research/Thesis_DRL.pdf

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.ddm import ddm_idet
>>> a = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(4), ZZ(5), ZZ(6)], [ZZ(7), ZZ(8), ZZ(9)]]
>>> a
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ddm_idet(a, ZZ)
0
>>> a
[[1, 2, 3], [4, -3, -6], [7, -6, 0]]
>>> [a[i][i] for i in range(len(a))]
[1, -3, 0]

sympy.polys.matrices.dense.ddm_iinv(ainv, a, K)[源代码][源代码]¶

ainv <– inv(a)

使用高斯-约旦消元法计算矩阵 $a$ 在域 $K$ 上的逆。结果存储在 $ainv$ 中。

在应为精确域的地面域中使用除法。

参见

ddm_irref: 底层例程。

示例

>>> from sympy.polys.matrices.ddm import ddm_iinv, ddm_imatmul
>>> from sympy import QQ
>>> a = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
>>> ainv = [[None, None], [None, None]]
>>> ddm_iinv(ainv, a, QQ)
>>> ainv
[[-2, 1], [3/2, -1/2]]
>>> result = [[QQ(0), QQ(0)], [QQ(0), QQ(0)]]
>>> ddm_imatmul(result, a, ainv)
>>> result
[[1, 0], [0, 1]]

sympy.polys.matrices.dense.ddm_ilu(a)[源代码][源代码]¶

a <– LU(a)

就地计算矩阵的LU分解。返回执行的行交换列表。

在应为精确域的地面域中使用除法。

这仅适用于 GF(p)、QQ、QQ_I 和 QQ<a> 等域。对于像 K(x) 这样的有理函数域，最好清除分母并使用无除法算法。使用枢轴操作来避免精确的零，但不用于浮点精度，因此 RR 和 CC 不适用（请改用 ddm_irref()）。

参见

ddm_irref
ddm_ilu_solve
sympy.matrices.matrixbase.MatrixBase.LUdecomposition

示例

>>> from sympy.polys.matrices.dense import ddm_ilu
>>> from sympy import QQ
>>> a = [[QQ(1, 2), QQ(1, 3)], [QQ(1, 4), QQ(1, 5)]]
>>> swaps = ddm_ilu(a)
>>> swaps
[]
>>> a
[[1/2, 1/3], [1/2, 1/30]]

使用 Matrix 的相同示例：

>>> from sympy import Matrix, S
>>> M = Matrix([[S(1)/2, S(1)/3], [S(1)/4, S(1)/5]])
>>> L, U, swaps = M.LUdecomposition()
>>> L
Matrix([
[  1, 0],
[1/2, 1]])
>>> U
Matrix([
[1/2,  1/3],
[  0, 1/30]])
>>> swaps
[]

sympy.polys.matrices.dense.ddm_ilu_solve(x, L, U, swaps, b)[源代码][源代码]¶

x <– solve(L*U*x = swaps(b))

求解线性系统，$A*x = b$，给定 $A$ 的 LU 分解。

在必须是域的地面域中使用除法。

原地修改 $x$。

参见

ddm_ilu: 就地计算矩阵的LU分解。
ddm_ilu_split: 计算矩阵的LU分解并分离$L$和$U$。
sympy.polys.matrices.domainmatrix.DomainMatrix.lu_solve: 此函数的高级接口。

示例

计算矩阵 $A$ 的 LU 分解（就地）：

>>> from sympy import QQ
>>> from sympy.polys.matrices.dense import ddm_ilu, ddm_ilu_solve
>>> A = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
>>> swaps = ddm_ilu(A)
>>> A
[[1, 2], [3, -2]]
>>> L = U = A

求解线性系统：

>>> b = [[QQ(5)], [QQ(6)]]
>>> x = [[None], [None]]
>>> ddm_ilu_solve(x, L, U, swaps, b)
>>> x
[[-4], [9/2]]

sympy.polys.matrices.dense.ddm_ilu_split(L, U, K)[源代码][源代码]¶

L, U <– LU(U)

计算矩阵 $L$ 的 LU 分解，并在原地存储下三角矩阵和上三角矩阵分别为 $L$ 和 $U$。返回执行的行交换列表。

在应为精确域的地面域中使用除法。

参见

ddm_ilu
ddm_ilu_solve

示例

>>> from sympy.polys.matrices.ddm import ddm_ilu_split
>>> from sympy import QQ
>>> L = [[QQ(0), QQ(0)], [QQ(0), QQ(0)]]
>>> U = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
>>> swaps = ddm_ilu_split(L, U, QQ)
>>> swaps
[]
>>> L
[[0, 0], [3, 0]]
>>> U
[[1, 2], [0, -2]]

sympy.polys.matrices.dense.ddm_imatmul( a: list[list[R]], b: Sequence[Sequence[R]], c: Sequence[Sequence[R]], ) → None[源代码][源代码]¶: a += b @ c

sympy.polys.matrices.dense.ddm_imul(a: list[list[R]], b: R) → None[源代码][源代码]¶: a <– a*b

sympy.polys.matrices.dense.ddm_ineg(a: list[list[R]]) → None[源代码][源代码]¶: a <– -a

sympy.polys.matrices.dense.ddm_irmul(a: list[list[R]], b: R) → None[源代码][源代码]¶: a <– b*a

sympy.polys.matrices.dense.ddm_irref(a, _partial_pivot=False)[源代码][源代码]¶

矩阵的就地简化行阶梯形式。

计算 $a$ 的简化行阶梯形式。原地修改 $a$ 并返回主元列的列表。

在基础域中使用朴素的高斯-若尔当消去法，该基础域必须是一个域。

这个例程只真正适合用于简单的字段域，如 GF(p)、QQ 和 QQ<a>，尽管对于更大的矩阵，即使是 QQ，使用无分数的方法可能更高效。

此方法不适用于有理函数域 (K(x)) ，因为元素会膨胀，导致代价高昂的 gcd 运算。在这种情况下，清除分母并使用无分数的方法可能会更有效。

对于像 RR 和 CC 这样的非精确数值域，传递 _partial_pivot=True 以使用部分旋转来控制舍入误差。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.rref: 此例程的高级接口。
ddm_irref_den: 此例程的无分数版本。
sdm_irref: 此例程的稀疏版本。

参考文献

[1]

https://en.wikipedia.org/wiki/Row_echelon_form#Reduced_row_echelon_form

示例

>>> from sympy.polys.matrices.dense import ddm_irref
>>> from sympy import QQ
>>> M = [[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)]]
>>> pivots = ddm_irref(M)
>>> M
[[1, 0, -1], [0, 1, 2]]
>>> pivots
[0, 1]

sympy.polys.matrices.dense.ddm_irref_den(a, K)[源代码][源代码]¶

a <– rref(a); return (den, pivots)

计算 $a$ 的无分数简化行阶梯形式（RREF）。原地修改 $a$ 并返回一个包含 RREF 的分母和主元列列表的元组。

参见

ddm_irref: 使用字段划分的此例程的版本。
sdm_irref: 稀疏版本的 ddm_irref()。
sdm_rref_den: 稀疏版本的 ddm_irref_den()。
sympy.polys.matrices.domainmatrix.DomainMatrix.rref_den: 更高级别的接口。

参考文献

[1]

Fraction-free 算法用于线性和多项式方程。George C. Nakos, Peter R. Turner, Robert M. Williams. https://dl.acm.org/doi/10.1145/271130.271133

示例

>>> from sympy.polys.matrices.dense import ddm_irref_den
>>> from sympy import ZZ, Matrix
>>> M = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(4), ZZ(5), ZZ(6)]]
>>> den, pivots = ddm_irref_den(M, ZZ)
>>> M
[[-3, 0, 3], [0, -3, -6]]
>>> den
-3
>>> pivots
[0, 1]
>>> Matrix(M).rref()[0]
Matrix([
[1, 0, -1],
[0, 1,  2]])

sympy.polys.matrices.dense.ddm_isub( a: list[list[R]], b: Sequence[Sequence[R]], ) → None[源代码][源代码]¶: a -= b

sympy.polys.matrices.dense.ddm_transpose( matrix: Sequence[Sequence[T]], ) → list[list[T]][源代码][源代码]¶: 矩阵转置

class sympy.polys.matrices._typing.RingElement(*args, **kwargs)[源代码][源代码]¶

一个环元素。

必须支持 +, -, *, ** 和 -。

SDM 类的模块。

class sympy.polys.matrices.sdm.SDM(elemsdict, shape, domain)[源代码][源代码]¶

基于多项式域元素的稀疏矩阵

这是一个字典子类，并且是一个字典的字典的包装器，支持基本的矩阵算术 +, -, , *。

为了创建一个新的 SDM ，需要一个字典的字典，将非零元素映射到矩阵中的对应行和列。

我们还需要指定 SDM 对象的形状和 Domain。

我们声明一个属于 QQ 域的 2x2 SDM 矩阵，如下所示。示例中的 2x2 矩阵是

\[\begin{split}A = \left[\begin{array}{ccc} 0 & \frac{1}{2} \\ 0 & 0 \end{array} \right]\end{split}\]

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> elemsdict = {0:{1:QQ(1, 2)}}
>>> A = SDM(elemsdict, (2, 2), QQ)
>>> A
{0: {1: 1/2}}

我们可以像操作矩阵类一样操作 SDM

>>> from sympy import ZZ
>>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
>>> B  = SDM({0:{0: ZZ(3)}, 1:{1:ZZ(4)}}, (2, 2), ZZ)
>>> A + B
{0: {0: 3, 1: 2}, 1: {0: 1, 1: 4}}

乘法

>>> A*B
{0: {1: 8}, 1: {0: 3}}
>>> A*ZZ(2)
{0: {1: 4}, 1: {0: 2}}

方法

`add`(B)	添加两个 `SDM` 矩阵
`charpoly`()	返回 `SDM` 矩阵的特征多项式的系数。
`clear`()
`convert_to`(K)	将 `SDM` 矩阵的 `Domain` 转换为 K
`copy`()	返回一个 `SDM` 对象的副本
`det`()	返回 A 的行列式
`diagonal`()	返回矩阵的对角线作为一个列表。
`eye`(shape, domain)	返回一个维度为 size x size 的单位 `SDM` 矩阵，属于指定的域
`from_ddm`(ddm)	从 `DDM` 创建 `SDM`。
`from_dod`(dod, shape, domain)	从字典的字典（dod）格式创建 `SDM`。
`from_dok`(dok, shape, domain)	从字典（dok）格式创建 `SDM`。
`from_flat_nz`(elements, data, domain)	在调用 `to_flat_nz()` 之后重建 `SDM`。
`from_list`(ddm, shape, domain)	从列表的列表创建 `SDM` 对象。
`from_list_flat`(elements, shape, domain)	从元素的扁平列表创建 `SDM`。
`fromkeys`(iterable[, value])	使用可迭代对象中的键创建一个新字典，并将值设置为指定的值。
`get`(key[, default])	如果字典中存在键，则返回键的值，否则返回默认值。
`hstack`(*B)	水平堆叠 `SDM` 矩阵。
`inv`()	返回矩阵 A 的逆矩阵
`is_diagonal`()	指示此矩阵是否为对角矩阵。
`is_lower`()	指示此矩阵是否为下三角矩阵。
`is_upper`()	指示此矩阵是否为上三角矩阵。
`is_zero_matrix`()	判断此矩阵是否所有元素均为零。
`items`()
`iter_items`()	遍历非零元素的索引和值。
`iter_values`()	遍历 `SDM` 矩阵的非零值。
`keys`()
`lll`([delta])	返回 `SDM` 矩阵的 LLL 约化基。
`lll_transform`([delta])	返回LLL约化基和变换矩阵。
`lu`()	返回矩阵 A 的 LU 分解
`lu_solve`(b)	使用LU分解来求解Ax = b，
`matmul`(B)	对两个SDM矩阵执行矩阵乘法
`mul`(b)	将 A 中的每个元素与标量 b 相乘
`neg`()	返回 `SDM` 矩阵的负值
`new`(sdm, shape, domain)
`nnz`()	在 `SDM` 矩阵中非零元素的数量。
`nullspace`()	矩阵 A 的 `SDM` 的零空间。
`nullspace_from_rref`([pivots])	返回 `SDM` 矩阵 `A` 在 RREF 中的零空间。
`pop`(key[, default])	如果未找到键，则返回给定的默认值；否则，引发 KeyError。
`popitem`(/)	移除并返回一个 (键, 值) 对作为 2-tuple。
`rref`()	返回 `SDM` 的简化行阶梯形式和主元列表。
`rref_den`()	返回简化行阶梯形式（RREF）及其分母和主元。
`scc`()	方阵 A 的强连通分量。
`setdefault`(key[, default])	如果字典中不存在键，则插入键并赋予默认值。
`sub`(B)	减去两个 `SDM` 矩阵
`to_ddm`()	将 `SDM` 对象转换为 `DDM` 对象
`to_dfm`()	将 `SDM` 对象转换为 `DFM` 对象
`to_dfm_or_ddm`()	如果可能，转换为 `DFM`，否则转换为 `DDM`。
`to_dod`()	转换为字典的字典（dod）格式。
`to_dok`()	转换为键字典（dok）格式。
`to_flat_nz`()	将 `SDM` 转换为非零元素和数据的扁平列表。
`to_list`()	将 `SDM` 对象转换为列表的列表。
`to_list_flat`()	将 `SDM` 转换为扁平列表。
`to_sdm`()	转换为 `SDM` 格式（返回自身）。
`transpose`()	返回一个 `SDM` 矩阵的转置
`update`([E, ]**F)	如果 E 存在且有 .keys() 方法，则执行： for k in E: D[k] = E[k] 如果 E 存在但没有 .keys() 方法，则执行： for k, v in E: D[k] = v 在任何一种情况下，之后都会执行： for k in F: D[k] = F[k]
`values`()
`vstack`(*B)	垂直堆叠 `SDM` 矩阵。
`zeros`(shape, domain)	返回一个指定形状的 `SDM` ，属于指定的域

applyfunc
diag
提取
提取切片
getitem
mul_elementwise
ones
特定
rmul
setitem

add(B)[源代码][源代码]¶

添加两个 SDM 矩阵

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
>>> B = SDM({0:{0: ZZ(3)}, 1:{1:ZZ(4)}}, (2, 2), ZZ)
>>> A.add(B)
{0: {0: 3, 1: 2}, 1: {0: 1, 1: 4}}

charpoly()[源代码][源代码]¶

返回 SDM 矩阵的特征多项式的系数。这些元素将是域元素。元素的域将与 SDM 的域相同。

示例

>>> from sympy import QQ, Symbol
>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy.polys import Poly
>>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
>>> A.charpoly()
[1, -5, -2]

我们可以使用系数通过 Poly 创建一个多项式

>>> x = Symbol('x')
>>> p = Poly(A.charpoly(), x, domain=A.domain)
>>> p
Poly(x**2 - 5*x - 2, x, domain='QQ')

convert_to(K)[源代码][源代码]¶

将 SDM 矩阵的 Domain 转换为 K

示例

>>> from sympy import ZZ, QQ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
>>> A.convert_to(QQ)
{0: {1: 2}, 1: {0: 1}}

copy()[源代码][源代码]¶

返回一个 SDM 对象的副本

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> elemsdict = {0:{1:QQ(2)}, 1:{}}
>>> A = SDM(elemsdict, (2, 2), QQ)
>>> B = A.copy()
>>> B
{0: {1: 2}, 1: {}}

det()[源代码][源代码]¶

返回 A 的行列式

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
>>> A.det()
-2

diagonal()[源代码][源代码]¶: 返回矩阵的对角线作为一个列表。

classmethod eye(shape, domain)[源代码][源代码]¶

返回一个维度为 size x size 的单位 SDM 矩阵，属于指定的域

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> I = SDM.eye((2, 2), QQ)
>>> I
{0: {0: 1}, 1: {1: 1}}

classmethod from_ddm(ddm)[源代码][源代码]¶

从 DDM 创建 SDM。

参见

to_ddm
from_list
from_list_flat
from_dok

示例

>>> from sympy.polys.matrices.ddm import DDM
>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> ddm = DDM( [[QQ(1, 2), 0], [0, QQ(3, 4)]], (2, 2), QQ)
>>> A = SDM.from_ddm(ddm)
>>> A
{0: {0: 1/2}, 1: {1: 3/4}}
>>> SDM.from_ddm(ddm).to_ddm() == ddm
True

classmethod from_dod(dod, shape, domain)[源代码][源代码]¶

从字典的字典（dod）格式创建 SDM。

参见

to_dod
sympy.polys.matrices.domainmatrix.DomainMatrix.to_dod

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> dod = {0: {1: QQ(2)}, 1: {0: QQ(3)}}
>>> A = SDM.from_dod(dod, (2, 2), QQ)
>>> A
{0: {1: 2}, 1: {0: 3}}
>>> A == SDM.from_dod(A.to_dod(), A.shape, A.domain)
True

classmethod from_dok(dok, shape, domain)[源代码][源代码]¶

从字典（dok）格式创建 SDM。

参见

to_dok
from_list
from_list_flat
from_ddm

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> dok = {(0, 1): QQ(2), (1, 0): QQ(3)}
>>> A = SDM.from_dok(dok, (2, 2), QQ)
>>> A
{0: {1: 2}, 1: {0: 3}}
>>> A == SDM.from_dok(A.to_dok(), A.shape, A.domain)
True

classmethod from_flat_nz(elements, data, domain)[源代码][源代码]¶

在调用 to_flat_nz() 之后重建 SDM。

参见 to_flat_nz() 以获取解释。

参见

to_flat_nz
from_list_flat
sympy.polys.matrices.ddm.DDM.from_flat_nz
sympy.polys.matrices.domainmatrix.DomainMatrix.from_flat_nz

classmethod from_list(ddm, shape, domain)[源代码][源代码]¶

从列表的列表创建 SDM 对象。

参数:

ddm:: 包含域元素的列表列表
形状：: Dimensions of SDM matrix
领域:: 表示 SDM 对象的 Domain

返回:

SDM 包含 ddm 的元素

参见

to_list
from_list_flat
from_dok
from_ddm

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> ddm = [[QQ(1, 2), QQ(0)], [QQ(0), QQ(3, 4)]]
>>> A = SDM.from_list(ddm, (2, 2), QQ)
>>> A
{0: {0: 1/2}, 1: {1: 3/4}}

classmethod from_list_flat(elements, shape, domain)[源代码][源代码]¶

从元素的扁平列表创建 SDM。

参见

to_list_flat
from_list
from_dok
from_ddm

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> A = SDM.from_list_flat([QQ(0), QQ(2), QQ(0), QQ(0)], (2, 2), QQ)
>>> A
{0: {1: 2}}
>>> A == A.from_list_flat(A.to_list_flat(), A.shape, A.domain)
True

hstack(*B)[源代码][源代码]¶

水平堆叠 SDM 矩阵。

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.sdm import SDM

>>> A = SDM({0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}}, (2, 2), ZZ)
>>> B = SDM({0: {0: ZZ(5), 1: ZZ(6)}, 1: {0: ZZ(7), 1: ZZ(8)}}, (2, 2), ZZ)
>>> A.hstack(B)
{0: {0: 1, 1: 2, 2: 5, 3: 6}, 1: {0: 3, 1: 4, 2: 7, 3: 8}}

>>> C = SDM({0: {0: ZZ(9), 1: ZZ(10)}, 1: {0: ZZ(11), 1: ZZ(12)}}, (2, 2), ZZ)
>>> A.hstack(B, C)
{0: {0: 1, 1: 2, 2: 5, 3: 6, 4: 9, 5: 10}, 1: {0: 3, 1: 4, 2: 7, 3: 8, 4: 11, 5: 12}}

inv()[源代码][源代码]¶

返回矩阵 A 的逆矩阵

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
>>> A.inv()
{0: {0: -2, 1: 1}, 1: {0: 3/2, 1: -1/2}}

is_diagonal()[源代码][源代码]¶: 指示此矩阵是否为对角矩阵。即使矩阵不是方阵，也可能返回 True。

is_lower()[源代码][源代码]¶: 指示此矩阵是否为下三角矩阵。即使矩阵不是方阵，也可能返回 True。

is_upper()[源代码][源代码]¶: 指示此矩阵是否为上三角矩阵。即使矩阵不是方阵，也可能返回 True。

is_zero_matrix()[源代码][源代码]¶: 判断此矩阵是否所有元素均为零。

iter_items()[源代码][源代码]¶

遍历非零元素的索引和值。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.iter_items

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> A = SDM({0: {1: QQ(2)}, 1: {0: QQ(3)}}, (2, 2), QQ)
>>> list(A.iter_items())
[((0, 1), 2), ((1, 0), 3)]

iter_values()[源代码][源代码]¶

遍历 SDM 矩阵的非零值。

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> A = SDM({0: {1: QQ(2)}, 1: {0: QQ(3)}}, (2, 2), QQ)
>>> list(A.iter_values())
[2, 3]

lll(delta=MPQ(3, 4))[源代码][源代码]¶: 返回 SDM 矩阵的 LLL 约化基。

lll_transform(delta=MPQ(3, 4))[源代码][源代码]¶: 返回LLL约化基和变换矩阵。

lu()[源代码][源代码]¶

返回矩阵 A 的 LU 分解

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
>>> A.lu()
({0: {0: 1}, 1: {0: 3, 1: 1}}, {0: {0: 1, 1: 2}, 1: {1: -2}}, [])

lu_solve(b)[源代码][源代码]¶

使用LU分解来求解Ax = b，

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
>>> b = SDM({0:{0:QQ(1)}, 1:{0:QQ(2)}}, (2, 1), QQ)
>>> A.lu_solve(b)
{1: {0: 1/2}}

matmul(B)[源代码][源代码]¶

对两个SDM矩阵执行矩阵乘法

参数:

A, B: 要相乘的SDM

返回:

SDM: 乘法后的SDM

Raises:

领域错误: 如果 A 的域与 B 的域不匹配

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
>>> B = SDM({0:{0:ZZ(2), 1:ZZ(3)}, 1:{0:ZZ(4)}}, (2, 2), ZZ)
>>> A.matmul(B)
{0: {0: 8}, 1: {0: 2, 1: 3}}

mul(b)[源代码][源代码]¶

将 A 中的每个元素与标量 b 相乘

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
>>> A.mul(ZZ(3))
{0: {1: 6}, 1: {0: 3}}

neg()[源代码][源代码]¶

返回 SDM 矩阵的负值

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
>>> A.neg()
{0: {1: -2}, 1: {0: -1}}

classmethod new(sdm, shape, domain)[源代码][源代码]¶

参数:

sdm: 用于非零元素的SDM的字典的字典
shape: 表示SDM维度的元组
domain: 表示 SDM 的 :py:class:`~.Domain`

返回:

一个 SDM 对象

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> elemsdict = {0:{1: QQ(2)}}
>>> A = SDM.new(elemsdict, (2, 2), QQ)
>>> A
{0: {1: 2}}

nnz()[源代码][源代码]¶

在 SDM 矩阵中非零元素的数量。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.nnz

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
>>> A.nnz()
2

nullspace()[源代码][源代码]¶

矩阵 A 的 SDM 的零空间。

矩阵的域必须是一个域。

最好使用 nullspace() 方法，而不是这个不再使用的方法。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.nullspace: 获取矩阵零空间的首选方法。

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0: QQ(2), 1: QQ(4)}}, (2, 2), QQ)
>>> A.nullspace()
({0: {0: -2, 1: 1}}, [1])

nullspace_from_rref(pivots=None)[源代码][源代码]¶

返回 SDM 矩阵 A 在 RREF 中的零空间。

矩阵的域可以是任何域。

矩阵必须已经是简化行阶梯形式（RREF）。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.nullspace: 通常会调用的高级函数，而不是直接调用这个函数。
sympy.polys.matrices.domainmatrix.DomainMatrix.nullspace_from_rref: 此函数的更高级别的直接等效函数。
sympy.polys.matrices.ddm.DDM.nullspace_from_rref: 密集 DDM 矩阵的等效函数。

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0: QQ(2), 1: QQ(4)}}, (2, 2), QQ)
>>> A_rref, pivots = A.rref()
>>> A_null, nonpivots = A_rref.nullspace_from_rref(pivots)
>>> A_null
{0: {0: -2, 1: 1}}
>>> pivots
[0]
>>> nonpivots
[1]

rref()[源代码][源代码]¶

返回 SDM 的简化行阶梯形式和主元列表。

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(2), 1:QQ(4)}}, (2, 2), QQ)
>>> A.rref()
({0: {0: 1, 1: 2}}, [0])

rref_den()[源代码][源代码]¶

返回简化行阶梯形式（RREF）及其分母和主元。

示例

>>> from sympy import QQ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(2), 1:QQ(4)}}, (2, 2), QQ)
>>> A.rref_den()
({0: {0: 1, 1: 2}}, 1, [0])

scc()[源代码][源代码]¶

方阵 A 的强连通分量。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.scc

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{0: ZZ(2)}, 1:{1:ZZ(1)}}, (2, 2), ZZ)
>>> A.scc()
[[0], [1]]

sub(B)[源代码][源代码]¶

减去两个 SDM 矩阵

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.sdm import SDM
>>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
>>> B  = SDM({0:{0: ZZ(3)}, 1:{1:ZZ(4)}}, (2, 2), ZZ)
>>> A.sub(B)
{0: {0: -3, 1: 2}, 1: {0: 1, 1: -4}}

to_ddm()[源代码][源代码]¶

将 SDM 对象转换为 DDM 对象

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> A = SDM({0:{1:QQ(2)}, 1:{}}, (2, 2), QQ)
>>> A.to_ddm()
[[0, 2], [0, 0]]

to_dfm()[源代码][源代码]¶

将 SDM 对象转换为 DFM 对象

参见

to_ddm
to_dfm_or_ddm
sympy.polys.matrices.domainmatrix.DomainMatrix.to_dfm

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> A = SDM({0:{1:QQ(2)}, 1:{}}, (2, 2), QQ)
>>> A.to_dfm()
[[0, 2], [0, 0]]

to_dfm_or_ddm()[源代码][源代码]¶

如果可能，转换为 DFM，否则转换为 DDM。

参见

to_ddm
to_dfm
sympy.polys.matrices.domainmatrix.DomainMatrix.to_dfm_or_ddm

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> A = SDM({0:{1:QQ(2)}, 1:{}}, (2, 2), QQ)
>>> A.to_dfm_or_ddm()
[[0, 2], [0, 0]]
>>> type(A.to_dfm_or_ddm())  # depends on the ground types
<class 'sympy.polys.matrices._dfm.DFM'>

to_dod()[源代码][源代码]¶

转换为字典的字典（dod）格式。

参见

from_dod
sympy.polys.matrices.domainmatrix.DomainMatrix.to_dod

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> A = SDM({0: {1: QQ(2)}, 1: {0: QQ(3)}}, (2, 2), QQ)
>>> A.to_dod()
{0: {1: 2}, 1: {0: 3}}

to_dok()[源代码][源代码]¶

转换为键字典（dok）格式。

参见

from_dok
to_list
to_list_flat
to_ddm

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> A = SDM({0: {1: QQ(2)}, 1: {0: QQ(3)}}, (2, 2), QQ)
>>> A.to_dok()
{(0, 1): 2, (1, 0): 3}

to_flat_nz()[源代码][源代码]¶

将 SDM 转换为非零元素和数据的扁平列表。

参见

from_flat_nz
to_list_flat
sympy.polys.matrices.ddm.DDM.to_flat_nz
sympy.polys.matrices.domainmatrix.DomainMatrix.to_flat_nz

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> A = SDM({0:{1:QQ(2)}, 1:{0: QQ(3)}}, (2, 2), QQ)
>>> elements, data = A.to_flat_nz()
>>> elements
[2, 3]
>>> A == A.from_flat_nz(elements, data, A.domain)
True

to_list()[源代码][源代码]¶

将 SDM 对象转换为列表的列表。

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> elemsdict = {0:{1:QQ(2)}, 1:{}}
>>> A = SDM(elemsdict, (2, 2), QQ)
>>> A.to_list()
[[0, 2], [0, 0]]

to_list_flat()[源代码][源代码]¶

将 SDM 转换为扁平列表。

参见

from_list_flat
to_list
to_dok
to_ddm

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> A = SDM({0:{1:QQ(2)}, 1:{0: QQ(3)}}, (2, 2), QQ)
>>> A.to_list_flat()
[0, 2, 3, 0]
>>> A == A.from_list_flat(A.to_list_flat(), A.shape, A.domain)
True

to_sdm()[源代码][源代码]¶: 转换为 SDM 格式（返回自身）。

transpose()[源代码][源代码]¶

返回一个 SDM 矩阵的转置

示例

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> A = SDM({0:{1:QQ(2)}, 1:{}}, (2, 2), QQ)
>>> A.transpose()
{1: {0: 2}}

vstack(*B)[源代码][源代码]¶

垂直堆叠 SDM 矩阵。

示例

>>> from sympy import ZZ
>>> from sympy.polys.matrices.sdm import SDM

>>> A = SDM({0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}}, (2, 2), ZZ)
>>> B = SDM({0: {0: ZZ(5), 1: ZZ(6)}, 1: {0: ZZ(7), 1: ZZ(8)}}, (2, 2), ZZ)
>>> A.vstack(B)
{0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}, 2: {0: 5, 1: 6}, 3: {0: 7, 1: 8}}

>>> C = SDM({0: {0: ZZ(9), 1: ZZ(10)}, 1: {0: ZZ(11), 1: ZZ(12)}}, (2, 2), ZZ)
>>> A.vstack(B, C)
{0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}, 2: {0: 5, 1: 6}, 3: {0: 7, 1: 8}, 4: {0: 9, 1: 10}, 5: {0: 11, 1: 12}}

classmethod zeros(shape, domain)[源代码][源代码]¶

返回一个指定形状的 SDM ，属于指定的域

在下面的示例中，我们声明了一个矩阵 A，其中，

\[\begin{split}A := \left[\begin{array}{ccc} 0 & 0 & 0 \\ 0 & 0 & 0 \end{array} \right]\end{split}\]

>>> from sympy.polys.matrices.sdm import SDM
>>> from sympy import QQ
>>> A = SDM.zeros((2, 3), QQ)
>>> A
{}

sympy.polys.matrices.sdm.sdm_berk(M, n, K)[源代码][源代码]¶

计算特征多项式的Berkowitz算法。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.charpoly: 此函数的高级接口。
sympy.polys.matrices.dense.ddm_berk: 该函数的密集版本。

参考文献

[1]

https://en.wikipedia.org/wiki/Samuelson%E2%80%93Berkowitz_algorithm

示例

>>> from sympy import Matrix
>>> from sympy.polys.matrices.sdm import sdm_berk
>>> from sympy.polys.domains import ZZ
>>> M = {0: {0: ZZ(1), 1:ZZ(2)}, 1: {0:ZZ(3), 1:ZZ(4)}}
>>> sdm_berk(M, 2, ZZ)
{0: 1, 1: -5, 2: -2}
>>> Matrix([[1, 2], [3, 4]]).charpoly()
PurePoly(lambda**2 - 5*lambda - 2, lambda, domain='ZZ')

sympy.polys.matrices.sdm.sdm_irref(A)[源代码][源代码]¶

稀疏矩阵 A 的 RREF 和枢轴。

计算矩阵 A 的简化行阶梯形式（RREF）并返回主元列的列表。此例程不会在原地操作，原始矩阵 A 保持不变。

矩阵的域必须是一个域。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.rref: 通常用于调用此例程的高级函数。
sympy.polys.matrices.dense.ddm_irref: 此例程的密集等效项。
sdm_rref_den: 此例程的无分数版本。

注释

该算法的成本完全由矩阵中的非零元素决定。该算法中任何步骤的成本都不依赖于矩阵的行数或列数。即使是在这些行上的主循环，也没有步骤依赖于非零行的数量。对于稀疏矩阵，该实现的运行速度远快于 ddm_rref。实际上，在撰写本文时，即使输入是完全密集的矩阵，它也比密集实现（略微）更快，因此在所有情况下似乎都更快。

矩阵的元素应支持使用 / 进行精确除法。例如，任何域（如 QQ）的元素都应没问题。没有尝试处理不精确的算术运算。

示例

此例程使用字典的字典稀疏矩阵表示法：

>>> from sympy import QQ
>>> from sympy.polys.matrices.sdm import sdm_irref
>>> A = {0: {0: QQ(1), 1: QQ(2)}, 1: {0: QQ(3), 1: QQ(4)}}
>>> Arref, pivots, _ = sdm_irref(A)
>>> Arref
{0: {0: 1}, 1: {1: 1}}
>>> pivots
[0, 1]

使用 MutableDenseMatrix 的类似计算将是

>>> from sympy import Matrix
>>> M = Matrix([[1, 2], [3, 4]])
>>> Mrref, pivots = M.rref()
>>> Mrref
Matrix([
[1, 0],
[0, 1]])
>>> pivots
(0, 1)

sympy.polys.matrices.sdm.sdm_nullspace_from_rref( A, one, ncols, pivots, nonzero_cols, )[源代码][源代码]¶: 从处于行简化阶梯形式的矩阵 A 中获取零空间

sympy.polys.matrices.sdm.sdm_particular_from_rref(A, ncols, pivots)[源代码][源代码]¶: 从处于行简化阶梯形式的A中获取一个特定解

sympy.polys.matrices.sdm.sdm_rref_den(A, K)[源代码][源代码]¶

返回 A 的简化行阶梯形式（RREF）及其分母。

RREF 是通过使用无分数的高斯-约旦消去法计算的。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.rref_den: 更高层次的接口到 sdm_rref_den，通常会使用这个接口而不是直接调用这个函数。
sympy.polys.matrices.sdm.sdm_rref_den: 使用此函数的 SDM 方法。
sdm_irref: 使用域除法计算简化行阶梯形式（RREF）。
ddm_irref_den: 该算法的密集版本。

参考文献

[1]

Fraction-free 算法用于线性和多项式方程。George C. Nakos, Peter R. Turner, Robert M. Williams. https://dl.acm.org/doi/10.1145/271130.271133

示例

>>> from sympy.polys.matrices.sdm import sdm_rref_den
>>> from sympy.polys.domains import ZZ
>>> A = {0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}}
>>> A_rref, den, pivots = sdm_rref_den(A, ZZ)
>>> A_rref
{0: {0: -2}, 1: {1: -2}}
>>> den
-2
>>> pivots
[0, 1]

class sympy.polys.matrices._dfm.DFM(rowslist, shape, domain)[源代码][源代码]¶

稠密 FLINT 矩阵。此类是 python-flint 中矩阵的包装器。

>>> from sympy.polys.domains import ZZ
>>> from sympy.polys.matrices.dfm import DFM
>>> dfm = DFM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
>>> dfm
[[1, 2], [3, 4]]
>>> dfm.rep
[1, 2]
[3, 4]
>>> type(dfm.rep)  
<class 'flint._flint.fmpz_mat'>

通常，DFM 类不会直接实例化，而是作为 DomainMatrix 的内部表示创建。当 $SYMPY_GROUND_TYPES$ 设置为 $flint$ 并且安装了 $python-flint$ 时，如果域受 python-flint 支持，则 DFM 类将自动用作 DomainMatrix 在密集格式中的内部表示。

>>> from sympy.polys.matrices.domainmatrix import DM
>>> dM = DM([[1, 2], [3, 4]], ZZ)
>>> dM.rep
[[1, 2], [3, 4]]

一个 DomainMatrix 可以通过调用 to_dfm() 方法转换为 DFM 。

>>> dM.to_dfm()
[[1, 2], [3, 4]]

方法

`add`(other)	添加两个 DFM 矩阵。
`applyfunc`(func, domain)	对DFM矩阵的每个条目应用一个函数。
`charpoly`()	使用 FLINT 计算矩阵的特征多项式。
`convert_to`(domain)	转换到新的域。
`copy`()	返回 self 的副本。
`det`()	使用 FLINT 计算矩阵的行列式。
`diag`(elements, domain)	返回一个对角矩阵。
`diagonal`()	返回 DFM 矩阵的对角线。
`extract`(rowslist, colslist)	提取一个子矩阵。
`extract_slice`(rowslice, colslice)	切片一个 DFM。
`eye`(n, domain)	返回大小为 n 的单位矩阵。
`from_ddm`(ddm)	从DDM转换。
`from_dod`(dod, shape, domain)	与 `to_dod()` 相反。
`from_dok`(dok, shape, domain)	的逆运算 $to_dod$。
`from_flat_nz`(elements, data, domain)	与 `to_flat_nz()` 相反。
`from_list`(rowslist, shape, domain)	从嵌套列表构建。
`from_list_flat`(elements, shape, domain)	与 `to_list_flat()` 相反。
`getitem`(i, j)	获取 `(i, j)` 项。
`hstack`(*others)	水平堆叠矩阵。
`inv`()	使用 FLINT 计算矩阵的逆。
`is_diagonal`()	如果矩阵是对角矩阵，则返回 `True`。
`is_lower`()	如果矩阵是下三角矩阵，则返回 `True`。
`is_upper`()	如果矩阵是上三角矩阵，则返回 `True`。
`is_zero_matrix`()	如果矩阵是零矩阵，则返回 `True`。
`iter_items`()	遍历矩阵中非零元素的索引和值。
`iter_values`()	遍历矩阵中的非零值。
`lll`([delta])	使用 FLINT 计算 LLL 约化基。
`lll_transform`([delta])	使用 FLINT 计算 LLL 约化基并进行变换。
`lu`()	返回矩阵的LU分解。
`lu_solve`(rhs)	使用 FLINT 求解矩阵方程。
`matmul`(other)	将两个 DFM 矩阵相乘。
`mul`(other)	将 DFM 矩阵从右侧乘以一个标量。
`mul_elementwise`(other)	两个DFM矩阵的逐元素乘法。
`neg`()	否定一个 DFM 矩阵。
`nnz`()	返回矩阵中非零元素的数量。
`nullspace`()	返回矩阵零空间的基础。
`nullspace_from_rref`([pivots])	返回矩阵零空间的基础。
`ones`(shape, domain)	返回一个一维DFM矩阵。
`particular`()	返回系统的特定解。
`rmul`(other)	将一个标量从左侧乘以一个DFM矩阵。
`scc`()	返回矩阵的强连通分量。
`setitem`(i, j, value)	设置 `(i, j)` 项。
`sub`(other)	减去两个 DFM 矩阵。
`to_ddm`()	转换为DDM。
`to_dfm`()	返回 self。
`to_dfm_or_ddm`()	转换为 `DFM`。
`to_dod`()	转换为 DOD。
`to_dok`()	转换为 DOK。
`to_flat_nz`()	转换为非零元素的扁平列表。
`to_list`()	转换为嵌套列表。
`to_list_flat`()	转换为平面列表。
`to_sdm`()	转换为 SDM。
`transpose`()	转置一个 DFM 矩阵。
`vstack`(*others)	垂直堆叠矩阵。
`zeros`(shape, domain)	返回一个零 DFM 矩阵。

add(other)[源代码][源代码]¶: 添加两个 DFM 矩阵。

applyfunc(func, domain)[源代码][源代码]¶: 对DFM矩阵的每个条目应用一个函数。

charpoly()[源代码][源代码]¶

使用 FLINT 计算矩阵的特征多项式。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.charpoly: 计算矩阵特征多项式的高级接口。

注释

调用底层 FLINT 矩阵的 .charpoly() 方法。

对于 ZZ 或 QQ ，这分别调用 fmpz_mat_charpoly 或 fmpq_mat_charpoly。

在编写时，fmpq_mat_charpoly 的实现会从整个矩阵中清除一个分母，然后调用 fmpz_mat_charpoly。然后，特征多项式的系数乘以分母的幂。

fmpz_mat_charpoly 方法使用带有CRT重构的模算法。模算法使用 nmod_mat_charpoly ，对于小矩阵和非素数模数使用Berkowitz方法，否则使用Danilevsky方法。

示例

>>> from sympy import Matrix
>>> M = Matrix([[1, 2], [3, 4]])
>>> dfm = M.to_DM().to_dfm()  # need ground types = 'flint'
>>> dfm
[[1, 2], [3, 4]]
>>> dfm.charpoly()
[1, -5, -2]

convert_to(domain)[源代码][源代码]¶: 转换到新的域。

copy()[源代码][源代码]¶: 返回 self 的副本。

det()[源代码][源代码]¶

使用 FLINT 计算矩阵的行列式。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.det: 计算矩阵行列式的高级接口。

注释

调用底层 FLINT 矩阵的 .det() 方法。

对于 ZZ 或 QQ ，这分别调用 fmpz_mat_det 或 fmpq_mat_det。

在编写时，fmpz_mat_det 的实现使用了多种算法之一，具体取决于矩阵的大小和条目的位大小。所使用的算法有：

用于非常小的（最多4x4）矩阵的辅助因子。
Bareiss 适用于小规模（最多 25x25）的矩阵。
适用于较大矩阵（最大60x60）或具有较大比特位的大矩阵的模块化算法。
对于较大的矩阵（60x60及以上），如果位大小小于矩阵的维度，则采用模块化“加速”。

fmpq_mat_det 的实现从每一行（而不是整个矩阵）清除分母，然后调用 fmpz_mat_det 并除以分母的乘积。

示例

>>> from sympy import Matrix
>>> M = Matrix([[1, 2], [3, 4]])
>>> dfm = M.to_DM().to_dfm()
>>> dfm
[[1, 2], [3, 4]]
>>> dfm.det()
-2

classmethod diag(elements, domain)[源代码][源代码]¶: 返回一个对角矩阵。

diagonal()[源代码][源代码]¶: 返回 DFM 矩阵的对角线。

extract(rowslist, colslist)[源代码][源代码]¶: 提取一个子矩阵。

extract_slice(rowslice, colslice)[源代码][源代码]¶: 切片一个 DFM。

classmethod eye(n, domain)[源代码][源代码]¶: 返回大小为 n 的单位矩阵。

classmethod from_ddm(ddm)[源代码][源代码]¶: 从DDM转换。

classmethod from_dod(dod, shape, domain)[源代码][源代码]¶: 与 to_dod() 相反。

classmethod from_dok(dok, shape, domain)[源代码][源代码]¶: 的逆运算 $to_dod$。

classmethod from_flat_nz(elements, data, domain)[源代码][源代码]¶: 与 to_flat_nz() 相反。

classmethod from_list(rowslist, shape, domain)[源代码][源代码]¶: 从嵌套列表构建。

classmethod from_list_flat(elements, shape, domain)[源代码][源代码]¶: 与 to_list_flat() 相反。

getitem(i, j)[源代码][源代码]¶: 获取 (i, j) 项。

hstack(*others)[源代码][源代码]¶: 水平堆叠矩阵。

inv()[源代码][源代码]¶

使用 FLINT 计算矩阵的逆。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.inv: 计算矩阵逆的高级方法。

注释

调用底层 FLINT 矩阵的 .inv() 方法。

目前，如果域是 ZZ 则会引发错误，但对于 QQ 将使用FLINT方法。

用于 ZZ 和 QQ 的 FLINT 方法是 fmpz_mat_inv 和 fmpq_mat_inv 。fmpz_mat_inv 方法计算一个带分母的逆矩阵。这是通过调用 fmpz_mat_solve 实现的（参见 lu_solve() 中的算法说明）。

fmpq_mat_inv 方法从每一行中清除分母，然后将这些分母乘入右边的单位矩阵，再调用 fmpz_mat_solve。

示例

>>> from sympy import Matrix, QQ
>>> M = Matrix([[1, 2], [3, 4]])
>>> dfm = M.to_DM().to_dfm().convert_to(QQ)
>>> dfm
[[1, 2], [3, 4]]
>>> dfm.inv()
[[-2, 1], [3/2, -1/2]]
>>> dfm.matmul(dfm.inv())
[[1, 0], [0, 1]]

is_diagonal()[源代码][源代码]¶: 如果矩阵是对角矩阵，则返回 True。

is_lower()[源代码][源代码]¶: 如果矩阵是下三角矩阵，则返回 True。

is_upper()[源代码][源代码]¶: 如果矩阵是上三角矩阵，则返回 True。

is_zero_matrix()[源代码][源代码]¶: 如果矩阵是零矩阵，则返回 True。

iter_items()[源代码][源代码]¶: 遍历矩阵中非零元素的索引和值。

iter_values()[源代码][源代码]¶: 遍历矩阵中的非零值。

lll(delta=0.75)[源代码][源代码]¶

使用 FLINT 计算 LLL 约化基。

更多信息请参见 lll_transform()。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.lll: 更高级别的接口，用于计算 LLL 约化基。
lll_transform: 计算 LLL 约化基和变换矩阵。

示例

>>> from sympy import Matrix
>>> M = Matrix([[1, 2, 3], [4, 5, 6]])
>>> M.to_DM().to_dfm().lll()
[[2, 1, 0], [-1, 1, 3]]

lll_transform(delta=0.75)[源代码][源代码]¶

使用 FLINT 计算 LLL 约化基并进行变换。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.lll: 更高级别的接口，用于计算 LLL 约化基。
lll: 计算 LLL 约化基而不使用变换矩阵。

示例

>>> from sympy import Matrix
>>> M = Matrix([[1, 2, 3], [4, 5, 6]]).to_DM().to_dfm()
>>> M_lll, T = M.lll_transform()
>>> M_lll
[[2, 1, 0], [-1, 1, 3]]
>>> T
[[-2, 1], [3, -1]]
>>> T.matmul(M) == M_lll
True

lu()[源代码][源代码]¶: 返回矩阵的LU分解。

lu_solve(rhs)[源代码][源代码]¶

使用 FLINT 求解矩阵方程。

参见

sympy.polys.matrices.domainmatrix.DomainMatrix.lu_solve: 解决矩阵方程的高级接口。

注释

调用底层 FLINT 矩阵的 .solve() 方法。

目前，如果域是 ZZ 则会引发错误，但对于 QQ 将使用FLINT方法。

用于 ZZ 和 QQ 的 FLINT 方法分别是 fmpz_mat_solve 和 fmpq_mat_solve。fmpq_mat_solve 方法使用两种算法之一：

对于小矩阵（<25行），它会清除矩阵和右侧之间的分母，并使用 fmpz_mat_solve。
对于较大的矩阵，它使用 fmpq_mat_solve_dixon，这是一种带有 QQ 上CRT重构的模块化方法。

fmpz_mat_solve 方法使用四种算法之一：

对于非常小的（<= 3x3）矩阵，它使用克莱姆法则。
对于小的（<= 15x15）矩阵，它使用无分数的LU求解。
否则，它使用Dixon方法或其他多模块方法。

示例

>>> from sympy import Matrix, QQ
>>> M = Matrix([[1, 2], [3, 4]])
>>> dfm = M.to_DM().to_dfm().convert_to(QQ)
>>> dfm
[[1, 2], [3, 4]]
>>> rhs = Matrix([1, 2]).to_DM().to_dfm().convert_to(QQ)
>>> dfm.lu_solve(rhs)
[[0], [1/2]]

matmul(other)[源代码][源代码]¶: 将两个 DFM 矩阵相乘。

mul(other)[源代码][源代码]¶: 将 DFM 矩阵从右侧乘以一个标量。

mul_elementwise(other)[源代码][源代码]¶: 两个DFM矩阵的逐元素乘法。

neg()[源代码][源代码]¶: 否定一个 DFM 矩阵。

nnz()[源代码][源代码]¶: 返回矩阵中非零元素的数量。

nullspace()[源代码][源代码]¶: 返回矩阵零空间的基础。

nullspace_from_rref(pivots=None)[源代码][源代码]¶: 返回矩阵零空间的基础。

classmethod ones(shape, domain)[源代码][源代码]¶: 返回一个一维DFM矩阵。

particular()[源代码][源代码]¶: 返回系统的特定解。

rmul(other)[源代码][源代码]¶: 将一个标量从左侧乘以一个DFM矩阵。

scc()[源代码][源代码]¶: 返回矩阵的强连通分量。

setitem(i, j, value)[源代码][源代码]¶: 设置 (i, j) 项。

sub(other)[源代码][源代码]¶: 减去两个 DFM 矩阵。

to_ddm()[源代码][源代码]¶: 转换为DDM。

to_dfm()[源代码][源代码]¶: 返回 self。

to_dfm_or_ddm()[源代码][源代码]¶

转换为 DFM。

这个 DFM 方法的存在是为了与 DDM 和 SDM 方法并行。对于 DFM ，它将始终返回 self。

参见

to_ddm
to_sdm
sympy.polys.matrices.domainmatrix.DomainMatrix.to_dfm_or_ddm

to_dod()[源代码][源代码]¶: 转换为 DOD。

to_dok()[源代码][源代码]¶: 转换为 DOK。

to_flat_nz()[源代码][源代码]¶: 转换为非零元素的扁平列表。

to_list()[源代码][源代码]¶: 转换为嵌套列表。

to_list_flat()[源代码][源代码]¶: 转换为平面列表。

to_sdm()[源代码][源代码]¶: 转换为 SDM。

transpose()[源代码][源代码]¶: 转置一个 DFM 矩阵。

vstack(*others)[源代码][源代码]¶: 垂直堆叠矩阵。

classmethod zeros(shape, domain)[源代码][源代码]¶: 返回一个零 DFM 矩阵。

sympy.polys.matrices.normalforms.smith_normal_form(m)[源代码][源代码]¶

返回矩阵 $m$ 在环 $domain$ 上的 Smith 标准型。只有当环是主理想域时，这才会有效。

示例

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

sympy.polys.matrices.normalforms.hermite_normal_form( A, *, D=None, check_rank=False, )[源代码][源代码]¶

计算 DomainMatrix A 在 ZZ 上的 Hermite 正规形式。

参数:

A : $m imes n$ DomainMatrix 在 ZZ 上。$m imes n$
D : ZZ, 可选ZZ, 可选: 设 $W$ 为 A 的 HNF。如果事先已知，一个正整数 D 是 $\det(W)$ 的任意倍数，则可以提供。在这种情况下，如果 A 的秩也为 $m$，那么我们可以使用一种替代算法，该算法在模 D 下工作，以防止系数爆炸。
check_rank布尔值，可选（默认=False）: 基本假设是，如果你为 D 传递一个值，那么你已经相信 A 的秩为 $m$，所以我们不会浪费时间为你检查它。如果你确实希望进行此检查（并且在检查失败时使用普通的、非模 D 算法），那么请将 check_rank 设置为 True。

返回:

DomainMatrix: 矩阵 A 的 HNF。

Raises:

DMDomainError: 如果矩阵的域不是 ZZ，或者如果给出了 D 但不在 ZZ 中。
DMShapeError: 如果使用了 D 算法，但矩阵的行数多于列数。

参考文献

[1]

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

示例

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