多项式级数运算#
任何有限泰勒级数，在所有实际用途上都是多项式。该模块利用稀疏多项式的高效表示和运算，实现了快速多变量级数操作。与Symphy相比的典型加速 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
虽然多项式的定义将多项式模的使用限制在泰勒级数上，但我们将其扩展到允许Laurent甚至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逐项存储多项式项，其中指数元组是键，该项的系数是值。为什么理性中没有理性的价值观 dict 从而支持有理指数。
所以我们采取的方法是修改稀疏 polys 允许非自然指数。结果很简单。我们只需删除对 int 中的指数 __pow__ 方法 PolyElement . 所以：
>>> 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 彼此的行为。我们引入一个布尔标志 series 在允许的列表中 Options 对于多项式（请参见 sympy.polys.polyoptions.Options ). 因此，当我们想要 sring 为了允许有理指数，我们提供一个 series=True 旗到 sring ：：
>>> 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 . 目前只支持基本函数。长期目标是取代SymPy的 series 方法与 rs_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函数主分支的级数展开式。
实例
>>> 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。实例
>>> 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)[源代码]#
级数的反正弦
返回asin的级数展开
p，约为0。实例
>>> 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)[源代码]#
一系列的正切。
返回tan的级数展开
p，约为0。实例
>>> 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)[源代码]#
级数余切
返回cot的系列扩展
p，约为0。实例
>>> 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。实例
>>> 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)[源代码]#
级数的余弦
返回cos的级数展开
p，约为0。实例
>>> 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，约为0。实例
>>> 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)[源代码]#
双曲正弦级数
返回sinh的级数展开
p，约为0。实例
>>> 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)[源代码]#
级数的双曲余弦
返回cosh的级数展开
p，约为0。实例
>>> 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)[源代码]#
级数的双曲正切
返回tanh的级数展开
p，约为0。实例
>>> 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/i!*x**i从sum f_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
Operations
- 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）\)。
算法
如果\(r\u i\)是顺序为\(i\)的解决方案，那么：\(ar\u i+f（r_i）-y=O\左（y^{i+1}\右）\)
如果\(r{i+1}\)是顺序为\(i+1\)的解，那么：\(ar{i+1}+f（r{i+1}）-y=O\左（y^{i+2}\右）\)
我们有\(r{i+1}=r\u i+e\)，这样，\(ae+f（r_i）=O\左（y^{i+2}\右）\)或\(e=-f（r_i）/a\)
因此，我们使用递归关系：\(r{i+1}=r}i-f（r_i）/a\)，边界条件为：\(rˉ1=y\)
实例
>>> 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)[源代码]#
第n根的多元级数展开
p.- 参数:
p ：表达式
计算根的多项式。
n ：整数
要计算的根的顺序。
x :
PolyElementprec ：整数
展开级数的顺序。
笔记
The result of this function is dependent on the ring over which the polynomial has been defined. If the answer involves a root of a constant, make sure that the polynomial is over a real field. It cannot yet handle roots of symbols.
实例
>>> 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.精确返回序列
prec在发电机里x注意，替换不是一个接一个地完成的
>>> 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输入序列。规则 ：
dict具有替换映射。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是有区别的。
实例
>>> 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)[源代码]#
整合
p关于x.- 参数:
x :
PolyElement关于哪个p是集成的。
实例
>>> 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)实例
>>> 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
工具书类
[R823]A、 Bostan，P.Flajolet，B.Salvy和E.Schost“两个代数数的快速计算”，研究报告4579，国家信息与自动化研究所
效用函数
- sympy.polys.ring_series.rs_is_puiseux(p, x)[源代码]#
测试是否
pPuiseux系列在吗x.如果在中具有负幂，则引发异常
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)[源代码]#
返回的puiseux系列 \(f(p, x, prec)\) .
功能时使用
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)[源代码]#
返回的puiseux系列 \(f(p, q, x, prec)\) .
功能时使用
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)\) with \(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)\)
tan系列首先针对虚拟变量_x计算，即， \(rs\_tan(\_x, iv, prec)\) . 然后我们用p代替x，得到期望的级数
- 参数:
p :
PolyElement要展开的多元级数。f ： \(ring\_series\) 要应用于的函数 \(p\) .
[args[-2]] :
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.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