多项式操作模块参考¶
多项式操作算法和代数对象。
参见 多项式操作 以获取 polys 模块的文档索引，以及 模块的基本功能 以获取介绍性解释。
基本多项式操作函数¶
- sympy.polys.polytools.poly(expr, *gens, **args)[源代码][源代码]¶
高效地将一个表达式转换为多项式。
示例
>>> from sympy import poly >>> from sympy.abc import x
>>> poly(x*(x**2 + x - 1)**2) Poly(x**5 + 2*x**4 - x**3 - 2*x**2 + x, x, domain='ZZ')
- sympy.polys.polytools.degree(f, gen=0)[源代码][源代码]¶
返回
f在给定变量中的次数。0 的度数是负无穷大。
示例
>>> from sympy import degree >>> from sympy.abc import x, y
>>> degree(x**2 + y*x + 1, gen=x) 2 >>> degree(x**2 + y*x + 1, gen=y) 1 >>> degree(0, x) -oo
- sympy.polys.polytools.degree_list(f, *gens, **args)[源代码][源代码]¶
返回
f在所有变量中的度数列表。示例
>>> from sympy import degree_list >>> from sympy.abc import x, y
>>> degree_list(x**2 + y*x + 1) (2, 1)
- sympy.polys.polytools.LC(f, *gens, **args)[源代码][源代码]¶
返回
f的首项系数。示例
>>> from sympy import LC >>> from sympy.abc import x, y
>>> LC(4*x**2 + 2*x*y**2 + x*y + 3*y) 4
- sympy.polys.polytools.LM(f, *gens, **args)[源代码][源代码]¶
返回
f的首项。示例
>>> from sympy import LM >>> from sympy.abc import x, y
>>> LM(4*x**2 + 2*x*y**2 + x*y + 3*y) x**2
- sympy.polys.polytools.LT(f, *gens, **args)[源代码][源代码]¶
返回
f的首项。示例
>>> from sympy import LT >>> from sympy.abc import x, y
>>> LT(4*x**2 + 2*x*y**2 + x*y + 3*y) 4*x**2
- sympy.polys.polytools.pdiv(f, g, *gens, **args)[源代码][源代码]¶
计算多项式
f和g的伪除法。示例
>>> from sympy import pdiv >>> from sympy.abc import x
>>> pdiv(x**2 + 1, 2*x - 4) (2*x + 4, 20)
- sympy.polys.polytools.prem(f, g, *gens, **args)[源代码][源代码]¶
计算多项式
f和g的伪余数。示例
>>> from sympy import prem >>> from sympy.abc import x
>>> prem(x**2 + 1, 2*x - 4) 20
- sympy.polys.polytools.pquo(f, g, *gens, **args)[源代码][源代码]¶
计算
f和g的多项式伪商。示例
>>> from sympy import pquo >>> from sympy.abc import x
>>> pquo(x**2 + 1, 2*x - 4) 2*x + 4 >>> pquo(x**2 - 1, 2*x - 1) 2*x + 1
- sympy.polys.polytools.pexquo(f, g, *gens, **args)[源代码][源代码]¶
计算多项式
f和g的精确伪商。示例
>>> from sympy import pexquo >>> from sympy.abc import x
>>> pexquo(x**2 - 1, 2*x - 2) 2*x + 2
>>> pexquo(x**2 + 1, 2*x - 4) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1
- sympy.polys.polytools.div(f, g, *gens, **args)[源代码][源代码]¶
计算多项式
f和g的除法。示例
>>> from sympy import div, ZZ, QQ >>> from sympy.abc import x
>>> div(x**2 + 1, 2*x - 4, domain=ZZ) (0, x**2 + 1) >>> div(x**2 + 1, 2*x - 4, domain=QQ) (x/2 + 1, 5)
- sympy.polys.polytools.rem(f, g, *gens, **args)[源代码][源代码]¶
计算多项式
f和g的余数。示例
>>> from sympy import rem, ZZ, QQ >>> from sympy.abc import x
>>> rem(x**2 + 1, 2*x - 4, domain=ZZ) x**2 + 1 >>> rem(x**2 + 1, 2*x - 4, domain=QQ) 5
- sympy.polys.polytools.quo(f, g, *gens, **args)[源代码][源代码]¶
计算多项式
f和g的商。示例
>>> from sympy import quo >>> from sympy.abc import x
>>> quo(x**2 + 1, 2*x - 4) x/2 + 1 >>> quo(x**2 - 1, x - 1) x + 1
- sympy.polys.polytools.exquo(f, g, *gens, **args)[源代码][源代码]¶
计算多项式
f和g的精确商。示例
>>> from sympy import exquo >>> from sympy.abc import x
>>> exquo(x**2 - 1, x - 1) x + 1
>>> exquo(x**2 + 1, 2*x - 4) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1
- sympy.polys.polytools.half_gcdex(f, g, *gens, **args)[源代码][源代码]¶
f和g的半扩展欧几里得算法。返回
(s, h)使得h = gcd(f, g)且s*f = h (mod g)。示例
>>> from sympy import half_gcdex >>> from sympy.abc import x
>>> half_gcdex(x**4 - 2*x**3 - 6*x**2 + 12*x + 15, x**3 + x**2 - 4*x - 4) (3/5 - x/5, x + 1)
- sympy.polys.polytools.gcdex(f, g, *gens, **args)[源代码][源代码]¶
f和g的扩展欧几里得算法。返回
(s, t, h)使得h = gcd(f, g)并且s*f + t*g = h。示例
>>> from sympy import gcdex >>> from sympy.abc import x
>>> gcdex(x**4 - 2*x**3 - 6*x**2 + 12*x + 15, x**3 + x**2 - 4*x - 4) (3/5 - x/5, x**2/5 - 6*x/5 + 2, x + 1)
- sympy.polys.polytools.invert(f, g, *gens, **args)[源代码][源代码]¶
在可能的情况下，对
f取g的模逆。示例
>>> from sympy import invert, S, mod_inverse >>> from sympy.abc import x
>>> invert(x**2 - 1, 2*x - 1) -4/3
>>> invert(x**2 - 1, x - 1) Traceback (most recent call last): ... NotInvertible: zero divisor
For more efficient inversion of Rationals, use the
sympy.core.intfunc.mod_inversefunction:>>> mod_inverse(3, 5) 2 >>> (S(2)/5).invert(S(7)/3) 5/2
- sympy.polys.polytools.subresultants(f, g, *gens, **args)[源代码][源代码]¶
计算
f和g的子结果PRS。示例
>>> from sympy import subresultants >>> from sympy.abc import x
>>> subresultants(x**2 + 1, x**2 - 1) [x**2 + 1, x**2 - 1, -2]
- sympy.polys.polytools.resultant(f, g, *gens, includePRS=False, **args)[源代码][源代码]¶
计算
f和g的结果。示例
>>> from sympy import resultant >>> from sympy.abc import x
>>> resultant(x**2 + 1, x**2 - 1) 4
- sympy.polys.polytools.discriminant(f, *gens, **args)[源代码][源代码]¶
计算
f的判别式。示例
>>> from sympy import discriminant >>> from sympy.abc import x
>>> discriminant(x**2 + 2*x + 3) -8
- sympy.polys.polytools.terms_gcd(f, *gens, **args)[源代码][源代码]¶
从
f中去除各项的最大公约数。如果
deep标志为 True，那么f的参数将会应用 terms_gcd。如果一个分数从
f中被分解出来，并且f是一个 Add，那么将返回一个未计算的 Mul，以防止自动简化重新分配它。提示clear，当设置为 False 时，可以用于防止在所有系数不是分数时进行这种分解。示例
>>> from sympy import terms_gcd, cos >>> from sympy.abc import x, y >>> terms_gcd(x**6*y**2 + x**3*y, x, y) x**3*y*(x**3*y + 1)
polys 例程的默认操作是将给定的表达式展开。terms_gcd 遵循这一行为：
>>> terms_gcd((3+3*x)*(x+x*y)) 3*x*(x*y + x + y + 1)
如果这不是期望的，那么可以将提示
expand设置为 False。在这种情况下，表达式将被视为由一个或多个项组成：>>> terms_gcd((3+3*x)*(x+x*y), expand=False) (3*x + 3)*(x*y + x)
为了遍历一个 Mul 的因子或其他函数的参数，可以使用
deep提示：>>> terms_gcd((3 + 3*x)*(x + x*y), expand=False, deep=True) 3*x*(x + 1)*(y + 1) >>> terms_gcd(cos(x + x*y), deep=True) cos(x*(y + 1))
有理数默认被分解：
>>> terms_gcd(x + y/2) (2*x + y)/2
只有 y-项的系数是一个分数；如果不希望在这种情况下提出 1/2，可以将标志
clear设置为 False：>>> terms_gcd(x + y/2, clear=False) x + y/2 >>> terms_gcd(x*y/2 + y**2, clear=False) y*(x/2 + y)
如果所有系数都是分数，则忽略
clear标志：>>> terms_gcd(x/3 + y/2, clear=False) (2*x + 3*y)/6
- sympy.polys.polytools.cofactors(f, g, *gens, **args)[源代码][源代码]¶
计算
f和g的最大公约数和余因子。返回多项式
(h, cff, cfg)使得h = gcd(f, g)，并且cff = quo(f, h)和cfg = quo(g, h)是所谓的f和g的余因子。示例
>>> from sympy import cofactors >>> from sympy.abc import x
>>> cofactors(x**2 - 1, x**2 - 3*x + 2) (x - 1, x + 1, x - 2)
- sympy.polys.polytools.gcd(f, g=None, *gens, **args)[源代码][源代码]¶
计算
f和g的最大公约数。示例
>>> from sympy import gcd >>> from sympy.abc import x
>>> gcd(x**2 - 1, x**2 - 3*x + 2) x - 1
- sympy.polys.polytools.gcd_list(seq, *gens, **args)[源代码][源代码]¶
计算多项式列表的最大公约数。
示例
>>> from sympy import gcd_list >>> from sympy.abc import x
>>> gcd_list([x**3 - 1, x**2 - 1, x**2 - 3*x + 2]) x - 1
- sympy.polys.polytools.lcm(f, g=None, *gens, **args)[源代码][源代码]¶
计算
f和g的最小公倍数。示例
>>> from sympy import lcm >>> from sympy.abc import x
>>> lcm(x**2 - 1, x**2 - 3*x + 2) x**3 - 2*x**2 - x + 2
- sympy.polys.polytools.lcm_list(seq, *gens, **args)[源代码][源代码]¶
计算多项式列表的最小公倍数。
示例
>>> from sympy import lcm_list >>> from sympy.abc import x
>>> lcm_list([x**3 - 1, x**2 - 1, x**2 - 3*x + 2]) x**5 - x**4 - 2*x**3 - x**2 + x + 2
- sympy.polys.polytools.trunc(f, p, *gens, **args)[源代码][源代码]¶
将
f对常数p取模。示例
>>> from sympy import trunc >>> from sympy.abc import x
>>> trunc(2*x**3 + 3*x**2 + 5*x + 7, 3) -x**3 - x + 1
- sympy.polys.polytools.monic(f, *gens, **args)[源代码][源代码]¶
将
f的所有系数除以LC(f)。示例
>>> from sympy import monic >>> from sympy.abc import x
>>> monic(3*x**2 + 4*x + 2) x**2 + 4*x/3 + 2/3
- sympy.polys.polytools.content(f, *gens, **args)[源代码][源代码]¶
计算
f的系数的最大公约数。示例
>>> from sympy import content >>> from sympy.abc import x
>>> content(6*x**2 + 8*x + 12) 2
- sympy.polys.polytools.primitive(f, *gens, **args)[源代码][源代码]¶
计算内容和
f的原始形式。示例
>>> from sympy.polys.polytools import primitive >>> from sympy.abc import x
>>> primitive(6*x**2 + 8*x + 12) (2, 3*x**2 + 4*x + 6)
>>> eq = (2 + 2*x)*x + 2
默认情况下会执行扩展：
>>> primitive(eq) (2, x**2 + x + 1)
将
expand设置为 False 以关闭此功能。请注意，提取不会是递归的；使用 as_content_primitive 方法进行递归、非破坏性的 Rational 提取。>>> primitive(eq, expand=False) (1, x*(2*x + 2) + 2)
>>> eq.as_content_primitive() (2, x*(x + 1) + 1)
- sympy.polys.polytools.compose(f, g, *gens, **args)[源代码][源代码]¶
计算函数组合
f(g)。示例
>>> from sympy import compose >>> from sympy.abc import x
>>> compose(x**2 + x, x - 1) x**2 - x
- sympy.polys.polytools.decompose(f, *gens, **args)[源代码][源代码]¶
计算
f的功能分解。示例
>>> from sympy import decompose >>> from sympy.abc import x
>>> decompose(x**4 + 2*x**3 - x - 1) [x**2 - x - 1, x**2 + x]
- sympy.polys.polytools.sturm(f, *gens, **args)[源代码][源代码]¶
计算
f的 Sturm 序列。示例
>>> from sympy import sturm >>> from sympy.abc import x
>>> sturm(x**3 - 2*x**2 + x - 3) [x**3 - 2*x**2 + x - 3, 3*x**2 - 4*x + 1, 2*x/9 + 25/9, -2079/4]
- sympy.polys.polytools.gff_list(f, *gens, **args)[源代码][源代码]¶
计算
f的最大阶乘因子列表。请注意，传递给 ff() 和 rf() 的输入应为 Poly 实例，以便使用这里的定义。
示例
>>> from sympy import gff_list, ff, Poly >>> from sympy.abc import x
>>> f = Poly(x**5 + 2*x**4 - x**3 - 2*x**2, x)
>>> gff_list(f) [(Poly(x, x, domain='ZZ'), 1), (Poly(x + 2, x, domain='ZZ'), 4)]
>>> (ff(Poly(x), 1)*ff(Poly(x + 2), 4)) == f True
>>> f = Poly(x**12 + 6*x**11 - 11*x**10 - 56*x**9 + 220*x**8 + 208*x**7 - 1401*x**6 + 1090*x**5 + 2715*x**4 - 6720*x**3 - 1092*x**2 + 5040*x, x)
>>> gff_list(f) [(Poly(x**3 + 7, x, domain='ZZ'), 2), (Poly(x**2 + 5*x, x, domain='ZZ'), 3)]
>>> ff(Poly(x**3 + 7, x), 2)*ff(Poly(x**2 + 5*x, x), 3) == f True
- sympy.polys.polytools.sqf_norm(f, *gens, **args)[源代码][源代码]¶
计算
f的无平方范数。返回
s,f,r, 使得g(x) = f(x-sa)且r(x) = Norm(g(x))是K上的无平方多项式，其中a是基域的代数扩展。示例
>>> from sympy import sqf_norm, sqrt >>> from sympy.abc import x
>>> sqf_norm(x**2 + 1, extension=[sqrt(3)]) ([1], x**2 - 2*sqrt(3)*x + 4, x**4 - 4*x**2 + 16)
- sympy.polys.polytools.sqf_part(f, *gens, **args)[源代码][源代码]¶
计算
f的无平方部分。示例
>>> from sympy import sqf_part >>> from sympy.abc import x
>>> sqf_part(x**3 - 3*x - 2) x**2 - x - 2
- sympy.polys.polytools.sqf_list(f, *gens, **args)[源代码][源代码]¶
计算
f的无平方因子列表。示例
>>> from sympy import sqf_list >>> from sympy.abc import x
>>> sqf_list(2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16) (2, [(x + 1, 2), (x + 2, 3)])
- sympy.polys.polytools.sqf(f, *gens, **args)[源代码][源代码]¶
计算
f的无平方因子分解。示例
>>> from sympy import sqf >>> from sympy.abc import x
>>> sqf(2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16) 2*(x + 1)**2*(x + 2)**3
- sympy.polys.polytools.factor_list(f, *gens, **args)[源代码][源代码]¶
计算
f的不可约因子列表。示例
>>> from sympy import factor_list >>> from sympy.abc import x, y
>>> factor_list(2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y) (2, [(x + y, 1), (x**2 + 1, 2)])
- sympy.polys.polytools.factor(f, *gens, deep=False, **args)[源代码][源代码]¶
计算表达式
f的不可约因子分解。（要将一个整数分解为质数，请使用factorint。）实现了两种模式：符号模式和形式模式。如果
f不是Poly的实例且未指定生成器，则使用前一种模式。否则，使用形式模式。在符号模式下，
factor()将遍历表达式树并对各部分进行因式分解，而无需事先展开，除非遇到Add的实例（在这种情况下使用正式的因式分解）。这样，factor()可以处理大指数或符号指数。默认情况下，因式分解是在有理数上计算的。要在其他域上进行因式分解，例如代数域或有限域，请使用适当的选项：
extension、modulus或domain。示例
>>> from sympy import factor, sqrt, exp >>> from sympy.abc import x, y
>>> factor(2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y) 2*(x + y)*(x**2 + 1)**2
>>> factor(x**2 + 1) x**2 + 1 >>> factor(x**2 + 1, modulus=2) (x + 1)**2 >>> factor(x**2 + 1, gaussian=True) (x - I)*(x + I)
>>> factor(x**2 - 2, extension=sqrt(2)) (x - sqrt(2))*(x + sqrt(2))
>>> factor((x**2 - 1)/(x**2 + 4*x + 4)) (x - 1)*(x + 1)/(x + 2)**2 >>> factor((x**2 + 4*x + 4)**10000000*(x**2 + 1)) (x + 2)**20000000*(x**2 + 1)
默认情况下，factor 处理整个表达式：
>>> eq = 2**(x**2 + 2*x + 1) >>> factor(eq) 2**(x**2 + 2*x + 1)
如果
deep标志为 True，则将分解子表达式：>>> factor(eq, deep=True) 2**((x + 1)**2)
如果
fraction标志为 False，则不会合并有理表达式。默认情况下，它是 True。>>> factor(5*x + 3*exp(2 - 7*x), deep=True) (5*x*exp(7*x) + 3*exp(2))*exp(-7*x) >>> factor(5*x + 3*exp(2 - 7*x), deep=True, fraction=False) 5*x + 3*exp(2)*exp(-7*x)
- sympy.polys.polytools.intervals(
- F,
- all=False,
- eps=None,
- inf=None,
- sup=None,
- strict=False,
- fast=False,
- sqf=False,
计算多项式
f的根的隔离区间。示例
>>> from sympy import intervals >>> from sympy.abc import x
>>> intervals(x**2 - 3) [((-2, -1), 1), ((1, 2), 1)] >>> intervals(x**2 - 3, eps=1e-2) [((-26/15, -19/11), 1), ((19/11, 26/15), 1)]
- sympy.polys.polytools.refine_root(
- f,
- s,
- t,
- eps=None,
- steps=None,
- fast=False,
- check_sqf=False,
将根的隔离区间精炼到给定的精度。
示例
>>> from sympy import refine_root >>> from sympy.abc import x
>>> refine_root(x**2 - 3, 1, 2, eps=1e-2) (19/11, 26/15)
- sympy.polys.polytools.count_roots(f, inf=None, sup=None)[源代码][源代码]¶
返回
f在[inf, sup]区间内的根的数量。如果
inf或sup是复数，它将返回在inf和sup为角的复数矩形内的根的数量。示例
>>> from sympy import count_roots, I >>> from sympy.abc import x
>>> count_roots(x**4 - 4, -3, 3) 2 >>> count_roots(x**4 - 4, 0, 1 + 3*I) 1
- sympy.polys.polytools.all_roots(
- f,
- multiple=True,
- radicals=True,
- extension=False,
返回
f的实根和复根及其重数。- 参数:
- f :
Expr或PolyExpr 或 Poly 具有有理数（或
Float）系数的单变量多项式。- multiple :
bool(默认True)。bool (默认 True)。 是否返回根的
列表或根/重数对的列表。- radicals :
bool(默认True)bool (默认 True) 对于一些无理根，使用简单的根式公式而不是
ComplexRootOf。- 扩展: ``bool`` (默认 ``False``)
是否在计算根之前构造一个代数扩展域。设置为
True对于寻找具有（无理数）代数系数的多项式的根是必要的，但可能会很慢。
- f :
- 返回:
- 一个
Expr列表（通常是ComplexRootOf）表示 - 每个根都会根据其重数返回，并重复出现。
- 作为
f的根。根总是唯一有序的，实根在前。 - 在复数根之前。实数根按递增顺序排列。
- 复数根按实部递增排序，然后按虚部递增排序。
- 虚部。
- 如果传递了
multiple=False，则返回一个根/多重性对的列表。 - 返回。
- 如果传递
radicals=False，则所有根都将表示为 - 要么是合理数，要么是
ComplexRootOf。
- 一个
参见
Poly.all_roots由
all_roots()使用的底层Poly方法。rootof计算单变量多项式的单个数值根。
real_roots使用
rootof()计算所有实根。ground_roots通过因式分解在基础域中计算一些根。
nroots使用近似数值技术计算所有根。
sympy.polys.polyroots.roots使用根式公式计算根的符号表达式。
参考文献
[1]https://en.wikipedia.org/wiki/阿贝尔-鲁菲尼定理
示例
>>> from sympy import all_roots >>> from sympy.abc import x, y
>>> print(all_roots(x**3 + 1)) [-1, 1/2 - sqrt(3)*I/2, 1/2 + sqrt(3)*I/2]
在某些情况下使用简单的根式公式，但避免使用三次和四次公式。相反，大多数非有理根将表示为
ComplexRootOf:>>> print(all_roots(x**3 + x + 1)) [CRootOf(x**3 + x + 1, 0), CRootOf(x**3 + x + 1, 1), CRootOf(x**3 + x + 1, 2)]
任何具有有理系数的任何次多项式的所有根都可以使用
ComplexRootOf表示。使用ComplexRootOf可以绕过五次及更高次多项式根式公式的可用性限制 _[1]:>>> p = x**5 - x - 1 >>> for r in all_roots(p): print(r) CRootOf(x**5 - x - 1, 0) CRootOf(x**5 - x - 1, 1) CRootOf(x**5 - x - 1, 2) CRootOf(x**5 - x - 1, 3) CRootOf(x**5 - x - 1, 4) >>> [r.evalf(3) for r in all_roots(p)] [1.17, -0.765 - 0.352*I, -0.765 + 0.352*I, 0.181 - 1.08*I, 0.181 + 1.08*I]
如果设置了 \(extension=True\)，
all_roots()可以处理非理性的代数系数。>>> from sympy import sqrt, expand >>> p = expand((x - sqrt(2))*(x - sqrt(3))) >>> print(p) x**2 - sqrt(3)*x - sqrt(2)*x + sqrt(6) >>> all_roots(p) Traceback (most recent call last): ... NotImplementedError: sorted roots not supported over EX >>> all_roots(p, extension=True) [sqrt(2), sqrt(3)]
代数系数也可以是复数。
>>> from sympy import I >>> all_roots(x**2 - I, extension=True) [-sqrt(2)/2 - sqrt(2)*I/2, sqrt(2)/2 + sqrt(2)*I/2] >>> all_roots(x**2 - sqrt(2)*I, extension=True) [-2**(3/4)/2 - 2**(3/4)*I/2, 2**(3/4)/2 + 2**(3/4)*I/2]
目前，超越系数无法由
all_roots()处理。对于代数或超越系数的情况，ground_roots()可能通过因式分解找到一些根：>>> from sympy import ground_roots >>> ground_roots(p, x, extension=True) {sqrt(2): 1, sqrt(3): 1}
如果系数是数值，则可以使用
nroots()来近似求出所有根：>>> from sympy import nroots >>> nroots(p, 5) [1.4142, 1.732]
如果系数是符号化的，则应使用
sympy.polys.polyroots.roots()或ground_roots()代替：>>> from sympy import roots, ground_roots >>> p = x**2 - 3*x*y + 2*y**2 >>> roots(p, x) {y: 1, 2*y: 1} >>> ground_roots(p, x) {y: 1, 2*y: 1}
- sympy.polys.polytools.real_roots(
- f,
- multiple=True,
- radicals=True,
- extension=False,
返回
f的实根及其重数。- 参数:
- f :
Expr或PolyExpr 或 Poly 具有有理数（或
Float）系数的单变量多项式。- multiple :
bool(默认True)。bool (默认 True)。 是否返回根的
列表或根/重数对的列表。- radicals :
bool(默认True)bool (默认 True) 对于一些无理根，使用简单的根式公式而不是
ComplexRootOf。- 扩展: ``bool`` (默认 ``False``)
是否在计算根之前构造一个代数扩展域。设置为
True对于寻找具有（无理数）代数系数的多项式的根是必要的，但可能会很慢。
- f :
- 返回:
- 一个
Expr列表（通常是ComplexRootOf）表示 - 返回的是实根。根按递增顺序排列，
- 根据它们作为
f根的重数重复。 - 如果传递了
multiple=False，则返回一个根/多重性对的列表。 - 返回。
- 如果传递
radicals=False，则所有根都将表示为 - 要么是合理数，要么是
ComplexRootOf。
- 一个
参见
Poly.real_roots由
real_roots()使用的底层Poly方法。rootof计算单变量多项式的单个数值根。
all_roots使用
rootof()计算所有实数和非实数根。ground_roots通过因式分解在基础域中计算一些根。
nroots使用近似数值技术计算所有根。
sympy.polys.polyroots.roots使用根式公式计算根的符号表达式。
参考文献
示例
>>> from sympy import real_roots >>> from sympy.abc import x, y
>>> real_roots(2*x**3 - 7*x**2 + 4*x + 4) [-1/2, 2, 2] >>> real_roots(2*x**3 - 7*x**2 + 4*x + 4, multiple=False) [(-1/2, 1), (2, 2)]
任何具有有理系数的任何次多项式的实根都可以使用
ComplexRootOf表示。>>> p = x**9 + 2*x + 2 >>> print(real_roots(p)) [CRootOf(x**9 + 2*x + 2, 0)] >>> [r.evalf(3) for r in real_roots(p)] [-0.865]
所有有理根将以有理数的形式返回。一些简单因子的根将使用根号或其他公式表示（除非传递了
radicals=False）。所有其他根将表示为ComplexRootOf。>>> p = (x + 7)*(x**2 - 2)*(x**3 + x + 1) >>> print(real_roots(p)) [-7, -sqrt(2), CRootOf(x**3 + x + 1, 0), sqrt(2)] >>> print(real_roots(p, radicals=False)) [-7, CRootOf(x**2 - 2, 0), CRootOf(x**3 + x + 1, 0), CRootOf(x**2 - 2, 1)]
所有返回的根表达式都将数值评估为没有虚部的实数。这与由
roots()使用的三次或四次公式生成的表达式形成对比，这些表达式受到不可约情况的影响 [1]:>>> from sympy import roots >>> p = 2*x**3 - 9*x**2 - 6*x + 3 >>> [r.evalf(5) for r in roots(p, multiple=True)] [5.0365 - 0.e-11*I, 0.33984 + 0.e-13*I, -0.87636 + 0.e-10*I] >>> [r.evalf(5) for r in real_roots(p, x)] [-0.87636, 0.33984, 5.0365] >>> [r.is_real for r in roots(p, multiple=True)] [None, None, None] >>> [r.is_real for r in real_roots(p)] [True, True, True]
使用
real_roots()等同于使用all_roots()（或rootof()）并过滤出仅有的实根：>>> from sympy import all_roots >>> r = [r for r in all_roots(p) if r.is_real] >>> real_roots(p) == r True
如果只需要实根，那么使用
real_roots()比使用all_roots()更快。使用real_roots()避免了复根隔离，这在处理通常具有比实根更多复根的高次多项式时，通常比实根隔离慢得多。如果设置 \(extension=True\)，
real_roots()可以处理非理性的代数系数。>>> from sympy import sqrt, expand >>> p = expand((x - sqrt(2))*(x - sqrt(3))) >>> print(p) x**2 - sqrt(3)*x - sqrt(2)*x + sqrt(6) >>> real_roots(p) Traceback (most recent call last): ... NotImplementedError: sorted roots not supported over EX >>> real_roots(p, extension=True) [sqrt(2), sqrt(3)]
超越系数目前无法由
real_roots()处理。在代数或超越系数的情况下，ground_roots()可能通过因式分解找到一些根：>>> from sympy import ground_roots >>> ground_roots(p, x, extension=True) {sqrt(2): 1, sqrt(3): 1}
如果系数是数值，则可以使用
nroots()来近似求出所有根：>>> from sympy import nroots >>> nroots(p, 5) [1.4142, 1.732]
如果系数是符号化的，则应使用
sympy.polys.polyroots.roots()或ground_roots()。>>> from sympy import roots, ground_roots >>> p = x**2 - 3*x*y + 2*y**2 >>> roots(p, x) {y: 1, 2*y: 1} >>> ground_roots(p, x) {y: 1, 2*y: 1}
- sympy.polys.polytools.nroots(f, n=15, maxsteps=50, cleanup=True)[源代码][源代码]¶
计算
f根的数值近似值。示例
>>> from sympy import nroots >>> from sympy.abc import x
>>> nroots(x**2 - 3, n=15) [-1.73205080756888, 1.73205080756888] >>> nroots(x**2 - 3, n=30) [-1.73205080756887729352744634151, 1.73205080756887729352744634151]
- sympy.polys.polytools.ground_roots(f, *gens, **args)[源代码][源代码]¶
通过在基础域中的因式分解来计算
f的根。示例
>>> from sympy import ground_roots >>> from sympy.abc import x
>>> ground_roots(x**6 - 4*x**4 + 4*x**3 - x**2) {0: 2, 1: 2}
- sympy.polys.polytools.nth_power_roots_poly(f, n, *gens, **args)[源代码][源代码]¶
构造一个多项式，其根的n次幂为
f的根。示例
>>> from sympy import nth_power_roots_poly, factor, roots >>> from sympy.abc import x
>>> f = x**4 - x**2 + 1 >>> g = factor(nth_power_roots_poly(f, 2))
>>> g (x**2 - x + 1)**2
>>> R_f = [ (r**2).expand() for r in roots(f) ] >>> R_g = roots(g).keys()
>>> set(R_f) == set(R_g) True
- sympy.polys.polytools.cancel(f, *gens, _signsimp=True, **args)[源代码][源代码]¶
在有理函数
f中消去公因子。示例
>>> from sympy import cancel, sqrt, Symbol, together >>> from sympy.abc import x >>> A = Symbol('A', commutative=False)
>>> cancel((2*x**2 - 2)/(x**2 - 2*x + 1)) (2*x + 2)/(x - 1) >>> cancel((sqrt(3) + sqrt(15)*A)/(sqrt(2) + sqrt(10)*A)) sqrt(6)/2
注意：由于 Rationals 的自动分布，一个和除以一个整数将显示为一个和。要恢复一个有理数形式，请对结果使用 \(together\)：
>>> cancel(x/2 + 1) x/2 + 1 >>> together(_) (x + 2)/2
- sympy.polys.polytools.reduced(f, G, *gens, **args)[源代码][源代码]¶
将多项式
f对一组多项式G取模。给定一个多项式
f和一个多项式集合G = (g_1, ..., g_n)，计算一组商q = (q_1, ..., q_n)和余数r，使得f = q_1*g_1 + ... + q_n*g_n + r，其中r消失或r是相对于G完全约化的多项式。示例
>>> from sympy import reduced >>> from sympy.abc import x, y
>>> reduced(2*x**4 + y**2 - x**2 + y**3, [x**3 - x, y**3 - y]) ([2*x, 1], x**2 + y**2 + y)
- sympy.polys.polytools.groebner(F, *gens, **args)[源代码][源代码]¶
计算一组多项式的约化Groebner基。
使用
order参数来设置用于计算基的多项式排序。允许的排序有lex、grlex和grevlex。如果没有指定排序，它默认使用lex。关于Groebner基的更多信息，请参阅参考文献和
solve_poly_system()的文档字符串。参考文献
示例
示例取自 [1]。
>>> from sympy import groebner >>> from sympy.abc import x, y
>>> F = [x*y - 2*y, 2*y**2 - x**2]
>>> groebner(F, x, y, order='lex') GroebnerBasis([x**2 - 2*y**2, x*y - 2*y, y**3 - 2*y], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, order='grlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grlex') >>> groebner(F, x, y, order='grevlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grevlex')
默认情况下，使用的是 Buchberger 算法的改进实现。可选地，可以使用 F5B 算法的实现。可以通过
method标志或使用sympy.polys.polyconfig.setup()函数来设置算法。>>> F = [x**2 - x - 1, (2*x - 1) * y - (x**10 - (1 - x)**10)]
>>> groebner(F, x, y, method='buchberger') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, method='f5b') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex')
- sympy.polys.polytools.is_zero_dimensional(F, *gens, **args)[源代码][源代码]¶
检查由 Groebner 基生成的理想是否是零维的。
该算法检查是否存在一组不可被
F中任何元素的首项整除的单项式，并且这组单项式是有界的。参考文献
David A. Cox, John B. Little, Donal O’Shea. 理想、变体和算法，第三版，第230页
- class sympy.polys.polytools.Poly(rep, *gens, **args)[源代码][源代码]¶
用于表示和操作多项式表达式的通用类。
有关一般文档，请参阅 多项式操作。
Poly 是 Basic 的子类，而不是 Expr，但实例可以通过
as_expr()方法转换为 Expr。自 1.6 版本弃用: 在二进制操作中结合 Poly 与非 Poly 对象已被弃用。请先将两个对象显式转换为 Poly 或 Expr。参见 在二元操作中混合 Poly 和非多项式表达式。
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。domain获取
Poly的基础域- 表达式
- expr_free_symbols
free_symbols多项式表达式的自由符号。
free_symbols_in_domainself域的自由符号。func表达式中的顶级函数。
gen返回主生成器。
- 生成
- is_algebraic
- is_antihermitian
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
is_cyclotomic如果
f是一个分圆多项式，则返回True。- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
is_ground如果
f是基域的一个元素，则返回True。- is_hermitian
is_homogeneous如果
f是齐次多项式，则返回True。- is_imaginary
- is_infinite
- is_integer
- is_irrational
is_irreducible如果
f在其定义域内没有因子，则返回True。is_linear如果
f在其所有变量中线性，则返回True。is_monic如果
f的首项系数为1，则返回True。is_monomial如果
f为零或仅有一个项，则返回True。is_multivariate如果
f是一个多元多项式，则返回True。- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
- is_odd
is_one如果
f是一个单位多项式，则返回True。- is_polar
- is_positive
- is_prime
is_primitive如果
f的系数的最大公约数为1，则返回True。is_quadratic如果
f在其所有变量中都是二次的，则返回True。- is_rational
- is_real
is_sqf如果
f是一个无平方多项式，则返回True。- is_transcendental
is_univariate如果
f是单变量多项式，则返回True。is_zero如果
f是零多项式，则返回True。one返回一个具有
self属性的多项式。- rep
unit返回具有
self属性的单位多项式。zero返回具有
self属性的零多项式。
方法
EC([order])返回
f的最后一个非零系数。EM([order])返回
f的最后一个非零单项式。ET([order])返回
f的最后一个非零项。LC([order])返回
f的首项系数。LM([order])返回
f的领先单项式。LT([order])返回
f的首项。TC()返回
f的尾系数。__call__(*values)在给定值处评估
f。abs()使
f中的所有系数为正。add(g)将两个多项式
f和g相加。add_ground(coeff)将一个地面域的元素添加到
f中。返回单变量多项式
f的所有系数。返回单变量多项式
f中的所有单项式。all_roots([multiple, radicals])返回一个包含实数和复数根及其重数的列表。
返回单变量多项式
f中的所有项。as_content_primitive([radical, clear])一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dict([native, zero])切换到
dict表示形式。as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_expr(*gens)将 Poly 实例转换为 Expr 实例。
as_list([native])切换到
列表表示形式。as_poly(*gens, **args)将
self转换为多项式，或返回None。atoms(*types)返回构成当前对象的原子。
cancel(g[, include])在有理函数
f/g中消去公因子。class_key()类的好顺序。
clear_denoms([convert])清除分母，但保持基础域。
coeff_monomial(monom)如果存在，返回
f中monom的系数，否则返回 None。coeffs([order])返回
f中按字典顺序排列的所有非零系数。cofactors(g)返回
f和g的最大公约数及其余因子。compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compose(g)计算
f和g的函数组合。content()返回多项式系数的最大公约数。
count(query)计算匹配的子表达式的数量。
count_ops([visual])用于返回操作计数的 count_ops 的包装器。
count_roots([inf, sup])返回
f在[inf, sup]区间内的根的数量。计算
f的功能分解。deflate()通过将
x_i**m映射到y_i来降低f的次数。degree([gen])返回
f在x_j中的次数。返回
f的度数列表。diff(*specs, **kwargs)计算
f的偏导数。计算
f的判别式。dispersion([g])计算多项式的 离散度。
dispersionset([g])计算两个多项式的 离散集。
div(g[, auto])f除以g的多项式带余除法。doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
eject(*gens)将选定的生成器弹出到地面领域。
eval(x[, a, auto])在给定的变量中计算
f在a处的值。exclude()从
f中移除不必要的生成器。exquo(g[, auto])计算多项式
f除以g的精确商。exquo_ground(coeff)f除以基域中一个元素的精确商。返回
f的不可约因子列表。返回
f的不可约因子列表。find(query[, group])查找所有匹配查询的子表达式。
from_dict(rep, *gens, **args)从
dict构建一个多项式。from_expr(rep, *gens, **args)从表达式构造多项式。
from_list(rep, *gens, **args)从
list构建一个多项式。from_poly(rep, *gens, **args)从多项式构建多项式。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
galois_group([by_name, max_tries, randomize])计算这个多项式的伽罗瓦群。
gcd(g)返回多项式
f和g的最大公约数。gcdex(g[, auto])f和g的扩展欧几里得算法。获取
f的基础域。获取
f的模数。gff_list()计算
f的最大阶乘分解。通过在基础域中的因式分解来计算
f的根。half_gcdex(g[, auto])f和g的半扩展欧几里得算法。has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_only_gens(*gens)如果
Poly(f, *gens)保留了基础域，则返回True。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
返回
f的齐次阶。homogenize(s)返回
f的齐次多项式。inject([front])将地面域生成器注入
f。integrate(*specs, **args)计算
f的不定积分。intervals([all, eps, inf, sup, fast, sqf])计算多项式
f的根的隔离区间。invert(g[, auto])在可能的情况下，对
f取g的模逆。is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
l1_norm()返回
f的 l1 范数。lcm(g)返回多项式
f和g的最小公倍数。length()返回
f中非零项的数量。lift()将代数系数转换为有理数。
ltrim(gen)从
f中移除位于指定gen左侧的虚拟生成器，按照生成器的顺序。match(*args, **kwargs)来自 Poly 的匹配表达式
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
max_norm()返回
f的最大范数。monic([auto])将所有系数除以
LC(f)。monoms([order])返回
f中按字典顺序排列的所有非零单项式。mul(g)将两个多项式
f和g相乘。mul_ground(coeff)将
f乘以基域的一个元素。neg()在
f中否定所有系数。new(rep, *gens)从原始表示构造
Poly实例。norm()计算定义在数域
K上的多项式f的共轭的乘积，Norm(f)。nroots([n, maxsteps, cleanup])计算
f根的数值近似值。nth(*N)返回
f的第n个系数，其中N是感兴趣项中生成元的指数。构造一个多项式，其根的n次幂为
f的根。pdiv(g)多项式
f除以g的伪除法。per(rep[, gens, remove])根据给定的表示创建一个多边形。
pexquo(g)多项式
f除以g的精确伪商。pow(n)将
f提升到一个非负的幂n。pquo(g)多项式
f除以g的伪商。prem(g)多项式
f对g的伪余数。返回内容和
f的原始形式。quo(g[, auto])计算多项式
f除以g的商。quo_ground(coeff)f除以基域中一个元素的商。在有理函数
f/g中清除分母。rcall(*args)通过表达式树递归应用于参数。
real_roots([multiple, radicals])返回带有重数的实根列表。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
refine_root(s, t[, eps, steps, fast, check_sqf])将根的隔离区间精炼到给定的精度。
rem(g[, auto])计算多项式
f除以g的余数。reorder(*gens, **args)高效地应用生成器的新顺序。
replace(x[, y])在生成器列表中将
x替换为y。resultant(g[, includePRS])通过PRS计算
f和g的结果。retract([field])重新计算多项式的地面域。
revert(n)计算
f**(-1)模x**n。rewrite(*args[, deep])使用定义的规则重写 self。
root(index[, radicals])获取多项式的索引根。
same_root(a, b)决定这个多项式的两个根是否相等。
set_domain(domain)设置
f的基础域。set_modulus(modulus)设置
f的模数。shift(a)高效计算泰勒位移
f(x + a)。shift_list(a)高效计算泰勒位移
f(X + A)。simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
slice(x, m[, n])取
f的连续子序列项。sort_key([order])返回一个排序键。
sqf_list([all])返回
f的无平方因子的列表。sqf_list_include([all])返回
f的无平方因子的列表。sqf_norm()计算
f的无平方范数。sqf_part()计算
f的无平方部分。sqr()对多项式
f进行平方。sturm([auto])计算
f的 Sturm 序列。sub(g)减去两个多项式
f和g。sub_ground(coeff)从
f中减去地面域的一个元素。计算
f和g的子结果PRS。subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
terms([order])返回
f中按字典顺序排列的所有非零项。从多项式
f中去除各项的最大公约数。termwise(func, *gens, **args)对
f的所有项应用一个函数。to_exact()使基础域精确。
to_field()将基础域设为一个域。
to_ring()将基础域设为一个环。
返回
f的总次数。transform(p, q)高效地评估函数变换
q**n * f(p/q)。trunc(p)将
f对常数p取模。unify(g)使
f和g属于同一个域。which_all_roots(candidates)从
candidates中找到无平方多项式f的根。which_real_roots(candidates)从
candidates中找到无平方多项式f的根。xreplace(rule)替换表达式中对象的出现。
coeff
复制
could_extract_minus_sign
eq
is_hypergeometric
不
示例
>>> from sympy import Poly >>> from sympy.abc import x, y
创建一个单变量多项式：
>>> Poly(x*(x**2 + x - 1)**2) Poly(x**5 + 2*x**4 - x**3 - 2*x**2 + x, x, domain='ZZ')
创建一个具有特定定义域的单变量多项式：
>>> from sympy import sqrt >>> Poly(x**2 + 2*x + sqrt(3), domain='R') Poly(1.0*x**2 + 2.0*x + 1.73205080756888, x, domain='RR')
创建一个多元多项式：
>>> Poly(y*x**2 + x*y + 1) Poly(x**2*y + x*y + 1, x, y, domain='ZZ')
创建一个单变量多项式，其中 y 是一个常数：
>>> Poly(y*x**2 + x*y + 1,x) Poly(y*x**2 + y*x + 1, x, domain='ZZ[y]')
你可以将上述多项式作为 y 的函数进行求值：
>>> Poly(y*x**2 + x*y + 1,x).eval(2) 6*y + 1
- EC(order=None)[源代码][源代码]¶
返回
f的最后一个非零系数。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**3 + 2*x**2 + 3*x, x).EC() 3
- EM(order=None)[源代码][源代码]¶
返回
f的最后一个非零单项式。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).EM() x**0*y**1
- ET(order=None)[源代码][源代码]¶
返回
f的最后一个非零项。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).ET() (x**0*y**1, 3)
- LC(order=None)[源代码][源代码]¶
返回
f的首项系数。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(4*x**3 + 2*x**2 + 3*x, x).LC() 4
- LM(order=None)[源代码][源代码]¶
返回
f的领先单项式。领先单项式表示在表达式 f 中具有主生成元最高幂的单项式。
示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).LM() x**2*y**0
- LT(order=None)[源代码][源代码]¶
返回
f的首项。领先项表示表达式 f 中主生成元的最高次幂项及其系数。
示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).LT() (x**2*y**0, 4)
- TC()[源代码][源代码]¶
返回
f的尾系数。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**3 + 2*x**2 + 3*x, x).TC() 0
- abs()[源代码][源代码]¶
使
f中的所有系数为正。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 - 1, x).abs() Poly(x**2 + 1, x, domain='ZZ')
- add(g)[源代码][源代码]¶
将两个多项式
f和g相加。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, x).add(Poly(x - 2, x)) Poly(x**2 + x - 1, x, domain='ZZ')
>>> Poly(x**2 + 1, x) + Poly(x - 2, x) Poly(x**2 + x - 1, x, domain='ZZ')
- add_ground(coeff)[源代码][源代码]¶
将一个地面域的元素添加到
f中。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x + 1).add_ground(2) Poly(x + 3, x, domain='ZZ')
- all_coeffs()[源代码][源代码]¶
返回单变量多项式
f的所有系数。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**3 + 2*x - 1, x).all_coeffs() [1, 0, 2, -1]
- all_monoms()[源代码][源代码]¶
返回单变量多项式
f中的所有单项式。参见
示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**3 + 2*x - 1, x).all_monoms() [(3,), (2,), (1,), (0,)]
- all_roots(multiple=True, radicals=True)[源代码][源代码]¶
返回一个包含实数和复数根及其重数的列表。
更多解释请参见
all_roots()。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(2*x**3 - 7*x**2 + 4*x + 4).all_roots() [-1/2, 2, 2] >>> Poly(x**3 + x + 1).all_roots() [CRootOf(x**3 + x + 1, 0), CRootOf(x**3 + x + 1, 1), CRootOf(x**3 + x + 1, 2)]
- all_terms()[源代码][源代码]¶
返回单变量多项式
f中的所有项。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**3 + 2*x - 1, x).all_terms() [((3,), 1), ((2,), 0), ((1,), 2), ((0,), -1)]
- as_dict(native=False, zero=False)[源代码][源代码]¶
切换到
dict表示形式。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + 2*x*y**2 - y, x, y).as_dict() {(0, 1): -1, (1, 2): 2, (2, 0): 1}
- as_expr(*gens)[源代码][源代码]¶
将 Poly 实例转换为 Expr 实例。
示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> f = Poly(x**2 + 2*x*y**2 - y, x, y)
>>> f.as_expr() x**2 + 2*x*y**2 - y >>> f.as_expr({x: 5}) 10*y**2 - y + 25 >>> f.as_expr(5, 6) 379
- as_poly(*gens, **args)[源代码][源代码]¶
将
self转换为多项式，或返回None。>>> from sympy import sin >>> from sympy.abc import x, y
>>> print((x**2 + x*y).as_poly()) Poly(x**2 + x*y, x, y, domain='ZZ')
>>> print((x**2 + x*y).as_poly(x, y)) Poly(x**2 + x*y, x, y, domain='ZZ')
>>> print((x**2 + sin(y)).as_poly(x, y)) None
- cancel(g, include=False)[源代码][源代码]¶
在有理函数
f/g中消去公因子。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(2*x**2 - 2, x).cancel(Poly(x**2 - 2*x + 1, x)) (1, Poly(2*x + 2, x, domain='ZZ'), Poly(x - 1, x, domain='ZZ'))
>>> Poly(2*x**2 - 2, x).cancel(Poly(x**2 - 2*x + 1, x), include=True) (Poly(2*x + 2, x, domain='ZZ'), Poly(x - 1, x, domain='ZZ'))
- clear_denoms(convert=False)[源代码][源代码]¶
清除分母，但保持基础域。
示例
>>> from sympy import Poly, S, QQ >>> from sympy.abc import x
>>> f = Poly(x/2 + S(1)/3, x, domain=QQ)
>>> f.clear_denoms() (6, Poly(3*x + 2, x, domain='QQ')) >>> f.clear_denoms(convert=True) (6, Poly(3*x + 2, x, domain='ZZ'))
- coeff_monomial(monom)[源代码][源代码]¶
如果存在，返回
f中monom的系数，否则返回 None。参见
nth使用单项式生成元的指数进行更高效的查询
示例
>>> from sympy import Poly, exp >>> from sympy.abc import x, y
>>> p = Poly(24*x*y*exp(8) + 23*x, x, y)
>>> p.coeff_monomial(x) 23 >>> p.coeff_monomial(y) 0 >>> p.coeff_monomial(x*y) 24*exp(8)
注意
Expr.coeff()的行为不同，如果可能的话会收集项；然而，必须将 Poly 转换为 Expr 才能使用该方法：>>> p.as_expr().coeff(x) 24*y*exp(8) + 23 >>> p.as_expr().coeff(y) 24*x*exp(8) >>> p.as_expr().coeff(x*y) 24*exp(8)
- coeffs(order=None)[源代码][源代码]¶
返回
f中按字典顺序排列的所有非零系数。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**3 + 2*x + 3, x).coeffs() [1, 2, 3]
- cofactors(g)[源代码][源代码]¶
返回
f和g的最大公约数及其余因子。返回多项式
(h, cff, cfg)使得h = gcd(f, g)，并且cff = quo(f, h)和cfg = quo(g, h)是所谓的f和g的余因子。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 - 1, x).cofactors(Poly(x**2 - 3*x + 2, x)) (Poly(x - 1, x, domain='ZZ'), Poly(x + 1, x, domain='ZZ'), Poly(x - 2, x, domain='ZZ'))
- compose(g)[源代码][源代码]¶
计算
f和g的函数组合。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + x, x).compose(Poly(x - 1, x)) Poly(x**2 - x, x, domain='ZZ')
- content()[源代码][源代码]¶
返回多项式系数的最大公约数。
示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(6*x**2 + 8*x + 12, x).content() 2
- count_roots(inf=None, sup=None)[源代码][源代码]¶
返回
f在[inf, sup]区间内的根的数量。示例
>>> from sympy import Poly, I >>> from sympy.abc import x
>>> Poly(x**4 - 4, x).count_roots(-3, 3) 2 >>> Poly(x**4 - 4, x).count_roots(0, 1 + 3*I) 1
- decompose()[源代码][源代码]¶
计算
f的功能分解。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**4 + 2*x**3 - x - 1, x, domain='ZZ').decompose() [Poly(x**2 - x - 1, x, domain='ZZ'), Poly(x**2 + x, x, domain='ZZ')]
- deflate()[源代码][源代码]¶
通过将
x_i**m映射到y_i来降低f的次数。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**6*y**2 + x**3 + 1, x, y).deflate() ((3, 2), Poly(x**2*y + x + 1, x, y, domain='ZZ'))
- degree(gen=0)[源代码][源代码]¶
返回
f在x_j中的次数。0 的度数是负无穷大。
示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + y*x + 1, x, y).degree() 2 >>> Poly(x**2 + y*x + y, x, y).degree(y) 1 >>> Poly(0, x).degree() -oo
- degree_list()[源代码][源代码]¶
返回
f的度数列表。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + y*x + 1, x, y).degree_list() (2, 1)
- diff(*specs, **kwargs)[源代码][源代码]¶
计算
f的偏导数。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + 2*x + 1, x).diff() Poly(2*x + 2, x, domain='ZZ')
>>> Poly(x*y**2 + x, x, y).diff((0, 0), (1, 1)) Poly(2*x*y, x, y, domain='ZZ')
- discriminant()[源代码][源代码]¶
计算
f的判别式。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 2*x + 3, x).discriminant() -8
- dispersion(g=None)[源代码][源代码]¶
计算多项式的 离散度。
对于两个多项式 \(f(x)\) 和 \(g(x)\) 且 \(\deg f > 0\) 和 \(\deg g > 0\)，分散度 \(\operatorname{dis}(f, g)\) 定义为：
\[\begin{split}\operatorname{dis}(f, g) & := \max\{ J(f,g) \cup \{0\} \} \\ & = \max\{ \{a \in \mathbb{N} | \gcd(f(x), g(x+a)) \neq 1\} \cup \{0\} \}\end{split}\]而对于单个多项式 \(\operatorname{dis}(f) := \operatorname{dis}(f, f)\)。
参考文献
示例
>>> from sympy import poly >>> from sympy.polys.dispersion import dispersion, dispersionset >>> from sympy.abc import x
简单多项式的离散集和离散度：
>>> fp = poly((x - 3)*(x + 3), x) >>> sorted(dispersionset(fp)) [0, 6] >>> dispersion(fp) 6
请注意，色散的定义不是对称的：
>>> fp = poly(x**4 - 3*x**2 + 1, x) >>> gp = fp.shift(-3) >>> sorted(dispersionset(fp, gp)) [2, 3, 4] >>> dispersion(fp, gp) 4 >>> sorted(dispersionset(gp, fp)) [] >>> dispersion(gp, fp) -oo
计算色散在域扩展上也适用：
>>> from sympy import sqrt >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>') >>> sorted(dispersionset(fp, gp)) [2] >>> sorted(dispersionset(gp, fp)) [1, 4]
我们甚至可以对具有符号系数的多项式进行计算：
>>> from sympy.abc import a >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x) >>> sorted(dispersionset(fp)) [0, 1]
- dispersionset(g=None)[源代码][源代码]¶
计算两个多项式的 离散集。
对于两个多项式 \(f(x)\) 和 \(g(x)\) 且 \(\deg f > 0\) 和 \(\deg g > 0\)，分散集 \(\operatorname{J}(f, g)\) 定义为：
\[\begin{split}\operatorname{J}(f, g) & := \{a \in \mathbb{N}_0 | \gcd(f(x), g(x+a)) \neq 1\} \\ & = \{a \in \mathbb{N}_0 | \deg \gcd(f(x), g(x+a)) \geq 1\}\end{split}\]对于单个多项式，定义 \(\operatorname{J}(f) := \operatorname{J}(f, f)\)。
参见
参考文献
示例
>>> from sympy import poly >>> from sympy.polys.dispersion import dispersion, dispersionset >>> from sympy.abc import x
简单多项式的离散集和离散度：
>>> fp = poly((x - 3)*(x + 3), x) >>> sorted(dispersionset(fp)) [0, 6] >>> dispersion(fp) 6
请注意，色散的定义不是对称的：
>>> fp = poly(x**4 - 3*x**2 + 1, x) >>> gp = fp.shift(-3) >>> sorted(dispersionset(fp, gp)) [2, 3, 4] >>> dispersion(fp, gp) 4 >>> sorted(dispersionset(gp, fp)) [] >>> dispersion(gp, fp) -oo
计算色散在域扩展上也适用：
>>> from sympy import sqrt >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>') >>> sorted(dispersionset(fp, gp)) [2] >>> sorted(dispersionset(gp, fp)) [1, 4]
我们甚至可以对具有符号系数的多项式进行计算：
>>> from sympy.abc import a >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x) >>> sorted(dispersionset(fp)) [0, 1]
- div(g, auto=True)[源代码][源代码]¶
f除以g的多项式带余除法。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, x).div(Poly(2*x - 4, x)) (Poly(1/2*x + 1, x, domain='QQ'), Poly(5, x, domain='QQ'))
>>> Poly(x**2 + 1, x).div(Poly(2*x - 4, x), auto=False) (Poly(0, x, domain='ZZ'), Poly(x**2 + 1, x, domain='ZZ'))
- property domain¶
获取
Poly的基础域示例
>>> from sympy import Poly, Symbol >>> x = Symbol('x') >>> p = Poly(x**2 + x) >>> p Poly(x**2 + x, x, domain='ZZ') >>> p.domain ZZ
- eject(*gens)[源代码][源代码]¶
将选定的生成器弹出到地面领域。
示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> f = Poly(x**2*y + x*y**3 + x*y + 1, x, y)
>>> f.eject(x) Poly(x*y**3 + (x**2 + x)*y + 1, y, domain='ZZ[x]') >>> f.eject(y) Poly(y*x**2 + (y**3 + y)*x + 1, x, domain='ZZ[y]')
- eval(x, a=None, auto=True)[源代码][源代码]¶
在给定的变量中计算
f在a处的值。示例
>>> from sympy import Poly >>> from sympy.abc import x, y, z
>>> Poly(x**2 + 2*x + 3, x).eval(2) 11
>>> Poly(2*x*y + 3*x + y + 2, x, y).eval(x, 2) Poly(5*y + 8, y, domain='ZZ')
>>> f = Poly(2*x*y + 3*x + y + 2*z, x, y, z)
>>> f.eval({x: 2}) Poly(5*y + 2*z + 6, y, z, domain='ZZ') >>> f.eval({x: 2, y: 5}) Poly(2*z + 31, z, domain='ZZ') >>> f.eval({x: 2, y: 5, z: 7}) 45
>>> f.eval((2, 5)) Poly(2*z + 31, z, domain='ZZ') >>> f(2, 5) Poly(2*z + 31, z, domain='ZZ')
- exclude()[源代码][源代码]¶
从
f中移除不必要的生成器。示例
>>> from sympy import Poly >>> from sympy.abc import a, b, c, d, x
>>> Poly(a + x, a, b, c, d, x).exclude() Poly(a + x, a, x, domain='ZZ')
- exquo(g, auto=True)[源代码][源代码]¶
计算多项式
f除以g的精确商。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 - 1, x).exquo(Poly(x - 1, x)) Poly(x + 1, x, domain='ZZ')
>>> Poly(x**2 + 1, x).exquo(Poly(2*x - 4, x)) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1
- exquo_ground(coeff)[源代码][源代码]¶
f除以基域中一个元素的精确商。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(2*x + 4).exquo_ground(2) Poly(x + 2, x, domain='ZZ')
>>> Poly(2*x + 3).exquo_ground(2) Traceback (most recent call last): ... ExactQuotientFailed: 2 does not divide 3 in ZZ
- factor_list()[源代码][源代码]¶
返回
f的不可约因子列表。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> f = 2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y
>>> Poly(f).factor_list() (2, [(Poly(x + y, x, y, domain='ZZ'), 1), (Poly(x**2 + 1, x, y, domain='ZZ'), 2)])
- factor_list_include()[源代码][源代码]¶
返回
f的不可约因子列表。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> f = 2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y
>>> Poly(f).factor_list_include() [(Poly(2*x + 2*y, x, y, domain='ZZ'), 1), (Poly(x**2 + 1, x, y, domain='ZZ'), 2)]
- property free_symbols¶
多项式表达式的自由符号。
示例
>>> from sympy import Poly >>> from sympy.abc import x, y, z
>>> Poly(x**2 + 1).free_symbols {x} >>> Poly(x**2 + y).free_symbols {x, y} >>> Poly(x**2 + y, x).free_symbols {x, y} >>> Poly(x**2 + y, x, z).free_symbols {x, y}
- property free_symbols_in_domain¶
self域的自由符号。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + 1).free_symbols_in_domain set() >>> Poly(x**2 + y).free_symbols_in_domain set() >>> Poly(x**2 + y, x).free_symbols_in_domain {y}
- galois_group(
- by_name=False,
- max_tries=30,
- randomize=False,
计算这个多项式的伽罗瓦群。
示例
>>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**4 - 2) >>> G, _ = f.galois_group(by_name=True) >>> print(G) S4TransitiveSubgroups.D4
- gcd(g)[源代码][源代码]¶
返回多项式
f和g的最大公约数。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 - 1, x).gcd(Poly(x**2 - 3*x + 2, x)) Poly(x - 1, x, domain='ZZ')
- gcdex(g, auto=True)[源代码][源代码]¶
f和g的扩展欧几里得算法。返回
(s, t, h)使得h = gcd(f, g)并且s*f + t*g = h。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15 >>> g = x**3 + x**2 - 4*x - 4
>>> Poly(f).gcdex(Poly(g)) (Poly(-1/5*x + 3/5, x, domain='QQ'), Poly(1/5*x**2 - 6/5*x + 2, x, domain='QQ'), Poly(x + 1, x, domain='QQ'))
- property gen¶
返回主生成器。
示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, x).gen x
- get_modulus()[源代码][源代码]¶
获取
f的模数。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, modulus=2).get_modulus() 2
- gff_list()[源代码][源代码]¶
计算
f的最大阶乘分解。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> f = x**5 + 2*x**4 - x**3 - 2*x**2
>>> Poly(f).gff_list() [(Poly(x, x, domain='ZZ'), 1), (Poly(x + 2, x, domain='ZZ'), 4)]
- ground_roots()[源代码][源代码]¶
通过在基础域中的因式分解来计算
f的根。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**6 - 4*x**4 + 4*x**3 - x**2).ground_roots() {0: 2, 1: 2}
- half_gcdex(g, auto=True)[源代码][源代码]¶
f和g的半扩展欧几里得算法。返回
(s, h)使得h = gcd(f, g)且s*f = h (mod g)。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15 >>> g = x**3 + x**2 - 4*x - 4
>>> Poly(f).half_gcdex(Poly(g)) (Poly(-1/5*x + 3/5, x, domain='QQ'), Poly(x + 1, x, domain='QQ'))
- has_only_gens(*gens)[源代码][源代码]¶
如果
Poly(f, *gens)保留了基础域，则返回True。示例
>>> from sympy import Poly >>> from sympy.abc import x, y, z
>>> Poly(x*y + 1, x, y, z).has_only_gens(x, y) True >>> Poly(x*y + z, x, y, z).has_only_gens(x, y) False
- homogeneous_order()[源代码][源代码]¶
返回
f的齐次阶。齐次多项式是一种多项式，其所有系数非零的单项式具有相同的总次数。这个次数是
f的齐次阶。如果你只想检查一个多项式是否是齐次的，那么使用Poly.is_homogeneous()。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> f = Poly(x**5 + 2*x**3*y**2 + 9*x*y**4) >>> f.homogeneous_order() 5
- homogenize(s)[源代码][源代码]¶
返回
f的齐次多项式。齐次多项式是一种多项式，其所有系数非零的单项式具有相同的全次数。如果你只想检查一个多项式是否是齐次的，那么使用
Poly.is_homogeneous()。如果你想不仅检查一个多项式是否是齐次的，还要计算其齐次阶数，那么使用Poly.homogeneous_order()。示例
>>> from sympy import Poly >>> from sympy.abc import x, y, z
>>> f = Poly(x**5 + 2*x**2*y**2 + 9*x*y**3) >>> f.homogenize(z) Poly(x**5 + 2*x**2*y**2*z + 9*x*y**3*z, x, y, z, domain='ZZ')
- inject(front=False)[源代码][源代码]¶
将地面域生成器注入
f。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> f = Poly(x**2*y + x*y**3 + x*y + 1, x)
>>> f.inject() Poly(x**2*y + x*y**3 + x*y + 1, x, y, domain='ZZ') >>> f.inject(front=True) Poly(y**3*x + y*x**2 + y*x + 1, y, x, domain='ZZ')
- integrate(*specs, **args)[源代码][源代码]¶
计算
f的不定积分。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + 2*x + 1, x).integrate() Poly(1/3*x**3 + x**2 + x, x, domain='QQ')
>>> Poly(x*y**2 + x, x, y).integrate((0, 1), (1, 0)) Poly(1/2*x**2*y**2 + 1/2*x**2, x, y, domain='QQ')
- intervals(
- all=False,
- eps=None,
- inf=None,
- sup=None,
- fast=False,
- sqf=False,
计算多项式
f的根的隔离区间。对于实根，使用 Vincent-Akritas-Strzebonski (VAS) 连分数方法。
参考文献
示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 - 3, x).intervals() [((-2, -1), 1), ((1, 2), 1)] >>> Poly(x**2 - 3, x).intervals(eps=1e-2) [((-26/15, -19/11), 1), ((19/11, 26/15), 1)]
- invert(g, auto=True)[源代码][源代码]¶
在可能的情况下，对
f取g的模逆。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 - 1, x).invert(Poly(2*x - 1, x)) Poly(-4/3, x, domain='QQ')
>>> Poly(x**2 - 1, x).invert(Poly(x - 1, x)) Traceback (most recent call last): ... NotInvertible: zero divisor
- property is_cyclotomic¶
如果
f是一个分圆多项式，则返回True。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> f = x**16 + x**14 - x**10 + x**8 - x**6 + x**2 + 1
>>> Poly(f).is_cyclotomic False
>>> g = x**16 + x**14 - x**10 - x**8 - x**6 + x**2 + 1
>>> Poly(g).is_cyclotomic True
- property is_ground¶
如果
f是基域的一个元素，则返回True。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x, x).is_ground False >>> Poly(2, x).is_ground True >>> Poly(y, x).is_ground True
- property is_homogeneous¶
如果
f是齐次多项式，则返回True。齐次多项式是一种多项式，其所有系数非零的单项式具有相同的总次数。如果你想不仅检查一个多项式是否是齐次的，还要计算其齐次次数，那么使用
Poly.homogeneous_order()。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + x*y, x, y).is_homogeneous True >>> Poly(x**3 + x*y, x, y).is_homogeneous False
- property is_irreducible¶
如果
f在其定义域内没有因子，则返回True。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + x + 1, x, modulus=2).is_irreducible True >>> Poly(x**2 + 1, x, modulus=2).is_irreducible False
- property is_linear¶
如果
f在其所有变量中线性，则返回True。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x + y + 2, x, y).is_linear True >>> Poly(x*y + 2, x, y).is_linear False
- property is_monic¶
如果
f的首项系数为1，则返回True。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x + 2, x).is_monic True >>> Poly(2*x + 2, x).is_monic False
- property is_monomial¶
如果
f为零或仅有一个项，则返回True。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(3*x**2, x).is_monomial True >>> Poly(3*x**2 + 1, x).is_monomial False
- property is_multivariate¶
如果
f是一个多元多项式，则返回True。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + x + 1, x).is_multivariate False >>> Poly(x*y**2 + x*y + 1, x, y).is_multivariate True >>> Poly(x*y**2 + x*y + 1, x).is_multivariate False >>> Poly(x**2 + x + 1, x, y).is_multivariate True
- property is_one¶
如果
f是一个单位多项式，则返回True。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(0, x).is_one False >>> Poly(1, x).is_one True
- property is_primitive¶
如果
f的系数的最大公约数为1，则返回True。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(2*x**2 + 6*x + 12, x).is_primitive False >>> Poly(x**2 + 3*x + 6, x).is_primitive True
- property is_quadratic¶
如果
f在其所有变量中都是二次的，则返回True。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x*y + 2, x, y).is_quadratic True >>> Poly(x*y**2 + 2, x, y).is_quadratic False
- property is_sqf¶
如果
f是一个无平方多项式，则返回True。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 - 2*x + 1, x).is_sqf False >>> Poly(x**2 - 1, x).is_sqf True
- property is_univariate¶
如果
f是单变量多项式，则返回True。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + x + 1, x).is_univariate True >>> Poly(x*y**2 + x*y + 1, x, y).is_univariate False >>> Poly(x*y**2 + x*y + 1, x).is_univariate True >>> Poly(x**2 + x + 1, x, y).is_univariate False
- property is_zero¶
如果
f是零多项式，则返回True。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(0, x).is_zero True >>> Poly(1, x).is_zero False
- l1_norm()[源代码][源代码]¶
返回
f的 l1 范数。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(-x**2 + 2*x - 3, x).l1_norm() 6
- lcm(g)[源代码][源代码]¶
返回多项式
f和g的最小公倍数。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 - 1, x).lcm(Poly(x**2 - 3*x + 2, x)) Poly(x**3 - 2*x**2 - x + 2, x, domain='ZZ')
- length()[源代码][源代码]¶
返回
f中非零项的数量。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 2*x - 1).length() 3
- lift()[源代码][源代码]¶
将代数系数转换为有理数。
示例
>>> from sympy import Poly, I >>> from sympy.abc import x
>>> Poly(x**2 + I*x + 1, x, extension=I).lift() Poly(x**4 + 3*x**2 + 1, x, domain='QQ')
- ltrim(gen)[源代码][源代码]¶
从
f中移除位于指定gen左侧的虚拟生成器，按照生成器的顺序。当gen是整数时，它指的是f的生成器元组中位于该位置的生成器。示例
>>> from sympy import Poly >>> from sympy.abc import x, y, z
>>> Poly(y**2 + y*z**2, x, y, z).ltrim(y) Poly(y**2 + y*z**2, y, z, domain='ZZ') >>> Poly(z, x, y, z).ltrim(-1) Poly(z, z, domain='ZZ')
- make_monic_over_integers_by_scaling_roots()[源代码][源代码]¶
将 QQ 或 ZZ 上的任何单变量多项式转换为 ZZ 上的首一多项式，必要时对根进行缩放。
- 返回:
- 对
(g, c) g 是多项式
c 是根必须缩放的整数
- 对
示例
>>> from sympy import Poly, S >>> from sympy.abc import x >>> f = Poly(x**2/2 + S(1)/4 * x + S(1)/8, x, domain='QQ') >>> f.make_monic_over_integers_by_scaling_roots() (Poly(x**2 + 2*x + 4, x, domain='ZZ'), 4)
- max_norm()[源代码][源代码]¶
返回
f的最大范数。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(-x**2 + 2*x - 3, x).max_norm() 3
- monic(auto=True)[源代码][源代码]¶
将所有系数除以
LC(f)。示例
>>> from sympy import Poly, ZZ >>> from sympy.abc import x
>>> Poly(3*x**2 + 6*x + 9, x, domain=ZZ).monic() Poly(x**2 + 2*x + 3, x, domain='QQ')
>>> Poly(3*x**2 + 4*x + 2, x, domain=ZZ).monic() Poly(x**2 + 4/3*x + 2/3, x, domain='QQ')
- monoms(order=None)[源代码][源代码]¶
返回
f中按字典顺序排列的所有非零单项式。参见
示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + 2*x*y**2 + x*y + 3*y, x, y).monoms() [(2, 0), (1, 2), (1, 1), (0, 1)]
- mul(g)[源代码][源代码]¶
将两个多项式
f和g相乘。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, x).mul(Poly(x - 2, x)) Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ')
>>> Poly(x**2 + 1, x)*Poly(x - 2, x) Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ')
- mul_ground(coeff)[源代码][源代码]¶
将
f乘以基域的一个元素。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x + 1).mul_ground(2) Poly(2*x + 2, x, domain='ZZ')
- neg()[源代码][源代码]¶
在
f中否定所有系数。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 - 1, x).neg() Poly(-x**2 + 1, x, domain='ZZ')
>>> -Poly(x**2 - 1, x) Poly(-x**2 + 1, x, domain='ZZ')
- norm()[源代码][源代码]¶
计算定义在数域
K上的多项式f的共轭的乘积，Norm(f)。示例
>>> from sympy import Poly, sqrt >>> from sympy.abc import x
>>> a, b = sqrt(2), sqrt(3)
一个关于二次扩张的多项式。两个共轭项 x - a 和 x + a。
>>> f = Poly(x - a, x, extension=a) >>> f.norm() Poly(x**2 - 2, x, domain='QQ')
一个四次扩展上的多项式。四个共轭 x - a, x - a, x + a 和 x + a。
>>> f = Poly(x - a, x, extension=(a, b)) >>> f.norm() Poly(x**4 - 4*x**2 + 4, x, domain='QQ')
- nroots(n=15, maxsteps=50, cleanup=True)[源代码][源代码]¶
计算
f根的数值近似值。- 参数:
- n … 要计算的位数
- maxsteps … 要执行的最大迭代次数
- 如果在 `maxsteps` 内无法达到精度 `n`，它将引发一个
- 异常。你需要以更高的 maxsteps 重新运行。
示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 - 3).nroots(n=15) [-1.73205080756888, 1.73205080756888] >>> Poly(x**2 - 3).nroots(n=30) [-1.73205080756887729352744634151, 1.73205080756887729352744634151]
- nth(*N)[源代码][源代码]¶
返回
f的第n个系数，其中N是感兴趣项中生成元的指数。示例
>>> from sympy import Poly, sqrt >>> from sympy.abc import x, y
>>> Poly(x**3 + 2*x**2 + 3*x, x).nth(2) 2 >>> Poly(x**3 + 2*x*y**2 + y**2, x, y).nth(1, 2) 2 >>> Poly(4*sqrt(x)*y) Poly(4*y*(sqrt(x)), y, sqrt(x), domain='ZZ') >>> _.nth(1, 1) 4
- nth_power_roots_poly(n)[源代码][源代码]¶
构造一个多项式，其根的n次幂为
f的根。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> f = Poly(x**4 - x**2 + 1)
>>> f.nth_power_roots_poly(2) Poly(x**4 - 2*x**3 + 3*x**2 - 2*x + 1, x, domain='ZZ') >>> f.nth_power_roots_poly(3) Poly(x**4 + 2*x**2 + 1, x, domain='ZZ') >>> f.nth_power_roots_poly(4) Poly(x**4 + 2*x**3 + 3*x**2 + 2*x + 1, x, domain='ZZ') >>> f.nth_power_roots_poly(12) Poly(x**4 - 4*x**3 + 6*x**2 - 4*x + 1, x, domain='ZZ')
- property one¶
返回一个具有
self属性的多项式。
- pdiv(g)[源代码][源代码]¶
多项式
f除以g的伪除法。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, x).pdiv(Poly(2*x - 4, x)) (Poly(2*x + 4, x, domain='ZZ'), Poly(20, x, domain='ZZ'))
- per(rep, gens=None, remove=None)[源代码][源代码]¶
根据给定的表示创建一个多边形。
示例
>>> from sympy import Poly, ZZ >>> from sympy.abc import x, y
>>> from sympy.polys.polyclasses import DMP
>>> a = Poly(x**2 + 1)
>>> a.per(DMP([ZZ(1), ZZ(1)], ZZ), gens=[y]) Poly(y + 1, y, domain='ZZ')
- pexquo(g)[源代码][源代码]¶
多项式
f除以g的精确伪商。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 - 1, x).pexquo(Poly(2*x - 2, x)) Poly(2*x + 2, x, domain='ZZ')
>>> Poly(x**2 + 1, x).pexquo(Poly(2*x - 4, x)) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1
- pow(n)[源代码][源代码]¶
将
f提升到一个非负的幂n。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x - 2, x).pow(3) Poly(x**3 - 6*x**2 + 12*x - 8, x, domain='ZZ')
>>> Poly(x - 2, x)**3 Poly(x**3 - 6*x**2 + 12*x - 8, x, domain='ZZ')
- pquo(g)[源代码][源代码]¶
多项式
f除以g的伪商。请参见函数 prem(f, g) 中的 Caveat 注释。
示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, x).pquo(Poly(2*x - 4, x)) Poly(2*x + 4, x, domain='ZZ')
>>> Poly(x**2 - 1, x).pquo(Poly(2*x - 2, x)) Poly(2*x + 2, x, domain='ZZ')
- prem(g)[源代码][源代码]¶
多项式
f对g的伪余数。- 注意：函数 prem(f, g, x) 可以安全地用于计算
在 Z[x] 中 _仅_ 使用子结式多项式余数序列 (prs’s)。
要在 Z[x] 中安全地计算欧几里得和 Sturmian prs’s，可以使用 sympy.polys.subresultants_qq_zz 模块中的相应函数。带有后缀 _pg 的模块中的函数在 Z[x] 中使用 rem(f, g, x) 计算 prs’s，而带有后缀 _amv 的函数在 Z[x] 中使用 rem_z(f, g, x) 计算 prs’s。
函数 rem_z(f, g, x) 与 prem(f, g, x) 的不同之处在于，为了计算 Z[x] 中的余数多项式，它将除数乘以除数的最高次项系数的绝对值，乘以次数 degree(f, x) - degree(g, x) + 1 的幂。
示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, x).prem(Poly(2*x - 4, x)) Poly(20, x, domain='ZZ')
- primitive()[源代码][源代码]¶
返回内容和
f的原始形式。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(2*x**2 + 8*x + 12, x).primitive() (2, Poly(x**2 + 4*x + 6, x, domain='ZZ'))
- quo(g, auto=True)[源代码][源代码]¶
计算多项式
f除以g的商。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, x).quo(Poly(2*x - 4, x)) Poly(1/2*x + 1, x, domain='QQ')
>>> Poly(x**2 - 1, x).quo(Poly(x - 1, x)) Poly(x + 1, x, domain='ZZ')
- quo_ground(coeff)[源代码][源代码]¶
f除以基域中一个元素的商。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(2*x + 4).quo_ground(2) Poly(x + 2, x, domain='ZZ')
>>> Poly(2*x + 3).quo_ground(2) Poly(x + 1, x, domain='ZZ')
- rat_clear_denoms(g)[源代码][源代码]¶
在有理函数
f/g中清除分母。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> f = Poly(x**2/y + 1, x) >>> g = Poly(x**3 + y, x)
>>> p, q = f.rat_clear_denoms(g)
>>> p Poly(x**2 + y, x, domain='ZZ[y]') >>> q Poly(y*x**3 + y**2, x, domain='ZZ[y]')
- real_roots(multiple=True, radicals=True)[源代码][源代码]¶
返回带有重数的实根列表。
更多解释请参见
real_roots()。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(2*x**3 - 7*x**2 + 4*x + 4).real_roots() [-1/2, 2, 2] >>> Poly(x**3 + x + 1).real_roots() [CRootOf(x**3 + x + 1, 0)]
- refine_root(
- s,
- t,
- eps=None,
- steps=None,
- fast=False,
- check_sqf=False,
将根的隔离区间精炼到给定的精度。
示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 - 3, x).refine_root(1, 2, eps=1e-2) (19/11, 26/15)
- rem(g, auto=True)[源代码][源代码]¶
计算多项式
f除以g的余数。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, x).rem(Poly(2*x - 4, x)) Poly(5, x, domain='ZZ')
>>> Poly(x**2 + 1, x).rem(Poly(2*x - 4, x), auto=False) Poly(x**2 + 1, x, domain='ZZ')
- reorder(*gens, **args)[源代码][源代码]¶
高效地应用生成器的新顺序。
示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + x*y**2, x, y).reorder(y, x) Poly(y**2*x + x**2, y, x, domain='ZZ')
- replace(x, y=None, **_ignore)[源代码][源代码]¶
在生成器列表中将
x替换为y。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + 1, x).replace(x, y) Poly(y**2 + 1, y, domain='ZZ')
- resultant(g, includePRS=False)[源代码][源代码]¶
通过PRS计算
f和g的结果。如果 includePRS=True，它会在结果中包含子结果 PRS。因为 PRS 用于计算结果，这比单独调用
subresultants()更高效。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> f = Poly(x**2 + 1, x)
>>> f.resultant(Poly(x**2 - 1, x)) 4 >>> f.resultant(Poly(x**2 - 1, x), includePRS=True) (4, [Poly(x**2 + 1, x, domain='ZZ'), Poly(x**2 - 1, x, domain='ZZ'), Poly(-2, x, domain='ZZ')])
- retract(field=None)[源代码][源代码]¶
重新计算多项式的地面域。
示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> f = Poly(x**2 + 1, x, domain='QQ[y]') >>> f Poly(x**2 + 1, x, domain='QQ[y]')
>>> f.retract() Poly(x**2 + 1, x, domain='ZZ') >>> f.retract(field=True) Poly(x**2 + 1, x, domain='QQ')
- revert(n)[源代码][源代码]¶
计算
f**(-1)模x**n。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(1, x).revert(2) Poly(1, x, domain='ZZ')
>>> Poly(1 + x, x).revert(1) Poly(1, x, domain='ZZ')
>>> Poly(x**2 - 2, x).revert(2) Traceback (most recent call last): ... NotReversible: only units are reversible in a ring
>>> Poly(1/x, x).revert(1) Traceback (most recent call last): ... PolynomialError: 1/x contains an element of the generators set
- root(index, radicals=True)[源代码][源代码]¶
获取多项式的索引根。
示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> f = Poly(2*x**3 - 7*x**2 + 4*x + 4)
>>> f.root(0) -1/2 >>> f.root(1) 2 >>> f.root(2) 2 >>> f.root(3) Traceback (most recent call last): ... IndexError: root index out of [-3, 2] range, got 3
>>> Poly(x**5 + x + 1).root(0) CRootOf(x**3 - x**2 + 1, 0)
- same_root(a, b)[源代码][源代码]¶
决定这个多项式的两个根是否相等。
示例
>>> from sympy import Poly, cyclotomic_poly, exp, I, pi >>> f = Poly(cyclotomic_poly(5)) >>> r0 = exp(2*I*pi/5) >>> indices = [i for i, r in enumerate(f.all_roots()) if f.same_root(r, r0)] >>> print(indices) [3]
- set_modulus(modulus)[源代码][源代码]¶
设置
f的模数。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(5*x**2 + 2*x - 1, x).set_modulus(2) Poly(x**2 + 1, x, modulus=2)
- shift(a)[源代码][源代码]¶
高效计算泰勒位移
f(x + a)。参见
shift_list多变量多项式的类似方法。
示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 - 2*x + 1, x).shift(2) Poly(x**2 + 2*x + 1, x, domain='ZZ')
- shift_list(a)[源代码][源代码]¶
高效计算泰勒位移
f(X + A)。参见
shift单变量多项式的类似方法。
示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x*y, [x,y]).shift_list([1, 2]) == Poly((x+1)*(y+2), [x,y]) True
- sqf_list(all=False)[源代码][源代码]¶
返回
f的无平方因子的列表。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> f = 2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16
>>> Poly(f).sqf_list() (2, [(Poly(x + 1, x, domain='ZZ'), 2), (Poly(x + 2, x, domain='ZZ'), 3)])
>>> Poly(f).sqf_list(all=True) (2, [(Poly(1, x, domain='ZZ'), 1), (Poly(x + 1, x, domain='ZZ'), 2), (Poly(x + 2, x, domain='ZZ'), 3)])
- sqf_list_include(all=False)[源代码][源代码]¶
返回
f的无平方因子的列表。示例
>>> from sympy import Poly, expand >>> from sympy.abc import x
>>> f = expand(2*(x + 1)**3*x**4) >>> f 2*x**7 + 6*x**6 + 6*x**5 + 2*x**4
>>> Poly(f).sqf_list_include() [(Poly(2, x, domain='ZZ'), 1), (Poly(x + 1, x, domain='ZZ'), 3), (Poly(x, x, domain='ZZ'), 4)]
>>> Poly(f).sqf_list_include(all=True) [(Poly(2, x, domain='ZZ'), 1), (Poly(1, x, domain='ZZ'), 2), (Poly(x + 1, x, domain='ZZ'), 3), (Poly(x, x, domain='ZZ'), 4)]
- sqf_norm()[源代码][源代码]¶
计算
f的无平方范数。返回
s,f,r, 使得g(x) = f(x-sa)且r(x) = Norm(g(x))是K上的无平方多项式，其中a是基域的代数扩展。示例
>>> from sympy import Poly, sqrt >>> from sympy.abc import x
>>> s, f, r = Poly(x**2 + 1, x, extension=[sqrt(3)]).sqf_norm()
>>> s [1] >>> f Poly(x**2 - 2*sqrt(3)*x + 4, x, domain='QQ<sqrt(3)>') >>> r Poly(x**4 - 4*x**2 + 16, x, domain='QQ')
- sqf_part()[源代码][源代码]¶
计算
f的无平方部分。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**3 - 3*x - 2, x).sqf_part() Poly(x**2 - x - 2, x, domain='ZZ')
- sqr()[源代码][源代码]¶
对多项式
f进行平方。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x - 2, x).sqr() Poly(x**2 - 4*x + 4, x, domain='ZZ')
>>> Poly(x - 2, x)**2 Poly(x**2 - 4*x + 4, x, domain='ZZ')
- sturm(auto=True)[源代码][源代码]¶
计算
f的 Sturm 序列。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**3 - 2*x**2 + x - 3, x).sturm() [Poly(x**3 - 2*x**2 + x - 3, x, domain='QQ'), Poly(3*x**2 - 4*x + 1, x, domain='QQ'), Poly(2/9*x + 25/9, x, domain='QQ'), Poly(-2079/4, x, domain='QQ')]
- sub(g)[源代码][源代码]¶
减去两个多项式
f和g。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, x).sub(Poly(x - 2, x)) Poly(x**2 - x + 3, x, domain='ZZ')
>>> Poly(x**2 + 1, x) - Poly(x - 2, x) Poly(x**2 - x + 3, x, domain='ZZ')
- sub_ground(coeff)[源代码][源代码]¶
从
f中减去地面域的一个元素。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x + 1).sub_ground(2) Poly(x - 1, x, domain='ZZ')
- subresultants(g)[源代码][源代码]¶
计算
f和g的子结果PRS。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, x).subresultants(Poly(x**2 - 1, x)) [Poly(x**2 + 1, x, domain='ZZ'), Poly(x**2 - 1, x, domain='ZZ'), Poly(-2, x, domain='ZZ')]
- terms(order=None)[源代码][源代码]¶
返回
f中按字典顺序排列的所有非零项。参见
示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + 2*x*y**2 + x*y + 3*y, x, y).terms() [((2, 0), 1), ((1, 2), 2), ((1, 1), 1), ((0, 1), 3)]
- terms_gcd()[源代码][源代码]¶
从多项式
f中去除各项的最大公约数。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**6*y**2 + x**3*y, x, y).terms_gcd() ((3, 1), Poly(x**3*y + 1, x, y, domain='ZZ'))
- termwise(func, *gens, **args)[源代码][源代码]¶
对
f的所有项应用一个函数。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> def func(k, coeff): ... k = k[0] ... return coeff//10**(2-k)
>>> Poly(x**2 + 20*x + 400).termwise(func) Poly(x**2 + 2*x + 4, x, domain='ZZ')
- to_exact()[源代码][源代码]¶
使基础域精确。
示例
>>> from sympy import Poly, RR >>> from sympy.abc import x
>>> Poly(x**2 + 1.0, x, domain=RR).to_exact() Poly(x**2 + 1, x, domain='QQ')
- to_field()[源代码][源代码]¶
将基础域设为一个域。
示例
>>> from sympy import Poly, ZZ >>> from sympy.abc import x
>>> Poly(x**2 + 1, x, domain=ZZ).to_field() Poly(x**2 + 1, x, domain='QQ')
- to_ring()[源代码][源代码]¶
将基础域设为一个环。
示例
>>> from sympy import Poly, QQ >>> from sympy.abc import x
>>> Poly(x**2 + 1, domain=QQ).to_ring() Poly(x**2 + 1, x, domain='ZZ')
- total_degree()[源代码][源代码]¶
返回
f的总次数。示例
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + y*x + 1, x, y).total_degree() 2 >>> Poly(x + y**5, x, y).total_degree() 5
- transform(p, q)[源代码][源代码]¶
高效地评估函数变换
q**n * f(p/q)。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 - 2*x + 1, x).transform(Poly(x + 1, x), Poly(x - 1, x)) Poly(4, x, domain='ZZ')
- trunc(p)[源代码][源代码]¶
将
f对常数p取模。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(2*x**3 + 3*x**2 + 5*x + 7, x).trunc(3) Poly(-x**3 - x + 1, x, domain='ZZ')
- unify(g)[源代码][源代码]¶
使
f和g属于同一个域。示例
>>> from sympy import Poly >>> from sympy.abc import x
>>> f, g = Poly(x/2 + 1), Poly(2*x + 1)
>>> f Poly(1/2*x + 1, x, domain='QQ') >>> g Poly(2*x + 1, x, domain='ZZ')
>>> F, G = f.unify(g)
>>> F Poly(1/2*x + 1, x, domain='QQ') >>> G Poly(2*x + 1, x, domain='QQ')
- property unit¶
返回具有
self属性的单位多项式。
- which_all_roots(candidates)[源代码][源代码]¶
从
candidates中找到无平方多项式f的根。示例
>>> from sympy import Poly, I >>> from sympy.abc import x
>>> f = Poly(x**4 - 1) >>> f.which_all_roots([-1, 1, -I, I, 0]) [-1, 1, -I, I] >>> f.which_all_roots([-1, 1, -I, I, I, I]) [-1, 1, -I, I]
这种方法很有用，因为它可以将提升到有理系数时产生的多余根通过这种方法过滤掉。
>>> f = Poly(x**2 + I*x - 1, x, extension=True) >>> f.lift() Poly(x**4 - x**2 + 1, x, domain='ZZ') >>> f.lift().all_roots() [CRootOf(x**4 - x**2 + 1, 0), CRootOf(x**4 - x**2 + 1, 1), CRootOf(x**4 - x**2 + 1, 2), CRootOf(x**4 - x**2 + 1, 3)] >>> f.which_all_roots(f.lift().all_roots()) [CRootOf(x**4 - x**2 + 1, 0), CRootOf(x**4 - x**2 + 1, 2)]
当对具有代数系数的多项式或具有高斯域的多项式调用 \(.all_roots()\) 时，此过程已经在内部完成。
>>> f.all_roots() [CRootOf(x**4 - x**2 + 1, 0), CRootOf(x**4 - x**2 + 1, 2)]
- which_real_roots(candidates)[源代码][源代码]¶
从
candidates中找到无平方多项式f的根。示例
>>> from sympy import Poly, sqrt >>> from sympy.abc import x
>>> f = Poly(x**4 - 1) >>> f.which_real_roots([-1, 1, 0, -2, 2]) [-1, 1] >>> f.which_real_roots([-1, 1, 1, 1, 1]) [-1, 1]
这种方法很有用，因为它可以将提升到有理系数时产生的多余根通过这种方法过滤掉。
>>> f = Poly(sqrt(2)*x**3 + x**2 - 1, x, extension=True) >>> f.lift() Poly(-2*x**6 + x**4 - 2*x**2 + 1, x, domain='QQ') >>> f.lift().real_roots() [-sqrt(2)/2, sqrt(2)/2] >>> f.which_real_roots(f.lift().real_roots()) [sqrt(2)/2]
当对具有代数系数的多项式调用 \(.real_roots()\) 时，此过程已经在内部完成。
>>> f.real_roots() [sqrt(2)/2]
- property zero¶
返回具有
self属性的零多项式。
- class sympy.polys.polytools.PurePoly(rep, *gens, **args)[源代码][源代码]¶
用于表示纯多项式的类。
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。domain获取
Poly的基础域- 表达式
- expr_free_symbols
free_symbols多项式的自由符号。
free_symbols_in_domainself域的自由符号。func表达式中的顶级函数。
gen返回主生成器。
- 生成
- is_algebraic
- is_antihermitian
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
is_cyclotomic如果
f是一个分圆多项式，则返回True。- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
is_ground如果
f是基域的一个元素，则返回True。- is_hermitian
is_homogeneous如果
f是齐次多项式，则返回True。- is_imaginary
- is_infinite
- is_integer
- is_irrational
is_irreducible如果
f在其定义域内没有因子，则返回True。is_linear如果
f在其所有变量中线性，则返回True。is_monic如果
f的首项系数为1，则返回True。is_monomial如果
f为零或仅有一个项，则返回True。is_multivariate如果
f是一个多元多项式，则返回True。- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
- is_odd
is_one如果
f是一个单位多项式，则返回True。- is_polar
- is_positive
- is_prime
is_primitive如果
f的系数的最大公约数为1，则返回True。is_quadratic如果
f在其所有变量中都是二次的，则返回True。- is_rational
- is_real
is_sqf如果
f是一个无平方多项式，则返回True。- is_transcendental
is_univariate如果
f是单变量多项式，则返回True。is_zero如果
f是零多项式，则返回True。one返回一个具有
self属性的多项式。- rep
unit返回具有
self属性的单位多项式。zero返回具有
self属性的零多项式。
方法
EC([order])返回
f的最后一个非零系数。EM([order])返回
f的最后一个非零单项式。ET([order])返回
f的最后一个非零项。LC([order])返回
f的首项系数。LM([order])返回
f的领先单项式。LT([order])返回
f的首项。TC()返回
f的尾系数。__call__(*values)在给定值处评估
f。abs()使
f中的所有系数为正。add(g)将两个多项式
f和g相加。add_ground(coeff)将一个地面域的元素添加到
f中。all_coeffs()返回单变量多项式
f的所有系数。all_monoms()返回单变量多项式
f中的所有单项式。all_roots([multiple, radicals])返回一个包含实数和复数根及其重数的列表。
all_terms()返回单变量多项式
f中的所有项。as_content_primitive([radical, clear])一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dict([native, zero])切换到
dict表示形式。as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_expr(*gens)将 Poly 实例转换为 Expr 实例。
as_list([native])切换到
列表表示形式。as_poly(*gens, **args)将
self转换为多项式，或返回None。atoms(*types)返回构成当前对象的原子。
cancel(g[, include])在有理函数
f/g中消去公因子。class_key()类的好顺序。
clear_denoms([convert])清除分母，但保持基础域。
coeff_monomial(monom)如果存在，返回
f中monom的系数，否则返回 None。coeffs([order])返回
f中按字典顺序排列的所有非零系数。cofactors(g)返回
f和g的最大公约数及其余因子。compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compose(g)计算
f和g的函数组合。content()返回多项式系数的最大公约数。
count(query)计算匹配的子表达式的数量。
count_ops([visual])用于返回操作计数的 count_ops 的包装器。
count_roots([inf, sup])返回
f在[inf, sup]区间内的根的数量。decompose()计算
f的功能分解。deflate()通过将
x_i**m映射到y_i来降低f的次数。degree([gen])返回
f在x_j中的次数。degree_list()返回
f的度数列表。diff(*specs, **kwargs)计算
f的偏导数。discriminant()计算
f的判别式。dispersion([g])计算多项式的 离散度。
dispersionset([g])计算两个多项式的 离散集。
div(g[, auto])f除以g的多项式带余除法。doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
eject(*gens)将选定的生成器弹出到地面领域。
eval(x[, a, auto])在给定的变量中计算
f在a处的值。exclude()从
f中移除不必要的生成器。exquo(g[, auto])计算多项式
f除以g的精确商。exquo_ground(coeff)f除以基域中一个元素的精确商。factor_list()返回
f的不可约因子列表。factor_list_include()返回
f的不可约因子列表。find(query[, group])查找所有匹配查询的子表达式。
from_dict(rep, *gens, **args)从
dict构建一个多项式。from_expr(rep, *gens, **args)从表达式构造多项式。
from_list(rep, *gens, **args)从
list构建一个多项式。from_poly(rep, *gens, **args)从多项式构建多项式。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
galois_group([by_name, max_tries, randomize])计算这个多项式的伽罗瓦群。
gcd(g)返回多项式
f和g的最大公约数。gcdex(g[, auto])f和g的扩展欧几里得算法。get_domain()获取
f的基础域。get_modulus()获取
f的模数。gff_list()计算
f的最大阶乘分解。ground_roots()通过在基础域中的因式分解来计算
f的根。half_gcdex(g[, auto])f和g的半扩展欧几里得算法。has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_only_gens(*gens)如果
Poly(f, *gens)保留了基础域，则返回True。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
homogeneous_order()返回
f的齐次阶。homogenize(s)返回
f的齐次多项式。inject([front])将地面域生成器注入
f。integrate(*specs, **args)计算
f的不定积分。intervals([all, eps, inf, sup, fast, sqf])计算多项式
f的根的隔离区间。invert(g[, auto])在可能的情况下，对
f取g的模逆。is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
l1_norm()返回
f的 l1 范数。lcm(g)返回多项式
f和g的最小公倍数。length()返回
f中非零项的数量。lift()将代数系数转换为有理数。
ltrim(gen)从
f中移除位于指定gen左侧的虚拟生成器，按照生成器的顺序。make_monic_over_integers_by_scaling_roots()match(*args, **kwargs)来自 Poly 的匹配表达式
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
max_norm()返回
f的最大范数。monic([auto])将所有系数除以
LC(f)。monoms([order])返回
f中按字典顺序排列的所有非零单项式。mul(g)将两个多项式
f和g相乘。mul_ground(coeff)将
f乘以基域的一个元素。neg()在
f中否定所有系数。new(rep, *gens)从原始表示构造
Poly实例。norm()计算定义在数域
K上的多项式f的共轭的乘积，Norm(f)。nroots([n, maxsteps, cleanup])计算
f根的数值近似值。nth(*N)返回
f的第n个系数，其中N是感兴趣项中生成元的指数。nth_power_roots_poly(n)构造一个多项式，其根的n次幂为
f的根。pdiv(g)多项式
f除以g的伪除法。per(rep[, gens, remove])根据给定的表示创建一个多边形。
pexquo(g)多项式
f除以g的精确伪商。pow(n)将
f提升到一个非负的幂n。pquo(g)多项式
f除以g的伪商。prem(g)多项式
f对g的伪余数。primitive()返回内容和
f的原始形式。quo(g[, auto])计算多项式
f除以g的商。quo_ground(coeff)f除以基域中一个元素的商。rat_clear_denoms(g)在有理函数
f/g中清除分母。rcall(*args)通过表达式树递归应用于参数。
real_roots([multiple, radicals])返回带有重数的实根列表。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
refine_root(s, t[, eps, steps, fast, check_sqf])将根的隔离区间精炼到给定的精度。
rem(g[, auto])计算多项式
f除以g的余数。reorder(*gens, **args)高效地应用生成器的新顺序。
replace(x[, y])在生成器列表中将
x替换为y。resultant(g[, includePRS])通过PRS计算
f和g的结果。retract([field])重新计算多项式的地面域。
revert(n)计算
f**(-1)模x**n。rewrite(*args[, deep])使用定义的规则重写 self。
root(index[, radicals])获取多项式的索引根。
same_root(a, b)决定这个多项式的两个根是否相等。
set_domain(domain)设置
f的基础域。set_modulus(modulus)设置
f的模数。shift(a)高效计算泰勒位移
f(x + a)。shift_list(a)高效计算泰勒位移
f(X + A)。simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
slice(x, m[, n])取
f的连续子序列项。sort_key([order])返回一个排序键。
sqf_list([all])返回
f的无平方因子的列表。sqf_list_include([all])返回
f的无平方因子的列表。sqf_norm()计算
f的无平方范数。sqf_part()计算
f的无平方部分。sqr()对多项式
f进行平方。sturm([auto])计算
f的 Sturm 序列。sub(g)减去两个多项式
f和g。sub_ground(coeff)从
f中减去地面域的一个元素。subresultants(g)计算
f和g的子结果PRS。subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
terms([order])返回
f中按字典顺序排列的所有非零项。terms_gcd()从多项式
f中去除各项的最大公约数。termwise(func, *gens, **args)对
f的所有项应用一个函数。to_exact()使基础域精确。
to_field()将基础域设为一个域。
to_ring()将基础域设为一个环。
total_degree()返回
f的总次数。transform(p, q)高效地评估函数变换
q**n * f(p/q)。trunc(p)将
f对常数p取模。unify(g)使
f和g属于同一个域。which_all_roots(candidates)从
candidates中找到无平方多项式f的根。which_real_roots(candidates)从
candidates中找到无平方多项式f的根。xreplace(rule)替换表达式中对象的出现。
coeff
复制
could_extract_minus_sign
eq
is_hypergeometric
不
- property free_symbols¶
多项式的自由符号。
示例
>>> from sympy import PurePoly >>> from sympy.abc import x, y
>>> PurePoly(x**2 + 1).free_symbols set() >>> PurePoly(x**2 + y).free_symbols set() >>> PurePoly(x**2 + y, x).free_symbols {y}
- class sympy.polys.polytools.GroebnerBasis(F, *gens, **args)[源代码][源代码]¶
表示一个简化的Groebner基。
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。- 领域
- expr_free_symbols
- 表达式
free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- 生成
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
is_zero_dimensional检查由 Groebner 基生成的理想是否是零维的。
- 顺序
- 多边形
方法
as_content_primitive([radical, clear])一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)返回构成当前对象的原子。
class_key()类的好顺序。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
contains(poly)检查
poly是否属于由self生成的理想。count(query)计算匹配的子表达式的数量。
count_ops([visual])用于返回操作计数的 count_ops 的包装器。
doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
fglm(order)将一个 Groebner 基从一个排序转换为另一个排序。
find(query[, group])查找所有匹配查询的子表达式。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
rcall(*args)通过表达式树递归应用于参数。
reduce(expr[, auto])将多项式模一个Groebner基。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])返回一个排序键。
subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule)替换表达式中对象的出现。
复制
could_extract_minus_sign
is_hypergeometric
- contains(poly)[源代码][源代码]¶
检查
poly是否属于由self生成的理想。示例
>>> from sympy import groebner >>> from sympy.abc import x, y
>>> f = 2*x**3 + y**3 + 3*y >>> G = groebner([x**2 + y**2 - 1, x*y - 2])
>>> G.contains(f) True >>> G.contains(f + 1) False
- fglm(order)[源代码][源代码]¶
将一个 Groebner 基从一个排序转换为另一个排序。
FGLM 算法将零维理想的约化 Groebner 基从一个排序转换为另一个排序。当直接计算特定排序下的 Groebner 基不可行时，通常使用这种方法。
参考文献
[1]J.C. Faugere, P. Gianni, D. Lazard, T. Mora (1994). 通过改变排序的高效零维Groebner基计算
示例
>>> from sympy.abc import x, y >>> from sympy import groebner
>>> F = [x**2 - 3*y - x + 1, y**2 - 2*x + y - 1] >>> G = groebner(F, x, y, order='grlex')
>>> list(G.fglm('lex')) [2*x - y**2 - y + 1, y**4 + 2*y**3 - 3*y**2 - 16*y + 7] >>> list(groebner(F, x, y, order='lex')) [2*x - y**2 - y + 1, y**4 + 2*y**3 - 3*y**2 - 16*y + 7]
- property is_zero_dimensional¶
检查由 Groebner 基生成的理想是否是零维的。
该算法检查是否存在一组不可被
F中任何元素的首项整除的单项式，并且这组单项式是有界的。参考文献
David A. Cox, John B. Little, Donal O’Shea. 理想、变体和算法，第三版，第230页
- reduce(expr, auto=True)[源代码][源代码]¶
将多项式模一个Groebner基。
给定一个多项式
f和一个多项式集合G = (g_1, ..., g_n)，计算一组商q = (q_1, ..., q_n)和余数r，使得f = q_1*f_1 + ... + q_n*f_n + r，其中r消失或r是相对于G完全约简的多项式。示例
>>> from sympy import groebner, expand >>> from sympy.abc import x, y
>>> f = 2*x**4 - x**2 + y**3 + y**2 >>> G = groebner([x**3 - x, y**3 - y])
>>> G.reduce(f) ([2*x, 1], x**2 + y**2 + y) >>> Q, r = _
>>> expand(sum(q*g for q, g in zip(Q, G)) + r) 2*x**4 - x**2 + y**3 + y**2 >>> _ == f True
额外的多项式操作函数¶
- sympy.polys.polyfuncs.symmetrize(F, *gens, **args)[源代码][源代码]¶
将多项式重写为基本对称多项式的形式。
对称多项式是一个多元多项式，它在任何变量置换下保持不变，即，如果 \(f = f(x_1, x_2, \dots, x_n)\)，那么 \(f = f(x_{i_1}, x_{i_2}, \dots, x_{i_n})\)，其中 \((i_1, i_2, \dots, i_n)\) 是 \((1, 2, \dots, n)\) 的一个置换（\(S_n\) 群的一个元素）。
返回一个对称多项式的元组
(f1, f2, ..., fn)，使得f = f1 + f2 + ... + fn。示例
>>> from sympy.polys.polyfuncs import symmetrize >>> from sympy.abc import x, y
>>> symmetrize(x**2 + y**2) (-2*x*y + (x + y)**2, 0)
>>> symmetrize(x**2 + y**2, formal=True) (s1**2 - 2*s2, 0, [(s1, x + y), (s2, x*y)])
>>> symmetrize(x**2 - y**2) (-2*x*y + (x + y)**2, -2*y**2)
>>> symmetrize(x**2 - y**2, formal=True) (s1**2 - 2*s2, -2*y**2, [(s1, x + y), (s2, x*y)])
- sympy.polys.polyfuncs.horner(f, *gens, **args)[源代码][源代码]¶
将多项式重写为霍纳形式。
在其他应用中，多项式在某点的求值在使用霍纳方案时是最优的 ([1])。
参考文献
[1] - https://en.wikipedia.org/wiki/Horner_scheme
示例
>>> from sympy.polys.polyfuncs import horner >>> from sympy.abc import x, y, a, b, c, d, e
>>> horner(9*x**4 + 8*x**3 + 7*x**2 + 6*x + 5) x*(x*(x*(9*x + 8) + 7) + 6) + 5
>>> horner(a*x**4 + b*x**3 + c*x**2 + d*x + e) e + x*(d + x*(c + x*(a*x + b)))
>>> f = 4*x**2*y**2 + 2*x**2*y + 2*x*y**2 + x*y
>>> horner(f, wrt=x) x*(x*y*(4*y + 2) + y*(2*y + 1))
>>> horner(f, wrt=y) y*(x*y*(4*x + 2) + x*(2*x + 1))
- sympy.polys.polyfuncs.interpolate(data, x)[源代码][源代码]¶
为在点 x（可以是符号或数值）处评估的数据点构造一个插值多项式。
示例
>>> from sympy.polys.polyfuncs import interpolate >>> from sympy.abc import a, b, x
列表被解释为好像它与从1开始的范围配对：
>>> interpolate([1, 4, 9, 16], x) x**2
这可以通过提供一个坐标列表来明确表示：
>>> interpolate([(1, 1), (2, 4), (3, 9)], x) x**2
（x，y）坐标也可以作为字典的键和值给出（并且这些点不必等间距）：
>>> interpolate([(-1, 2), (1, 2), (2, 5)], x) x**2 + 1 >>> interpolate({-1: 2, 1: 2, 2: 5}, x) x**2 + 1
如果插值只使用一次，那么可以直接传递感兴趣的值，而不是传递一个符号：
>>> interpolate([1, 4, 9], 5) 25
也支持符号坐标：
>>> [(i,interpolate((a, b), i)) for i in range(1, 4)] [(1, a), (2, b), (3, -a + 2*b)]
域构造器¶
- sympy.polys.constructor.construct_domain(obj, **args)[源代码][源代码]¶
为一组表达式构建一个最小的域。
- 参数:
- obj: list 或 dict
用于构建域的表达式。
- **args: 关键字参数
影响域选择的选项。
- 返回:
- (K, 元素): 域和域元素列表
可以表示表达式的域 K 以及表示与 K 中元素相同的表达式的域元素列表或字典。
参见
DomainExpr
示例
给定一个
Integer列表，construct_domain将返回域 ZZ 和作为 ZZ 元素的整数列表。>>> from sympy import construct_domain, S >>> expressions = [S(2), S(3), S(4)] >>> K, elements = construct_domain(expressions) >>> K ZZ >>> elements [2, 3, 4] >>> type(elements[0]) <class 'int'> >>> type(expressions[0]) <class 'sympy.core.numbers.Integer'>
>>> construct_domain([S(1)/2, S(3)/4]) (QQ, [1/2, 3/4])
如果有符号，则返回多项式环 K[x]。
>>> from sympy import symbols >>> x, y = symbols('x, y') >>> construct_domain([2*x + 1, S(3)/4]) (QQ[x], [2*x + 1, 3/4]) >>> construct_domain([2*x + 1, y]) (ZZ[x,y], [2*x + 1, y])
如果任何符号出现负幂，则将返回有理函数域 K(x)。
>>> construct_domain([y/x, x/(1 - y)]) (ZZ(x,y), [y/x, -x/(y - 1)])
非理性的代数数在默认情况下会产生 EX 域。关键字参数
extension=True会导致构建一个代数数域 QQ<a>。>>> from sympy import sqrt >>> construct_domain([sqrt(2)]) (EX, [EX(sqrt(2))]) >>> construct_domain([sqrt(2)], extension=True) (QQ<sqrt(2)>, [ANP([1, 0], [1, 0, -2], QQ)])
以元组形式编码的单项式¶
- sympy.polys.monomials.itermonomials(
- variables,
- max_degrees,
- min_degrees=None,
max_degrees和min_degrees要么都是整数，要么都是列表。除非另有规定，min_degrees要么是0要么是[0, ..., 0]。返回所有单项式
monom的生成器，使得对于所有i，要么min_degree <= total_degree(monom) <= max_degree，要么min_degrees[i] <= degree_list(monom)[i] <= max_degrees[i]。
- sympy.polys.monomials.monomial_count(V, N)[源代码][源代码]¶
计算单项式的数量。
单项式的数量由以下公式给出：
\[\frac{(\#V + N)!}{\#V! N!}\]其中 \(N\) 是总次数，\(V\) 是一组变量。
示例
>>> from sympy.polys.monomials import itermonomials, monomial_count >>> from sympy.polys.orderings import monomial_key >>> from sympy.abc import x, y
>>> monomial_count(2, 2) 6
>>> M = list(itermonomials([x, y], 2))
>>> sorted(M, key=monomial_key('grlex', [y, x])) [1, x, y, x**2, x*y, y**2] >>> len(M) 6
单项式的排序¶
多项式根的正式操作¶
- sympy.polys.rootoftools.rootof(
- f,
- x,
- index=None,
- radicals=True,
- expand=True,
单变量多项式的索引根。
Returns either a
ComplexRootOfobject or an explicit expression involving radicals.- 参数:
- f表达式
单变量多项式。
- x符号, 可选
f的生成器- 索引int 或 Integer
- 部首布尔
如果可能，返回一个根式表达式。
- 展开布尔
展开
f。
- class sympy.polys.rootoftools.RootOf(
- f,
- x,
- index=None,
- radicals=True,
- expand=True,
表示一个单变量多项式的根。
不同类型多项式根的基类。目前仅支持复数根。
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
is_number如果
self没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
- 多边形
方法
apart([x])请参阅 sympy.polys 中的 apart 函数。
args_cnc([cset, warn, split_1])返回 [交换因子, 非交换因子] 的自身。
as_coeff_Add([rational])高效地提取求和的系数。
as_coeff_Mul([rational])高效地提取乘积的系数。
as_coeff_add(*deps)返回元组 (c, args)，其中 self 被写成一个 Add，
a。as_coeff_exponent(x)c*x**e -> c,e其中 x 可以是任何符号表达式。as_coeff_mul(*deps, **kwargs)返回元组 (c, args)，其中 self 被写成一个 Mul，
m。as_coefficient(expr)提取给定表达式中的符号系数。
as_coefficients_dict(*syms)返回一个字典，将术语映射到它们的 Rational 系数。
as_content_primitive([radical, clear])此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_expr(*gens)将多项式转换为 SymPy 表达式。
as_independent(*deps, **hint)将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
as_leading_term(*symbols[, logx, cdir])返回自身级数展开的主导（非零）项。
as_numer_denom()返回一个表达式的分子和分母。
as_ordered_factors([order])返回有序因子列表（如果是 Mul），否则返回 [self]。
as_ordered_terms([order, data])将表达式转换为有序的项列表。
as_poly(*gens, **args)将
self转换为多项式，或返回None。as_powers_dict()将自身作为一个因子的字典返回，每个因子都被视为一个幂。
as_real_imag([deep])对 'self' 执行复杂的扩展，并返回一个包含收集到的实部和虚部的元组。
as_terms()将一个表达式转换为项的列表。
aseries([x, n, bound, hir])自变量的渐近级数展开
atoms(*types)返回构成当前对象的原子。
cancel(*gens, **args)参见 sympy.polys 中的取消函数
class_key()类的好顺序。
coeff(x[, n, right, _first])返回包含
x**n的项中的系数。collect(syms[, func, evaluate, exact, ...])请参阅 sympy.simplify 中的 collect 函数。
combsimp()请参阅 sympy.simplify 中的 combsimp 函数。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compute_leading_term(x[, logx])已弃用的函数，用于计算级数的首项。
conjugate()返回 'self' 的复数共轭。
could_extract_minus_sign()如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
count(query)计算匹配的子表达式的数量。
count_ops([visual])doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
equals(other[, failing_expression])如果 self == other 则返回 True，如果不相等则返回 False，或者返回 None。
evalf([n, subs, maxn, chop, strict, quad, ...])将给定的公式计算到 n 位精度。
expand([deep, modulus, power_base, ...])使用提示扩展表达式。
extract_additively(c)如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
extract_branch_factor([allow_half])尝试以
exp_polar(2*pi*I*n)*z的方式优雅地表达自身。extract_multiplicatively(c)如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
factor(*gens, **args)参见 sympy.polys.polytools 中的 factor() 函数
find(query[, group])查找所有匹配查询的子表达式。
fourier_series([limits])计算自身的傅里叶正弦/余弦级数。
fps([x, x0, dir, hyper, order, rational, full])计算自身的形式幂级数。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
gammasimp()参见 sympy.simplify 中的 gammasimp 函数
getO()如果有加法 O(..) 符号，则返回该符号，否则返回 None。
getn()返回表达式的顺序。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
integrate(*args, **kwargs)请参阅 sympy.integrals 中的 integrate 函数。
invert(g, *gens, **args)返回
self对g的乘法逆元，其中self``（和 ``g）可以是符号表达式。is_algebraic_expr(*syms)此测试给定的表达式是否在给定的符号 syms 中是代数的。
is_constant(*wrt, **flags)如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
is_meromorphic(x, a)此测试表达式是否作为给定符号
x的函数在点a处是亚纯的。is_polynomial(*syms)如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
is_rational_function(*syms)测试函数是否是给定符号 syms 中的两个多项式的比率。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
leadterm(x[, logx, cdir])返回前导项 a*x**b 作为元组 (a, b)。
limit(x, xlim[, dir])计算极限 x->xlim。
lseries([x, x0, dir, logx, cdir])用于生成序列项的迭代器的包装器。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
normal()返回表达式为分数形式。
nseries([x, x0, n, dir, logx, cdir])如果假设允许，则包装到 _eval_nseries，否则包装到 series。
nsimplify([constants, tolerance, full])参见 sympy.simplify 中的 nsimplify 函数
powsimp(*args, **kwargs)请参阅 sympy.simplify 中的 powsimp 函数
primitive()返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
radsimp(**kwargs)参见 sympy.simplify 中的 radsimp 函数
ratsimp()参见 sympy.simplify 中的 ratsimp 函数。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
removeO()如果存在，移除加性的 O(..) 符号
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
round([n])返回 x 四舍五入到给定的十进制位数。
separate([deep, force])参见 sympy.simplify 中的单独函数
series([x, x0, n, dir, logx, cdir])在
x = x0附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
taylor_term(n, x, *previous_terms)泰勒项的一般方法。
together(*args, **kwargs)请参阅 sympy.polys 中的 together 函数。
trigsimp(**args)参见 sympy.simplify 中的 trigsimp 函数
xreplace(rule)替换表达式中对象的出现。
伴随
as_base_exp
复制
差异
目录
is_hypergeometric
转置
- class sympy.polys.rootoftools.ComplexRootOf(
- f,
- x,
- index=None,
- radicals=False,
- expand=True,
表示多项式的索引复数根。
单变量多项式的根被分离成不相交的实数或复数区间，并以固定顺序索引：
实根优先，并按递增顺序排列；
接下来是复数根，它们首先按实部递增排序，其次按虚部递增排序。
目前仅允许有理系数。可以作为
CRootOf导入。为了避免混淆，生成器必须是一个符号。- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。- 表达式
expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- 索引
- is_antihermitian
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_hermitian
- is_imaginary
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_zero
- 多边形
方法
all_roots(poly[, radicals])获取多项式的实根和复根。
apart([x])请参阅 sympy.polys 中的 apart 函数。
args_cnc([cset, warn, split_1])返回 [交换因子, 非交换因子] 的自身。
as_coeff_Add([rational])高效地提取求和的系数。
as_coeff_Mul([rational])高效地提取乘积的系数。
as_coeff_add(*deps)返回元组 (c, args)，其中 self 被写成一个 Add，
a。as_coeff_exponent(x)c*x**e -> c,e其中 x 可以是任何符号表达式。as_coeff_mul(*deps, **kwargs)返回元组 (c, args)，其中 self 被写成一个 Mul，
m。as_coefficient(expr)提取给定表达式中的符号系数。
as_coefficients_dict(*syms)返回一个字典，将术语映射到它们的 Rational 系数。
as_content_primitive([radical, clear])此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_expr(*gens)将多项式转换为 SymPy 表达式。
as_independent(*deps, **hint)将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
as_leading_term(*symbols[, logx, cdir])返回自身级数展开的主导（非零）项。
as_numer_denom()返回一个表达式的分子和分母。
as_ordered_factors([order])返回有序因子列表（如果是 Mul），否则返回 [self]。
as_ordered_terms([order, data])将表达式转换为有序的项列表。
as_poly(*gens, **args)将
self转换为多项式，或返回None。as_powers_dict()将自身作为一个因子的字典返回，每个因子都被视为一个幂。
as_real_imag([deep])对 'self' 执行复杂的扩展，并返回一个包含收集到的实部和虚部的元组。
as_terms()将一个表达式转换为项的列表。
aseries([x, n, bound, hir])自变量的渐近级数展开
atoms(*types)返回构成当前对象的原子。
cancel(*gens, **args)参见 sympy.polys 中的取消函数
class_key()类的好顺序。
重置实数和复数的缓存。
coeff(x[, n, right, _first])返回包含
x**n的项中的系数。collect(syms[, func, evaluate, exact, ...])请参阅 sympy.simplify 中的 collect 函数。
combsimp()请参阅 sympy.simplify 中的 combsimp 函数。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compute_leading_term(x[, logx])已弃用的函数，用于计算级数的首项。
conjugate()返回 'self' 的复数共轭。
could_extract_minus_sign()如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
count(query)计算匹配的子表达式的数量。
count_ops([visual])doit(**hints)评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
equals(other[, failing_expression])如果 self == other 则返回 True，如果不相等则返回 False，或者返回 None。
eval_approx(n[, return_mpmath])以给定的精度评估这个复杂的根。
eval_rational([dx, dy, n])返回一个
self的 Rational 近似值，其实部和虚部的近似值分别与真实值的误差在dx和dy以内。evalf([n, subs, maxn, chop, strict, quad, ...])将给定的公式计算到 n 位精度。
expand([deep, modulus, power_base, ...])使用提示扩展表达式。
extract_additively(c)如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
extract_branch_factor([allow_half])尝试以
exp_polar(2*pi*I*n)*z的方式优雅地表达自身。extract_multiplicatively(c)如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
factor(*gens, **args)参见 sympy.polys.polytools 中的 factor() 函数
find(query[, group])查找所有匹配查询的子表达式。
fourier_series([limits])计算自身的傅里叶正弦/余弦级数。
fps([x, x0, dir, hyper, order, rational, full])计算自身的形式幂级数。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
gammasimp()参见 sympy.simplify 中的 gammasimp 函数
getO()如果有加法 O(..) 符号，则返回该符号，否则返回 None。
getn()返回表达式的顺序。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
integrate(*args, **kwargs)请参阅 sympy.integrals 中的 integrate 函数。
invert(g, *gens, **args)返回
self对g的乘法逆元，其中self``（和 ``g）可以是符号表达式。is_algebraic_expr(*syms)此测试给定的表达式是否在给定的符号 syms 中是代数的。
is_constant(*wrt, **flags)如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
is_meromorphic(x, a)此测试表达式是否作为给定符号
x的函数在点a处是亚纯的。is_polynomial(*syms)如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
is_rational_function(*syms)测试函数是否是给定符号 syms 中的两个多项式的比率。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
leadterm(x[, logx, cdir])返回前导项 a*x**b 作为元组 (a, b)。
limit(x, xlim[, dir])计算极限 x->xlim。
lseries([x, x0, dir, logx, cdir])用于生成序列项的迭代器的包装器。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
normal()返回表达式为分数形式。
nseries([x, x0, n, dir, logx, cdir])如果假设允许，则包装到 _eval_nseries，否则包装到 series。
nsimplify([constants, tolerance, full])参见 sympy.simplify 中的 nsimplify 函数
powsimp(*args, **kwargs)请参阅 sympy.simplify 中的 powsimp 函数
primitive()返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
radsimp(**kwargs)参见 sympy.simplify 中的 radsimp 函数
ratsimp()参见 sympy.simplify 中的 ratsimp 函数。
rcall(*args)通过表达式树递归应用于参数。
real_roots(poly[, radicals])获取多项式的实根。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
removeO()如果存在，移除加性的 O(..) 符号
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
round([n])返回 x 四舍五入到给定的十进制位数。
separate([deep, force])参见 sympy.simplify 中的单独函数
series([x, x0, n, dir, logx, cdir])在
x = x0附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
taylor_term(n, x, *previous_terms)泰勒项的一般方法。
together(*args, **kwargs)请参阅 sympy.polys 中的 together 函数。
trigsimp(**args)参见 sympy.simplify 中的 trigsimp 函数
xreplace(rule)替换表达式中对象的出现。
伴随
as_base_exp
复制
差异
目录
is_hypergeometric
转置
注释
尽管可以从非符号生成器构造 PurePoly，但不允许使用非符号的 RootOf 实例，以避免对所表示的根产生混淆。
>>> from sympy import exp, PurePoly >>> PurePoly(x) == PurePoly(exp(x)) True >>> CRootOf(x - 1, 0) 1 >>> CRootOf(exp(x) - 1, 0) # would correspond to x == 0 Traceback (most recent call last): ... sympy.polys.polyerrors.PolynomialError: generator must be a Symbol
示例
>>> from sympy import CRootOf, rootof >>> from sympy.abc import x
CRootOf 是一种引用多项式特定根的方法。如果有有理根，它将被返回：
>>> CRootOf.clear_cache() # for doctest reproducibility >>> CRootOf(x**2 - 4, 0) -2
是否返回涉及根号的根取决于
radicals标志是否为真（使用 rootof 时设置为 True）：>>> CRootOf(x**2 - 3, 0) CRootOf(x**2 - 3, 0) >>> CRootOf(x**2 - 3, 0, radicals=True) -sqrt(3) >>> rootof(x**2 - 3, 0) -sqrt(3)
以下内容不能用部首表示：
>>> r = rootof(4*x**5 + 16*x**3 + 12*x**2 + 7, 0); r CRootOf(4*x**5 + 16*x**3 + 12*x**2 + 7, 0)
根的界限可以被观察到，并且这些界限被评估方法用来获取根的数值近似值。
>>> interval = r._get_interval(); interval (-1, 0) >>> r.evalf(2) -0.98
evalf 方法会细化根的边界宽度，直到它保证在这些边界内的任何十进制近似值都能满足所需的精度。然后，它会存储细化后的区间，以便后续在请求的精度或更低精度下的请求无需重新计算根的边界，并且会非常快速地返回结果。
在上述评估之前，间隔是
>>> interval (-1, 0)
评估后，现在
>>> r._get_interval() (-165/169, -206/211)
要重置给定多项式的所有区间，可以从多项式的任何 CRootOf 实例调用
_reset()方法：>>> r._reset() >>> r._get_interval() (-1, 0)
eval_approx()方法也会在给定的精度下找到根，但除非在根的范围内搜索根失败，否则区间不会被修改。并且使用割线法来找到根。（evalf方法使用二分法，并且总是会更新区间。）>>> r.eval_approx(2) -0.98
需要稍微更新区间以找到那个根：
>>> r._get_interval() (-1, -1/2)
evalf_rational将计算根的合理近似值，以达到所需的精度或准确度。>>> r.eval_rational(n=2) -69629/71318
>>> t = CRootOf(x**3 + 10*x + 1, 1) >>> t.eval_rational(1e-1) 15/256 - 805*I/256 >>> t.eval_rational(1e-1, 1e-4) 3275/65536 - 414645*I/131072 >>> t.eval_rational(1e-4, 1e-4) 6545/131072 - 414645*I/131072 >>> t.eval_rational(n=2) 104755/2097152 - 6634255*I/2097152
- classmethod _get_roots_alg(
- method,
- poly,
- radicals,
返回具有代数系数的多项式的指定类型的后处理根。它假设域已经是一个代数域。首先使用 _get_roots_qq 找到根，然后使用无平方因子来过滤根并获得正确的重数。
- classmethod _refine_complexes(complexes)[源代码][源代码]¶
返回复数，使得非共轭根的边界矩形不会相交。此外，确保 ay 和 by 都不为 0，以保证非实数根在 y 边界上与实数根不同。
- classmethod clear_cache()[源代码][源代码]¶
重置实数和复数的缓存。
用于近似根实例的区间会根据需要进行更新。当请求查看区间时，会显示最新的值。\(clear_cache\) 将重置所有 CRootOf 实例回到其原始状态。
参见
- eval_approx(n, return_mpmath=False)[源代码][源代码]¶
以给定的精度评估这个复杂的根。
此方法使用割线法，并且使用根的边界来生成初始猜测并检查返回的根是否有效。如果方法收敛到根边界之外，边界将被缩小并更新。
- eval_rational(
- dx=None,
- dy=None,
- n=15,
返回一个
self的 Rational 近似值，其实部和虚部的近似值分别在真实值的dx和dy范围内。或者，可以指定n位精度的数字。区间通过二分法进行细化，并确保收敛。根的边界在细化完成后更新，因此在相同或更低精度下重新计算时，无需重复细化过程，速度应会快得多。
以下示例首先为所有4阶勒让德多项式的根获得1e-8精度的有理逼近。由于所有根都小于1，这将确保逼近的十进制表示（包括舍入）正确到6位小数：
>>> from sympy import legendre_poly, Symbol >>> x = Symbol("x") >>> p = legendre_poly(4, x, polys=True) >>> r = p.real_roots()[-1] >>> r.eval_rational(10**-8).n(6) 0.861136
然而，进行两步计算并非必要：可以直接计算十进制表示：
>>> r.evalf(17) 0.86113631159405258
- class sympy.polys.rootoftools.RootSum(
- expr,
- func=None,
- x=None,
- auto=True,
- quadratic=False,
表示单变量多项式的所有根之和。
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
- 自动
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。- 表达式
expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
- 有趣
func表达式中的顶级函数。
- is_algebraic
- is_antihermitian
- is_commutative
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_complex
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_extended_real
- is_finite
- is_hermitian
- is_imaginary
- is_infinite
- is_integer
- is_irrational
- is_negative
- is_noninteger
- is_nonnegative
- is_nonpositive
- is_nonzero
is_number如果
self没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。- is_odd
- is_polar
- is_positive
- is_prime
- is_rational
- is_real
- is_transcendental
- is_zero
- 多边形
方法
apart([x])请参阅 sympy.polys 中的 apart 函数。
args_cnc([cset, warn, split_1])返回 [交换因子, 非交换因子] 的自身。
as_coeff_Add([rational])高效地提取求和的系数。
as_coeff_Mul([rational])高效地提取乘积的系数。
as_coeff_add(*deps)返回元组 (c, args)，其中 self 被写成一个 Add，
a。as_coeff_exponent(x)c*x**e -> c,e其中 x 可以是任何符号表达式。as_coeff_mul(*deps, **kwargs)返回元组 (c, args)，其中 self 被写成一个 Mul，
m。as_coefficient(expr)提取给定表达式中的符号系数。
as_coefficients_dict(*syms)返回一个字典，将术语映射到它们的 Rational 系数。
as_content_primitive([radical, clear])此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
as_dummy()返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_expr(*gens)将多项式转换为 SymPy 表达式。
as_independent(*deps, **hint)将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
as_leading_term(*symbols[, logx, cdir])返回自身级数展开的主导（非零）项。
as_numer_denom()返回一个表达式的分子和分母。
as_ordered_factors([order])返回有序因子列表（如果是 Mul），否则返回 [self]。
as_ordered_terms([order, data])将表达式转换为有序的项列表。
as_poly(*gens, **args)将
self转换为多项式，或返回None。as_powers_dict()将自身作为一个因子的字典返回，每个因子都被视为一个幂。
as_real_imag([deep])对 'self' 执行复杂的扩展，并返回一个包含收集到的实部和虚部的元组。
as_terms()将一个表达式转换为项的列表。
aseries([x, n, bound, hir])自变量的渐近级数展开
atoms(*types)返回构成当前对象的原子。
cancel(*gens, **args)参见 sympy.polys 中的取消函数
class_key()类的好顺序。
coeff(x[, n, right, _first])返回包含
x**n的项中的系数。collect(syms[, func, evaluate, exact, ...])请参阅 sympy.simplify 中的 collect 函数。
combsimp()请参阅 sympy.simplify 中的 combsimp 函数。
compare(other)如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compute_leading_term(x[, logx])已弃用的函数，用于计算级数的首项。
conjugate()返回 'self' 的复数共轭。
could_extract_minus_sign()如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
count(query)计算匹配的子表达式的数量。
count_ops([visual])doit(**hints)dummy_eq(other[, symbol])比较两个表达式并处理哑符号。
equals(other[, failing_expression])如果 self == other 则返回 True，如果不相等则返回 False，或者返回 None。
evalf([n, subs, maxn, chop, strict, quad, ...])将给定的公式计算到 n 位精度。
expand([deep, modulus, power_base, ...])使用提示扩展表达式。
extract_additively(c)如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
extract_branch_factor([allow_half])尝试以
exp_polar(2*pi*I*n)*z的方式优雅地表达自身。extract_multiplicatively(c)如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
factor(*gens, **args)参见 sympy.polys.polytools 中的 factor() 函数
find(query[, group])查找所有匹配查询的子表达式。
fourier_series([limits])计算自身的傅里叶正弦/余弦级数。
fps([x, x0, dir, hyper, order, rational, full])计算自身的形式幂级数。
fromiter(args, **assumptions)从可迭代对象创建一个新对象。
gammasimp()参见 sympy.simplify 中的 gammasimp 函数
getO()如果有加法 O(..) 符号，则返回该符号，否则返回 None。
getn()返回表达式的顺序。
has(*patterns)测试是否有任何子表达式匹配任何模式。
has_free(*patterns)如果 self 包含对象
x作为自由表达式，则返回 True，否则返回 False。has_xfree(s)如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
integrate(*args, **kwargs)请参阅 sympy.integrals 中的 integrate 函数。
invert(g, *gens, **args)返回
self对g的乘法逆元，其中self``（和 ``g）可以是符号表达式。is_algebraic_expr(*syms)此测试给定的表达式是否在给定的符号 syms 中是代数的。
is_constant(*wrt, **flags)如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
is_meromorphic(x, a)此测试表达式是否作为给定符号
x的函数在点a处是亚纯的。is_polynomial(*syms)如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
is_rational_function(*syms)测试函数是否是给定符号 syms 中的两个多项式的比率。
is_same(b[, approx])如果 a 和 b 结构相同则返回 True，否则返回 False。
leadterm(x[, logx, cdir])返回前导项 a*x**b 作为元组 (a, b)。
limit(x, xlim[, dir])计算极限 x->xlim。
lseries([x, x0, dir, logx, cdir])用于生成序列项的迭代器的包装器。
match(pattern[, old])模式匹配。
matches(expr[, repl_dict, old])用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
new(poly, func[, auto])构造新的
RootSum实例。normal()返回表达式为分数形式。
nseries([x, x0, n, dir, logx, cdir])如果假设允许，则包装到 _eval_nseries，否则包装到 series。
nsimplify([constants, tolerance, full])参见 sympy.simplify 中的 nsimplify 函数
powsimp(*args, **kwargs)请参阅 sympy.simplify 中的 powsimp 函数
primitive()返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
radsimp(**kwargs)参见 sympy.simplify 中的 radsimp 函数
ratsimp()参见 sympy.simplify 中的 ratsimp 函数。
rcall(*args)通过表达式树递归应用于参数。
refine([assumption])请参阅 sympy.assumptions 中的 refine 函数。
removeO()如果存在，移除加性的 O(..) 符号
replace(query, value[, map, simultaneous, exact])将
self中匹配的子表达式替换为value。rewrite(*args[, deep])使用定义的规则重写 self。
round([n])返回 x 四舍五入到给定的十进制位数。
separate([deep, force])参见 sympy.simplify 中的单独函数
series([x, x0, n, dir, logx, cdir])在
x = x0附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。simplify(**kwargs)请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])subs(*args, **kwargs)在简化参数后，在表达式中用新内容替换旧内容。
taylor_term(n, x, *previous_terms)泰勒项的一般方法。
together(*args, **kwargs)请参阅 sympy.polys 中的 together 函数。
trigsimp(**args)参见 sympy.simplify 中的 trigsimp 函数
xreplace(rule)替换表达式中对象的出现。
伴随
as_base_exp
复制
差异
目录
is_hypergeometric
转置
符号根查找算法¶
- sympy.polys.polyroots.roots(
- f,
- *gens,
- auto=True,
- cubics=True,
- trig=False,
- quartics=True,
- quintics=False,
- multiple=False,
- filter=None,
- predicate=None,
- strict=False,
- **flags,
计算单变量多项式的符号根。
给定一个具有符号系数的单变量多项式 f（或多项式的系数列表），返回一个包含其根及其重数的字典。
只有可以通过根式表达的根才会被返回。要获取完整的根集，请使用 RootOf 类或数值方法。默认情况下，算法中使用三次和四次公式。如果由于输出不可读而要禁用它们，请分别设置
cubics=False或quartics=False。如果三次根是实数但用复数表示（不可约情况 [1]），可以将trig标志设置为 True，以便用余弦和反余弦函数返回解。要从特定域获取根，请使用以下指定符之一设置
filter标志：Z, Q, R, I, C。默认情况下返回所有根（这等同于设置filter='C'）。默认情况下，返回一个字典，以在多个根的情况下提供紧凑的结果。然而，要获取包含所有这些根的列表，请将
multiple标志设置为 True；列表将在结果中相邻出现相同的根。（对于给定的 Poly，all_roots 方法将按数值顺序给出根。）如果
strict标志为 True，如果找到的根被认为是未完全解出的（因为某些根不能用根式表示），则会引发UnsolvableFactorError。参考文献
示例
>>> from sympy import Poly, roots, degree >>> from sympy.abc import x, y
>>> roots(x**2 - 1, x) {-1: 1, 1: 1}
>>> p = Poly(x**2-1, x) >>> roots(p) {-1: 1, 1: 1}
>>> p = Poly(x**2-y, x, y)
>>> roots(Poly(p, x)) {-sqrt(y): 1, sqrt(y): 1}
>>> roots(x**2 - y, x) {-sqrt(y): 1, sqrt(y): 1}
>>> roots([1, 0, -1]) {-1: 1, 1: 1}
roots只会返回可以用根式表达的根。如果给定的多项式有一些或所有的根不能用根式表达，那么roots的结果将分别是不完整或空的。结果不完整的示例：
>>> roots((x-1)*(x**5-x+1), x) {1: 1}
在这种情况下，多项式有一个无法求解的五次因子，其根不能用根式表示。多项式有一个有理根（由于因子 \((x-1)\)），该根被返回，因为
roots总是找到所有有理根。结果为空的示例：
>>> roots(x**7-3*x**2+1, x) {}
在这里，多项式没有可以用根式表示的根，因此
roots返回一个空字典。roots生成的结果是完整的当且仅当每个根的重数之和等于多项式的次数。如果 strict=True，结果不完整时将引发 UnsolvableFactorError。结果可以按如下方式检查完整性：
>>> f = x**3-2*x**2+1 >>> sum(roots(f, x).values()) == degree(f, x) True >>> f = (x-1)*(x**5-x+1) >>> sum(roots(f, x).values()) == degree(f, x) False
特殊多项式¶
- sympy.polys.specialpolys.swinnerton_dyer_poly(n, x=None, polys=False)[源代码][源代码]¶
生成 \(x\) 中的第 n 个 Swinnerton-Dyer 多项式。
- 参数:
- n整数
\(n\) 决定了多项式的顺序
- x可选的
- 多边形bool, 可选
polys=True返回一个表达式，否则（默认）返回一个表达式。
- sympy.polys.specialpolys.interpolating_poly(n, x, X='x', Y='y')[源代码][源代码]¶
构造
n个数据点的拉格朗日插值多项式。如果为X和Y提供了值序列，则将使用前n个值。
- sympy.polys.specialpolys.cyclotomic_poly(n, x=None, polys=False)[源代码][源代码]¶
生成 \(x\) 中的 \(n\) 阶分圆多项式。
- 参数:
- n整数
\(n\) 决定了多项式的顺序
- x可选的
- 多边形bool, 可选
polys=True返回一个表达式，否则（默认）返回一个表达式。
正交多项式¶
- sympy.polys.orthopolys.chebyshevt_poly(n, x=None, polys=False)[源代码][源代码]¶
生成第一类切比雪夫多项式 \(T_n(x)\)。
- 参数:
- n整数
多项式的次数。
- x可选的
- 多边形bool, 可选
如果为真，返回一个多项式，否则（默认）返回一个表达式。
- sympy.polys.orthopolys.chebyshevu_poly(n, x=None, polys=False)[源代码][源代码]¶
生成第二类切比雪夫多项式 \(U_n(x)\)。
- 参数:
- n整数
多项式的次数。
- x可选的
- 多边形bool, 可选
如果为真，返回一个多项式，否则（默认）返回一个表达式。
- sympy.polys.orthopolys.gegenbauer_poly(n, a, x=None, polys=False)[源代码][源代码]¶
生成Gegenbauer多项式 \(C_n^{(a)}(x)\)。
- 参数:
- n整数
多项式的次数。
- x可选的
- a
确定系数列表的最小域。
- 多边形bool, 可选
如果为真，返回一个多项式，否则（默认）返回一个表达式。
- sympy.polys.orthopolys.hermite_poly(n, x=None, polys=False)[源代码][源代码]¶
生成埃尔米特多项式 \(H_n(x)\)。
- 参数:
- n整数
多项式的次数。
- x可选的
- 多边形bool, 可选
如果为真，返回一个多项式，否则（默认）返回一个表达式。
- sympy.polys.orthopolys.hermite_prob_poly(n, x=None, polys=False)[源代码][源代码]¶
生成概率论者的埃尔米特多项式 \(He_n(x)\)。
- 参数:
- n整数
多项式的次数。
- x可选的
- 多边形bool, 可选
如果为真，返回一个多项式，否则（默认）返回一个表达式。
- sympy.polys.orthopolys.jacobi_poly(n, a, b, x=None, polys=False)[源代码][源代码]¶
生成 Jacobi 多项式 \(P_n^{(a,b)}(x)\)。
- 参数:
- n整数
多项式的次数。
- a
系数列表的最小域的下限。
- b
系数列表的最小域的上限。
- x可选的
- 多边形bool, 可选
如果为真，返回一个多项式，否则（默认）返回一个表达式。
- sympy.polys.orthopolys.legendre_poly(n, x=None, polys=False)[源代码][源代码]¶
生成勒让德多项式 \(P_n(x)\)。
- 参数:
- n整数
多项式的次数。
- x可选的
- 多边形bool, 可选
如果为真，返回一个多项式，否则（默认）返回一个表达式。
- sympy.polys.orthopolys.laguerre_poly(n, x=None, alpha=0, polys=False)[源代码][源代码]¶
生成Laguerre多项式 \(L_n^{(\alpha)}(x)\)。
- 参数:
- n整数
多项式的次数。
- x可选的
- alpha可选的
确定系数列表的最小域。
- 多边形bool, 可选
如果为真，返回一个多项式，否则（默认）返回一个表达式。
- sympy.polys.orthopolys.spherical_bessel_fn(n, x=None, polys=False)[源代码][源代码]¶
球贝塞尔函数的系数。
这些仅在 jn() 函数中需要。
系数是从以下计算得出的：
fn(0, z) = 1/z fn(1, z) = 1/z**2 fn(n-1, z) + fn(n+1, z) == (2*n+1)/z * fn(n, z)
- 参数:
- n整数
多项式的次数。
- x可选的
- 多边形bool, 可选
如果为真，返回一个多项式，否则（默认）返回一个表达式。
示例
>>> from sympy.polys.orthopolys import spherical_bessel_fn as fn >>> from sympy import Symbol >>> z = Symbol("z") >>> fn(1, z) z**(-2) >>> fn(2, z) -1/z + 3/z**3 >>> fn(3, z) -6/z**2 + 15/z**4 >>> fn(4, z) 1/z - 45/z**3 + 105/z**5
Appell 序列¶
- sympy.polys.appellseqs.bernoulli_poly(n, x=None, polys=False)[源代码][源代码]¶
生成伯努利多项式 \(\operatorname{B}_n(x)\)。
\(\operatorname{B}_n(x)\) 是满足唯一性的多项式。
\[\int_{x}^{x+1} \operatorname{B}_n(t) \,dt = x^n.\]基于此，对于非负整数 \(s\) 和整数 \(a\) 和 \(b\)
\[\sum_{k=a}^{b} k^s = \frac{\operatorname{B}_{s+1}(b+1) - \operatorname{B}_{s+1}(a)}{s+1}\]这与雅各布·伯努利引入伯努利数的原始动机有关，即这些多项式在 \(x = 1\) 处的值。
- 参数:
- n整数
多项式的次数。
- x可选的
- 多边形bool, 可选
如果为真，返回一个多项式，否则（默认）返回一个表达式。
参考文献
[1]示例
>>> from sympy import summation >>> from sympy.abc import x >>> from sympy.polys import bernoulli_poly >>> bernoulli_poly(5, x) x**5 - 5*x**4/2 + 5*x**3/3 - x/6
>>> def psum(p, a, b): ... return (bernoulli_poly(p+1,b+1) - bernoulli_poly(p+1,a)) / (p+1) >>> psum(4, -6, 27) 3144337 >>> summation(x**4, (x, -6, 27)) 3144337
>>> psum(1, 1, x).factor() x*(x + 1)/2 >>> psum(2, 1, x).factor() x*(x + 1)*(2*x + 1)/6 >>> psum(3, 1, x).factor() x**2*(x + 1)**2/4
- sympy.polys.appellseqs.bernoulli_c_poly(n, x=None, polys=False)[源代码][源代码]¶
生成中心伯努利多项式 \(\operatorname{B}_n^c(x)\)。
这些是普通伯努利多项式的缩放和移位版本，以这样的方式完成，使得 \(\operatorname{B}_n^c(x)\) 对于偶数或奇数 \(n\) 分别是偶函数或奇函数：
\[\operatorname{B}_n^c(x) = 2^n \operatorname{B}_n \left(\frac{x+1}{2}\right)\]- 参数:
- n整数
多项式的次数。
- x可选的
- 多边形bool, 可选
如果为真，返回一个多项式，否则（默认）返回一个表达式。
- sympy.polys.appellseqs.genocchi_poly(n, x=None, polys=False)[源代码][源代码]¶
生成Genocchi多项式 \(\operatorname{G}_n(x)\)。
\(\operatorname{G}_n(x)\) 是普通和中心伯努利多项式之间的差的两倍，因此具有度数 \(n-1\)：
\[\operatorname{G}_n(x) = 2 (\operatorname{B}_n(x) - \operatorname{B}_n^c(x))\]定义中的因子2使得 \(\operatorname{G}_n(x)\) 具有整数系数。
- 参数:
- n整数
多项式的次数加一。
- x可选的
- 多边形bool, 可选
如果为真，返回一个多项式，否则（默认）返回一个表达式。
- sympy.polys.appellseqs.euler_poly(n, x=None, polys=False)[源代码][源代码]¶
生成欧拉多项式 \(\operatorname{E}_n(x)\)。
这些是Genocchi多项式的缩放和重新索引版本：
\[\operatorname{E}_n(x) = -\frac{\operatorname{G}_{n+1}(x)}{n+1}\]- 参数:
- n整数
多项式的次数。
- x可选的
- 多边形bool, 可选
如果为真，返回一个多项式，否则（默认）返回一个表达式。
- sympy.polys.appellseqs.andre_poly(n, x=None, polys=False)[源代码][源代码]¶
生成安德烈多项式 \(\mathcal{A}_n(x)\)。
这是Appell序列，其中常数系数构成了欧拉数序列
euler(n)。因此，它们具有整数系数，并且奇偶性与 \(n\) 的奇偶性匹配。Luschny 称这些多项式为 瑞士军刀多项式，因为它们在 0 和 1 处的值可以简单地转换为伯努利数和欧拉数。这里称它们为 Andre 多项式，因为对于 \(n \ge 0\)，\(|\mathcal{A}_n(n\bmod 2)|\) 生成了 Luschny 所称的 Andre 数，即 OEIS 中的 A000111。
- 参数:
- n整数
多项式的次数。
- x可选的
- 多边形bool, 可选
如果为真，返回一个多项式，否则（默认）返回一个表达式。
参考文献
[1]Peter Luschny, “An introduction to the Bernoulli function”, https://arxiv.org/abs/2009.06743
示例
>>> from sympy import bernoulli, euler, genocchi >>> from sympy.abc import x >>> from sympy.polys import andre_poly >>> andre_poly(9, x) x**9 - 36*x**7 + 630*x**5 - 5124*x**3 + 12465*x
>>> [andre_poly(n, 0) for n in range(11)] [1, 0, -1, 0, 5, 0, -61, 0, 1385, 0, -50521] >>> [euler(n) for n in range(11)] [1, 0, -1, 0, 5, 0, -61, 0, 1385, 0, -50521] >>> [andre_poly(n-1, 1) * n / (4**n - 2**n) for n in range(1, 11)] [1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0, 5/66] >>> [bernoulli(n) for n in range(1, 11)] [1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0, 5/66] >>> [-andre_poly(n-1, -1) * n / (-2)**(n-1) for n in range(1, 11)] [-1, -1, 0, 1, 0, -3, 0, 17, 0, -155] >>> [genocchi(n) for n in range(1, 11)] [-1, -1, 0, 1, 0, -3, 0, 17, 0, -155]
>>> [abs(andre_poly(n, n%2)) for n in range(11)] [1, 1, 1, 2, 5, 16, 61, 272, 1385, 7936, 50521]
有理函数的操作¶
- sympy.polys.rationaltools.together(expr, deep=False, fraction=True)[源代码][源代码]¶
使用符号方法去嵌套和合并有理表达式。
此函数接受一个表达式或表达式容器，并通过去嵌套和组合有理子表达式将其（它们）组合在一起。不会采取任何英勇措施来最小化结果分子和分母的次数。要获得完全简化的表达式，请使用
cancel()。然而，together()可以在输出中尽可能多地保留输入表达式的结构（不会执行扩展）。可以组合多种对象，包括列表、元组、集合、关系对象、积分等。还可以通过将
deep标志设置为True来转换函数应用的内部。根据定义，
together()是apart()的补充，因此apart(together(expr))应该返回不变的 expr。然而，请注意，together()仅使用符号方法，因此可能需要使用cancel()来进行代数简化并最小化分子和分母的次数。示例
>>> from sympy import together, exp >>> from sympy.abc import x, y, z
>>> together(1/x + 1/y) (x + y)/(x*y) >>> together(1/x + 1/y + 1/z) (x*y + x*z + y*z)/(x*y*z)
>>> together(1/(x*y) + 1/y**2) (x + y)/(x*y**2)
>>> together(1/(1 + 1/x) + 1/(1 + 1/y)) (x*(y + 1) + y*(x + 1))/((x + 1)*(y + 1))
>>> together(exp(1/x + 1/y)) exp(1/y + 1/x) >>> together(exp(1/x + 1/y), deep=True) exp((x + y)/(x*y))
>>> together(1/exp(x) + 1/(x*exp(x))) (x + 1)*exp(-x)/x
>>> together(1/exp(2*x) + 1/(x*exp(3*x))) (x*exp(x) + 1)*exp(-3*x)/x
部分分式分解¶
- sympy.polys.partfrac.apart(f, x=None, full=False, **options)[源代码][源代码]¶
计算有理函数的偏分式分解。
给定一个有理函数
f，计算f的部分分式分解。有两种算法可用：一种是基于未定系数法，另一种是 Bronstein 的完整部分分式分解算法。未定系数法（通过
full=False选择）使用多项式因式分解（因此接受与因式分解相同的选项）来处理分母。默认情况下，它在有理数上工作，因此不支持分母具有非有理根（例如，无理数、复数根）的分解（参见因式分解的选项）。通过使用
full=True可以选择 Bronstein 算法，并允许对具有非有理根的分母进行分解。可以通过doit()获得人类可读的结果（见下文示例）。示例
>>> from sympy.polys.partfrac import apart >>> from sympy.abc import x, y
默认情况下，使用待定系数法：
>>> apart(y/(x + 2)/(x + 1), x) -y/(x + 2) + y/(x + 1)
当分母的根不是有理数时，待定系数法不提供结果：
>>> apart(y/(x**2 + x + 1), x) y/(x**2 + x + 1)
你可以通过设置
full=True来选择 Bronstein 算法：>>> apart(y/(x**2 + x + 1), x, full=True) RootSum(_w**2 + _w + 1, Lambda(_a, (-2*_a*y/3 - y/3)/(-_a + x)))
调用
doit()会产生一个人类可读的结果：>>> apart(y/(x**2 + x + 1), x, full=True).doit() (-y/3 - 2*y*(-1/2 - sqrt(3)*I/2)/3)/(x + 1/2 + sqrt(3)*I/2) + (-y/3 - 2*y*(-1/2 + sqrt(3)*I/2)/3)/(x + 1/2 - sqrt(3)*I/2)
- sympy.polys.partfrac.apart_list(f, x=None, dummies=None, **options)[源代码][源代码]¶
计算有理函数的偏分式分解，并以结构化形式返回结果。
给定一个有理函数
f，计算f的部分分式分解。此方法仅支持 Bronstein 的完整部分分式分解算法。返回值结构化程度高，非常适合进一步的算法处理，而不是供人阅读。该函数返回一个包含三个元素的元组：第一个项是公共系数，不包含用于分解的变量 \(x\)。（它是基域 \(K\) 的一个元素。）
第二个部分是分解的多项式部分。这可以是零多项式。（它是 \(K[x]\) 的一个元素。）
第三部分本身是一个四元组的列表。每个四元组按以下顺序包含以下元素：
（不一定是不可约的）多项式 \(D\)，其根 \(w_i\) 出现在一堆相关分数项的线性分母中。（此项也可以是显式根的列表。然而，目前
apart_list永远不会以这种方式返回结果，但相关的assemble_partfrac_list函数接受此格式作为输入。）分数的分子，写成根 \(w\) 的函数
分数的线性分母 不包括其幂指数 ，写成根 \(w\) 的函数。
分母需要被提升的幂次。
可以通过使用函数
assemble_partfrac_list来重建一个简单的表达式。参考文献
[1]示例
第一个示例：
>>> from sympy.polys.partfrac import apart_list, assemble_partfrac_list >>> from sympy.abc import x, t
>>> f = (2*x**3 - 2*x) / (x**2 - 2*x + 1) >>> pfd = apart_list(f) >>> pfd (1, Poly(2*x + 4, x, domain='ZZ'), [(Poly(_w - 1, _w, domain='ZZ'), Lambda(_a, 4), Lambda(_a, -_a + x), 1)])
>>> assemble_partfrac_list(pfd) 2*x + 4 + 4/(x - 1)
第二个例子：
>>> f = (-2*x - 2*x**2) / (3*x**2 - 6*x) >>> pfd = apart_list(f) >>> pfd (-1, Poly(2/3, x, domain='QQ'), [(Poly(_w - 2, _w, domain='ZZ'), Lambda(_a, 2), Lambda(_a, -_a + x), 1)])
>>> assemble_partfrac_list(pfd) -2/3 - 2/(x - 2)
另一个例子，展示符号参数：
>>> pfd = apart_list(t/(x**2 + x + t), x) >>> pfd (1, Poly(0, x, domain='ZZ[t]'), [(Poly(_w**2 + _w + t, _w, domain='ZZ[t]'), Lambda(_a, -2*_a*t/(4*t - 1) - t/(4*t - 1)), Lambda(_a, -_a + x), 1)])
>>> assemble_partfrac_list(pfd) RootSum(_w**2 + _w + t, Lambda(_a, (-2*_a*t/(4*t - 1) - t/(4*t - 1))/(-_a + x)))
此示例摘自 Bronstein 的原始论文：
>>> f = 36 / (x**5 - 2*x**4 - 2*x**3 + 4*x**2 + x - 2) >>> pfd = apart_list(f) >>> pfd (1, Poly(0, x, domain='ZZ'), [(Poly(_w - 2, _w, domain='ZZ'), Lambda(_a, 4), Lambda(_a, -_a + x), 1), (Poly(_w**2 - 1, _w, domain='ZZ'), Lambda(_a, -3*_a - 6), Lambda(_a, -_a + x), 2), (Poly(_w + 1, _w, domain='ZZ'), Lambda(_a, -4), Lambda(_a, -_a + x), 1)])
>>> assemble_partfrac_list(pfd) -4/(x + 1) - 3/(x + 1)**2 - 9/(x - 1)**2 + 4/(x - 2)
- sympy.polys.partfrac.assemble_partfrac_list(partial_list)[源代码][源代码]¶
从函数
apart_list获得的结构化结果中重新组装一个完整的偏分数分解。参见
示例
此示例摘自 Bronstein 的原始论文：
>>> from sympy.polys.partfrac import apart_list, assemble_partfrac_list >>> from sympy.abc import x
>>> f = 36 / (x**5 - 2*x**4 - 2*x**3 + 4*x**2 + x - 2) >>> pfd = apart_list(f) >>> pfd (1, Poly(0, x, domain='ZZ'), [(Poly(_w - 2, _w, domain='ZZ'), Lambda(_a, 4), Lambda(_a, -_a + x), 1), (Poly(_w**2 - 1, _w, domain='ZZ'), Lambda(_a, -3*_a - 6), Lambda(_a, -_a + x), 2), (Poly(_w + 1, _w, domain='ZZ'), Lambda(_a, -4), Lambda(_a, -_a + x), 1)])
>>> assemble_partfrac_list(pfd) -4/(x + 1) - 3/(x + 1)**2 - 9/(x - 1)**2 + 4/(x - 2)
如果我们碰巧知道一些根，我们可以很容易地在结构内部提供它们：
>>> pfd = apart_list(2/(x**2-2)) >>> pfd (1, Poly(0, x, domain='ZZ'), [(Poly(_w**2 - 2, _w, domain='ZZ'), Lambda(_a, _a/2), Lambda(_a, -_a + x), 1)])
>>> pfda = assemble_partfrac_list(pfd) >>> pfda RootSum(_w**2 - 2, Lambda(_a, _a/(-_a + x)))/2
>>> pfda.doit() -sqrt(2)/(2*(x + sqrt(2))) + sqrt(2)/(2*(x - sqrt(2)))
>>> from sympy import Dummy, Poly, Lambda, sqrt >>> a = Dummy("a") >>> pfd = (1, Poly(0, x, domain='ZZ'), [([sqrt(2),-sqrt(2)], Lambda(a, a/2), Lambda(a, -a + x), 1)])
>>> assemble_partfrac_list(pfd) -sqrt(2)/(2*(x + sqrt(2))) + sqrt(2)/(2*(x - sqrt(2)))
多项式的离散¶
- sympy.polys.dispersion.dispersionset(p, q=None, *gens, **args)[源代码][源代码]¶
计算两个多项式的 离散集。
对于两个多项式 \(f(x)\) 和 \(g(x)\) 且 \(\deg f > 0\) 和 \(\deg g > 0\)，分散集 \(\operatorname{J}(f, g)\) 定义为：
\[\begin{split}\operatorname{J}(f, g) & := \{a \in \mathbb{N}_0 | \gcd(f(x), g(x+a)) \neq 1\} \\ & = \{a \in \mathbb{N}_0 | \deg \gcd(f(x), g(x+a)) \geq 1\}\end{split}\]对于单个多项式，定义 \(\operatorname{J}(f) := \operatorname{J}(f, f)\)。
参见
参考文献
示例
>>> from sympy import poly >>> from sympy.polys.dispersion import dispersion, dispersionset >>> from sympy.abc import x
简单多项式的离散集和离散度：
>>> fp = poly((x - 3)*(x + 3), x) >>> sorted(dispersionset(fp)) [0, 6] >>> dispersion(fp) 6
请注意，色散的定义不是对称的：
>>> fp = poly(x**4 - 3*x**2 + 1, x) >>> gp = fp.shift(-3) >>> sorted(dispersionset(fp, gp)) [2, 3, 4] >>> dispersion(fp, gp) 4 >>> sorted(dispersionset(gp, fp)) [] >>> dispersion(gp, fp) -oo
计算色散在域扩展上也适用：
>>> from sympy import sqrt >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>') >>> sorted(dispersionset(fp, gp)) [2] >>> sorted(dispersionset(gp, fp)) [1, 4]
我们甚至可以对具有符号系数的多项式进行计算：
>>> from sympy.abc import a >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x) >>> sorted(dispersionset(fp)) [0, 1]
- sympy.polys.dispersion.dispersion(p, q=None, *gens, **args)[源代码][源代码]¶
计算多项式的 离散度。
对于两个多项式 \(f(x)\) 和 \(g(x)\) 且 \(\deg f > 0\) 和 \(\deg g > 0\)，分散度 \(\operatorname{dis}(f, g)\) 定义为：
\[\begin{split}\operatorname{dis}(f, g) & := \max\{ J(f,g) \cup \{0\} \} \\ & = \max\{ \{a \in \mathbb{N} | \gcd(f(x), g(x+a)) \neq 1\} \cup \{0\} \}\end{split}\]并且对于单个多项式 \(\operatorname{dis}(f) := \operatorname{dis}(f, f)\)。注意我们定义 \(\max\{\} := -\infty\)。
参考文献
示例
>>> from sympy import poly >>> from sympy.polys.dispersion import dispersion, dispersionset >>> from sympy.abc import x
简单多项式的离散集和离散度：
>>> fp = poly((x - 3)*(x + 3), x) >>> sorted(dispersionset(fp)) [0, 6] >>> dispersion(fp) 6
请注意，色散的定义不是对称的：
>>> fp = poly(x**4 - 3*x**2 + 1, x) >>> gp = fp.shift(-3) >>> sorted(dispersionset(fp, gp)) [2, 3, 4] >>> dispersion(fp, gp) 4 >>> sorted(dispersionset(gp, fp)) [] >>> dispersion(gp, fp) -oo
空集的最大值定义为 \(-\infty\)，如本例所示。
计算色散在域扩展上也适用：
>>> from sympy import sqrt >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>') >>> sorted(dispersionset(fp, gp)) [2] >>> sorted(dispersionset(gp, fp)) [1, 4]
我们甚至可以对具有符号系数的多项式进行计算：
>>> from sympy.abc import a >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x) >>> sorted(dispersionset(fp)) [0, 1]