多项式内部操作模块#
多项式模块的实现在内部以“层次”结构。有四个级别，称为L0、L1、L2和L3。第三级和第四级包含面向用户的功能，在上一节中进行了描述。本节重点介绍零级和一级。
levelzero提供了核心多项式操作功能和类似C的低级接口。第一级将这个低级功能封装到面向对象的结构中。这些是 not 用户看到的类，而是polys模块内部使用的类。
在实现中还有一个额外的复杂问题。这是因为所有多项式操作都与 地域 . 例如，当分解一个 \(x^{{10}} - 1\) ，我们必须决定系数应该属于哪个环，或者更简单地说，在因式分解中允许出现哪些系数。这种系数的选择称为基域。典型的选择包括整数 \(\mathbb{{Z}}\) ，有理数 \(\mathbb{{Q}}\) 或者各种相关的环和场。但是在多项式环上进行因式分解是完全合法的（尽管在本例中没有兴趣），比如 \(k[Y]\) 在哪里 \(k\) 是一个固定的领域。
因此，多项式操作算法（复杂的如因子分解和简单的加法或乘法）必须依赖其他代码来操作系数。在多项式操作模块中，这样的代码被封装在所谓的“域”中。域基本上是一个工厂对象：它接受数据的各种表示形式，并将它们转换为具有统一接口的对象。域创建的每个对象都必须实现算术运算 \(+\) ， \(-\) 和 \(\times\) . 其他操作通过域访问，例如 ZZ.quo(ZZ(4), ZZ(2)) .
注意有一些 圆度 多项式环域使用一级类，一级类使用零级函数，零级函数使用域。原则上，在当前的实现中，可以像 \(k[X][Y]\) . 这将产生更多的层。因此，在同构环中工作 \(k[X, Y]\) 优先考虑。
零级#
零级包含多项式操作模块的大量代码。
稠密多元多项式的处理#
这些函数可用于在 \(K[X_0, \ldots, X_u]\) . 在稠密表示中操作多元多项式的函数具有前缀 dmp_ . 只适用于一元多项式的函数（即。 \(u = 0\) )有前缀吗 dup__ . 地域 \(K\) 必须显式传递。对于许多多元多项式操作函数也有层次性 \(u\) ，即发电机数量减去1，必须通过。（请注意，在许多情况下， dup_ 提供了功能版本，这可能会稍微更有效。）
基本操作：
- sympy.polys.densebasic.dmp_LC(f, K)[源代码]#
回归超前系数
f.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import poly_LC
>>> poly_LC([], ZZ) 0 >>> poly_LC([ZZ(1), ZZ(2), ZZ(3)], ZZ) 1
- sympy.polys.densebasic.dmp_TC(f, K)[源代码]#
返回尾随系数
f.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import poly_TC
>>> poly_TC([], ZZ) 0 >>> poly_TC([ZZ(1), ZZ(2), ZZ(3)], ZZ) 3
- sympy.polys.densebasic.dmp_ground_LC(f, u, K)[源代码]#
返回地面引导系数。
实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_ground_LC
>>> f = ZZ.map([[[1], [2, 3]]])
>>> dmp_ground_LC(f, 2, ZZ) 1
- sympy.polys.densebasic.dmp_ground_TC(f, u, K)[源代码]#
返回地面拖曳系数。
实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_ground_TC
>>> f = ZZ.map([[[1], [2, 3]]])
>>> dmp_ground_TC(f, 2, ZZ) 3
- sympy.polys.densebasic.dmp_true_LT(f, u, K)[源代码]#
返回前导项
c * x_1**n_1 ... x_k**n_k.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_true_LT
>>> f = ZZ.map([[4], [2, 0], [3, 0, 0]])
>>> dmp_true_LT(f, 1, ZZ) ((2, 0), 4)
- sympy.polys.densebasic.dmp_degree(f, u)[源代码]#
返回前导度
f在里面x_0在里面K[X].Note that the degree of 0 is negative infinity (
float('-inf')).实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_degree
>>> dmp_degree([[[]]], 2) -inf
>>> f = ZZ.map([[2], [1, 2, 3]])
>>> dmp_degree(f, 1) 1
- sympy.polys.densebasic.dmp_degree_in(f, j, u)[源代码]#
返回前导度
f在里面x_j在里面K[X].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_degree_in
>>> f = ZZ.map([[2], [1, 2, 3]])
>>> dmp_degree_in(f, 0, 1) 1 >>> dmp_degree_in(f, 1, 1) 2
- sympy.polys.densebasic.dmp_degree_list(f, u)[源代码]#
返回的度数列表
f在里面K[X].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_degree_list
>>> f = ZZ.map([[1], [1, 2, 3]])
>>> dmp_degree_list(f, 1) (1, 2)
- sympy.polys.densebasic.dmp_strip(f, u)[源代码]#
从中删除前导零
f在里面K[X].实例
>>> from sympy.polys.densebasic import dmp_strip
>>> dmp_strip([[], [0, 1, 2], [1]], 1) [[0, 1, 2], [1]]
- sympy.polys.densebasic.dmp_validate(f, K=None)[源代码]#
返回中的级别数
f并递归地剥离它。实例
>>> from sympy.polys.densebasic import dmp_validate
>>> dmp_validate([[], [0, 1, 2], [1]]) ([[1, 2], [1]], 1)
>>> dmp_validate([[1], 1]) Traceback (most recent call last): ... ValueError: invalid data structure for a multivariate polynomial
- sympy.polys.densebasic.dup_reverse(f)[源代码]#
计算
x**n * f(1/x)，即：反向f在里面K[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dup_reverse
>>> f = ZZ.map([1, 2, 3, 0])
>>> dup_reverse(f) [3, 2, 1]
- sympy.polys.densebasic.dmp_copy(f, u)[源代码]#
创建多项式的新副本
f在里面K[X].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_copy
>>> f = ZZ.map([[1], [1, 2]])
>>> dmp_copy(f, 1) [[1], [1, 2]]
- sympy.polys.densebasic.dmp_to_tuple(f, u)[源代码]#
转换 \(f\) 一个嵌套的元组。
这是哈希所需的。这类似于dmp_copy（）。
实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_to_tuple
>>> f = ZZ.map([[1], [1, 2]])
>>> dmp_to_tuple(f, 1) ((1,), (1, 2))
- sympy.polys.densebasic.dmp_normal(f, u, K)[源代码]#
规范化给定域中的多元多项式。
实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_normal
>>> dmp_normal([[], [0, 1, 2]], 1, ZZ) [[1, 2]]
- sympy.polys.densebasic.dmp_convert(f, u, K0, K1)[源代码]#
转换的基域
f从K0到K1.实例
>>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_convert
>>> R, x = ring("x", ZZ)
>>> dmp_convert([[R(1)], [R(2)]], 1, R.to_domain(), ZZ) [[1], [2]] >>> dmp_convert([[ZZ(1)], [ZZ(2)]], 1, ZZ, R.to_domain()) [[1], [2]]
- sympy.polys.densebasic.dmp_from_sympy(f, u, K)[源代码]#
转换的基域
f从SymPy到K.实例
>>> from sympy import S >>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_from_sympy
>>> dmp_from_sympy([[S(1)], [S(2)]], 1, ZZ) == [[ZZ(1)], [ZZ(2)]] True
- sympy.polys.densebasic.dmp_nth(f, n, u, K)[源代码]#
返回
n-th系数f在里面K[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_nth
>>> f = ZZ.map([[1], [2], [3]])
>>> dmp_nth(f, 0, 1, ZZ) [3] >>> dmp_nth(f, 4, 1, ZZ) []
- sympy.polys.densebasic.dmp_ground_nth(f, N, u, K)[源代码]#
返回地面
n-th系数f在里面K[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_ground_nth
>>> f = ZZ.map([[1], [2, 3]])
>>> dmp_ground_nth(f, (0, 1), 1, ZZ) 2
- sympy.polys.densebasic.dmp_zero_p(f, u)[源代码]#
返回
True如果f零英寸K[X].实例
>>> from sympy.polys.densebasic import dmp_zero_p
>>> dmp_zero_p([[[[[]]]]], 4) True >>> dmp_zero_p([[[[[1]]]]], 4) False
- sympy.polys.densebasic.dmp_zero(u)[源代码]#
返回多元零。
实例
>>> from sympy.polys.densebasic import dmp_zero
>>> dmp_zero(4) [[[[[]]]]]
- sympy.polys.densebasic.dmp_one_p(f, u, K)[源代码]#
返回
True如果f有一个在K[X].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_one_p
>>> dmp_one_p([[[ZZ(1)]]], 2, ZZ) True
- sympy.polys.densebasic.dmp_one(u, K)[源代码]#
返回多元一
K.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_one
>>> dmp_one(2, ZZ) [[[1]]]
- sympy.polys.densebasic.dmp_ground_p(f, c, u)[源代码]#
如果返回真
f是恒定的K[X].实例
>>> from sympy.polys.densebasic import dmp_ground_p
>>> dmp_ground_p([[[3]]], 3, 2) True >>> dmp_ground_p([[[4]]], None, 2) True
- sympy.polys.densebasic.dmp_ground(c, u)[源代码]#
返回一个多元常量。
实例
>>> from sympy.polys.densebasic import dmp_ground
>>> dmp_ground(3, 5) [[[[[[3]]]]]] >>> dmp_ground(1, -1) 1
- sympy.polys.densebasic.dmp_zeros(n, u, K)[源代码]#
返回多元零的列表。
实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_zeros
>>> dmp_zeros(3, 2, ZZ) [[[[]]], [[[]]], [[[]]]] >>> dmp_zeros(3, -1, ZZ) [0, 0, 0]
- sympy.polys.densebasic.dmp_grounds(c, n, u)[源代码]#
返回多元常量列表。
实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_grounds
>>> dmp_grounds(ZZ(4), 3, 2) [[[[4]]], [[[4]]], [[[4]]]] >>> dmp_grounds(ZZ(4), 3, -1) [4, 4, 4]
- sympy.polys.densebasic.dmp_negative_p(f, u, K)[源代码]#
返回
True如果LC(f)是否定的。实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_negative_p
>>> dmp_negative_p([[ZZ(1)], [-ZZ(1)]], 1, ZZ) False >>> dmp_negative_p([[-ZZ(1)], [ZZ(1)]], 1, ZZ) True
- sympy.polys.densebasic.dmp_positive_p(f, u, K)[源代码]#
返回
True如果LC(f)是肯定的。实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_positive_p
>>> dmp_positive_p([[ZZ(1)], [-ZZ(1)]], 1, ZZ) True >>> dmp_positive_p([[-ZZ(1)], [ZZ(1)]], 1, ZZ) False
- sympy.polys.densebasic.dmp_from_dict(f, u, K)[源代码]#
创建一个
K[X]多项式dict.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_from_dict
>>> dmp_from_dict({(0, 0): ZZ(3), (0, 1): ZZ(2), (2, 1): ZZ(1)}, 1, ZZ) [[1, 0], [], [2, 3]] >>> dmp_from_dict({}, 0, ZZ) []
- sympy.polys.densebasic.dmp_to_dict(f, u, K=None, zero=False)[源代码]#
转换为
K[X]多项式到adict''.实例
>>> from sympy.polys.densebasic import dmp_to_dict
>>> dmp_to_dict([[1, 0], [], [2, 3]], 1) {(0, 0): 3, (0, 1): 2, (2, 1): 1} >>> dmp_to_dict([], 0) {}
- sympy.polys.densebasic.dmp_swap(f, i, j, u, K)[源代码]#
变换
K[..x_i..x_j..]到K[..x_j..x_i..].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_swap
>>> f = ZZ.map([[[2], [1, 0]], []])
>>> dmp_swap(f, 0, 1, 2, ZZ) [[[2], []], [[1, 0], []]] >>> dmp_swap(f, 1, 2, 2, ZZ) [[[1], [2, 0]], [[]]] >>> dmp_swap(f, 0, 2, 2, ZZ) [[[1, 0]], [[2, 0], []]]
- sympy.polys.densebasic.dmp_permute(f, P, u, K)[源代码]#
返回多项式
K[x_{{P(1)}},..,x_{{P(n)}}].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_permute
>>> f = ZZ.map([[[2], [1, 0]], []])
>>> dmp_permute(f, [1, 0, 2], 2, ZZ) [[[2], []], [[1, 0], []]] >>> dmp_permute(f, [1, 2, 0], 2, ZZ) [[[1], []], [[2, 0], []]]
- sympy.polys.densebasic.dmp_nest(f, l, K)[源代码]#
返回嵌套的多元值
l-级别。实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_nest
>>> dmp_nest([[ZZ(1)]], 2, ZZ) [[[[1]]]]
- sympy.polys.densebasic.dmp_raise(f, l, u, K)[源代码]#
返回引发的多元多项式
l-级别。实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_raise
>>> f = ZZ.map([[], [1, 2]])
>>> dmp_raise(f, 2, 1, ZZ) [[[[]]], [[[1]], [[2]]]]
- sympy.polys.densebasic.dmp_deflate(f, u, K)[源代码]#
地图
x_i**m_i到y_i在多项式中K[X].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_deflate
>>> f = ZZ.map([[1, 0, 0, 2], [], [3, 0, 0, 4]])
>>> dmp_deflate(f, 1, ZZ) ((2, 3), [[1, 2], [3, 4]])
- sympy.polys.densebasic.dmp_multi_deflate(polys, u, K)[源代码]#
地图
x_i**m_i到y_i在一组多项式中K[X].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_multi_deflate
>>> f = ZZ.map([[1, 0, 0, 2], [], [3, 0, 0, 4]]) >>> g = ZZ.map([[1, 0, 2], [], [3, 0, 4]])
>>> dmp_multi_deflate((f, g), 1, ZZ) ((2, 1), ([[1, 0, 0, 2], [3, 0, 0, 4]], [[1, 0, 2], [3, 0, 4]]))
- sympy.polys.densebasic.dmp_inflate(f, M, u, K)[源代码]#
地图
y_i到x_i**k_i在多项式中K[X].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_inflate
>>> f = ZZ.map([[1, 2], [3, 4]])
>>> dmp_inflate(f, (2, 3), 1, ZZ) [[1, 0, 0, 2], [], [3, 0, 0, 4]]
- sympy.polys.densebasic.dmp_exclude(f, u, K)[源代码]#
排除无用级别
f.返回排除的级别，新排除的级别
f和新的u.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_exclude
>>> f = ZZ.map([[[1]], [[1], [2]]])
>>> dmp_exclude(f, 2, ZZ) ([2], [[1], [1, 2]], 1)
- sympy.polys.densebasic.dmp_include(f, J, u, K)[源代码]#
包括无用级别
f.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_include
>>> f = ZZ.map([[1], [1, 2]])
>>> dmp_include(f, [2], 1, ZZ) [[[1]], [[1], [2]]]
- sympy.polys.densebasic.dmp_inject(f, u, K, front=False)[源代码]#
转换
f从K[X][Y]到K[X,Y].实例
>>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_inject
>>> R, x,y = ring("x,y", ZZ)
>>> dmp_inject([R(1), x + 2], 0, R.to_domain()) ([[[1]], [[1], [2]]], 2) >>> dmp_inject([R(1), x + 2], 0, R.to_domain(), front=True) ([[[1]], [[1, 2]]], 2)
- sympy.polys.densebasic.dmp_eject(f, u, K, front=False)[源代码]#
转换
f从K[X,Y]到K[X][Y].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_eject
>>> dmp_eject([[[1]], [[1], [2]]], 2, ZZ['x', 'y']) [1, x + 2]
- sympy.polys.densebasic.dmp_terms_gcd(f, u, K)[源代码]#
从中删除术语的GCD
f在里面K[X].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_terms_gcd
>>> f = ZZ.map([[1, 0], [1, 0, 0], [], []])
>>> dmp_terms_gcd(f, 1, ZZ) ((2, 1), [[1], [1, 0]])
- sympy.polys.densebasic.dmp_list_terms(f, u, K, order=None)[源代码]#
列出所有非零项
f以给定的顺序order.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_list_terms
>>> f = ZZ.map([[1, 1], [2, 3]])
>>> dmp_list_terms(f, 1, ZZ) [((1, 1), 1), ((1, 0), 1), ((0, 1), 2), ((0, 0), 3)] >>> dmp_list_terms(f, 1, ZZ, order='grevlex') [((1, 1), 1), ((1, 0), 1), ((0, 1), 2), ((0, 0), 3)]
- sympy.polys.densebasic.dmp_apply_pairs(f, g, h, args, u, K)[源代码]#
应用
h对的系数对f和g.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dmp_apply_pairs
>>> h = lambda x, y, z: 2*x + y - z
>>> dmp_apply_pairs([[1], [2, 3]], [[3], [2, 1]], h, (1,), 1, ZZ) [[4], [5, 6]]
- sympy.polys.densebasic.dup_random(n, a, b, K)[源代码]#
返回次多项式
n系数为[a, b].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.densebasic import dup_random
>>> dup_random(3, -10, 10, ZZ) [-2, -8, 9, -4]
算术运算：
- sympy.polys.densearith.dmp_add_term(f, c, i, u, K)[源代码]#
添加
c(x_2..x_u)*x_0**i到f在里面K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_add_term(x*y + 1, 2, 2) 2*x**2 + x*y + 1
- sympy.polys.densearith.dmp_sub_term(f, c, i, u, K)[源代码]#
减去
c(x_2..x_u)*x_0**i从f在里面K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_sub_term(2*x**2 + x*y + 1, 2, 2) x*y + 1
- sympy.polys.densearith.dmp_mul_term(f, c, i, u, K)[源代码]#
乘法
f通过c(x_2..x_u)*x_0**i在里面K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_mul_term(x**2*y + x, 3*y, 2) 3*x**4*y**2 + 3*x**3*y
- sympy.polys.densearith.dmp_add_ground(f, c, u, K)[源代码]#
将一个基域元素添加到
f.实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_add_ground(x**3 + 2*x**2 + 3*x + 4, ZZ(4)) x**3 + 2*x**2 + 3*x + 8
- sympy.polys.densearith.dmp_sub_ground(f, c, u, K)[源代码]#
从中减去基域的一个元素
f.实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_sub_ground(x**3 + 2*x**2 + 3*x + 4, ZZ(4)) x**3 + 2*x**2 + 3*x
- sympy.polys.densearith.dmp_mul_ground(f, c, u, K)[源代码]#
乘法
f通过一个常量值K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_mul_ground(2*x + 2*y, ZZ(3)) 6*x + 6*y
- sympy.polys.densearith.dmp_quo_ground(f, c, u, K)[源代码]#
商等于常数
K[X].实例
>>> from sympy.polys import ring, ZZ, QQ
>>> R, x,y = ring("x,y", ZZ) >>> R.dmp_quo_ground(2*x**2*y + 3*x, ZZ(2)) x**2*y + x
>>> R, x,y = ring("x,y", QQ) >>> R.dmp_quo_ground(2*x**2*y + 3*x, QQ(2)) x**2*y + 3/2*x
- sympy.polys.densearith.dmp_exquo_ground(f, c, u, K)[源代码]#
常数的精确商
K[X].实例
>>> from sympy.polys import ring, QQ >>> R, x,y = ring("x,y", QQ)
>>> R.dmp_exquo_ground(x**2*y + 2*x, QQ(2)) 1/2*x**2*y + x
- sympy.polys.densearith.dup_lshift(f, n, K)[源代码]#
高效倍增
f通过x**n在里面K[x].实例
>>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ)
>>> R.dup_lshift(x**2 + 1, 2) x**4 + x**2
- sympy.polys.densearith.dup_rshift(f, n, K)[源代码]#
有效地划分
f通过x**n在里面K[x].实例
>>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ)
>>> R.dup_rshift(x**4 + x**2, 2) x**2 + 1 >>> R.dup_rshift(x**4 + x**2 + 2, 2) x**2 + 1
- sympy.polys.densearith.dmp_abs(f, u, K)[源代码]#
使所有系数为正
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_abs(x**2*y - x) x**2*y + x
- sympy.polys.densearith.dmp_neg(f, u, K)[源代码]#
求多项式的反
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_neg(x**2*y - x) -x**2*y + x
- sympy.polys.densearith.dmp_add(f, g, u, K)[源代码]#
在中添加稠密多项式
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_add(x**2 + y, x**2*y + x) x**2*y + x**2 + x + y
- sympy.polys.densearith.dmp_sub(f, g, u, K)[源代码]#
减去稠密多项式
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_sub(x**2 + y, x**2*y + x) -x**2*y + x**2 - x + y
- sympy.polys.densearith.dmp_add_mul(f, g, h, u, K)[源代码]#
返回
f + g*h在哪里？f, g, h在K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_add_mul(x**2 + y, x, x + 2) 2*x**2 + 2*x + y
- sympy.polys.densearith.dmp_sub_mul(f, g, h, u, K)[源代码]#
返回
f - g*h在哪里？f, g, h在K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_sub_mul(x**2 + y, x, x + 2) -2*x + y
- sympy.polys.densearith.dmp_mul(f, g, u, K)[源代码]#
重密多项式
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_mul(x*y + 1, x) x**2*y + x
- sympy.polys.densearith.dmp_sqr(f, u, K)[源代码]#
平方稠密多项式
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_sqr(x**2 + x*y + y**2) x**4 + 2*x**3*y + 3*x**2*y**2 + 2*x*y**3 + y**4
- sympy.polys.densearith.dmp_pow(f, n, u, K)[源代码]#
提高
f到n-输入功率K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_pow(x*y + 1, 3) x**3*y**3 + 3*x**2*y**2 + 3*x*y + 1
- sympy.polys.densearith.dmp_pdiv(f, g, u, K)[源代码]#
多项式伪除法
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_pdiv(x**2 + x*y, 2*x + 2) (2*x + 2*y - 2, -4*y + 4)
- sympy.polys.densearith.dmp_prem(f, g, u, K)[源代码]#
多项式伪余数
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_prem(x**2 + x*y, 2*x + 2) -4*y + 4
- sympy.polys.densearith.dmp_pquo(f, g, u, K)[源代码]#
多项式精确伪商
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = x**2 + x*y >>> g = 2*x + 2*y >>> h = 2*x + 2
>>> R.dmp_pquo(f, g) 2*x
>>> R.dmp_pquo(f, h) 2*x + 2*y - 2
- sympy.polys.densearith.dmp_pexquo(f, g, u, K)[源代码]#
多项式伪商
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = x**2 + x*y >>> g = 2*x + 2*y >>> h = 2*x + 2
>>> R.dmp_pexquo(f, g) 2*x
>>> R.dmp_pexquo(f, h) Traceback (most recent call last): ... ExactQuotientFailed: [[2], [2]] does not divide [[1], [1, 0], []]
- sympy.polys.densearith.dmp_rr_div(f, g, u, K)[源代码]#
环上余数的多元除。
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_rr_div(x**2 + x*y, 2*x + 2) (0, x**2 + x*y)
- sympy.polys.densearith.dmp_ff_div(f, g, u, K)[源代码]#
域上带余数的多项式除法。
实例
>>> from sympy.polys import ring, QQ >>> R, x,y = ring("x,y", QQ)
>>> R.dmp_ff_div(x**2 + x*y, 2*x + 2) (1/2*x + 1/2*y - 1/2, -y + 1)
- sympy.polys.densearith.dmp_div(f, g, u, K)[源代码]#
带余数的多项式除法
K[X].实例
>>> from sympy.polys import ring, ZZ, QQ
>>> R, x,y = ring("x,y", ZZ) >>> R.dmp_div(x**2 + x*y, 2*x + 2) (0, x**2 + x*y)
>>> R, x,y = ring("x,y", QQ) >>> R.dmp_div(x**2 + x*y, 2*x + 2) (1/2*x + 1/2*y - 1/2, -y + 1)
- sympy.polys.densearith.dmp_rem(f, g, u, K)[源代码]#
多项式余数返回
K[X].实例
>>> from sympy.polys import ring, ZZ, QQ
>>> R, x,y = ring("x,y", ZZ) >>> R.dmp_rem(x**2 + x*y, 2*x + 2) x**2 + x*y
>>> R, x,y = ring("x,y", QQ) >>> R.dmp_rem(x**2 + x*y, 2*x + 2) -y + 1
- sympy.polys.densearith.dmp_quo(f, g, u, K)[源代码]#
返回精确的多项式商
K[X].实例
>>> from sympy.polys import ring, ZZ, QQ
>>> R, x,y = ring("x,y", ZZ) >>> R.dmp_quo(x**2 + x*y, 2*x + 2) 0
>>> R, x,y = ring("x,y", QQ) >>> R.dmp_quo(x**2 + x*y, 2*x + 2) 1/2*x + 1/2*y - 1/2
- sympy.polys.densearith.dmp_exquo(f, g, u, K)[源代码]#
返回多项式商
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = x**2 + x*y >>> g = x + y >>> h = 2*x + 2
>>> R.dmp_exquo(f, g) x
>>> R.dmp_exquo(f, h) Traceback (most recent call last): ... ExactQuotientFailed: [[2], [2]] does not divide [[1], [1, 0], []]
- sympy.polys.densearith.dmp_max_norm(f, u, K)[源代码]#
返回多项式的最大范数
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_max_norm(2*x*y - x - 3) 3
- sympy.polys.densearith.dmp_l1_norm(f, u, K)[源代码]#
返回中多项式的l1范数
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_l1_norm(2*x*y - x - 3) 6
- sympy.polys.densearith.dmp_expand(polys, u, K)[源代码]#
将中的几个多项式相乘
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_expand([x**2 + y**2, x + 1]) x**3 + x**2 + x*y**2 + y**2
其他工具：
- sympy.polys.densetools.dmp_integrate(f, m, u, K)[源代码]#
计算的不定积分
f在里面x_0在里面K[X].实例
>>> from sympy.polys import ring, QQ >>> R, x,y = ring("x,y", QQ)
>>> R.dmp_integrate(x + 2*y, 1) 1/2*x**2 + 2*x*y >>> R.dmp_integrate(x + 2*y, 2) 1/6*x**3 + x**2*y
- sympy.polys.densetools.dmp_integrate_in(f, m, j, u, K)[源代码]#
计算的不定积分
f在里面x_j在里面K[X].实例
>>> from sympy.polys import ring, QQ >>> R, x,y = ring("x,y", QQ)
>>> R.dmp_integrate_in(x + 2*y, 1, 0) 1/2*x**2 + 2*x*y >>> R.dmp_integrate_in(x + 2*y, 1, 1) x*y + y**2
- sympy.polys.densetools.dmp_diff(f, m, u, K)[源代码]#
m-中的一阶导数x_0多项式的K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = x*y**2 + 2*x*y + 3*x + 2*y**2 + 3*y + 1
>>> R.dmp_diff(f, 1) y**2 + 2*y + 3 >>> R.dmp_diff(f, 2) 0
- sympy.polys.densetools.dmp_diff_in(f, m, j, u, K)[源代码]#
m-中的一阶导数x_j多项式的K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = x*y**2 + 2*x*y + 3*x + 2*y**2 + 3*y + 1
>>> R.dmp_diff_in(f, 1, 0) y**2 + 2*y + 3 >>> R.dmp_diff_in(f, 1, 1) 2*x*y + 2*x + 4*y + 3
- sympy.polys.densetools.dmp_eval(f, a, u, K)[源代码]#
求值多项式
x_0 = a在里面K[X]使用霍纳方案。实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_eval(2*x*y + 3*x + y + 2, 2) 5*y + 8
- sympy.polys.densetools.dmp_eval_in(f, a, j, u, K)[源代码]#
求值多项式
x_j = a在里面K[X]使用霍纳方案。实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = 2*x*y + 3*x + y + 2
>>> R.dmp_eval_in(f, 2, 0) 5*y + 8 >>> R.dmp_eval_in(f, 2, 1) 7*x + 4
- sympy.polys.densetools.dmp_eval_tail(f, A, u, K)[源代码]#
求值多项式
x_j = a_j, ...在里面K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = 2*x*y + 3*x + y + 2
>>> R.dmp_eval_tail(f, [2]) 7*x + 4 >>> R.dmp_eval_tail(f, [2, 2]) 18
- sympy.polys.densetools.dmp_diff_eval_in(f, m, a, j, u, K)[源代码]#
多项式的求导与求值
x_j在a在里面K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = x*y**2 + 2*x*y + 3*x + 2*y**2 + 3*y + 1
>>> R.dmp_diff_eval_in(f, 1, 2, 0) y**2 + 2*y + 3 >>> R.dmp_diff_eval_in(f, 1, 2, 1) 6*x + 11
- sympy.polys.densetools.dmp_trunc(f, p, u, K)[源代码]#
减少
K[X]多项式模p在里面K[Y].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = 3*x**2*y + 8*x**2 + 5*x*y + 6*x + 2*y + 3 >>> g = (y - 1).drop(x)
>>> R.dmp_trunc(f, g) 11*x**2 + 11*x + 5
- sympy.polys.densetools.dmp_ground_trunc(f, p, u, K)[源代码]#
减少
K[X]多项式模a常数p在里面K.实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = 3*x**2*y + 8*x**2 + 5*x*y + 6*x + 2*y + 3
>>> R.dmp_ground_trunc(f, ZZ(3)) -x**2 - x*y - y
- sympy.polys.densetools.dup_monic(f, K)[源代码]#
将所有系数除以
LC(f)在里面K[x].实例
>>> from sympy.polys import ring, ZZ, QQ
>>> R, x = ring("x", ZZ) >>> R.dup_monic(3*x**2 + 6*x + 9) x**2 + 2*x + 3
>>> R, x = ring("x", QQ) >>> R.dup_monic(3*x**2 + 4*x + 2) x**2 + 4/3*x + 2/3
- sympy.polys.densetools.dmp_ground_monic(f, u, K)[源代码]#
将所有系数除以
LC(f)在里面K[X].实例
>>> from sympy.polys import ring, ZZ, QQ
>>> R, x,y = ring("x,y", ZZ) >>> f = 3*x**2*y + 6*x**2 + 3*x*y + 9*y + 3
>>> R.dmp_ground_monic(f) x**2*y + 2*x**2 + x*y + 3*y + 1
>>> R, x,y = ring("x,y", QQ) >>> f = 3*x**2*y + 8*x**2 + 5*x*y + 6*x + 2*y + 3
>>> R.dmp_ground_monic(f) x**2*y + 8/3*x**2 + 5/3*x*y + 2*x + 2/3*y + 1
- sympy.polys.densetools.dup_content(f, K)[源代码]#
计算
f在里面K[x].实例
>>> from sympy.polys import ring, ZZ, QQ
>>> R, x = ring("x", ZZ) >>> f = 6*x**2 + 8*x + 12
>>> R.dup_content(f) 2
>>> R, x = ring("x", QQ) >>> f = 6*x**2 + 8*x + 12
>>> R.dup_content(f) 2
- sympy.polys.densetools.dmp_ground_content(f, u, K)[源代码]#
计算
f在里面K[X].实例
>>> from sympy.polys import ring, ZZ, QQ
>>> R, x,y = ring("x,y", ZZ) >>> f = 2*x*y + 6*x + 4*y + 12
>>> R.dmp_ground_content(f) 2
>>> R, x,y = ring("x,y", QQ) >>> f = 2*x*y + 6*x + 4*y + 12
>>> R.dmp_ground_content(f) 2
- sympy.polys.densetools.dup_primitive(f, K)[源代码]#
计算内容和原始形式
f在里面K[x].实例
>>> from sympy.polys import ring, ZZ, QQ
>>> R, x = ring("x", ZZ) >>> f = 6*x**2 + 8*x + 12
>>> R.dup_primitive(f) (2, 3*x**2 + 4*x + 6)
>>> R, x = ring("x", QQ) >>> f = 6*x**2 + 8*x + 12
>>> R.dup_primitive(f) (2, 3*x**2 + 4*x + 6)
- sympy.polys.densetools.dmp_ground_primitive(f, u, K)[源代码]#
计算内容和原始形式
f在里面K[X].实例
>>> from sympy.polys import ring, ZZ, QQ
>>> R, x,y = ring("x,y", ZZ) >>> f = 2*x*y + 6*x + 4*y + 12
>>> R.dmp_ground_primitive(f) (2, x*y + 3*x + 2*y + 6)
>>> R, x,y = ring("x,y", QQ) >>> f = 2*x*y + 6*x + 4*y + 12
>>> R.dmp_ground_primitive(f) (2, x*y + 3*x + 2*y + 6)
- sympy.polys.densetools.dup_extract(f, g, K)[源代码]#
从一对多项式中提取公共内容
K[x].实例
>>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ)
>>> R.dup_extract(6*x**2 + 12*x + 18, 4*x**2 + 8*x + 12) (2, 3*x**2 + 6*x + 9, 2*x**2 + 4*x + 6)
- sympy.polys.densetools.dmp_ground_extract(f, g, u, K)[源代码]#
从一对多项式中提取公共内容
K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_ground_extract(6*x*y + 12*x + 18, 4*x*y + 8*x + 12) (2, 3*x*y + 6*x + 9, 2*x*y + 4*x + 6)
- sympy.polys.densetools.dup_real_imag(f, K)[源代码]#
返回二元多项式
f1和f2，这样f = f1 + f2*I.实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dup_real_imag(x**3 + x**2 + x + 1) (x**3 + x**2 - 3*x*y**2 + x - y**2 + 1, 3*x**2*y + 2*x*y - y**3 + y)
- sympy.polys.densetools.dup_mirror(f, K)[源代码]#
有效评价作文
f(-x)在里面K[x].实例
>>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ)
>>> R.dup_mirror(x**3 + 2*x**2 - 4*x + 2) -x**3 + 2*x**2 + 4*x + 2
- sympy.polys.densetools.dup_scale(f, a, K)[源代码]#
有效评估成分
f(a*x)在里面K[x].实例
>>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ)
>>> R.dup_scale(x**2 - 2*x + 1, ZZ(2)) 4*x**2 - 4*x + 1
- sympy.polys.densetools.dup_shift(f, a, K)[源代码]#
泰勒位移的有效评价
f(x + a)在里面K[x].实例
>>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ)
>>> R.dup_shift(x**2 - 2*x + 1, ZZ(2)) x**2 + 2*x + 1
- sympy.polys.densetools.dup_transform(f, p, q, K)[源代码]#
评估功能转换
q**n * f(p/q)在里面K[x].实例
>>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ)
>>> R.dup_transform(x**2 - 2*x + 1, x**2 + 1, x - 1) x**4 - 2*x**3 + 5*x**2 - 4*x + 4
- sympy.polys.densetools.dmp_compose(f, g, u, K)[源代码]#
评价功能成分
f(g)在里面K[X].实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_compose(x*y + 2*x + y, y) y**2 + 3*y
- sympy.polys.densetools.dup_decompose(f, K)[源代码]#
计算函数分解
f在里面K[x].给定一元多项式
f对于特征为零的字段中的系数，返回列表[f_1, f_2, ..., f_n]，其中：f = f_1 o f_2 o ... f_n = f_1(f_2(... f_n))
和
f_2, ..., f_n是至少二次的一元齐次多项式。与因式分解不同，多项式的完全函数分解不是唯一的，请考虑以下示例：
f o g = f(x + b) o (g - b)x**n o x**m = x**m o x**nT_n o T_m = T_m o T_n
在哪里？
T_n和T_m是切比雪夫多项式。实例
>>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ)
>>> R.dup_decompose(x**4 - 2*x**3 + x**2) [x**2, x**2 - x]
工具书类
- sympy.polys.densetools.dmp_lift(f, u, K)[源代码]#
将代数系数转换为整数
K[X].实例
>>> from sympy.polys import ring, QQ >>> from sympy import I
>>> K = QQ.algebraic_field(I) >>> R, x = ring("x", K)
>>> f = x**2 + K([QQ(1), QQ(0)])*x + K([QQ(2), QQ(0)])
>>> R.dmp_lift(f) x**8 + 2*x**6 + 9*x**4 - 8*x**2 + 16
- sympy.polys.densetools.dup_sign_variations(f, K)[源代码]#
计算符号的变化数
f在里面K[x].实例
>>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ)
>>> R.dup_sign_variations(x**4 - x**2 - x + 1) 2
- sympy.polys.densetools.dmp_clear_denoms(f, u, K0, K1=None, convert=False)[源代码]#
明确分母，即转换
K_0到K_1.实例
>>> from sympy.polys import ring, QQ >>> R, x,y = ring("x,y", QQ)
>>> f = QQ(1,2)*x + QQ(1,3)*y + 1
>>> R.dmp_clear_denoms(f, convert=False) (6, 3*x + 2*y + 6) >>> R.dmp_clear_denoms(f, convert=True) (6, 3*x + 2*y + 6)
有限域系数稠密单变量多项式的处理#
此模块中的函数带有前缀 gf_ ，表示有限域的经典名称“Galois Fields”。请注意，许多多项式因式分解算法都是通过简化为有限域的情况来工作的，因此在这种情况下有特殊的实现是合理的，这是由性能和某些方法的必要性所证明的，这些方法甚至在一般域上都没有意义。
- sympy.polys.galoistools.gf_crt(U, M, K=None)[源代码]#
中国剩余定理。
给定一组整数余数
u_0,...,u_n以及一组余素数模m_0,...,m_n，返回一个整数u，这样u = u_i mod m_i对于i = `` 0，…，n。实例
考虑一组残留物
U = [49, 76, 65]以及一组模M = [99, 97, 95]. 然后我们有：>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_crt >>> gf_crt([49, 76, 65], [99, 97, 95], ZZ) 639985
这是正确的结果，因为：
>>> [639985 % m for m in [99, 97, 95]] [49, 76, 65]
注意：这是一个没有错误检查的低级例程。
- sympy.polys.galoistools.gf_crt1(M, K)[源代码]#
中国剩余定理的第一部分。
实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_crt, gf_crt1, gf_crt2 >>> U = [49, 76, 65] >>> M = [99, 97, 95]
The following two codes have the same result.
>>> gf_crt(U, M, ZZ) 639985
>>> p, E, S = gf_crt1(M, ZZ) >>> gf_crt2(U, M, p, E, S, ZZ) 639985
However, it is faster when we want to fix
Mand compute for multiple U, i.e. the following cases:>>> p, E, S = gf_crt1(M, ZZ) >>> Us = [[49, 76, 65], [23, 42, 67]] >>> for U in Us: ... print(gf_crt2(U, M, p, E, S, ZZ)) 639985 236237
- sympy.polys.galoistools.gf_crt2(U, M, p, E, S, K)[源代码]#
中国剩余定理的第二部分。
See
gf_crt1for usage.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_crt2
>>> U = [49, 76, 65] >>> M = [99, 97, 95] >>> p = 912285 >>> E = [9215, 9405, 9603] >>> S = [62, 24, 12]
>>> gf_crt2(U, M, p, E, S, ZZ) 639985
- sympy.polys.galoistools.gf_int(a, p)[源代码]#
胁迫
a mod p范围内的整数[-p/2, p/2].实例
>>> from sympy.polys.galoistools import gf_int
>>> gf_int(2, 7) 2 >>> gf_int(5, 7) -2
- sympy.polys.galoistools.gf_degree(f)[源代码]#
返回前导度
f.实例
>>> from sympy.polys.galoistools import gf_degree
>>> gf_degree([1, 1, 2, 0]) 3 >>> gf_degree([]) -1
- sympy.polys.galoistools.gf_LC(f, K)[源代码]#
返回前导系数
f.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_LC
>>> gf_LC([3, 0, 1], ZZ) 3
- sympy.polys.galoistools.gf_TC(f, K)[源代码]#
返回
f.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_TC
>>> gf_TC([3, 0, 1], ZZ) 1
- sympy.polys.galoistools.gf_strip(f)[源代码]#
从中删除前导零
f.实例
>>> from sympy.polys.galoistools import gf_strip
>>> gf_strip([0, 0, 0, 3, 0, 1]) [3, 0, 1]
- sympy.polys.galoistools.gf_trunc(f, p)[源代码]#
减所有系数的模
p.实例
>>> from sympy.polys.galoistools import gf_trunc
>>> gf_trunc([7, -2, 3], 5) [2, 3, 3]
- sympy.polys.galoistools.gf_normal(f, p, K)[源代码]#
规范化所有系数
K.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_normal
>>> gf_normal([5, 10, 21, -3], 5, ZZ) [1, 2]
- sympy.polys.galoistools.gf_from_dict(f, p, K)[源代码]#
创建一个
GF(p)[x]从dicta多项式。实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_from_dict
>>> gf_from_dict({10: ZZ(4), 4: ZZ(33), 0: ZZ(-1)}, 5, ZZ) [4, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4]
- sympy.polys.galoistools.gf_to_dict(f, p, symmetric=True)[源代码]#
转换为
GF(p)[x]多项式到一个字典。实例
>>> from sympy.polys.galoistools import gf_to_dict
>>> gf_to_dict([4, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4], 5) {0: -1, 4: -2, 10: -1} >>> gf_to_dict([4, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4], 5, symmetric=False) {0: 4, 4: 3, 10: 4}
- sympy.polys.galoistools.gf_from_int_poly(f, p)[源代码]#
创建一个
GF(p)[x]多项式自Z[x].实例
>>> from sympy.polys.galoistools import gf_from_int_poly
>>> gf_from_int_poly([7, -2, 3], 5) [2, 3, 3]
- sympy.polys.galoistools.gf_to_int_poly(f, p, symmetric=True)[源代码]#
转换为
GF(p)[x]多项式到Z[x].实例
>>> from sympy.polys.galoistools import gf_to_int_poly
>>> gf_to_int_poly([2, 3, 3], 5) [2, -2, -2] >>> gf_to_int_poly([2, 3, 3], 5, symmetric=False) [2, 3, 3]
- sympy.polys.galoistools.gf_neg(f, p, K)[源代码]#
求多项式的反
GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_neg
>>> gf_neg([3, 2, 1, 0], 5, ZZ) [2, 3, 4, 0]
- sympy.polys.galoistools.gf_add_ground(f, a, p, K)[源代码]#
计算
f + a在哪里？f在里面GF(p)[x]和a在里面GF(p).实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_add_ground
>>> gf_add_ground([3, 2, 4], 2, 5, ZZ) [3, 2, 1]
- sympy.polys.galoistools.gf_sub_ground(f, a, p, K)[源代码]#
计算
f - a在哪里？f在里面GF(p)[x]和a在里面GF(p).实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_sub_ground
>>> gf_sub_ground([3, 2, 4], 2, 5, ZZ) [3, 2, 2]
- sympy.polys.galoistools.gf_mul_ground(f, a, p, K)[源代码]#
计算
f * a在哪里？f在里面GF(p)[x]和a在里面GF(p).实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_mul_ground
>>> gf_mul_ground([3, 2, 4], 2, 5, ZZ) [1, 4, 3]
- sympy.polys.galoistools.gf_quo_ground(f, a, p, K)[源代码]#
计算
f/a在哪里？f在里面GF(p)[x]和a在里面GF(p).实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_quo_ground
>>> gf_quo_ground(ZZ.map([3, 2, 4]), ZZ(2), 5, ZZ) [4, 1, 2]
- sympy.polys.galoistools.gf_add(f, g, p, K)[源代码]#
在中添加多项式
GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_add
>>> gf_add([3, 2, 4], [2, 2, 2], 5, ZZ) [4, 1]
- sympy.polys.galoistools.gf_sub(f, g, p, K)[源代码]#
减去多项式
GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_sub
>>> gf_sub([3, 2, 4], [2, 2, 2], 5, ZZ) [1, 0, 2]
- sympy.polys.galoistools.gf_mul(f, g, p, K)[源代码]#
乘法多项式
GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_mul
>>> gf_mul([3, 2, 4], [2, 2, 2], 5, ZZ) [1, 0, 3, 2, 3]
- sympy.polys.galoistools.gf_sqr(f, p, K)[源代码]#
平方多项式
GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_sqr
>>> gf_sqr([3, 2, 4], 5, ZZ) [4, 2, 3, 1, 1]
- sympy.polys.galoistools.gf_add_mul(f, g, h, p, K)[源代码]#
返回
f + g*h在哪里？f，g，h在里面GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_add_mul >>> gf_add_mul([3, 2, 4], [2, 2, 2], [1, 4], 5, ZZ) [2, 3, 2, 2]
- sympy.polys.galoistools.gf_sub_mul(f, g, h, p, K)[源代码]#
计算
f - g*h在哪里？f，g，h在里面GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_sub_mul
>>> gf_sub_mul([3, 2, 4], [2, 2, 2], [1, 4], 5, ZZ) [3, 3, 2, 1]
- sympy.polys.galoistools.gf_expand(F, p, K)[源代码]#
展开结果
factor()在里面GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_expand
>>> gf_expand([([3, 2, 4], 1), ([2, 2], 2), ([3, 1], 3)], 5, ZZ) [4, 3, 0, 3, 0, 1, 4, 1]
- sympy.polys.galoistools.gf_div(f, g, p, K)[源代码]#
余数除法
GF(p)[x].给定一元多项式
f和g有限域中的系数p元素，返回多项式q和r（商和余数）使f = q*g + r.考虑多项式
x**3 + x + 1和x**2 + x在GF（2）中：>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_div, gf_add_mul >>> gf_div(ZZ.map([1, 0, 1, 1]), ZZ.map([1, 1, 0]), 2, ZZ) ([1, 1], [1])
结果我们得到了商
x + 1和余数1，因此：>>> gf_add_mul(ZZ.map([1]), ZZ.map([1, 1]), ZZ.map([1, 1, 0]), 2, ZZ) [1, 0, 1, 1]
工具书类
- sympy.polys.galoistools.gf_rem(f, g, p, K)[源代码]#
计算多项式余数
GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_rem
>>> gf_rem(ZZ.map([1, 0, 1, 1]), ZZ.map([1, 1, 0]), 2, ZZ) [1]
- sympy.polys.galoistools.gf_quo(f, g, p, K)[源代码]#
计算精确商
GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_quo
>>> gf_quo(ZZ.map([1, 0, 1, 1]), ZZ.map([1, 1, 0]), 2, ZZ) [1, 1] >>> gf_quo(ZZ.map([1, 0, 3, 2, 3]), ZZ.map([2, 2, 2]), 5, ZZ) [3, 2, 4]
- sympy.polys.galoistools.gf_exquo(f, g, p, K)[源代码]#
计算多项式商
GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_exquo
>>> gf_exquo(ZZ.map([1, 0, 3, 2, 3]), ZZ.map([2, 2, 2]), 5, ZZ) [3, 2, 4]
>>> gf_exquo(ZZ.map([1, 0, 1, 1]), ZZ.map([1, 1, 0]), 2, ZZ) Traceback (most recent call last): ... ExactQuotientFailed: [1, 1, 0] does not divide [1, 0, 1, 1]
- sympy.polys.galoistools.gf_lshift(f, n, K)[源代码]#
高效倍增
f通过x**n.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_lshift
>>> gf_lshift([3, 2, 4], 4, ZZ) [3, 2, 4, 0, 0, 0, 0]
- sympy.polys.galoistools.gf_rshift(f, n, K)[源代码]#
有效地划分
f通过x**n.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_rshift
>>> gf_rshift([1, 2, 3, 4, 0], 3, ZZ) ([1, 2], [3, 4, 0])
- sympy.polys.galoistools.gf_pow(f, n, p, K)[源代码]#
计算
f**n在里面GF(p)[x]使用重复的平方。实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_pow
>>> gf_pow([3, 2, 4], 3, 5, ZZ) [2, 4, 4, 2, 2, 1, 4]
- sympy.polys.galoistools.gf_pow_mod(f, n, g, p, K)[源代码]#
计算
f**n在里面GF(p)[x]/(g)使用重复的平方。给定多项式
f和g在里面GF(p)[x]和一个非负整数n，有效地计算f**n (mod g)i、 e.剩余的f**n从除法依据g，使用重复平方算法。实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_pow_mod
>>> gf_pow_mod(ZZ.map([3, 2, 4]), 3, ZZ.map([1, 1]), 5, ZZ) []
工具书类
- sympy.polys.galoistools.gf_gcd(f, g, p, K)[源代码]#
欧几里德算法
GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_gcd
>>> gf_gcd(ZZ.map([3, 2, 4]), ZZ.map([2, 2, 3]), 5, ZZ) [1, 3]
- sympy.polys.galoistools.gf_lcm(f, g, p, K)[源代码]#
计算多项式LCM
GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_lcm
>>> gf_lcm(ZZ.map([3, 2, 4]), ZZ.map([2, 2, 3]), 5, ZZ) [1, 2, 0, 4]
- sympy.polys.galoistools.gf_cofactors(f, g, p, K)[源代码]#
计算多项式GCD和余因子
GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_cofactors
>>> gf_cofactors(ZZ.map([3, 2, 4]), ZZ.map([2, 2, 3]), 5, ZZ) ([1, 3], [3, 3], [2, 1])
- sympy.polys.galoistools.gf_gcdex(f, g, p, K)[源代码]#
扩展欧几里德算法
GF(p)[x].给定多项式
f和g在里面GF(p)[x]，计算多项式s，t和h，这样h = gcd(f, g)和s*f + t*g = h. EEA的典型应用是求解多项式丢番图方程。考虑多项式
f = (x + 7) (x + 1)，g = (x + 7) (x**2 + 1)在里面GF(11)[x]. 扩展欧几里德算法的应用给出：>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_gcdex, gf_mul, gf_add >>> s, t, g = gf_gcdex(ZZ.map([1, 8, 7]), ZZ.map([1, 7, 1, 7]), 11, ZZ) >>> s, t, g ([5, 6], [6], [1, 7])
我们得到了多项式
s = 5*x + 6和t = 6，以及其他gcd(f, g) = x + 7. 这是正确的，因为：>>> S = gf_mul(s, ZZ.map([1, 8, 7]), 11, ZZ) >>> T = gf_mul(t, ZZ.map([1, 7, 1, 7]), 11, ZZ) >>> gf_add(S, T, 11, ZZ) == [1, 7] True
工具书类
- sympy.polys.galoistools.gf_monic(f, p, K)[源代码]#
计算LC和monic多项式
GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_monic
>>> gf_monic(ZZ.map([3, 2, 4]), 5, ZZ) (3, [1, 4, 3])
- sympy.polys.galoistools.gf_diff(f, p, K)[源代码]#
微分多项式
GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_diff
>>> gf_diff([3, 2, 4], 5, ZZ) [1, 2]
- sympy.polys.galoistools.gf_eval(f, a, p, K)[源代码]#
评估
f(a)在里面GF(p)使用霍纳方案。实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_eval
>>> gf_eval([3, 2, 4], 2, 5, ZZ) 0
- sympy.polys.galoistools.gf_multi_eval(f, A, p, K)[源代码]#
评估
f(a)对于a在里面[a_1, ..., a_n].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_multi_eval
>>> gf_multi_eval([3, 2, 4], [0, 1, 2, 3, 4], 5, ZZ) [4, 4, 0, 2, 0]
- sympy.polys.galoistools.gf_compose(f, g, p, K)[源代码]#
计算多项式组成
f(g)在里面GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_compose
>>> gf_compose([3, 2, 4], [2, 2, 2], 5, ZZ) [2, 4, 0, 3, 0]
- sympy.polys.galoistools.gf_compose_mod(g, h, f, p, K)[源代码]#
计算多项式组成
g(h)在里面GF(p)[x]/(f).实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_compose_mod
>>> gf_compose_mod(ZZ.map([3, 2, 4]), ZZ.map([2, 2, 2]), ZZ.map([4, 3]), 5, ZZ) [4]
- sympy.polys.galoistools.gf_trace_map(a, b, c, n, f, p, K)[源代码]#
计算多项式迹映射
GF(p)[x]/(f).给定多项式
f在里面GF(p)[x]，多项式a，b，c在商环中GF(p)[x]/(f)这样的话b = c**t (mod f)为了一些积极的力量t属于p，和一个正整数n，返回映射：a -> a**t**n, a + a**t + a**t**2 + ... + a**t**n (mod f)
在因式分解中，
b = x**p mod f和c = x mod f. 这样我们就可以在等次因式分解程序中高效地计算迹多项式，比其他方法（如迭代Frobenius算法）快得多。实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_trace_map
>>> gf_trace_map([1, 2], [4, 4], [1, 1], 4, [3, 2, 4], 5, ZZ) ([1, 3], [1, 3])
工具书类
- sympy.polys.galoistools.gf_random(n, p, K)[源代码]#
在中生成随机多项式
GF(p)[x]程度的n.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_random >>> gf_random(10, 5, ZZ) [1, 2, 3, 2, 1, 1, 1, 2, 0, 4, 2]
- sympy.polys.galoistools.gf_irreducible(n, p, K)[源代码]#
生成随机不可约次多项式
n在里面GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_irreducible >>> gf_irreducible(10, 5, ZZ) [1, 4, 2, 2, 3, 2, 4, 1, 4, 0, 4]
- sympy.polys.galoistools.gf_irreducible_p(f, p, K)[源代码]#
多项式不可约性的检验
f在里面GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_irreducible_p
>>> gf_irreducible_p(ZZ.map([1, 4, 2, 2, 3, 2, 4, 1, 4, 0, 4]), 5, ZZ) True >>> gf_irreducible_p(ZZ.map([3, 2, 4]), 5, ZZ) False
- sympy.polys.galoistools.gf_sqf_p(f, p, K)[源代码]#
返回
True如果f是自由的吗GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_sqf_p
>>> gf_sqf_p(ZZ.map([3, 2, 4]), 5, ZZ) True >>> gf_sqf_p(ZZ.map([2, 4, 4, 2, 2, 1, 4]), 5, ZZ) False
- sympy.polys.galoistools.gf_sqf_part(f, p, K)[源代码]#
返回a的正方形自由部分
GF(p)[x]多项式的。实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_sqf_part
>>> gf_sqf_part(ZZ.map([1, 1, 3, 0, 1, 0, 2, 2, 1]), 5, ZZ) [1, 4, 3]
- sympy.polys.galoistools.gf_sqf_list(f, p, K, all=False)[源代码]#
返回a的平方自由分解
GF(p)[x]多项式的。Given a polynomial
finGF(p)[x], returns the leading coefficient offand a square-free decompositionf_1**e_1 f_2**e_2 ... f_k**e_ksuch that allf_iare monic polynomials and(f_i, f_j)fori != jare co-prime ande_1 ... e_kare given in increasing order. All trivial terms (i.e.f_i = 1) are not included in the output.考虑多项式
f = x**11 + 1结束GF(11)[x]：：>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import ( ... gf_from_dict, gf_diff, gf_sqf_list, gf_pow, ... ) ... >>> f = gf_from_dict({11: ZZ(1), 0: ZZ(1)}, 11, ZZ)
注意
f'(x) = 0：：>>> gf_diff(f, 11, ZZ) []
This phenomenon does not happen in characteristic zero. However we can still compute square-free decomposition of
fusinggf_sqf():>>> gf_sqf_list(f, 11, ZZ) (1, [([1, 1], 11)])
我们得到了因式分解
f = (x + 1)**11. 这是正确的，因为：>>> gf_pow([1, 1], 11, 11, ZZ) == f True
工具书类
- sympy.polys.galoistools.gf_Qmatrix(f, p, K)[源代码]#
计算Berlekamp's
Q矩阵。实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_Qmatrix
>>> gf_Qmatrix([3, 2, 4], 5, ZZ) [[1, 0], [3, 4]]
>>> gf_Qmatrix([1, 0, 0, 0, 1], 5, ZZ) [[1, 0, 0, 0], [0, 4, 0, 0], [0, 0, 1, 0], [0, 0, 0, 4]]
- sympy.polys.galoistools.gf_Qbasis(Q, p, K)[源代码]#
计算
Q.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_Qmatrix, gf_Qbasis
>>> gf_Qbasis(gf_Qmatrix([1, 0, 0, 0, 1], 5, ZZ), 5, ZZ) [[1, 0, 0, 0], [0, 0, 1, 0]]
>>> gf_Qbasis(gf_Qmatrix([3, 2, 4], 5, ZZ), 5, ZZ) [[1, 0]]
- sympy.polys.galoistools.gf_berlekamp(f, p, K)[源代码]#
无平方因子
f在里面GF(p)[x]对于小型p.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_berlekamp
>>> gf_berlekamp([1, 0, 0, 0, 1], 5, ZZ) [[1, 0, 2], [1, 0, 3]]
- sympy.polys.galoistools.gf_zassenhaus(f, p, K)[源代码]#
无平方因子
f在里面GF(p)[x]对于介质p.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_zassenhaus
>>> gf_zassenhaus(ZZ.map([1, 4, 3]), 5, ZZ) [[1, 1], [1, 3]]
- sympy.polys.galoistools.gf_shoup(f, p, K)[源代码]#
无平方因子
f在里面GF(p)[x]大的p.实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_shoup
>>> gf_shoup(ZZ.map([1, 4, 3]), 5, ZZ) [[1, 1], [1, 3]]
- sympy.polys.galoistools.gf_factor_sqf(f, p, K, method=None)[源代码]#
因子无平方多项式
f在里面GF(p)[x].实例
>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_factor_sqf
>>> gf_factor_sqf(ZZ.map([3, 2, 4]), 5, ZZ) (3, [[1, 1], [1, 3]])
- sympy.polys.galoistools.gf_factor(f, p, K)[源代码]#
因子（非平方自由）多项式
GF(p)[x].给出一个可能的非平方自由多项式
f在里面GF(p)[x]，返回其不可约的完全因式分解：f_1(x)**e_1 f_2(x)**e_2 ... f_d(x)**e_d
每一个
f_i是一元多项式gcd(f_i, f_j) == 1，为了i != j. 结果被作为一个由导系数组成的元组给出f以及一系列因素f他们的多样性。该算法首先计算
f然后迭代分解每个无平方因子。考虑一个非平方自由多项式
f = (7*x + 1) (x + 2)**2在里面GF(11)[x]. 我们得到它的不可约因子分解如下：>>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_factor >>> gf_factor(ZZ.map([5, 2, 7, 2]), 11, ZZ) (5, [([1, 2], 1), ([1, 8], 2)])
We arrived with factorization
f = 5 (x + 2) (x + 8)**2. We did not recover the exact form of the input polynomial because we requested to get monic factors offand its leading coefficient separately.平方自由因子
f不可简化为不可分解的GF(p)使用三种截然不同的方法：- 贝莱坎普
对于非常小的值非常有效
p（通常p < 25）- 康托·扎森豪斯
有效的平均投入和“典型”
p- Shoup Kaltofen Gathen公司
高效，输入和模数非常大
如果要使用特定的因子分解方法，而不是默认的方法，请设置
GF_FACTOR_METHOD其中一个berlekamp，zassenhaus或shoup价值观。工具书类
- sympy.polys.galoistools.gf_value(f, a)[源代码]#
字段R中“a”处多项式“f”的值。
实例
>>> from sympy.polys.galoistools import gf_value
>>> gf_value([1, 7, 2, 4], 11) 2204
- sympy.polys.galoistools.gf_csolve(f, n)[源代码]#
求f（x）同余0模（n）。
将n划分为典型因子，并对每个因子求解f（x）cong 0 mod（p**e）。将中国剩余定理应用于结果，返回最终答案。
实例
解决 [1，1，7] 全等0模（189）：
>>> from sympy.polys.galoistools import gf_csolve >>> gf_csolve([1, 1, 7], 189) [13, 49, 76, 112, 139, 175]
参见
sympy.ntheory.residue_ntheory.polynomial_congruencea higher level solving routine
工具书类
[R792]《数论导论》第五版，作者：伊万·尼文、扎克曼和蒙哥马利。
稀疏分布多项式和向量的处理#
Dense representations quickly require infeasible amounts of storage and
computation time if the number of variables increases. For this reason,
there is code to manipulate polynomials in a sparse representation. The Ring
object and elements are implemented by the classes PolyRing and
PolyElement.
在交换代数中，人们不仅研究多项式，而且还研究多项式 模块 多项式环上。多项式操作模块为有限生成的自由模块提供了基本的低级支持。这主要用于Groebner基计算（参见此处），因此操作函数只提供给所需的扩展。它们带有前缀 sdm_ . 注意，在示例中，自由模块的生成器称为 \(f_1, f_2, \ldots\) .
- sympy.polys.distributedmodules.sdm_monomial_mul(M, X)[源代码]#
乘法元组
X表示单项式的 \(K[X]\) 进入元组M表示单项式的 \(F\) .实例
倍增 \(xy^3\) 进入之内 \(x f_1\) 产量 \(x^2 y^3 f_1\) ：
>>> from sympy.polys.distributedmodules import sdm_monomial_mul >>> sdm_monomial_mul((1, 1, 0), (1, 3)) (1, 2, 3)
- sympy.polys.distributedmodules.sdm_monomial_deg(M)[源代码]#
返回
M.实例
例如 \(x^2 y f_5\) 是3：
>>> from sympy.polys.distributedmodules import sdm_monomial_deg >>> sdm_monomial_deg((5, 2, 1)) 3
- sympy.polys.distributedmodules.sdm_monomial_divides(A, B)[源代码]#
是否存在一个（多项式）单项式X，使得XA=B？
实例
正面例子：
在下面的例子中，单项式是以x，y和生成器，f_1，f_2等形式给出的。该单项式的元组形式用于调用sdm_monogical_divides。注意：生成器在表达式中最后出现，但在元组中第一个出现，其他因子的出现顺序与它们在单项式表达式中的顺序相同。
\(A = f_1\) divides \(B = f_1\)
>>> from sympy.polys.distributedmodules import sdm_monomial_divides >>> sdm_monomial_divides((1, 0, 0), (1, 0, 0)) True
\(A = f_1\) divides \(B = x^2 y f_1\)
>>> sdm_monomial_divides((1, 0, 0), (1, 2, 1)) True
\(A = xy f_5\) divides \(B = x^2 y f_5\)
>>> sdm_monomial_divides((5, 1, 1), (5, 2, 1)) True
反面例子：
\(A = f_1\) does not divide \(B = f_2\)
>>> sdm_monomial_divides((1, 0, 0), (2, 0, 0)) False
\(A = x f_1\) does not divide \(B = f_1\)
>>> sdm_monomial_divides((1, 1, 0), (1, 0, 0)) False
\(A = xy^2 f_5\) does not divide \(B = y f_5\)
>>> sdm_monomial_divides((5, 1, 2), (5, 0, 1)) False
- sympy.polys.distributedmodules.sdm_from_dict(d, O)[源代码]#
从字典创建sdm。
在这里
O是要使用的单项式顺序。实例
>>> from sympy.polys.distributedmodules import sdm_from_dict >>> from sympy.polys import QQ, lex >>> dic = {(1, 1, 0): QQ(1), (1, 0, 0): QQ(2), (0, 1, 0): QQ(0)} >>> sdm_from_dict(dic, lex) [((1, 1, 0), 1), ((1, 0, 0), 2)]
- sympy.polys.distributedmodules.sdm_add(f, g, O, K)[源代码]#
添加两个模块元素
f，g.在地面上进行加法运算
K，单项式根据O.实例
所有例子都使用字典序。
\((xy f_1) + (f_2) = f_2 + xy f_1\)
>>> from sympy.polys.distributedmodules import sdm_add >>> from sympy.polys import lex, QQ >>> sdm_add([((1, 1, 1), QQ(1))], [((2, 0, 0), QQ(1))], lex, QQ) [((2, 0, 0), 1), ((1, 1, 1), 1)]
\((xy f_1) + (-xy f_1)\) = 0`
>>> sdm_add([((1, 1, 1), QQ(1))], [((1, 1, 1), QQ(-1))], lex, QQ) []
\((f_1) + (2f_1) = 3f_1\)
>>> sdm_add([((1, 0, 0), QQ(1))], [((1, 0, 0), QQ(2))], lex, QQ) [((1, 0, 0), 3)]
\((yf_1) + (xf_1) = xf_1 + yf_1\)
>>> sdm_add([((1, 0, 1), QQ(1))], [((1, 1, 0), QQ(1))], lex, QQ) [((1, 1, 0), 1), ((1, 0, 1), 1)]
- sympy.polys.distributedmodules.sdm_LM(f)[源代码]#
返回的前导单项式
f.仅在以下情况下有效 \(f \ne 0\) .
实例
>>> from sympy.polys.distributedmodules import sdm_LM, sdm_from_dict >>> from sympy.polys import QQ, lex >>> dic = {(1, 2, 3): QQ(1), (4, 0, 0): QQ(1), (4, 0, 1): QQ(1)} >>> sdm_LM(sdm_from_dict(dic, lex)) (4, 0, 1)
- sympy.polys.distributedmodules.sdm_LT(f)[源代码]#
返回的前导项
f.仅在以下情况下有效 \(f \ne 0\) .
实例
>>> from sympy.polys.distributedmodules import sdm_LT, sdm_from_dict >>> from sympy.polys import QQ, lex >>> dic = {(1, 2, 3): QQ(1), (4, 0, 0): QQ(2), (4, 0, 1): QQ(3)} >>> sdm_LT(sdm_from_dict(dic, lex)) ((4, 0, 1), 3)
- sympy.polys.distributedmodules.sdm_mul_term(f, term, O, K)[源代码]#
乘以分布式模块元素
f通过（多项式）项term.系数的乘法是在地磁场上进行的
K，单体的顺序如下所示O.实例
\(0 f_1 = 0\)
>>> from sympy.polys.distributedmodules import sdm_mul_term >>> from sympy.polys import lex, QQ >>> sdm_mul_term([((1, 0, 0), QQ(1))], ((0, 0), QQ(0)), lex, QQ) []
\(x 0 = 0\)
>>> sdm_mul_term([], ((1, 0), QQ(1)), lex, QQ) []
\((x) (f_1) = xf_1\)
>>> sdm_mul_term([((1, 0, 0), QQ(1))], ((1, 0), QQ(1)), lex, QQ) [((1, 1, 0), 1)]
\((2xy) (3x f_1 + 4y f_2) = 8xy^2 f_2 + 6x^2y f_1\)
>>> f = [((2, 0, 1), QQ(4)), ((1, 1, 0), QQ(3))] >>> sdm_mul_term(f, ((1, 1), QQ(2)), lex, QQ) [((2, 1, 2), 8), ((1, 2, 1), 6)]
- sympy.polys.distributedmodules.sdm_deg(f)[源代码]#
度
f.这是它所有单项式的最大度数。无效if
f是零。实例
>>> from sympy.polys.distributedmodules import sdm_deg >>> sdm_deg([((1, 2, 3), 1), ((10, 0, 1), 1), ((2, 3, 4), 4)]) 7
- sympy.polys.distributedmodules.sdm_from_vector(vec, O, K, **opts)[源代码]#
从表达式的iterable创建sdm。
系数在“地面”字段中创建
K，项按单项式顺序排列O. 命名参数被传递到polys转换代码，并可用于指定示例生成器。实例
>>> from sympy.polys.distributedmodules import sdm_from_vector >>> from sympy.abc import x, y, z >>> from sympy.polys import QQ, lex >>> sdm_from_vector([x**2+y**2, 2*z], lex, QQ) [((1, 0, 0, 1), 2), ((0, 2, 0, 0), 1), ((0, 0, 2, 0), 1)]
- sympy.polys.distributedmodules.sdm_to_vector(f, gens, K, n=None)[源代码]#
转换sdm
f在多项式表达式列表中。多项式环的生成器通过
gens. 模块的等级是猜测的，或者通过n. 地面场假定为K.实例
>>> from sympy.polys.distributedmodules import sdm_to_vector >>> from sympy.abc import x, y, z >>> from sympy.polys import QQ >>> f = [((1, 0, 0, 1), QQ(2)), ((0, 2, 0, 0), QQ(1)), ((0, 0, 2, 0), QQ(1))] >>> sdm_to_vector(f, [x, y, z], QQ) [x**2 + y**2, 2*z]
多项式因式分解算法#
欧几里得算法的许多变体：
经典余数序列#
让 \(K\) 作为一个领域，并考虑戒指 \(K[X]\) 一个不确定多项式 \(X\) 系数为 \(K\) . 给定两个元素 \(f\) 和 \(g\) 属于 \(K[X]\) 具有 \(g\neq 0\) 有唯一多项式 \(q\) 和 \(r\) 这样的话 \(f = qg + r\) 和 \(\deg(r) < \deg(g)\) 或 \(r = 0\) . 它们表示为 \(\mathrm{{quo}}(f,g)\) （ 商 ） \(\mathrm{{rem}}(f,g)\) （ 余数 )，所以我们有 部门标识
所以每个理想 \(I\) 属于 \(K[X]\) 是由任何元素生成的主理想 \(\neq 0\) 最低程度（假设 \(I\) 非零）。事实上，如果 \(g\) 是一个多项式 \(f\) 是的任何元素 \(I\) ， \(\mathrm{{rem}}(f,g)\) 属于 \(I\) 作为线性组合 \(f\) 和 \(g\) ，因此必须为零；因此 \(f\) 是的倍数 \(g\) .
使用此结果可以找到 greatest common divisor （gcd）任何多项式的 \(f,g,\ldots\) 在里面 \(K[X]\) .如果 \(I\) 是由给定多项式的所有线性组合所形成的理想值 \(K[X]\) 和 \(d\) 是它的生成元，那么多项式的每一个公约数也被除 \(d\) . 另一方面，给定的多项式是生成元的倍数 \(d\) ；因此 \(d\) 是多项式的gcd，表示为 \(\mathrm{{gcd}}(f,g,\ldots)\) .
两个多项式的gcd算法 \(f\) 和 \(g\) 在里面 \(K[X]\) 现在可以得到如下结果。根据部门身份， \(r = \mathrm{{rem}}(f,g)\) 是在理想中产生的 \(f\) 和 \(g\) 以及 \(f\) 是在理想中产生的 \(g\) 和 \(r\) . 由此产生了由对产生的理想 \((f,g)\) 和 \((g,r)\) 都是一样的。设置 \(f_0 = f\) ， \(f_1 = g\) ，并递归定义 \(f_i = \mathrm{{rem}}(f_{{i-2}},f_{{i-1}})\) 对于 \(i\ge 2\) . 递归在有限步数后结束，使用 \(f_{{k+1}}=0\) ，因为多项式的度数是严格递减的。根据上面的话，所有的对 \((f_{{i-1}},f_i)\) 产生同样的理想。尤其是由 \(f\) 和 \(g\) 由生成 \(f_k\) 独自一人 \(f_{{k+1}} = 0\) . 因此 \(d = f_k\) gcd是 \(f\) 和 \(g\) .
多项式序列 \(f_0\), \(f_1,\ldots, f_k\) is called the Euclidean polynomial remainder sequence determined by \((f,g)\) because of the analogy with the classical Euclidean algorithm 对于自然数的gcd。
该算法可以被扩展以获得 \(d\) 依据 \(f\) 和 \(g\) 通过使用全除法恒等式递归地编写每个 \(f_i\) 作为线性组合 \(f\) 和 \(g\) . 这就产生了一个等式
类似于 Bézout's identity 对于整数。
- sympy.polys.euclidtools.dmp_half_gcdex(f, g, u, K)[源代码]#
半扩展欧几里德算法 \(F[X]\) .
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
- sympy.polys.euclidtools.dmp_gcdex(f, g, u, K)[源代码]#
扩展欧几里德算法 \(F[X]\) .
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
简化余数序列#
像往常一样，假设系数场 \(K\) 是积分域的分数域 \(A\) . 在这种情况下，欧几里德余数序列中多项式的系数（分子和分母）往往增长得非常快。
如果 \(A\) 是一个唯一的因式分解域，可以通过消除分子和分母的公因子来减少系数。进一步的简化是可能的，注意到 \(K[X]\) 不是唯一的：它可以乘以任何（非零）常数因子。
任意多项式 \(f\) 在里面 \(K[X]\) 可以通过提取其系数分子的分母和公因子来简化。这就产生了表示 \(f = cF\) 在哪里？ \(c\in K\) 是 内容 属于 \(f\) 和 \(F\) 是一个 原始的 多项式，即 \(A[X]\) 有互质系数。
可以通过替换给定多项式来启动算法 \(f\) 和 \(g\) 它们的原始部分。这只会修改 \(\mathrm{{rem}}(f,g)\) 一个常数因子。用它的本原部分代替它，递归地继续得到欧氏余数序列中多项式的所有本原部分，包括本原 \(\mathrm{{gcd}}(f,g)\) .
这个序列是 本原多项式余数序列 . 这是一个例子 一般多项式余数序列 其中计算的余数被常数乘数（或除数）修改，以简化结果。
子合成序列#
原始多项式序列的系数并没有过大的增长，但原始部分的计算需要额外的处理工作。此外，该方法只适用于唯一因子分解域的分数域，不包括一般的数域。
柯林斯 [柯林斯67] 意识到所谓的 次结式多项式 一对多项式也构成了广义余数序列。这些多项式的系数可表示为给定多项式系数的行列式。因此，它们的大小（对数）只能线性增长。另外，如果给定多项式的系数在子域中 \(A\) 次结式多项式也是如此。这意味着子结果序列与原始余数序列相似，而不依赖于 \(A\) .
为了了解子结果如何与余数序列相关联，请回忆一下所有的多项式 \(h\) 序列中是给定多项式的线性组合 \(f\) 和 \(g\)
用多项式 \(u\) 和 \(v\) 在里面 \(K[X]\) . 此外，从扩展的欧几里德算法中可以看出 \(u\) 和 \(v\) 相对较低，一步一步增长有限。
Let \(n = \deg(f)\), and \(m = \deg(g)\), and assume \(n\ge m\). If \(\deg(h) = j < m\), the coefficients of the powers \(X^k\) (\(k > j\)) in the products \(uf\) and \(vg\) cancel each other. In particular, the products must have the same degree, say, \(l\). Then \(\deg(u) = l - n\) and \(\deg(v) = l - m\) with a total of \(2l -n - m + 2\) coefficients to be determined.
On the other hand, the equality \(h = uf + vg\) implies that \(l - j\) linear combinations of the coefficients are zero, those associated with the powers \(X^i\) (\(j < i \leq l\)), and one has a given non-zero value, namely the leading coefficient of \(h\).
为了满足这些要求 \(l - j + 1\) 线性方程待确定的系数总数不能低于 \(l - j + 1\) ，一般来说。这就导致了不平等 \(l \ge n + m - j - 1\) . 拿 \(l = n + m - j - 1\) ，我们得到 \(\deg(u) = m - j - 1\) 和 \(\deg(v) = n - j - 1\) .
在案件中 \(j = 0\) the matrix of the resulting system of linear equations is the Sylvester matrix \(S(f,g)\) associated to \(f\) and \(g\), an \((n+m)\times (n+m)\) matrix with coefficients of \(f\) and \(g\) as entries. Its determinant is the resultant \(\mathrm{{res}}(f,g)\) 一对的 \((f,g)\) . 非零当且仅当 \(f\) 和 \(g\) 相对最好。
对于任何 \(j\) 间隔时间 \(0\) 到 \(m\) 线性系统的矩阵是 \((n+m-2j)\times (n+m-2j)\) 西尔维斯特矩阵的子阵。其决定因素 \(s_j(f,g)\) 被称为 \(j\) 钍 标量子合成 属于 \(f\) 和 \(g\) .
如果 \(s_j(f,g)\) 不是零，关联的方程 \(h = uf + vg\) 有一个独特的解决方案 \(\deg(h) = j\) 以及 \(h\) 具有任何给定的值；具有领先系数的值 \(s_j(f,g)\) 是 \(j\) 钍 次结式多项式 或者，简单地说， 子结果 一对的 \((f,g)\) ，并表示 \(S_j(f,g)\) . 这种选择保证了剩余系数也是西尔维斯特矩阵的某些子行列式。特别是，如果 \(f\) 和 \(g\) 在 \(A[X]\) ，也是 \(S_j(f,g)\) 也。子结果的这种结构适用于任何 \(j\) 之间 \(0\) 和 \(m\) 不管价值 \(s_j(f,g)\) ；如果为零，则 \(\deg(S_j(f,g)) < j\) .
子结果的性质如下。让 \(n_0 = \deg(f)\) ， \(n_1 = \deg(g)\) ， \(n_2, \ldots, n_k\) 是余数序列中多项式次数的递减序列。让 \(0 \le j \le n_1\) ；然后
\(s_j(f,g)\ne 0\) 当且仅当 \(j = n_i\) 对某些人来说 \(i\) .
\(S_j(f,g)\ne 0\) 当且仅当 \(j = n_i\) 或 \(j = n_i - 1\) 对某些人来说 \(i\) .
通常情况下， \(n_{{i-1}} - n_i = 1\) 对于 \(1 < i \le k\) .如果 \(n_{{i-1}} - n_i > 1\) 对某些人来说 \(i\) (the 反常的 案例），那么 \(S_{{n_{{i-1}}-1}}(f,g)\) 和 \(S_{{n_i}}(f,g)\) 是彼此的常数倍数。因此任何一个都可以包含在多项式余数序列中。前者由更小的行列式给出，所以它的系数应该更小。
柯林斯定义了 子余数序列 通过设置
在正常情况下，这些与 \(S_{{n_i}}(f,g)\) . 他还导出了常数的表达式 \(\gamma_i\) 在余数公式中
根据 \(f_1,\ldots,f_{{i-1}}\) ，在野外工作 \(K\) .
布朗和特劳布 [布朗特拉布71] 后来发展了一种计算系数的递归程序 \(\gamma_i\) . 他们的算法处理域的元素 \(A\) 排他性（假设 \(f,g\in A[X]\) ). 然而，在异常情况下却出现了一个问题，即 \(A\) 只能推测是准确的。
随后布朗证明了这一点 [布朗78] 他证明了除法的结果实际上是一个标量子结果。更具体地说，在计算 \(f_i\) 是 \(s_{{n_{{i-2}}}}(f,g)\) （定理3）。这个发现的含义是标量子结果作为算法的副产品来计算，除了 \(s_{{n_k}}(f,g)\) 找到后就不需要了 \(f_{{k+1}} = 0\) . 完成最后一步，我们得到所有非零标量子结果，包括最后一个，如果这个结果不为零，则为结果。
- sympy.polys.euclidtools.dmp_inner_subresultants(f, g, u, K)[源代码]#
子结果PRS算法 \(K[X]\) .
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = 3*x**2*y - y**3 - 4 >>> g = x**2 + x*y**3 - 9
>>> a = 3*x*y**4 + y**3 - 27*y + 4 >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16
>>> prs = [f, g, a, b] >>> sres = [[1], [1], [3, 0, 0, 0, 0], [-3, 0, 0, -12, 1, 0, -54, 8, 729, -216, 16]]
>>> R.dmp_inner_subresultants(f, g) == (prs, sres) True
- sympy.polys.euclidtools.dmp_subresultants(f, g, u, K)[源代码]#
计算 \(K[X]\) .
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = 3*x**2*y - y**3 - 4 >>> g = x**2 + x*y**3 - 9
>>> a = 3*x*y**4 + y**3 - 27*y + 4 >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16
>>> R.dmp_subresultants(f, g) == [f, g, a, b] True
- sympy.polys.euclidtools.dmp_prs_resultant(f, g, u, K)[源代码]#
合成算法 \(K[X]\) 使用子结果pr。
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = 3*x**2*y - y**3 - 4 >>> g = x**2 + x*y**3 - 9
>>> a = 3*x*y**4 + y**3 - 27*y + 4 >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16
>>> res, prs = R.dmp_prs_resultant(f, g)
>>> res == b # resultant has n-1 variables False >>> res == b.drop(x) True >>> prs == [f, g, a, b] True
- sympy.polys.euclidtools.dmp_zz_modular_resultant(f, g, p, u, K)[源代码]#
计算的结果 \(f\) 和 \(g\) 模a素数 \(p\) .
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = x + y + 2 >>> g = 2*x*y + x + 3
>>> R.dmp_zz_modular_resultant(f, g, 5) -2*y**2 + 1
- sympy.polys.euclidtools.dmp_zz_collins_resultant(f, g, u, K)[源代码]#
柯林斯模结式算法 \(Z[X]\) .
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = x + y + 2 >>> g = 2*x*y + x + 3
>>> R.dmp_zz_collins_resultant(f, g) -2*y**2 - 5*y + 1
- sympy.polys.euclidtools.dmp_qq_collins_resultant(f, g, u, K0)[源代码]#
柯林斯模结式算法 \(Q[X]\) .
实例
>>> from sympy.polys import ring, QQ >>> R, x,y = ring("x,y", QQ)
>>> f = QQ(1,2)*x + y + QQ(2,3) >>> g = 2*x*y + x + 3
>>> R.dmp_qq_collins_resultant(f, g) -2*y**2 - 7/3*y + 5/6
- sympy.polys.euclidtools.dmp_resultant(f, g, u, K, includePRS=False)[源代码]#
计算 \(K[X]\) .
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> f = 3*x**2*y - y**3 - 4 >>> g = x**2 + x*y**3 - 9
>>> R.dmp_resultant(f, g) -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16
- sympy.polys.euclidtools.dmp_discriminant(f, u, K)[源代码]#
计算多项式的判别式 \(K[X]\) .
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y,z,t = ring("x,y,z,t", ZZ)
>>> R.dmp_discriminant(x**2*y + x*z + t) -4*y*t + z**2
- sympy.polys.euclidtools.dmp_rr_prs_gcd(f, g, u, K)[源代码]#
使用环上的子结果计算多项式GCD。
返回
(h, cff, cfg)这样的话a = gcd(f, g)，cff = quo(f, h)和cfg = quo(g, h).实例
>>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ)
>>> f = x**2 + 2*x*y + y**2 >>> g = x**2 + x*y
>>> R.dmp_rr_prs_gcd(f, g) (x + y, x + y, x)
- sympy.polys.euclidtools.dmp_ff_prs_gcd(f, g, u, K)[源代码]#
使用域上的子结果计算多项式GCD。
返回
(h, cff, cfg)这样的话a = gcd(f, g)，cff = quo(f, h)和cfg = quo(g, h).实例
>>> from sympy.polys import ring, QQ >>> R, x,y, = ring("x,y", QQ)
>>> f = QQ(1,2)*x**2 + x*y + QQ(1,2)*y**2 >>> g = x**2 + x*y
>>> R.dmp_ff_prs_gcd(f, g) (x + y, 1/2*x + 1/2*y, x)
- sympy.polys.euclidtools.dmp_zz_heu_gcd(f, g, u, K)[源代码]#
启发式多项式GCD \(Z[X]\) .
给定一元多项式 \(f\) 和 \(g\) 在里面 \(Z[X]\) ，返回它们的GCD和余因子，即多项式
h，cff和cfg因此：h = gcd(f, g), cff = quo(f, h) and cfg = quo(g, h)
该算法是纯启发式的，这意味着它可能无法计算GCD。这将通过引发异常来表示。在这种情况下，您需要切换到另一个GCD方法。
该算法通过计算多项式f和g在某些点上的GCD并计算这些求值的（快速）整数GCD来计算多项式GCD。通过插值从整数图像中恢复多项式GCD。求值过程将f和g变量逐级缩减为一个大整数。最后一步是验证插值多项式是否是正确的GCD。这给了输入多项式的辅助因子作为副作用。
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ)
>>> f = x**2 + 2*x*y + y**2 >>> g = x**2 + x*y
>>> R.dmp_zz_heu_gcd(f, g) (x + y, x + y, x)
工具书类
- sympy.polys.euclidtools.dmp_qq_heu_gcd(f, g, u, K0)[源代码]#
启发式多项式GCD \(Q[X]\) .
返回
(h, cff, cfg)这样的话a = gcd(f, g)，cff = quo(f, h)和cfg = quo(g, h).实例
>>> from sympy.polys import ring, QQ >>> R, x,y, = ring("x,y", QQ)
>>> f = QQ(1,4)*x**2 + x*y + y**2 >>> g = QQ(1,2)*x**2 + x*y
>>> R.dmp_qq_heu_gcd(f, g) (x + 2*y, 1/4*x + 1/2*y, 1/2*x)
- sympy.polys.euclidtools.dmp_inner_gcd(f, g, u, K)[源代码]#
计算多项式GCD和 \(f\) 和 \(g\) 在里面 \(K[X]\) .
返回
(h, cff, cfg)这样的话a = gcd(f, g)，cff = quo(f, h)和cfg = quo(g, h).实例
>>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ)
>>> f = x**2 + 2*x*y + y**2 >>> g = x**2 + x*y
>>> R.dmp_inner_gcd(f, g) (x + y, x + y, x)
- sympy.polys.euclidtools.dmp_gcd(f, g, u, K)[源代码]#
计算的多项式GCD \(f\) 和 \(g\) 在里面 \(K[X]\) .
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ)
>>> f = x**2 + 2*x*y + y**2 >>> g = x**2 + x*y
>>> R.dmp_gcd(f, g) x + y
- sympy.polys.euclidtools.dmp_lcm(f, g, u, K)[源代码]#
计算的多项式LCM \(f\) 和 \(g\) 在里面 \(K[X]\) .
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ)
>>> f = x**2 + 2*x*y + y**2 >>> g = x**2 + x*y
>>> R.dmp_lcm(f, g) x**3 + 2*x**2*y + x*y**2
- sympy.polys.euclidtools.dmp_content(f, u, K)[源代码]#
返回多元系数的GCD。
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ)
>>> R.dmp_content(2*x*y + 6*x + 4*y + 12) 2*y + 6
- sympy.polys.euclidtools.dmp_primitive(f, u, K)[源代码]#
返回多元内容和原始多项式。
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ)
>>> R.dmp_primitive(2*x*y + 6*x + 4*y + 12) (2*y + 6, x + 2)
- sympy.polys.euclidtools.dmp_cancel(f, g, u, K, include=True)[源代码]#
消去有理函数中的公因式 \(f/g\) .
实例
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ)
>>> R.dmp_cancel(2*x**2 - 2, x**2 - 2*x + 1) (2*x + 2, x - 1)
特征零点的多项式因式分解：
- sympy.polys.factortools.dup_zz_hensel_step(m, f, g, h, s, t, K)[源代码]#
亨塞尔的一步 \(Z[x]\) .
给定正整数 \(m\) 和 \(Z[x]\) 多项式 \(f\) ， \(g\) ， \(h\) ， \(s\) 和 \(t\) 因此：
f = g*h (mod m) s*g + t*h = 1 (mod m) lc(f) is not a zero divisor (mod m) lc(h) = 1 deg(f) = deg(g) + deg(h) deg(s) < deg(h) deg(t) < deg(g)
返回多项式 \(G\) ， \(H\) ， \(S\) 和 \(T\) ，这样：
f = G*H (mod m**2) S*G + T*H = 1 (mod m**2)
工具书类
- sympy.polys.factortools.dup_zz_hensel_lift(p, f, f_list, l, K)[源代码]#
多因素Hensel提升 \(Z[x]\) .
给予质数 \(p\) ，多项式 \(f\) 结束 \(Z[x]\) 这样的话 \(lc(f)\) 是单位模 \(p\) ，一元对互素多项式 \(f_i\) 结束 \(Z[x]\) 令人满意的：：
f = lc(f) f_1 ... f_r (mod p)
and a positive integer \(l\), returns a list of monic polynomials \(F_1,\ F_2,\ \dots,\ F_r\) satisfying:
f = lc(f) F_1 ... F_r (mod p**l) F_i = f_i (mod p), i = 1..r
工具书类
- sympy.polys.factortools.dup_cyclotomic_p(f, K, irreducible=False)[源代码]#
有效地测试
f是一个分圆多项式。实例
>>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ)
>>> f = x**16 + x**14 - x**10 + x**8 - x**6 + x**2 + 1 >>> R.dup_cyclotomic_p(f) False
>>> g = x**16 + x**14 - x**10 - x**8 - x**6 + x**2 + 1 >>> R.dup_cyclotomic_p(g) True
工具书类
Bradford, Russell J., and James H. Davenport. "Effective tests for cyclotomic polynomials." In International Symposium on Symbolic and Algebraic Computation, pp. 244-251. Springer, Berlin, Heidelberg, 1988.
- sympy.polys.factortools.dup_zz_cyclotomic_factor(f, K)[源代码]#
有效因子多项式 \(x**n - 1\) 和 \(x**n + 1\) 在里面 \(Z[x]\) .
给定一元多项式 \(f\) 在里面 \(Z[x]\) 返回因子的列表 \(f\) ，前提是 \(f\) 在表格中 \(x**n - 1\) 或 \(x**n + 1\) 对于 \(n >= 1\) . 否则返回None。
因子分解是使用 \(f\) ，这使得该方法比任何其他直接因子分解方法（如Zassenhaus的）快得多。
工具书类
- sympy.polys.factortools.dup_zz_factor(f, K)[源代码]#
因子（非平方自由）多项式 \(Z[x]\) .
给定一元多项式 \(f\) 在里面 \(Z[x]\) 计算其完全因子化 \(f_1, ..., f_n\) 整数上的不可约：
f = content(f) f_1**k_1 ... f_n**k_n
因式分解是通过将输入多项式化为一个本原无平方多项式并使用Zassenhaus算法进行因式分解来计算的。审判庭用于恢复因素的多重性。
结果以元组形式返回，该元组包含：
(content(f), [(f_1, k_1), ..., (f_n, k_n))
实例
考虑多项式 \(f = 2*x**4 - 2\) ：：
>>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_zz_factor(2*x**4 - 2) (2, [(x - 1, 1), (x + 1, 1), (x**2 + 1, 1)])
结果我们得到了以下因子分解：
f = 2 (x - 1) (x + 1) (x**2 + 1)
注意，这是对整数的完全因式分解，但是对于高斯整数，我们可以对最后一项进行因子分解。
默认情况下，多项式 \(x**n - 1\) 和 \(x**n + 1\) 使用分圆分解来加速计算。要禁用此行为，请设置分圆=False。
工具书类
- sympy.polys.factortools.dmp_zz_wang_hensel_lifting(f, H, LC, A, p, u, K)[源代码]#
Wang/EEZ：并行Hensel提升算法。
- sympy.polys.factortools.dmp_zz_wang(f, u, K, mod=None, seed=None)[源代码]#
因子本原平方自由多项式 \(Z[X]\) .
给定多元多项式 \(f\) 在里面 \(Z[x_1,...,x_n]\) ，它是原始的和自由的 \(x_1\) ，计算因子分解 \(f\) 变成整数上的不可约数。
该过程基于王的增强扩展Zassenhaus算法。该算法通过查看 \(f\) 作为一元多项式 \(Z[x_2,...,x_n][x_1]\) ，为其计算求值映射：
x_2 -> a_2, ..., x_n -> a_n
where \(a_i\), for \(i = 2, \dots, n\), are carefully chosen integers. The mapping is used to transform \(f\) into a univariate polynomial in \(Z[x_1]\), which can be factored efficiently using Zassenhaus algorithm. The last step is to lift univariate factors to obtain true multivariate factors. For this purpose a parallel Hensel lifting procedure is used.
参数
seed传递给_randint，可用于种子randint（当为整数时）或（出于测试目的）可以是一个数字序列。工具书类
- sympy.polys.factortools.dmp_zz_factor(f, u, K)[源代码]#
因子（非平方自由）多项式 \(Z[X]\) .
Given a multivariate polynomial \(f\) in \(Z[x]\) computes its complete factorization \(f_1, \dots, f_n\) into irreducibles over integers:
f = content(f) f_1**k_1 ... f_n**k_n
因子分解是通过将输入多项式化为一个原始无平方多项式，然后使用增强的扩展Zassenhaus（EEZ）算法进行分解。审判庭用于恢复因素的多重性。
结果以元组形式返回，该元组包含：
(content(f), [(f_1, k_1), ..., (f_n, k_n))
考虑多项式 \(f = 2*(x**2 - y**2)\) ：：
>>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> R.dmp_zz_factor(2*x**2 - 2*y**2) (2, [(x - y, 1), (x + y, 1)])
结果我们得到了以下因子分解：
f = 2 (x - y) (x + y)
工具书类
Groebner基算法#
Groebner基可以用来回答计算交换代数中的许多问题。它们的计算相当复杂，而且对性能非常敏感。我们在这里介绍各种Groebner基计算算法的低层实现；请参阅手册的前一节了解用法。
- sympy.polys.groebnertools.groebner(seq, ring, method=None)[源代码]#
计算一组多项式的Groebner基 \(K[X]\) .
包装（默认）改进的Buchberger和其他计算Groebner基的算法。算法的选择可以通过
method参数或sympy.polys.polyconfig.setup()在哪里method要么可以buchberger或f5b.
- sympy.polys.groebnertools.spoly(p1, p2, ring)[源代码]#
计算LCM（LM（p1）、LM（p2））/LM（p1） p1 - LCM(LM(p1), LM(p2))/LM(p2) p2这是S-poly，前提是p1和p2是monic
- sympy.polys.groebnertools.red_groebner(G, ring)[源代码]#
计算约化Groebner基，摘自BeckerWeispfenning93，第216页
选择已生成理想的生成器子集，并为其计算约化的Groebner基。
- sympy.polys.fglmtools.matrix_fglm(F, ring, O_to)[源代码]#
转换约化Groebner基
F零维理想w.r.t。O_from降低了Groebner基w.r.t。O_to.工具书类
[R801]J、 C.Faugere，P.Gianni，D.Lazard，T.Mora（1994年）。零维Groebner基的序变换高效计算
还提供了模块的Groebner基算法：
- sympy.polys.distributedmodules.sdm_spoly(f, g, O, K, phantom=None)[源代码]#
计算
f和g.地面场假定为
K，单项式根据O.这是无效的，如果
f或g是零。如果 \(f\) 和 \(g\) 涉及不同的基本要素 \(F\) ，它们的s-poly定义为零。否则它是某种线性组合 \(f\) 和 \(g\) 其中前导项取消。看到了吗 [SCA，定义2.3.6] 有关详细信息。
如果
phantom不是None，它应该是一对模块元素，在其中执行与on相同的操作f和g. 在本例中，返回两个结果。实例
>>> from sympy.polys.distributedmodules import sdm_spoly >>> from sympy.polys import QQ, lex >>> f = [((2, 1, 1), QQ(1)), ((1, 0, 1), QQ(1))] >>> g = [((2, 3, 0), QQ(1))] >>> h = [((1, 2, 3), QQ(1))] >>> sdm_spoly(f, h, lex, QQ) [] >>> sdm_spoly(f, g, lex, QQ) [((1, 2, 1), 1)]
- sympy.polys.distributedmodules.sdm_ecart(f)[源代码]#
计算
f.This is defined to be the difference of the total degree of \(f\) and the total degree of the leading monomial of \(f\) [SCA, defn 2.3.7].
如果f为零，则无效。
实例
>>> from sympy.polys.distributedmodules import sdm_ecart >>> sdm_ecart([((1, 2, 3), 1), ((1, 0, 1), 1)]) 0 >>> sdm_ecart([((2, 2, 1), 1), ((1, 5, 1), 1)]) 3
- sympy.polys.distributedmodules.sdm_nf_mora(f, G, O, K, phantom=None)[源代码]#
计算
f关于G还有秩序O.地面场假定为
K，单项式根据O.弱正规形的定义见 [SCA.2，定义3] . 它们不是独一无二的。此函数根据 \(G\) .
弱正规形最重要的性质是：如果 \(R\) 环与单项式序相关（如果序是全局的，我们只有 \(R = K[x_1, \ldots, x_n]\) ，否则是一定的本地化）， \(I\) 任何理想 \(R\) 和 \(G\) 标准基础 \(I\) ，那么对于任何人 \(f \in R\) ，我们有 \(f \in I\) 当且仅当 \(NF(f | G) = 0\) .
这是计算任意单项式弱正规形的广义Mora算法 [SCA，算法2.3.9] .
如果
phantom不是None，它应该是一对“幻影”参数，对其执行与上相同的计算f，G，然后返回两个结果。
- sympy.polys.distributedmodules.sdm_groebner(G, NF, O, K, extended=False)[源代码]#
计算
G关于秩序O.该算法使用正规形式
NF，例如sdm_nf_mora. 地面场假定为K，单项式根据O.让 \(N\) 表示由元素生成的子模块 \(G\) . 标准基础 \(N\) 是子集 \(S\) 属于 \(N\) ，这样 \(in(S) = in(N)\) ，对于任何子集 \(X\) 属于 \(F\) ， \(in(X)\) 表示由元素的初始形式生成的子模块 \(X\) . [SCA，定义2.3.2]
如果标准基的任何子集都不是标准基，则称为最小基。
有人可能会说，标准基地总是发电机组。
最低标准基数并非唯一。此算法根据 \(G\) .
如果
extended=True计算了初始生成元到groebner基的转移矩阵。也就是说，返回一个系数向量的列表，用G.此函数实现“糖”策略，请参阅
Giovini等人：“一个糖立方体，请”或布氏算法中的选择策略。
选项#
选项管理器 Poly 以及公共API函数。
- class sympy.polys.polyoptions.Options(gens, args, flags=None, strict=False)[源代码]#
多项式操作模块的选项管理器。
实例
>>> from sympy.polys.polyoptions import Options >>> from sympy.polys.polyoptions import build_options
>>> from sympy.abc import x, y, z
>>> Options((x, y, z), {'domain': 'ZZ'}) {'auto': False, 'domain': ZZ, 'gens': (x, y, z)}
>>> build_options((x, y, z), {'domain': 'ZZ'}) {'auto': False, 'domain': ZZ, 'gens': (x, y, z)}
Options
扩展---布尔选项
Gens---选项
Wrt---选项
排序---选项
订单---选项
字段---布尔选项
贪心---布尔选项
域---选项
Split---布尔选项
高斯---布尔选项
扩展---选项
模数---选项
对称---布尔选项
Strict---boolean选项
Flags
Auto---布尔标志
Frac---布尔标志
形式---布尔标志
Polys---布尔标志
Include---布尔标志
All---布尔标志
Gen---旗子
系列---布尔标志
配置#
多项式操作算法的配置实用程序。
例外情况#
这些是多项式模块定义的例外。
TODO分类和解释
参考文献#
模块化GCD#
- sympy.polys.modulargcd.modgcd_univariate(f, g)[源代码]#
计算中两个多项式的GCD \(\mathbb{{Z}}[x]\) 使用模块化算法。
该算法计算两个一元整数多项式的GCD \(f\) 和 \(g\) 通过计算 \(\mathbb{{Z}}_p[x]\) 合适的底漆 \(p\) 然后利用中国剩余定理重构系数。只为那些很有可能是理想的GCD的候选人进行审判。
- 参数:
f ：多元元素
一元整多项式
g ：多元元素
一元整多项式
- 返回:
h ：多元元素
多项式的GCD \(f\) 和 \(g\)
cff ：多元元素
的辅因子 \(f\) ，即 \(\frac{{f}}{{h}}\)
cfg ：多元元素
的辅因子 \(g\) ，即 \(\frac{{g}}{{h}}\)
实例
>>> from sympy.polys.modulargcd import modgcd_univariate >>> from sympy.polys import ring, ZZ
>>> R, x = ring("x", ZZ)
>>> f = x**5 - 1 >>> g = x - 1
>>> h, cff, cfg = modgcd_univariate(f, g) >>> h, cff, cfg (x - 1, x**4 + x**3 + x**2 + x + 1, 1)
>>> cff * h == f True >>> cfg * h == g True
>>> f = 6*x**2 - 6 >>> g = 2*x**2 + 4*x + 2
>>> h, cff, cfg = modgcd_univariate(f, g) >>> h, cff, cfg (2*x + 2, 3*x - 3, x + 1)
>>> cff * h == f True >>> cfg * h == g True
工具书类
- sympy.polys.modulargcd.modgcd_bivariate(f, g)[源代码]#
计算中两个多项式的GCD \(\mathbb{{Z}}[x, y]\) 使用模块化算法。
该算法计算了两个二元整数多项式的GCD \(f\) 和 \(g\) 通过计算 \(\mathbb{{Z}}_p[x, y]\) 合适的底漆 \(p\) 然后利用中国剩余定理重构系数。计算二元GCD \(\mathbb{{Z}}_p\) ，多项式 \(f \; \mathrm{{mod}} \, p\) 和 \(g \; \mathrm{{mod}} \, p\) 在评估 \(y = a\) 当然 \(a \in \mathbb{{Z}}_p\) 然后他们的单变量GCD \(\mathbb{{Z}}_p[x]\) 是计算出来的。对这些进行插值可以得到 \(\mathbb{{Z}}_p[x, y]\) . 验证结果 \(\mathbb{{Z}}[x, y]\) ，试划分完成，但只适用于非常有可能达到预期GCD的候选人。
- 参数:
f ：多元元素
二元整数多项式
g ：多元元素
二元整数多项式
- 返回:
h ：多元元素
多项式的GCD \(f\) 和 \(g\)
cff ：多元元素
的辅因子 \(f\) ，即 \(\frac{{f}}{{h}}\)
cfg ：多元元素
的辅因子 \(g\) ，即 \(\frac{{g}}{{h}}\)
实例
>>> from sympy.polys.modulargcd import modgcd_bivariate >>> from sympy.polys import ring, ZZ
>>> R, x, y = ring("x, y", ZZ)
>>> f = x**2 - y**2 >>> g = x**2 + 2*x*y + y**2
>>> h, cff, cfg = modgcd_bivariate(f, g) >>> h, cff, cfg (x + y, x - y, x + y)
>>> cff * h == f True >>> cfg * h == g True
>>> f = x**2*y - x**2 - 4*y + 4 >>> g = x + 2
>>> h, cff, cfg = modgcd_bivariate(f, g) >>> h, cff, cfg (x + 2, x*y - x - 2*y + 2, 1)
>>> cff * h == f True >>> cfg * h == g True
工具书类
- sympy.polys.modulargcd.modgcd_multivariate(f, g)[源代码]#
计算中两个多项式的GCD \(\mathbb{{Z}}[x_0, \ldots, x_{{k-1}}]\) 使用模块化算法。
该算法计算了两个多元整数多项式的GCD \(f\) and \(g\) by calculating the GCD in \(\mathbb{{Z}}_p[x_0, \ldots, x_{{k-1}}]\) for suitable primes \(p\) and then reconstructing the coefficients with the Chinese Remainder Theorem. To compute the multivariate GCD over \(\mathbb{{Z}}_p\) the recursive subroutine
_ 使用modgcd多变量。验证结果 `mathbb{{Z}}[x_0, ldots, x_{{k-1}}]()，试划分完成，但只适用于非常有可能达到预期GCD的候选人。- 参数:
f ：多元元素
多元整数多项式
g ：多元元素
多元整数多项式
- 返回:
h ：多元元素
多项式的GCD \(f\) 和 \(g\)
cff ：多元元素
的辅因子 \(f\) ，即 \(\frac{{f}}{{h}}\)
cfg ：多元元素
的辅因子 \(g\) ，即 \(\frac{{g}}{{h}}\)
实例
>>> from sympy.polys.modulargcd import modgcd_multivariate >>> from sympy.polys import ring, ZZ
>>> R, x, y = ring("x, y", ZZ)
>>> f = x**2 - y**2 >>> g = x**2 + 2*x*y + y**2
>>> h, cff, cfg = modgcd_multivariate(f, g) >>> h, cff, cfg (x + y, x - y, x + y)
>>> cff * h == f True >>> cfg * h == g True
>>> R, x, y, z = ring("x, y, z", ZZ)
>>> f = x*z**2 - y*z**2 >>> g = x**2*z + z
>>> h, cff, cfg = modgcd_multivariate(f, g) >>> h, cff, cfg (z, x*z - y*z, x**2 + 1)
>>> cff * h == f True >>> cfg * h == g True
工具书类
- sympy.polys.modulargcd._modgcd_multivariate_p(f, g, p, degbound, contbound)[源代码]#
计算中两个多项式的GCD \(\mathbb{{Z}}_p[x_0, \ldots, x_{{k-1}}]\) .
该算法通过对多项式的求值，逐步减少了问题的求解 \(f\) 和 \(g\) 在 \(x_{{k-1}} = a\) 适合 \(a \in \mathbb{{Z}}_p\) 然后递归地调用自身来计算 \(\mathbb{{Z}}_p[x_0, \ldots, x_{{k-2}}]\) . 如果这些递归调用对于足够的计算点成功，则 \(k\) 变量被插值，否则算法返回
None. 每次计算GCD或内容时，都会将它们的度数与边界进行比较。如果遇到大于界限的度数，则当前调用将返回None必须选择一个新的评价点。如果在某一点上度较小，则相应的界被更新，算法将失败。- 参数:
f ：多元元素
带系数的多元整数多项式 \(\mathbb{{Z}}_p\)
g ：多元元素
带系数的多元整数多项式 \(\mathbb{{Z}}_p\)
p ：整数
质数，模 \(f\) 和 \(g\)
脱胶 ：整数对象列表
degbound[i]is an upper bound for the degree of the GCD of \(f\) and \(g\) in the variable \(x_i\)接触 ：整数对象列表
contbound[i]是中GCD内容程度的上界 \(\mathbb{{Z}}_p[x_i][x_0, \ldots, x_{{i-1}}]\) ，contbound[0]不使用，所以可以任意选择。- 返回:
h ：多元元素
多项式的GCD \(f\) 和 \(g\) 或
None
工具书类
- sympy.polys.modulargcd.func_field_modgcd(f, g)[源代码]#
计算两个多项式的GCD \(f\) 和 \(g\) 在里面 \(\mathbb Q(\alpha)[x_0, \ldots, x_{{n-1}}]\) 使用模块化算法。
该算法首先计算原始关联 \(\check m_{{\alpha}}(z)\) 最小多项式的 \(m_{{\alpha}}\) 在里面 \(\mathbb{{Z}}[z]\) 以及 \(f\) 和 \(g\) 在里面 \(\mathbb{{Z}}[x_1, \ldots, x_{{n-1}}][z]/(\check m_{{\alpha}})[x_0]\) . 然后计算GCD \(\mathbb Q(x_1, \ldots, x_{{n-1}})[z]/(m_{{\alpha}}(z))[x_0]\) . 这是通过计算 \(\mathbb{{Z}}_p(x_1, \ldots, x_{{n-1}})[z]/(\check m_{{\alpha}}(z))[x_0]\) 合适的底漆 \(p\) 然后利用中国剩余定理和有理重构法对系数进行重构。GCD结束 \(\mathbb{{Z}}_p(x_1, \ldots, x_{{n-1}})[z]/(\check m_{{\alpha}}(z))[x_0]\) 是用递归子例程计算的，它计算 \(x_{{n-1}} = a\) 合适的评估点 \(a \in \mathbb Z_p\) 然后递归地调用自身，直到基域不再包含任何参数。为 \(\mathbb{{Z}}_p[z]/(\check m_{{\alpha}}(z))[x_0]\) 采用欧几里德算法。然后对这些递归调用的结果进行插值，并使用有理函数重构来获得正确的系数。结果，都在 \(\mathbb Q(x_1, \ldots, x_{{n-1}})[z]/(m_{{\alpha}}(z))[x_0]\) 和 \(\mathbb{{Z}}_p(x_1, \ldots, x_{{n-1}})[z]/(\check m_{{\alpha}}(z))[x_0]\) ，经无分数试验部门验证。
除了上述GCD计算外，还有一些GCD \(\mathbb Q(\alpha)[x_1, \ldots, x_{{n-1}}]\) 必须进行计算，因为将多项式视为一元多项式会导致GCD的虚假内容。为了这个
func_field_modgcd递归调用。- 参数:
f, g ：多元元素
多项式 \(\mathbb Q(\alpha)[x_0, \ldots, x_{{n-1}}]\)
- 返回:
h ：多元元素
多项式的monic GCD \(f\) 和 \(g\)
cff ：多元元素
的辅因子 \(f\) ，即 \(\frac f h\)
cfg ：多元元素
的辅因子 \(g\) ，即 \(\frac g h\)
实例
>>> from sympy.polys.modulargcd import func_field_modgcd >>> from sympy.polys import AlgebraicField, QQ, ring >>> from sympy import sqrt
>>> A = AlgebraicField(QQ, sqrt(2)) >>> R, x = ring('x', A)
>>> f = x**2 - 2 >>> g = x + sqrt(2)
>>> h, cff, cfg = func_field_modgcd(f, g)
>>> h == x + sqrt(2) True >>> cff * h == f True >>> cfg * h == g True
>>> R, x, y = ring('x, y', A)
>>> f = x**2 + 2*sqrt(2)*x*y + 2*y**2 >>> g = x + sqrt(2)*y
>>> h, cff, cfg = func_field_modgcd(f, g)
>>> h == x + sqrt(2)*y True >>> cff * h == f True >>> cfg * h == g True
>>> f = x + sqrt(2)*y >>> g = x + y
>>> h, cff, cfg = func_field_modgcd(f, g)
>>> h == R.one True >>> cff * h == f True >>> cfg * h == g True
工具书类
无证#
poly模块的许多部分仍然没有文档记录，即使在文档中也很少见。请贡献！