使用多项式进行序列操作

任何有限泰勒级数，实际上在所有实际用途上都是多项式。该模块利用稀疏多项式的有效表示和操作，实现了非常快速的多元级数处理。与SymPy的``series``方法相比，典型的速度提升在20-100范围内，随着处理的级数变大，差距会扩大。

所有函数都会在用户指定的某个环上展开给定的级数。因此，计算出的级数的系数取决于所使用的环。例如:

>>> from sympy.polys import ring, QQ, RR
>>> from sympy.polys.ring_series import rs_sin
>>> R, x, y = ring('x, y', QQ)
>>> rs_sin(x*y, x, 5)
-1/6*x**3*y**3 + x*y

QQ 代表有理数域。在这里，所有系数都是有理数。建议在使用环级数时使用 QQ，因为它会自动选择最快的有理数类型。

同样地，如果使用了一个实数域:

>>> R, x, y = ring('x, y', RR)
>>> rs_sin(x*y, x, 5)
-0.166666666666667*x**3*y**3 + x*y

尽管多项式的定义限制了 Polynomial 模块仅用于泰勒级数，我们扩展了它以允许使用洛朗级数甚至 Puiseux 级数（带有分数指数）:

>>> from sympy.polys.ring_series import rs_cos, rs_tan
>>> R, x, y = ring('x, y', QQ)

>>> rs_cos(x + x*y, x, 3)/x**3
-1/2*x**(-1)*y**2 - x**(-1)*y - 1/2*x**(-1) + x**(-3)

>>> rs_tan(x**QQ(2, 5)*y**QQ(1, 2), x, 2)
1/3*x**(6/5)*y**(3/2) + x**(2/5)*y**(1/2)

默认情况下，PolyElement 不允许非自然数作为指数。它将分数转换为整数，并在遇到负指数时引发错误。ring series 模块的目标是快速级数展开，而不是使用 polys 模块。我们将其用作后端的原因仅仅是因为它实现了稀疏表示以及我们所需的大多数基本功能。然而，polys 的这种默认行为对 ring series 来说是有限的。

需要注意的是，在 polys 使用的数据结构 dict 中，不存在（对有理数指数的）这种限制。稀疏多项式（PolyElement）使用 Python 字典逐项存储多项式，其中指数元组是键，该项的系数是值。我们没有理由不能在 dict 中使用有理数值来支持有理数指数。

因此，我们采取的方法是修改稀疏的 polys 以允许非自然指数。结果证明这非常简单。我们只需要删除 PolyElement 的 __pow__ 方法中指数转换为 int 的部分。所以:

>>> x**QQ(3, 4)
x**(3/4)

而不是像之前那样为 1。

虽然这一更改违反了多项式的定义，但它目前并未破坏任何东西。理想情况下，我们不应该以任何方式修改 polys。但为了获得我们想要的所有 series 功能，没有找到其他简单的办法。如果需要，我们可以将 polys 的修改部分与核心 polys 分开。如果找到其他优雅的解决方案，那就更好了。

本模块函数返回的所有序列都是 PolyElement 类的实例。要将其与其他 SymPy 类型一起使用，请将其转换为 Expr:

>>> from sympy.polys.ring_series import rs_exp
>>> from sympy.abc import a, b, c
>>> series = rs_exp(x, x, 5)
>>> a + series.as_expr()
a + x**4/24 + x**3/6 + x**2/2 + x + 1

rs_series

直接使用基本环级数函数确实提供了更多的控制，但同时也具有局限性。为所需的级数展开创建适当的环，并知道调用哪个环级数函数，这些事情可能不是每个人都很熟悉。

\(rs_series\) 是一个函数，它接受任意 Expr 并调用适当的环级数函数返回其展开式。返回的级数是一个在尽可能简单的（几乎是可能的）环上的多项式。它在解析给定表达式时递归地构建环，并在需要时向环中添加生成器。一些例子:

>>> from sympy.polys.ring_series import rs_series
>>> from sympy.functions.elementary.trigonometric import sin
>>> rs_series(sin(a + b), a, 5) 
1/24*sin(b)*a**4 - 1/2*sin(b)*a**2 + sin(b) - 1/6*cos(b)*a**3 + cos(b)*a

>>> rs_series(sin(exp(a*b) + cos(a + c)), a, 2) 
-sin(c)*cos(cos(c) + 1)*a + cos(cos(c) + 1)*a*b + sin(cos(c) + 1)

>>> rs_series(sin(a + b)*cos(a + c)*tan(a**2 + b), a, 2) 
cos(b)*cos(c)*tan(b)*a - sin(b)*sin(c)*tan(b)*a + sin(b)*cos(c)*tan(b)

它可以展开涉及多个函数的多变量复杂表达式，最重要的是，它的速度非常快:

>>> %timeit ((sin(a) + cos(a))**10).series(a, 0, 5) 
1 loops, best of 3: 1.33 s per loop

>>> %timeit rs_series((sin(a) + cos(a))**10, a, 5) 
100 loops, best of 3: 4.13 ms per loop

\(rs_series\) 的速度超过 300 倍。给定一个要展开的表达式，解析它会有一些固定的开销。因此，对于较大的阶数，速度提升变得更加显著:

>>> %timeit rs_series((sin(a) + cos(a))**10, a, 100) 
10 loops, best of 3: 32.8 ms per loop

为了找出给定表达式的正确环，\(rs_series\) 使用了 \(sring\) 函数，该函数又使用了 \(polys\) 模块中的其他函数。如上所述，不允许使用非自然数指数。但限制在于指数而不是生成器。因此，\(polys\) 允许所有类型的符号项作为生成器，以确保指数是自然数:

>>> from sympy.polys.rings import sring
>>> R, expr = sring(1/a**3 + a**QQ(3, 7)); R
Polynomial ring in 1/a, a**(1/7) over ZZ with lex order

在上面的例子中，\(1/a\) 和 \(a**(1/7)\) 将被视为完全不同的原子。出于所有实际目的，我们可以让 \(b = 1/a\) 和 \(c = a**(1/7)\) 并进行操作。实际上，涉及 \(1/a\) 和 `a**(1/7)`（及其幂）的表达式永远不会简化:

>>> expr*R(1/a)
(1/a)**4 + (1/a)*(a**(1/7))**3

这导致了在操作 Laurent 和 Puiseux 级数时遇到了类似的问题，就像之前遇到的那样。幸运的是，这次我们有了一个优雅的解决方案，并且能够将 series 和 polys 的行为彼此隔离。我们在多项式的允许 Options 列表中引入了一个布尔标志 series``（参见 :class:`sympy.polys.polyoptions.Options`）。因此，当我们希望 ``sring 允许有理数指数时，我们向 sring 提供一个 series=True 标志:

>>> rs_series(sin(a**QQ(1, 3)), a, 3)
-1/5040*a**(7/3) + 1/120*a**(5/3) - 1/6*a + a**(1/3)

贡献

\(rs_series\) 尚未完全实现。目前，它仅支持涉及 sin、cos、exp 和 tan 的表达式的多元泰勒展开。添加剩余函数并不困难，它们将逐步添加。如果您有兴趣协助，请阅读 ring_series.py 中的注释。目前，它不支持 Puiseux 级数（尽管基本函数支持）。预计这一问题将很快得到解决。

你也可以向 ring_series.py 添加更多功能。目前仅支持基本函数。长期目标是使用 rs_series 替换 SymPy 当前的 series 方法。

参考

此模块中的函数带有前缀 rs_，代表“环级数”。它们操作由 polys.ring.ring 提供的稀疏表示中的有限幂级数。

基本函数

sympy.polys.ring_series.rs_log(p, x, prec)

p 的对数模 O(x**prec)。

注释

使用了 integral dx p**-1*d p/dx 的截断。

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_log
>>> R, x = ring('x', QQ)
>>> rs_log(1 + x, x, 8)
1/7*x**7 - 1/6*x**6 + 1/5*x**5 - 1/4*x**4 + 1/3*x**3 - 1/2*x**2 + x
>>> rs_log(x**QQ(3, 2) + 1, x, 5)
1/3*x**(9/2) - 1/2*x**3 + x**(3/2)

sympy.polys.ring_series.rs_LambertW(p, x, prec)

计算 Lambert W 函数主分支的级数展开。

参见

LambertW

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_LambertW
>>> R, x, y = ring('x, y', QQ)
>>> rs_LambertW(x + x*y, x, 3)
-x**2*y**2 - 2*x**2*y - x**2 + x*y + x

sympy.polys.ring_series.rs_exp(p, x, prec)

对一个序列进行幂运算，模 O(x**prec)

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_exp
>>> R, x = ring('x', QQ)
>>> rs_exp(x**2, x, 7)
1/6*x**6 + 1/2*x**4 + x**2 + 1

sympy.polys.ring_series.rs_atan(p, x, prec)

一个序列的反正切

返回 p 的反正切在 0 附近的级数展开。

参见

atan

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_atan
>>> R, x, y = ring('x, y', QQ)
>>> rs_atan(x + x*y, x, 4)
-1/3*x**3*y**3 - x**3*y**2 - x**3*y - 1/3*x**3 + x*y + x

sympy.polys.ring_series.rs_asin(p, x, prec)

序列的反正弦

返回 p 的反正弦在 0 附近的级数展开。

参见

asin

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_asin
>>> R, x, y = ring('x, y', QQ)
>>> rs_asin(x, x, 8)
5/112*x**7 + 3/40*x**5 + 1/6*x**3 + x

sympy.polys.ring_series.rs_tan(p, x, prec)

序列的切线。

返回 p 的 tan 函数在 0 附近的级数展开。

参见

_tan1, tan

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_tan
>>> R, x, y = ring('x, y', QQ)
>>> rs_tan(x + x*y, x, 4)
1/3*x**3*y**3 + x**3*y**2 + x**3*y + 1/3*x**3 + x*y + x

sympy.polys.ring_series._tan1(p, x, prec)

rs_tan() 的辅助函数。

使用牛顿法返回单变量级数的 tan 级数展开。它利用了 atan 的级数展开比 tan 的级数展开更容易的事实。

考虑 \(f(x) = y - \arctan(x)\) 设 r 是使用牛顿法找到的 f(x) 的根。那么 \(f(r) = 0\) 或者 \(y = \arctan(x)\) 其中 \(x = \tan(y)\) 如所需。

sympy.polys.ring_series.rs_cot(p, x, prec)

一个序列的余切

返回 p 的余切函数在 0 附近的级数展开。

参见

cot

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_cot
>>> R, x, y = ring('x, y', QQ)
>>> rs_cot(x, x, 6)
-2/945*x**5 - 1/45*x**3 - 1/3*x + x**(-1)

sympy.polys.ring_series.rs_sin(p, x, prec)

一个级数的正弦

返回 p 的正弦值在 0 附近的级数展开。

参见

sin

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_sin
>>> R, x, y = ring('x, y', QQ)
>>> rs_sin(x + x*y, x, 4)
-1/6*x**3*y**3 - 1/2*x**3*y**2 - 1/2*x**3*y - 1/6*x**3 + x*y + x
>>> rs_sin(x**QQ(3, 2) + x*y**QQ(7, 5), x, 4)
-1/2*x**(7/2)*y**(14/5) - 1/6*x**3*y**(21/5) + x**(3/2) + x*y**(7/5)

sympy.polys.ring_series.rs_cos(p, x, prec)

余弦级数

返回 p 的余弦在 0 附近的级数展开。

参见

cos

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_cos
>>> R, x, y = ring('x, y', QQ)
>>> rs_cos(x + x*y, x, 4)
-1/2*x**2*y**2 - x**2*y - 1/2*x**2 + 1
>>> rs_cos(x + x*y, x, 4)/x**QQ(7, 5)
-1/2*x**(3/5)*y**2 - x**(3/5)*y - 1/2*x**(3/5) + x**(-7/5)

sympy.polys.ring_series.rs_cos_sin(p, x, prec)

返回元组 (rs_cos(p, x, prec)`, `rs_sin(p, x, prec))。

比分别调用 rs_cos 和 rs_sin 更快

sympy.polys.ring_series.rs_atanh(p, x, prec)

序列的双曲反正切

返回 p 的 atanh 在 0 附近的级数展开。

参见

atanh

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_atanh
>>> R, x, y = ring('x, y', QQ)
>>> rs_atanh(x + x*y, x, 4)
1/3*x**3*y**3 + x**3*y**2 + x**3*y + 1/3*x**3 + x*y + x

sympy.polys.ring_series.rs_sinh(p, x, prec)

序列的双曲正弦

返回 p 的 sinh 在 0 附近的级数展开。

参见

sinh

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_sinh
>>> R, x, y = ring('x, y', QQ)
>>> rs_sinh(x + x*y, x, 4)
1/6*x**3*y**3 + 1/2*x**3*y**2 + 1/2*x**3*y + 1/6*x**3 + x*y + x

sympy.polys.ring_series.rs_cosh(p, x, prec)

一个级数的双曲余弦

返回 p 的 cosh 在 0 附近的级数展开。

参见

cosh

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_cosh
>>> R, x, y = ring('x, y', QQ)
>>> rs_cosh(x + x*y, x, 4)
1/2*x**2*y**2 + x**2*y + 1/2*x**2 + 1

sympy.polys.ring_series.rs_tanh(p, x, prec)

序列的双曲正切

返回 p 的 tanh 在 0 附近的级数展开。

参见

tanh

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_tanh
>>> R, x, y = ring('x, y', QQ)
>>> rs_tanh(x + x*y, x, 4)
-1/3*x**3*y**3 - x**3*y**2 - x**3*y - 1/3*x**3 + x*y + x

sympy.polys.ring_series.rs_hadamard_exp(p1, inverse=False)

从 sum f_i*x**i 返回 sum f_i/i!*x**i，其中 x 是第一个变量。

如果 invers=True 返回 sum f_i*i!*x**i

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_hadamard_exp
>>> R, x = ring('x', QQ)
>>> p = 1 + x + x**2 + x**3
>>> rs_hadamard_exp(p)
1/6*x**3 + 1/2*x**2 + x + 1

操作

sympy.polys.ring_series.rs_mul(p1, p2, x, prec)

返回给定两个级数的乘积，模 O(x**prec)。

x 是序列变量或其在生成器中的位置。

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_mul
>>> R, x = ring('x', QQ)
>>> p1 = x**2 + 2*x + 1
>>> p2 = x + 1
>>> rs_mul(p1, p2, x, 3)
3*x**2 + 3*x + 1

sympy.polys.ring_series.rs_square(p1, x, prec)

对序列进行平方运算，模 O(x**prec)

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_square
>>> R, x = ring('x', QQ)
>>> p = x**2 + 2*x + 1
>>> rs_square(p, x, 3)
6*x**2 + 4*x + 1

sympy.polys.ring_series.rs_pow(p1, n, x, prec)

返回 p1**n 模 O(x**prec)

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_pow
>>> R, x = ring('x', QQ)
>>> p = x + 1
>>> rs_pow(p, 4, x, 3)
6*x**2 + 4*x + 1

sympy.polys.ring_series.rs_series_inversion(p, x, prec)

多元级数反演 1/p 模 O(x**prec)。

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_series_inversion
>>> R, x, y = ring('x, y', QQ)
>>> rs_series_inversion(1 + x*y**2, x, 4)
-x**3*y**6 + x**2*y**4 - x*y**2 + 1
>>> rs_series_inversion(1 + x*y**2, y, 4)
-x*y**2 + 1
>>> rs_series_inversion(x + x**2, x, 4)
x**3 - x**2 + x - 1 + x**(-1)

sympy.polys.ring_series.rs_series_reversion(p, x, n, y)

系列的重演。

p 是一个形如 O(x**n) 的序列，其中 \(p = ax + f(x)\)，\(a\) 是一个不等于 0 的数。

\(f(x) = \sum_{k=2}^{n-1} a_kx_k\)

参数:

a_k可以多项式依赖于其他变量，未指明。

x名为 x 的变量。

y名为 y 的变量。

返回:

求解 \(p = y\)，即给定 \(ax + f(x) - y = 0\)，

找到解 \(x = r(y)\) 直到 \(O(y^n)\)。

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_series_reversion, rs_trunc
>>> R, x, y, a, b = ring('x, y, a, b', QQ)
>>> p = x - x**2 - 2*b*x**2 + 2*a*b*x**2
>>> p1 = rs_series_reversion(p, x, 3, y); p1
-2*y**2*a*b + 2*y**2*b + y**2 + y
>>> rs_trunc(p.compose(x, p1), y, 3)
y

sympy.polys.ring_series.rs_nth_root(p, n, x, prec)

p 的 n 次根的多变量级数展开。

参数:

p表达式

计算根的多项式。

n整数

要计算的根的顺序。

xPolyElement

prec整数

展开序列的顺序。

注释

此函数的结果取决于多项式所定义的环。如果答案涉及常数的根，请确保多项式定义在实数域上。它尚不能处理符号的根。

示例

>>> from sympy.polys.domains import QQ, RR
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_nth_root
>>> R, x, y = ring('x, y', QQ)
>>> rs_nth_root(1 + x + x*y, -3, x, 3)
2/9*x**2*y**2 + 4/9*x**2*y + 2/9*x**2 - 1/3*x*y - 1/3*x + 1
>>> R, x, y = ring('x, y', RR)
>>> rs_nth_root(3 + x + x*y, 3, x, 2)
0.160249952256379*x*y + 0.160249952256379*x + 1.44224957030741

sympy.polys.ring_series.rs_trunc(p1, x, prec)

在 x 变量中截断级数，精度为 prec ，即模 O(x**prec)

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_trunc
>>> R, x = ring('x', QQ)
>>> p = x**10 + x**5 + x + 1
>>> rs_trunc(p, x, 12)
x**10 + x**5 + x + 1
>>> rs_trunc(p, x, 10)
x**5 + x + 1

sympy.polys.ring_series.rs_subs(p, rules, x, prec)

根据 rules 中的映射进行截断替换。

在生成器 x 中返回一个精度为 prec 的序列

请注意，替换不是一个接一个地进行的

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_subs
>>> R, x, y = ring('x, y', QQ)
>>> p = x**2 + y**2
>>> rs_subs(p, {x: x+ y, y: x+ 2*y}, x, 3)
2*x**2 + 6*x*y + 5*y**2
>>> (x + y)**2 + (x + 2*y)**2
2*x**2 + 6*x*y + 5*y**2

这与

>>> rs_subs(rs_subs(p, {x: x+ y}, x, 3), {y: x+ 2*y}, x, 3)
5*x**2 + 12*x*y + 8*y**2

参数:

p : PolyElement 输入序列。PolyElement 输入系列。

规则 : 带有替换映射的 字典。带有替换映射的字典。

x : PolyElement 其中要进行级数截断。要进行级数截断的多项式元素。

prec : Integer 截断后序列的阶数。截断后序列的整数顺序。

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_subs
>>> R, x, y = ring('x, y', QQ)
>>> rs_subs(x**2+y**2, {y: (x+y)**2}, x, 3)
 6*x**2*y**2 + x**2 + 4*x*y**3 + y**4

sympy.polys.ring_series.rs_diff(p, x)

返回 p 对 x 的偏导数。

参数:

x : PolyElement 相对于 p 进行微分的对象。相对于哪个 PolyElement 对 p 进行微分。

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_diff
>>> R, x, y = ring('x, y', QQ)
>>> p = x + x**2*y**3
>>> rs_diff(p, x)
2*x*y**3 + 1

sympy.polys.ring_series.rs_integrate(p, x)

对 x 积分 p。

参数:

x : PolyElement 相对于 p 进行积分。关于 p 进行积分的 PolyElement。

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_integrate
>>> R, x, y = ring('x, y', QQ)
>>> p = x + x**2*y**3
>>> rs_integrate(p, x)
1/3*x**3*y**3 + 1/2*x**2

sympy.polys.ring_series.rs_newton(p, x, prec)

计算多项式 p 的截断牛顿和

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_newton
>>> R, x = ring('x', QQ)
>>> p = x**2 - 2
>>> rs_newton(p, x, 5)
8*x**4 + 4*x**2 + 2

sympy.polys.ring_series.rs_compose_add(p1, p2)

计算组合和 prod(p2(x - beta) for beta root of p1)

参考文献

[1]

toctree 是一个 reStructuredText 的 指令，一种非常通用的标记。指令可以有参数、选项和内容。

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_compose_add
>>> R, x = ring('x', QQ)
>>> f = x**2 - 2
>>> g = x**2 - 3
>>> rs_compose_add(f, g)
x**4 - 10*x**2 + 1

实用函数

sympy.polys.ring_series.rs_is_puiseux(p, x)

测试 p 是否是 x 中的 Puiseux 级数。

如果在 x 中有负幂，则引发异常。

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_is_puiseux
>>> R, x = ring('x', QQ)
>>> p = x**QQ(2,5) + x**QQ(2,3) + x
>>> rs_is_puiseux(p, x)
True

sympy.polys.ring_series.rs_puiseux(f, p, x, prec)

返回 \(f(p, x, prec)\) 的 Puiseux 级数。

当函数 f 仅针对常规系列实现时使用。

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_puiseux, rs_exp
>>> R, x = ring('x', QQ)
>>> p = x**QQ(2,5) + x**QQ(2,3) + x
>>> rs_puiseux(rs_exp,p, x, 1)
1/2*x**(4/5) + x**(2/3) + x**(2/5) + 1

sympy.polys.ring_series.rs_puiseux2(f, p, q, x, prec)

返回 \(f(p, q, x, prec)\) 的 Puiseux 级数。

当函数 f 仅针对常规系列实现时使用。

sympy.polys.ring_series.rs_series_from_list(p, c, x, prec, concur=1)

返回一个序列 \(sum c[n]*p**n\) 模 \(O(x**prec)\)。

它通过并发求和来减少乘法次数。

\(ax = [1, p, p**2, .., p**(J - 1)]\) \(s = sum(c[i]*ax[i]\) for i in \(range(r, (r + 1)*J))*p**((K - 1)*J)\) 其中 \(K >= (n + 1)/J\)

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_series_from_list, rs_trunc
>>> R, x = ring('x', QQ)
>>> p = x**2 + x + 1
>>> c = [1, 2, 3]
>>> rs_series_from_list(p, c, x, 4)
6*x**3 + 11*x**2 + 8*x + 6
>>> rs_trunc(1 + 2*p + 3*p**2, x, 4)
6*x**3 + 11*x**2 + 8*x + 6
>>> pc = R.from_list(list(reversed(c)))
>>> rs_trunc(pc.compose(x, p), x, 4)
6*x**3 + 11*x**2 + 8*x + 6

sympy.polys.ring_series.rs_fun(p, f, *args)

通过替换计算的多变量级数的功能。

使用 f 方法名的案例用于计算多元级数的 \(rs_tan\) 和 \(rs_nth_root\)：

\(rs_fun(p, tan, iv, prec)\)

首先计算虚拟变量 _x 的 tan 级数，即 \(rs\_tan(\_x, iv, prec)\)。然后我们将 _x 替换为 p 以获得所需的级数

参数:

p : PolyElement 要展开的多变量级数。PolyElement 要展开的多变量级数。

f : 要应用于 \(p\) 的 \(ring_series\) 函数。ring_series 函数应用于 p。

args[-2] : PolyElement 关于它，级数将被展开。关于哪个的 PolyElement，该系列将被展开。

args[-1]展开系列所需的顺序。

示例

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_fun, _tan1
>>> R, x, y = ring('x, y', QQ)
>>> p = x + x*y + x**2*y + x**3*y**2
>>> rs_fun(p, _tan1, x, 4)
1/3*x**3*y**3 + 2*x**3*y**2 + x**3*y + 1/3*x**3 + x**2*y + x*y + x

sympy.polys.ring_series.mul_xin(p, i, n)

返回 \(p*x_i**n\)。

\(x\_i\) 是 p 中的第 i 个变量。

sympy.polys.ring_series.pow_xin(p, i, n)

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import pow_xin
>>> R, x, y = ring('x, y', QQ)
>>> p = x**QQ(2,5) + x + x**QQ(2,3)
>>> index = p.ring.gens.index(x)
>>> pow_xin(p, index, 15)
x**15 + x**10 + x**6