SymPy 1.13 中文文档（十五）

原文：docs.sympy.org/latest/index.html

级数

原文：docs.sympy.org/latest/modules/series/index.html

该系列模块将级数展开实现为一个函数，并实现了许多相关函数。

目录

• 级数展开

• 序列

• 傅立叶级数

• 形式幂级数

• 序列的极限

级数展开

原文：docs.sympy.org/latest/modules/series/series.html

极限

本模块的主要目的是计算极限。

sympy.series.limits.limit(e, z, z0, dir='+')

计算在点z0处的e(z)的极限。

参数：

e : 表达式，要计算其极限

z : 表示极限中的变量的符号。

其他符号被视为常数。不支持多变量极限。

z0 : z趋向的值。可以是任何表达式，

包括oo和-oo。

dir : 字符串，可选（默认为“+”）

如果dir="+-"，则极限是双向的，如果dir="+"，则从右侧（z->z0+）；如果dir="-"，则从左侧（z->z0-）。对于无限的z0（oo或-oo），dir参数由无限方向确定（即对于oo，dir="-"）。

示例

>>> from sympy import limit, sin, oo
>>> from sympy.abc import x
>>> limit(sin(x)/x, x, 0)
1
>>> limit(1/x, x, 0) # default dir='+'
oo
>>> limit(1/x, x, 0, dir="-")
-oo
>>> limit(1/x, x, 0, dir='+-')
zoo
>>> limit(1/x, x, oo)
0 

注意

首先我们尝试一些启发式方法处理像“x”，“1/x”，“x**2”和类似的简单和频繁的情况，以便处理速度更快。对于所有其他情况，我们使用 Gruntz 算法（请参阅 gruntz()函数）。

另请参见

limit_seq

返回序列的极限。

class sympy.series.limits.Limit(e, z, z0, dir='+')

表示一个未评估的极限。

示例

>>> from sympy import Limit, sin
>>> from sympy.abc import x
>>> Limit(sin(x)/x, x, 0)
Limit(sin(x)/x, x, 0, dir='+')
>>> Limit(1/x, x, 0, dir="-")
Limit(1/x, x, 0, dir='-') 

doit(**hints)

评估极限。

参数：

deep : bool, optional (default: True)

在进行极限之前调用涉及的表达式的doit方法。

hints : optional keyword arguments

被传递给doit方法；仅在 deep 为 True 时使用。

如上所述，极限计算的主要工具是 gruntz()函数，它实现了 Gruntz 算法来计算极限。

Gruntz 算法

本节介绍了用于计算极限的算法基础。大多数情况下，limit()函数应该正常工作。但是，记住它的实现方式仍然很有用，以防某些情况出乎意料。

首先我们定义函数的一个排序。假设(f(x))和(g(x))是两个实值函数，使得(\lim_{x \to \infty} f(x) = \infty)和同样(\lim_{x \to \infty} g(x) = \infty)。我们将说(f(x)) 支配 (g(x))，写作(f(x) \succ g(x))，如果对于所有(a, b \in \mathbb{R}{>0})，我们有(\lim{x \to \infty} \frac{f(x)^a}{g(x)^b} = \infty)。我们还说(f(x))和(g(x)) 具有相同的可比性类，如果既不是(f(x) \succ g(x))也不是(g(x) \succ f(x))，并将其表示为(f(x) \asymp g(x))。

注意，无论何时(a, b \in \mathbb{R}_{>0})，则(a f(x)^b \asymp f(x))，我们将使用此来扩展对所有函数的定义，它们随着(x \to \infty)趋向于(0)或(\pm \infty)。因此，我们声明(f(x) \asymp 1/f(x))和(f(x) \asymp -f(x))。

可以轻松展示以下示例：

• (e^x \succ x^m)

• (e^{x²} \succ e^{mx})

• (e^{e^x} \succ e^{x^m})

• (x^m \asymp x^n)

• (e^{x + \frac{1}{x}} \asymp e^{x + \log{x}} \asymp e^x)。

根据上述定义，可以证明以下属性：

假设(\omega)，(g_1, g_2, \ldots)是(x)的函数，(\lim_{x \to \infty} \omega = 0)，并且对于所有(i)，(\omega \succ g_i)。让(c_1, c_2, \ldots \in \mathbb{R})，其中(c_1 < c_2 < \cdots)。

然后(\lim_{x \to \infty} \sum_i g_i \omega^{c_i} = \lim_{x \to \infty} g_1 \omega^{c_1})。

对于(g_1 = g)和如上所述的(\omega)，我们还有以下简单的结果：

• 对于(c > 0)，(\lim_{x \to \infty} g \omega^c = 0)
• 对于(c < 0)，当(g)的符号（最终）确定时，(\lim_{x \to \infty} g \omega^c = \pm \infty)，其中符号由(g)的符号确定。
• (\lim_{x \to \infty} g \omega⁰ = \lim_{x \to \infty} g).

使用这些结果产生了计算(\lim_{x \to \infty} f(x))的以下策略：

1. 找到最快变化子表达式（MRV 集合）的集合(f(x))。也就是说，从(f(x))的所有子表达式集合中，找到在关系(\succ)下是最大的元素。

2. 选择一个与 MRV 集合中的元素相同可比性类的函数(\omega)，使得(\lim_{x \to \infty} \omega = 0)。

3. 将(f(x))在(\omega)中作为级数展开，以满足上述定理的前提条件。

4. 应用定理并得出对(\lim_{x \to \infty} f(x))的计算结果，可能通过递归地处理(g_1(x))。

注释

这段阐述省略了几个细节。许多细节在 gruntz.py 文件中有描述，并且都可以在格伦茨非常易读的论文中找到。尚未解释的最重要的几点是：

1. 给定(f(x))和(g(x))，我们如何确定(f(x) \succ g(x))，(g(x) \succ f(x))或(g(x) \asymp f(x))？

2. 我们如何找到一个表达式的 MRV 集合？

3. 我们如何计算级数展开？

4. 为什么算法会终止？

如果你感兴趣，请务必查看格伦茨论文。

参考

sympy.series.gruntz.gruntz(e, z, z0, dir='+')

使用 Gruntz 算法计算在点 z0 处的 e(z)的极限。

解释

z0可以是任何表达式，包括 oo 和-oo。

对于dir="+"（默认），它从右侧计算极限（z->z0+），对于dir="-"，从左侧计算极限（z->z0-）。对于无穷大 z0（oo 或-oo），dir 参数无关紧要。

该算法完全在 gruntz.py 文件的模块文档字符串中进行了详细描述。它严重依赖于级数展开。在大多数情况下，仅当速度更快的 limit()函数（使用启发式算法）失败时才会使用 gruntz()。

sympy.series.gruntz.compare(a, b, x)

如果 a<b，则返回“<”，如果 a == b，则返回“=”，如果 a>b，则返回“>”

sympy.series.gruntz.rewrite(e, Omega, x, wsym)

e(x) … 函数 Omega … mrv 集合 wsym … 将用于 w 的符号

返回以 w 和 log(w)的术语重写的 e。有关示例和正确结果，请参阅 test_rewrite1()。

sympy.series.gruntz.build_expression_tree(Omega, rewrites)

重写的辅助函数。

我们需要对 Omega（mrv 集合）进行排序，以便在替换任何需要重写的表达式之前替换表达式：

e1 ---> e2 ---> e3
         \
          -> e4 

在这里我们可以执行 e1, e2, e3, e4 或 e1, e2, e4, e3。为此，我们将节点组装成树，并按高度排序。

此函数构建树，然后重写并对节点进行排序。

sympy.series.gruntz.mrv_leadterm(e, x)

对于 e 返回 (c0, e0)。

sympy.series.gruntz.calculate_series(e, x, logx=None)

计算 e 在 x 中至少一个系列项。

这是最常失败的地方，因此它处于自己的函数中。

sympy.series.gruntz.limitinf(e, x)

当 x-> oo 时限制 e(x)。

sympy.series.gruntz.sign(e, x)

对于 x-> oo 返回表达式 e(x) 的符号。

e >  0 for x sufficiently large ...  1
e == 0 for x sufficiently large ...  0
e <  0 for x sufficiently large ... -1 

如果 e 对于任意大的 x 改变符号，这个函数的结果目前未定义（例如 sin(x)）。

请注意，仅当 e 对于足够大的 x 是 常数 时，此函数才返回零。[如果 e 是常数，当然，这与 e 的符号是相同的。]

sympy.series.gruntz.mrv(e, x)

返回 ‘e’ 中最迅速变化（mrv）子表达式的子集，并且用这些子表达式重写 ‘e’。

sympy.series.gruntz.mrv_max1(f, g, exps, x)

计算两组表达式 f 和 g 的最大值，它们处于相同的可比较类中，即 mrv_max1() 比较 f 和 g（两个元素）并返回集合，如果它们具有相同的变化顺序，则返回相应的替换。

sympy.series.gruntz.mrv_max3(f, expsf, g, expsg, union, expsboth, x)

计算两组表达式 f 和 g 的最大值，它们处于相同的可比较类中，即 max() 比较 f 和 g（两个元素）并返回 (f, expsf)（如果 f 更大），(g, expsg)（如果 g 更大），或者 (union, expsboth)（如果 f、g 属于相同类）。

class sympy.series.gruntz.SubsSet

存储 (expr, dummy) 对及如何重写表达式的方法。

解释

gruntz 算法需要将某些表达式重写为一个新变量 w 的术语。我们不能使用 subs，因为它对我们来说太智能了。例如：

> Omega=[exp(exp(_p - exp(-_p))/(1 - 1/_p)), exp(exp(_p))]
> O2=[exp(-exp(_p) + exp(-exp(-_p))*exp(_p)/(1 - 1/_p))/_w, 1/_w]
> e = exp(exp(_p - exp(-_p))/(1 - 1/_p)) - exp(exp(_p))
> e.subs(Omega[0],O2[0]).subs(Omega[1],O2[1])
-1/w + exp(exp(p)*exp(-exp(-p))/(1 - 1/p)) 

真的不是我们想要的！

因此，我们采取了更难的方式，并记录了所有我们可能想要用虚拟变量替换的东西。考虑表达式：

exp(x - exp(-x)) + exp(x) + x. 

mrv 集合为 {exp(x), exp(-x), exp(x - exp(-x))}。我们引入对应的虚拟变量 d1, d2, d3 并重新表述：

d3 + d1 + x. 

该类首先跟踪映射 expr->variable，即此阶段将是一个字典：

{exp(x): d1, exp(-x): d2, exp(x - exp(-x)): d3}. 

[原来这样做更方便。] 但有时 mrv 集合中的表达式具有其他 mrv 集合中的表达式作为子表达式，我们也需要跟踪这一点。在这种情况下，d3 实际上是 exp(x - d2)，因此在这个阶段重写为：

{d3: exp(x-d2)}. 

函数 rewrite 利用所有这些信息来正确地用 w 的术语重写我们的表达式。在这种情况下，w 可以选择为 exp(-x)，即 d2。正确的重写如下：

exp(-w)/w + 1/w + x. 

copy()

创建 SubsSet 的浅拷贝

do_subs(e)

用表达式替换变量

meets(s2)

告诉我们 self 和 s2 是否有非空交集

union(s2, exps=None)

计算 self 和 s2 的并集，并调整 exps

更直观的级数展开

这通过创建 Basic.series() 的包装来实现。这允许使用 series(xcos(x),x)，可能比 (xcos(x)).series(x) 更直观。

例子

>>> from sympy import Symbol, cos, series
>>> x = Symbol('x')
>>> series(cos(x),x)
1 - x**2/2 + x**4/24 + O(x**6) 

参考文献

sympy.series.series.series(expr, x=None, x0=0, n=6, dir='+')

关于点 (x = x0) 周围的表达式的级数展开。

参数：

expr：表达式

将要展开级数的表达式。

x：符号

这是要计算的表达式的变量。

x0：数值

计算中 x 计算的值。可以是从 -oo 到 oo 的任意值。

n : 值

要展开的级数项数。

dir : 字符串，可选

级数展开可以是双向的。如果 dir="+"，则 (x->x0+)。如果 dir="-"，则 (x->x0-)。对于无限的 x0 (oo 或 -oo)，dir 参数由无穷的方向确定（即 dir="-" 适用于 oo）。

返回：

表达式

关于 x0 的表达式的级数展开

示例

>>> from sympy import series, tan, oo
>>> from sympy.abc import x
>>> f = tan(x)
>>> series(f, x, 2, 6, "+")
tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +
(x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +
5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +
2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2)) 

>>> series(f, x, 2, 3, "-")
tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))
+ O((x - 2)**3, (x, 2)) 

>>> series(f, x, 2, oo, "+")
Traceback (most recent call last):
...
TypeError: 'Infinity' object cannot be interpreted as an integer 

参见

sympy.core.expr.Expr.series

参见 Expr.series() 的文档字符串以获取此包装器的完整详细信息。

阶数项

此模块还实现了自动跟踪展开的阶数。

示例

>>> from sympy import Symbol, Order
>>> x = Symbol('x')
>>> Order(x) + x**2
O(x)
>>> Order(x) + 1
1 + O(x) 

参考

class sympy.series.order.Order(expr, *args, **kwargs)

表示某些函数的极限行为。

解释

函数的阶基于函数在某个极限处的极限行为进行特征化。当前仅支持将极限点设为数字。这以大 O 表示法表示 [R835]。

函数 (g(x)) 关于点 (a) 的阶的正式定义是，当 (x \rightarrow a) 时，(g(x) = O(f(x))) 当且仅当存在 (\delta > 0) 和 (M > 0)，使得 (|g(x)| \leq M|f(x)|) 对于 (|x-a| < \delta) 成立。这等价于 (\limsup_{x \rightarrow a} |g(x)/f(x)| < \infty)。

让我们通过以下示例来说明，通过对 (\sin(x)) 在 0 处的展开来理解：

[\sin(x) = x - x³/3! + O(x⁵)]

在这种情况下，(O(x⁵) = x⁵/5! - x⁷/7! + \cdots)。根据 (O) 的定义，存在 (\delta > 0) 和 (M)，使得：

[|x⁵/5! - x⁷/7! + ....| <= M|x⁵| \text{ for } |x| < \delta]

或由备用定义：

[\lim_{x \rightarrow 0} | (x⁵/5! - x⁷/7! + ....) / x⁵| < \infty]

这当然是正确的，因为

[\lim_{x \rightarrow 0} | (x⁵/5! - x⁷/7! + ....) / x⁵| = 1/5!]

如通常所用，函数的阶可以直观地被认为代表大于指定幂的所有项。例如，(O(x³)) 对应于任何与 (x³, x⁴,\ldots) 和任何更高幂次成比例的项。对于多项式，这将留下与 (x²)、(x) 和常数成比例的项。

示例

>>> from sympy import O, oo, cos, pi
>>> from sympy.abc import x, y 

>>> O(x + x**2)
O(x)
>>> O(x + x**2, (x, 0))
O(x)
>>> O(x + x**2, (x, oo))
O(x**2, (x, oo)) 

>>> O(1 + x*y)
O(1, x, y)
>>> O(1 + x*y, (x, 0), (y, 0))
O(1, x, y)
>>> O(1 + x*y, (x, oo), (y, oo))
O(x*y, (x, oo), (y, oo)) 

>>> O(1) in O(1, x)
True
>>> O(1, x) in O(1)
False
>>> O(x) in O(1, x)
True
>>> O(x**2) in O(x)
True 

>>> O(x)*x
O(x**2)
>>> O(x) - O(x)
O(x)
>>> O(cos(x))
O(1)
>>> O(cos(x), (x, pi/2))
O(x - pi/2, (x, pi/2)) 

注意

在 O(f(x), x) 中，假定表达式 f(x) 具有主导项。O(f(x), x) 自动转换为 O(f(x).as_leading_term(x),x)。

O(expr*f(x), x) 是 O(f(x), x)

O(expr, x) 是 O(1)

O(0, x) 等于 0。

多变量 O 也是支持的：

O(f(x, y), x, y) 被转换为 O(f(x, y).as_leading_term(x,y).as_leading_term(y), x, y)

在多变量情况下，假设关于各个符号的极限交换。

如果没有传递符号，则表达式中的所有符号都被使用，并且假定极限点为零。

参考

[R835] (1,2)

大 O 表示法

contains(expr)

如果expr属于Order(self.expr, *self.variables)，则返回 True。如果self属于expr，则返回 False。如果无法确定包含关系（例如当self和expr具有不同的符号时），则返回 None。

级数加速

TODO

参考

sympy.series.acceleration.richardson(A, k, n, N)

使用具有项 A(n), A(n+1), …, A(n+N+1)的 Richardson 外推计算 lim k->oo A(k)的近似。通常选择 N ~= 2*n 可以得到良好的结果。

示例

一个简单的例子是使用极限定义计算 exp(1)。这个极限收敛缓慢；n = 100 只能产生两个准确的数字：

>>> from sympy.abc import n
>>> e = (1 + 1/n)**n
>>> print(round(e.subs(n, 100).evalf(), 10))
2.7048138294 

使用 11 个适当选择的项进行 Richardson 外推得到的值精确到指定的精度：

>>> from sympy import E
>>> from sympy.series.acceleration import richardson
>>> print(round(richardson(e, n, 10, 20).evalf(), 10))
2.7182818285
>>> print(round(E.evalf(), 10))
2.7182818285 

另一个有用的应用是加快级数的收敛速度。计算 zeta(2)级数 1/k**2 的前 100 项仅产生两个准确的数字：

>>> from sympy.abc import k, n
>>> from sympy import Sum
>>> A = Sum(k**-2, (k, 1, n))
>>> print(round(A.subs(n, 100).evalf(), 10))
1.6349839002 

Richardson 外推表现得更好：

>>> from sympy import pi
>>> print(round(richardson(A, n, 10, 20).evalf(), 10))
1.6449340668
>>> print(round(((pi**2)/6).evalf(), 10))     # Exact value
1.6449340668 

sympy.series.acceleration.shanks(A, k, n, m=1)

使用 n 项 Shanks 变换 S(A)(n)计算 lim k->oo A(k)的近似。当 m > 1 时，计算 m 倍递归 Shanks 变换 S(S(…S(A)…))(n)。

Shanks 变换适用于在极点或奇点附近收敛缓慢的泰勒级数求和，例如对于 log(2)：

>>> from sympy.abc import k, n
>>> from sympy import Sum, Integer
>>> from sympy.series.acceleration import shanks
>>> A = Sum(Integer(-1)**(k+1) / k, (k, 1, n))
>>> print(round(A.subs(n, 100).doit().evalf(), 10))
0.6881721793
>>> print(round(shanks(A, n, 25).evalf(), 10))
0.6931396564
>>> print(round(shanks(A, n, 25, 5).evalf(), 10))
0.6931471806 

正确的值为 0.6931471805599453094172321215。

余项

TODO

参考

sympy.series.residues.residue(expr, x, x0)

在点 x=x0 处找到expr的余项。

余项定义为关于x=x0的幂级数展开中1/(x-x0)的系数。

示例

>>> from sympy import Symbol, residue, sin
>>> x = Symbol("x")
>>> residue(1/x, x, 0)
1
>>> residue(1/x**2, x, 0)
0
>>> residue(2/sin(x), x, 0)
2 

这个函数对于余项定理[1]至关重要。

参考文献

[R836]

en.wikipedia.org/wiki/Residue_theorem

序列

原文：docs.sympy.org/latest/modules/series/sequences.html

序列是一个有限或无限的惰性评估列表。

sympy.series.sequences.sequence(seq, limits=None)

返回适当的序列对象。

解释

如果seq是 SymPy 序列，则返回SeqPer对象，否则返回SeqFormula对象。

示例

>>> from sympy import sequence
>>> from sympy.abc import n
>>> sequence(n**2, (n, 0, 5))
SeqFormula(n**2, (n, 0, 5))
>>> sequence((1, 2, 3), (n, 0, 5))
SeqPer((1, 2, 3), (n, 0, 5)) 

参见

sympy.series.sequences.SeqPer，sympy.series.sequences.SeqFormula

序列基类

class sympy.series.sequences.SeqBase(*args)

序列的基类

coeff(pt)

返回点pt处的系数

coeff_mul(other)

当other不是序列时应使用。应定义以定义自定义行为。

示例

>>> from sympy import SeqFormula
>>> from sympy.abc import n
>>> SeqFormula(n**2).coeff_mul(2)
SeqFormula(2*n**2, (n, 0, oo)) 

注意事项

‘*’仅定义序列与序列的乘法。

find_linear_recurrence(n, d=None, gfvar=None)

如果可能的话，找到满足序列前n项的序列的最短线性递归，其阶数(\leq) n/2。如果指定了d，则找到阶数(\leq) min(d, n/2)的最短线性递归。返回系数列表[b(1), b(2), ...]，对应于递归关系x(n) = b(1)*x(n-1) + b(2)*x(n-2) + ...。如果找不到递归，则返回[]。如果指定了gfvar，还返回以gfvar为变量的普通生成函数。

示例

>>> from sympy import sequence, sqrt, oo, lucas
>>> from sympy.abc import n, x, y
>>> sequence(n**2).find_linear_recurrence(10, 2)
[]
>>> sequence(n**2).find_linear_recurrence(10)
[3, -3, 1]
>>> sequence(2**n).find_linear_recurrence(10)
[2]
>>> sequence(23*n**4+91*n**2).find_linear_recurrence(10)
[5, -10, 10, -5, 1]
>>> sequence(sqrt(5)*(((1 + sqrt(5))/2)**n - (-(1 + sqrt(5))/2)**(-n))/5).find_linear_recurrence(10)
[1, 1]
>>> sequence(x+y*(-2)**(-n), (n, 0, oo)).find_linear_recurrence(30)
[1/2, 1/2]
>>> sequence(3*5**n + 12).find_linear_recurrence(20,gfvar=x)
([6, -5], 3*(5 - 21*x)/((x - 1)*(5*x - 1)))
>>> sequence(lucas(n)).find_linear_recurrence(15,gfvar=x)
([1, 1], (x - 2)/(x**2 + x - 1)) 

property free_symbols

此方法返回对象中的符号，不包括那些具有特定值的符号（即虚符号）。

示例

>>> from sympy import SeqFormula
>>> from sympy.abc import n, m
>>> SeqFormula(m*n**2, (n, 0, 5)).free_symbols
{m} 

property gen

返回序列的生成器

property interval

序列定义的区间

property length

序列的长度

property start

序列的起始点。该点包括在内。

property stop

序列的结束点。该点包括在内。

property variables

返回一个包含绑定变量的元组。

初等序列

class sympy.series.sequences.SeqFormula(formula, limits=None)

基于公式表示的序列。

基于公式生成元素的序列。

示例

>>> from sympy import SeqFormula, oo, Symbol
>>> n = Symbol('n')
>>> s = SeqFormula(n**2, (n, 0, 5))
>>> s.formula
n**2 

对特定点的值

>>> s.coeff(3)
9 

支持切片

>>> s[:]
[0, 1, 4, 9, 16, 25] 

可迭代的

>>> list(s)
[0, 1, 4, 9, 16, 25] 

序列从负无穷开始

>>> SeqFormula(n**2, (-oo, 0))[0:6]
[0, 1, 4, 9, 16, 25] 

参见

sympy.series.sequences.SeqPer

coeff_mul(coeff)

参见SeqBase.coeff_mul的文档字符串

class sympy.series.sequences.SeqPer(periodical, limits=None)

表示周期序列。

元素在给定周期后重复。

示例

>>> from sympy import SeqPer, oo
>>> from sympy.abc import k 

>>> s = SeqPer((1, 2, 3), (0, 5))
>>> s.periodical
(1, 2, 3)
>>> s.period
3 

对特定点的值

>>> s.coeff(3)
1 

支持切片

>>> s[:]
[1, 2, 3, 1, 2, 3] 

可迭代的

>>> list(s)
[1, 2, 3, 1, 2, 3] 

序列从负无穷开始

>>> SeqPer((1, 2, 3), (-oo, 0))[0:6]
[1, 2, 3, 1, 2, 3] 

周期公式

>>> SeqPer((k, k**2, k**3), (k, 0, oo))[0:6]
[0, 1, 8, 3, 16, 125] 

参见

sympy.series.sequences.SeqFormula

coeff_mul(coeff)

参见SeqBase.coeff_mul的文档字符串

单例序列

class sympy.series.sequences.EmptySequence

表示空序列。

空序列也作为单例S.EmptySequence可用。

示例

>>> from sympy import EmptySequence, SeqPer
>>> from sympy.abc import x
>>> EmptySequence
EmptySequence
>>> SeqPer((1, 2), (x, 0, 10)) + EmptySequence
SeqPer((1, 2), (x, 0, 10))
>>> SeqPer((1, 2)) * EmptySequence
EmptySequence
>>> EmptySequence.coeff_mul(-1)
EmptySequence 

coeff_mul(coeff)

参见SeqBase.coeff_mul的文档字符串

复合序列

class sympy.series.sequences.SeqAdd(*args, **kwargs)

逐项加法序列。

规则：

• 序列定义的区间是各序列相应区间的交集。

• 任何内容 + EmptySequence保持不变。

• 其他规则在序列类的 _add 方法中定义。

示例

>>> from sympy import EmptySequence, oo, SeqAdd, SeqPer, SeqFormula
>>> from sympy.abc import n
>>> SeqAdd(SeqPer((1, 2), (n, 0, oo)), EmptySequence)
SeqPer((1, 2), (n, 0, oo))
>>> SeqAdd(SeqPer((1, 2), (n, 0, 5)), SeqPer((1, 2), (n, 6, 10)))
EmptySequence
>>> SeqAdd(SeqPer((1, 2), (n, 0, oo)), SeqFormula(n**2, (n, 0, oo)))
SeqAdd(SeqFormula(n**2, (n, 0, oo)), SeqPer((1, 2), (n, 0, oo)))
>>> SeqAdd(SeqFormula(n**3), SeqFormula(n**2))
SeqFormula(n**3 + n**2, (n, 0, oo)) 

另请参见

sympy.series.sequences.SeqMul

static reduce(args)

使用已知规则简化 SeqAdd。

遍历所有对，并询问组成序列是否能通过与其他组成序列简化自己。

注意事项

改编自 Union.reduce

class sympy.series.sequences.SeqMul(*args, **kwargs)

表示序列的逐项乘法。

解释

仅处理序列的乘法。如需与其他对象相乘，请参见 SeqBase.coeff_mul()。

规则：

• 序列定义的区间是各序列相应区间的交集。

• 任何 * EmptySequence 返回 EmptySequence。

• 其他规则在序列类的 _mul 方法中定义。

示例

>>> from sympy import EmptySequence, oo, SeqMul, SeqPer, SeqFormula
>>> from sympy.abc import n
>>> SeqMul(SeqPer((1, 2), (n, 0, oo)), EmptySequence)
EmptySequence
>>> SeqMul(SeqPer((1, 2), (n, 0, 5)), SeqPer((1, 2), (n, 6, 10)))
EmptySequence
>>> SeqMul(SeqPer((1, 2), (n, 0, oo)), SeqFormula(n**2))
SeqMul(SeqFormula(n**2, (n, 0, oo)), SeqPer((1, 2), (n, 0, oo)))
>>> SeqMul(SeqFormula(n**3), SeqFormula(n**2))
SeqFormula(n**5, (n, 0, oo)) 

另请参见

sympy.series.sequences.SeqAdd

static reduce(args)

使用已知规则简化 SeqMul。

解释

遍历所有对，并询问组成序列是否能通过与其他组成序列简化自己。

注意事项

改编自 Union.reduce

递归序列

class sympy.series.sequences.RecursiveSeq(recurrence, yn, n, initial=None, start=0)

有限阶递归序列。

参数：

recurrence：定义递归的 SymPy 表达式

这 不 是一个等式，只是第 n 项等于的表达式。例如，如果 a(n) = f(a(n - 1), ..., a(n - d))，那么表达式应为 f(a(n - 1), ..., a(n - d))。

yn：应用的未定义函数

将序列的第 n 项表示为例如 y(n)，其中 y 是一个未定义的函数，( n ) 是序列的索引。

n：符号参数

递归所在的变量名称，例如，如果递归函数是 y(n)，则该变量为 n。

initial：长度与递归的次数相等的可迭代对象

递归的初始值。

start：序列的起始值（包含）

解释

即依赖于其前一个固定数量的值的序列 a(n)。其一般形式为

a(n) = f(a(n - 1), a(n - 2), …, a(n - d))

对于某个固定的正整数 d，其中 f 是由 SymPy 表达式定义的某个函数。

示例

>>> from sympy import Function, symbols
>>> from sympy.series.sequences import RecursiveSeq
>>> y = Function("y")
>>> n = symbols("n")
>>> fib = RecursiveSeq(y(n - 1) + y(n - 2), y(n), n, [0, 1]) 

>>> fib.coeff(3) # Value at a particular point
2 

>>> fib[:6] # supports slicing
[0, 1, 1, 2, 3, 5] 

>>> fib.recurrence # inspect recurrence
Eq(y(n), y(n - 2) + y(n - 1)) 

>>> fib.degree # automatically determine degree
2 

>>> for x in zip(range(10), fib): # supports iteration
...     print(x)
(0, 0)
(1, 1)
(2, 1)
(3, 2)
(4, 3)
(5, 5)
(6, 8)
(7, 13)
(8, 21)
(9, 34) 

另请参见

sympy.series.sequences.SeqFormula

property initial

序列的初始值

property interval

序列定义的区间。

property n

序列的索引符号

property recurrence

定义递归的方程。

property start

序列的起始点。包含此点

property stop

序列的结束点。（oo）

property y

序列第 n 项的未定义函数

property yn

应用的函数，表示第 n 项

Fourier 级数

原文：docs.sympy.org/latest/modules/series/fourier.html

提供计算 Fourier 级数的方法。

class sympy.series.fourier.FourierSeries(*args)

表示 Fourier 正弦/余弦级数。

Explanation

此类仅表示 Fourier 级数。不执行任何计算。

如何计算 Fourier 级数，请参见fourier_series()的文档字符串。

参见

sympy.series.fourier.fourier_series

scale(s)

通过与 x 无关的项来缩放函数。

Explanation

f(x) -> s * f(x)

如果已计算出 f(x)的 Fourier 级数，则此方法很快。

Examples

>>> from sympy import fourier_series, pi
>>> from sympy.abc import x
>>> s = fourier_series(x**2, (x, -pi, pi))
>>> s.scale(2).truncate()
-8*cos(x) + 2*cos(2*x) + 2*pi**2/3 

scalex(s)

通过与 x 无关的项来缩放 x。

Explanation

f(x) -> f(s*x)

如果已计算出 f(x)的 Fourier 级数，则此方法很快。

Examples

>>> from sympy import fourier_series, pi
>>> from sympy.abc import x
>>> s = fourier_series(x**2, (x, -pi, pi))
>>> s.scalex(2).truncate()
-4*cos(2*x) + cos(4*x) + pi**2/3 

shift(s)

将函数按独立于 x 的项移位。

Explanation

f(x) -> f(x) + s

如果已计算出 f(x)的 Fourier 级数，则此方法很快。

Examples

>>> from sympy import fourier_series, pi
>>> from sympy.abc import x
>>> s = fourier_series(x**2, (x, -pi, pi))
>>> s.shift(1).truncate()
-4*cos(x) + cos(2*x) + 1 + pi**2/3 

shiftx(s)

通过与 x 无关的项来移位 x。

Explanation

f(x) -> f(x + s)

如果已计算出 f(x)的 Fourier 级数，则此方法很快。

Examples

>>> from sympy import fourier_series, pi
>>> from sympy.abc import x
>>> s = fourier_series(x**2, (x, -pi, pi))
>>> s.shiftx(1).truncate()
-4*cos(x + 1) + cos(2*x + 2) + pi**2/3 

sigma_approximation(n=3)

返回关于阶数 n 的 Fourier 级数的(\sigma)-近似。

参数：

n : int

在近似中考虑的最高阶数。

返回：

表达式：

将函数展开为 Fourier 级数的 Sigma 近似。

Explanation

Sigma 近似调整 Fourier 求和以消除在不连续点处可能发生的吉布斯现象。对于周期为 T 的函数的 sigma-近似级数可以写成

[s(\theta) = \frac{1}{2} a_0 + \sum _{k=1}^{m-1} \operatorname{sinc} \Bigl( \frac{k}{m} \Bigr) \cdot \left[ a_k \cos \Bigl( \frac{2\pi k}{T} \theta \Bigr) + b_k \sin \Bigl( \frac{2\pi k}{T} \theta \Bigr) \right],]

其中(a_0, a_k, b_k, k=1,\ldots,{m-1})是标准 Fourier 级数系数，(\operatorname{sinc} \Bigl( \frac{k}{m} \Bigr))是以标准化的(\operatorname{sinc})函数表示的 Lanczos (\sigma)因子。

Examples

>>> from sympy import fourier_series, pi
>>> from sympy.abc import x
>>> s = fourier_series(x, (x, -pi, pi))
>>> s.sigma_approximation(4)
2*sin(x)*sinc(pi/4) - 2*sin(2*x)/pi + 2*sin(3*x)*sinc(3*pi/4)/3 

Notes

sigma_approximation()的行为与truncate()不同 - 它获取小于 n 的所有非零项，而不是前 n 个非零项。

参见

sympy.series.fourier.FourierSeries.truncate

References

[R830]

en.wikipedia.org/wiki/Gibbs_phenomenon

[R831]

en.wikipedia.org/wiki/Sigma_approximation

truncate(n=3)

返回级数的前 n 个非零项。

如果n为 None，则返回一个迭代器。

参数：

n : int 或 None

近似值的非零项数或无。

返回：

表达式或迭代器：

将函数近似展开为傅里叶级数。

示例

>>> from sympy import fourier_series, pi
>>> from sympy.abc import x
>>> s = fourier_series(x, (x, -pi, pi))
>>> s.truncate(4)
2*sin(x) - sin(2*x) + 2*sin(3*x)/3 - sin(4*x)/2 

参见

sympy.series.fourier.FourierSeries.sigma_approximation

sympy.series.fourier.fourier_series(f, limits=None, finite=True)

计算傅里叶三角级数展开。

参数：

限制：（sym，start，end），可选

sym 表示计算级数时所使用的符号。

start 和 end 表示傅里叶级数收敛到给定函数的区间的起始和结束。

默认范围指定为 (-\pi) 至 (\pi)。

返回：

傅里叶级数

表示傅里叶三角级数的符号对象。

解释

定义在区间 ((a, b)) 上的傅里叶三角级数为：

[\frac{a_0}{2} + \sum_{n=1}^{\infty} (a_n \cos(\frac{2n \pi x}{L}) + b_n \sin(\frac{2n \pi x}{L}))]

其系数为：

[L = b - a][a_0 = \frac{2}{L} \int_{a}^{b}{f(x) dx}][a_n = \frac{2}{L} \int_{a}^{b}{f(x) \cos(\frac{2n \pi x}{L}) dx}][b_n = \frac{2}{L} \int_{a}^{b}{f(x) \sin(\frac{2n \pi x}{L}) dx}]

函数 (f(x)) 是否应周期性地给出的条件超出必要，因为只需考虑系列在给定区间内收敛到 (f(x))，而不是整个实数线上。

这也为计算带来了很多便利，因为您无需通过分段、模运算来人为地使 (f(x)) 成为周期函数，而是可以在区间 ((a, b)) 中塑造函数，使其看起来像期望的周期函数，计算出的级数将自动成为 (f(x)) 周期版本的级数。

该属性在下面的示例部分有所说明。

示例

计算 (f(x) = x²) 的傅里叶级数：

>>> from sympy import fourier_series, pi
>>> from sympy.abc import x
>>> f = x**2
>>> s = fourier_series(f, (x, -pi, pi))
>>> s1 = s.truncate(n=3)
>>> s1
-4*cos(x) + cos(2*x) + pi**2/3 

傅里叶级数的移动：

>>> s.shift(1).truncate()
-4*cos(x) + cos(2*x) + 1 + pi**2/3
>>> s.shiftx(1).truncate()
-4*cos(x + 1) + cos(2*x + 2) + pi**2/3 

傅里叶级数的缩放：

>>> s.scale(2).truncate()
-8*cos(x) + 2*cos(2*x) + 2*pi**2/3
>>> s.scalex(2).truncate()
-4*cos(2*x) + cos(4*x) + pi**2/3 

计算 (f(x) = x) 的傅里叶级数：

这说明了截断到更高阶会有更好的收敛性。

>>> from sympy import fourier_series, pi, plot
>>> from sympy.abc import x
>>> f = x
>>> s = fourier_series(f, (x, -pi, pi))
>>> s1 = s.truncate(n = 3)
>>> s2 = s.truncate(n = 5)
>>> s3 = s.truncate(n = 7)
>>> p = plot(f, s1, s2, s3, (x, -pi, pi), show=False, legend=True) 

>>> p[0].line_color = (0, 0, 0)
>>> p[0].label = 'x'
>>> p[1].line_color = (0.7, 0.7, 0.7)
>>> p[1].label = 'n=3'
>>> p[2].line_color = (0.5, 0.5, 0.5)
>>> p[2].label = 'n=5'
>>> p[3].line_color = (0.3, 0.3, 0.3)
>>> p[3].label = 'n=7' 

>>> p.show() 

（png，hires.png，pdf）

这说明了当指定不同范围时，级数如何收敛到不同的锯齿波。

>>> s1 = fourier_series(x, (x, -1, 1)).truncate(10)
>>> s2 = fourier_series(x, (x, -pi, pi)).truncate(10)
>>> s3 = fourier_series(x, (x, 0, 1)).truncate(10)
>>> p = plot(x, s1, s2, s3, (x, -5, 5), show=False, legend=True) 

>>> p[0].line_color = (0, 0, 0)
>>> p[0].label = 'x'
>>> p[1].line_color = (0.7, 0.7, 0.7)
>>> p[1].label = '[-1, 1]'
>>> p[2].line_color = (0.5, 0.5, 0.5)
>>> p[2].label = '[-pi, pi]'
>>> p[3].line_color = (0.3, 0.3, 0.3)
>>> p[3].label = '[0, 1]' 

>>> p.show() 

（png，hires.png，pdf）

注释

由于计算 an、bn 所需的积分而导致傅里叶级数计算较慢。

通过在已计算的傅里叶级数上使用移位和缩放，而不是重新计算，可以更快地计算函数的傅里叶级数。

例如，如果已知x**2的傅里叶级数，则通过移位 -1 可以找到x**2 - 1的傅里叶级数。

另见

sympy.series.fourier.FourierSeries

参考资料

[R832]

mathworld.wolfram.com/FourierSeries.html

形式幂级数

原文：docs.sympy.org/latest/modules/series/formal.html

计算和操作形式幂级数的方法。

class sympy.series.formal.FormalPowerSeries(*args)

表示函数的形式幂级数。

解释

不执行计算。此类仅用于表示级数。不执行检查。

用于计算系列的 fps().

另请参见

sympy.series.formal.fps

coeff_bell(n)

self.coeff_bell(n) 返回第二类贝尔多项式的序列。请注意 n 应为整数。

第二类贝尔多项式（有时称为“部分”贝尔多项式或不完全贝尔多项式）定义为

[B_{n,k}(x_1, x_2,\dotsc x_{n-k+1}) = \sum_{j_1+j_2+j_2+\dotsb=k \atop j_1+2j_2+3j_2+\dotsb=n} \frac{n!}{j_1!j_2!\dotsb j_{n-k+1}!} \left(\frac{x_1}{1!} \right)^{j_1} \left(\frac{x_2}{2!} \right)^{j_2} \dotsb \left(\frac{x_{n-k+1}}{(n-k+1)!} \right) ^{j_{n-k+1}}.]

• bell(n, k, (x1, x2, ...)) 给出第二类贝尔多项式，(B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1})).

另请参见

sympy.functions.combinatorial.numbers.bell

compose(other, x=None, n=6)

返回组合函数的形式幂级数的截断项，最多到指定的 n。

参数:

n : 数字，可选

指定应截断多项式的项的顺序。

解释

如果 f 和 g 是两个不同函数的形式幂级数，则组合形式幂级数 fp 的系数序列 ak 如下。

[\sum\limits_{k=0}^{n} b_k B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1})]

示例

>>> from sympy import fps, sin, exp
>>> from sympy.abc import x
>>> f1 = fps(exp(x))
>>> f2 = fps(sin(x)) 

>>> f1.compose(f2, x).truncate()
1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6) 

>>> f1.compose(f2, x).truncate(8)
1 + x + x**2/2 - x**4/8 - x**5/15 - x**6/240 + x**7/90 + O(x**8) 

另请参见

sympy.functions.combinatorial.numbers.bell, sympy.series.formal.FormalPowerSeriesCompose

参考文献

[R824]

Comtet, Louis: Advanced combinatorics; the art of finite and infinite expansions. Reidel, 1974.

property infinite

返回系列的无限表示

integrate(x=None, **kwargs)

积分形式幂级数。

示例

>>> from sympy import fps, sin, integrate
>>> from sympy.abc import x
>>> f = fps(sin(x))
>>> f.integrate(x).truncate()
-1 + x**2/2 - x**4/24 + O(x**6)
>>> integrate(f, (x, 0, 1))
1 - cos(1) 

inverse(x=None, n=6)

返回形式幂级数的截断项的逆，最多到指定的 n。

参数:

n : 数字，可选

指定应截断多项式的项的顺序。

解释

如果 f 和 g 是两个不同函数的形式幂级数，则组合形式幂级数 fp 的系数序列 ak 如下。

[\sum\limits_{k=0}^{n} (-1)^{k} x_0^{-k-1} B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1})]

示例

>>> from sympy import fps, exp, cos
>>> from sympy.abc import x
>>> f1 = fps(exp(x))
>>> f2 = fps(cos(x)) 

>>> f1.inverse(x).truncate()
1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + O(x**6) 

>>> f2.inverse(x).truncate(8)
1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + O(x**8) 

另请参见

sympy.functions.combinatorial.numbers.bell, sympy.series.formal.FormalPowerSeriesInverse

参考文献

[R825]

Comtet, Louis: 高级组合数学；有限和无限展开的艺术。Reidel, 1974.

polynomial(n=6)

截断的级数作为多项式。

解释

返回 f 的级数展开，直到阶数为 O(x**n) 作为多项式（不包括 O 项）。

product(other, x=None, n=6)

两个形式幂级数相乘，使用离散卷积并返回截断的指定阶数的项。

参数：

n : 数字, 可选

指定应截断多项式的项的顺序。

示例

>>> from sympy import fps, sin, exp
>>> from sympy.abc import x
>>> f1 = fps(sin(x))
>>> f2 = fps(exp(x)) 

>>> f1.product(f2, x).truncate(4)
x + x**2 + x**3/3 + O(x**4) 

另请参见

sympy.discrete.convolutions, sympy.series.formal.FormalPowerSeriesProduct

truncate(n=6)

截断级数。

解释

返回 f 的截断级数展开，直到阶数为 O(x**n)。

如果 n 为 None，则返回一个无限迭代器。

sympy.series.formal.fps(f, x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)

生成 f 的形式幂级数。

参数：

x : 符号, 可选

如果 x 为 None 并且 f 是单变量的，则将提供单变量符号，否则将引发错误。

x0 : 数字, 可选

执行级数展开的点。默认为 0。

dir : {1, -1, ‘+’, ‘-‘}, 可选

如果 dir 为 1 或 ‘+’，则从右边计算级数；如果为 -1 或 ‘-’，则从左边计算级数。对于光滑函数，此标志不会改变结果。默认为 1。

hyper : {True, False}, 可选

将 hyper 设置为 False 以跳过超几何算法。默认设置为 False。

order : 整数, 可选

f 的导数的顺序，默认为 4。

rational : {True, False}, 可选

将 rational 设置为 False 以跳过有理算法。默认设置为 True。

full : {True, False}, 可选

将 full 设置为 True 以增加有理算法的范围。有关详细信息，请参阅 rational_algorithm()。默认设置为 False。

解释

返回关于 x = x0 的 f 的形式级数展开，关于 x 的形式为 FormalPowerSeries 对象。

形式幂级数使用使用不同算法计算的显式公式表示。

有关计算公式的详细信息，请参阅 compute_fps()。

示例

>>> from sympy import fps, ln, atan, sin
>>> from sympy.abc import x, n 

有理函数

>>> fps(ln(1 + x)).truncate()
x - x**2/2 + x**3/3 - x**4/4 + x**5/5 + O(x**6) 

>>> fps(atan(x), full=True).truncate()
x - x**3/3 + x**5/5 + O(x**6) 

符号函数

>>> fps(x**n*sin(x**2), x).truncate(8)
-x**(n + 6)/6 + x**(n + 2) + O(x**(n + 8)) 

另请参见

sympy.series.formal.FormalPowerSeries, sympy.series.formal.compute_fps

sympy.series.formal.compute_fps(f, x, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)

计算函数的形式幂级数的公式。

参数：

x：符号

x0：数值，可选

执行级数展开的点。默认为 0。

dir：{1, -1, ‘+’, ‘-‘}，可选

如果 dir 为 1 或‘+’，则从右侧计算级数；如果为-1 或‘-’，则从左侧计算级数。对于平滑函数，此标志不会改变结果。默认为 1。

hyper：{True, False}，可选

将 hyper 设置为 False 以跳过超几何算法。默认为 False。

order：整数，可选

f的导数阶数，默认为 4。

rational：{True, False}，可选

将 rational 设置为 False 以跳过有理算法。默认为 True。

full：{True, False}，可选

将 full 设置为 True 以增加有理算法的范围。详见rational_algorithm()。默认为 False。

返回：

ak：序列

系数序列。

xk：序列

x 的幂序列。

ind：表达式

独立项。

mul：Pow

常见术语。

解释

尝试应用以下技术计算公式（按顺序）：

• rational_algorithm

• 超几何算法

参见

sympy.series.formal.rational_algorithm，sympy.series.formal.hyper_algorithm

class sympy.series.formal.FormalPowerSeriesCompose(*args)

表示两个函数的组合形式幂级数。

解释

不执行计算。项按逐项逻辑计算，而不是点对点逻辑。

FormalPowerSeries对象与FormalPowerSeriesCompose对象之间有两个区别。第一个参数包含组合中涉及的外部函数和内部函数。此外，系数序列包含将与自定义bell_seq有限序列相乘的通用序列。然后将有限项相加以获得最终项。

参见

sympy.series.formal.FormalPowerSeries，sympy.series.formal.FiniteFormalPowerSeries

property function

组合形式幂级数的函数。

class sympy.series.formal.FormalPowerSeriesInverse(*args)

表示形式幂级数的逆。

解释

不执行计算。项按逐项逻辑计算，而不是点对点逻辑。

FormalPowerSeries 对象与 FormalPowerSeriesInverse 对象之间有一个区别。系数序列包含一个通用序列，将乘以一个自定义的 bell_seq 有限序列。然后将添加有限项以得到最终项。

另见

sympy.series.formal.FormalPowerSeries，sympy.series.formal.FiniteFormalPowerSeries

property function

形式幂级数的反函数。

class sympy.series.formal.FormalPowerSeriesProduct(*args)

表示两个函数的形式幂级数的乘积。

解释

不进行计算。使用逐项逻辑计算项，而不是点对点逻辑。

FormalPowerSeries 对象与 FormalPowerSeriesProduct 对象之间有两个区别。第一个参数包含参与乘积的两个函数。此外，系数序列包含涉及函数的形式幂级数的系数序列。

另见

sympy.series.formal.FormalPowerSeries，sympy.series.formal.FiniteFormalPowerSeries

property function

两个形式幂级数的乘积函数。

class sympy.series.formal.FiniteFormalPowerSeries(*args)

产品、组合和反函数的基类

有理算法

sympy.series.formal.rational_independent(terms, x)

返回所有有理独立项的列表。

示例

>>> from sympy import sin, cos
>>> from sympy.series.formal import rational_independent
>>> from sympy.abc import x 

>>> rational_independent([cos(x), sin(x)], x)
[cos(x), sin(x)]
>>> rational_independent([x**2, sin(x), x*sin(x), x**3], x)
[x**3 + x**2, x*sin(x) + sin(x)] 

sympy.series.formal.rational_algorithm(f, x, k, order=4, full=False)

计算函数形式幂级数系数的有理算法。

参数：

x：符号

order：整数，可选

函数 f 的导数阶数，默认为 4。

full：布尔值

返回：

formula：表达式

ind：表达

独立项。

order：整数

full：布尔值

解释

当 f(x) 或 f(x) 的某个导数是 x 的有理函数时适用。

rational_algorithm() 使用 apart() 函数进行部分分解。apart() 默认使用‘未定系数法’。通过设置 full=True，可以改用‘Bronstein 算法’。

寻找函数的 4 阶导数（默认）。可以使用 order 选项覆盖此行为。

示例

>>> from sympy import log, atan
>>> from sympy.series.formal import rational_algorithm as ra
>>> from sympy.abc import x, k 

>>> ra(1 / (1 - x), x, k)
(1, 0, 0)
>>> ra(log(1 + x), x, k)
(-1/((-1)**k*k), 0, 1) 

>>> ra(atan(x), x, k, full=True)
((-I/(2*(-I)**k) + I/(2*I**k))/k, 0, 1) 

注

通过设置 full=True，可以增加使用 rational_algorithm 解决的可接受函数范围。应谨慎使用此选项，因为它会显著减慢由 apart() 函数返回的 RootSum 对象上的 doit 计算。尽可能使用 full=False。

参见

sympy.polys.partfrac.apart

参考文献

[R826]

形式幂级数 - Dominik Gruntz, Wolfram Koepf

[R827]

计算代数中的幂级数 - Wolfram Koepf

超几何算法

sympy.series.formal.simpleDE(f, x, g, order=4)

生成简单的 DE。

解释

DE 的形式为

[f^k(x) + \sum\limits_{j=0}^{k-1} A_j f^j(x) = 0]

其中 (A_j) 应该是 x 的有理函数。

生成至多 4 阶（默认）的 DE。DE 也可以具有自由参数。

通过增加阶数，可以找到更高阶的 DE。

返回一个元组 (DE, order)。

sympy.series.formal.exp_re(DE, r, k)

将具有常数系数的 DE（如指数式）转换为 RE。

解释

执行替换：

[f^j(x) \to r(k + j)]

规范化术语，使得术语的最低阶始终为 r(k)。

例子

>>> from sympy import Function, Derivative
>>> from sympy.series.formal import exp_re
>>> from sympy.abc import x, k
>>> f, r = Function('f'), Function('r') 

>>> exp_re(-f(x) + Derivative(f(x)), r, k)
-r(k) + r(k + 1)
>>> exp_re(Derivative(f(x), x) + Derivative(f(x), (x, 2)), r, k)
r(k) + r(k + 1) 

参见

sympy.series.formal.hyper_re

sympy.series.formal.hyper_re(DE, r, k)

将 DE 转换为 RE。

解释

执行替换：

[x^l f^j(x) \to (k + 1 - l)j . a{k + j - l}]

规范化术语，使得术语的最低阶始终为 r(k)。

例子

>>> from sympy import Function, Derivative
>>> from sympy.series.formal import hyper_re
>>> from sympy.abc import x, k
>>> f, r = Function('f'), Function('r') 

>>> hyper_re(-f(x) + Derivative(f(x)), r, k)
(k + 1)*r(k + 1) - r(k)
>>> hyper_re(-x*f(x) + Derivative(f(x), (x, 2)), r, k)
(k + 2)*(k + 3)*r(k + 3) - r(k) 

参见

sympy.series.formal.exp_re

sympy.series.formal.rsolve_hypergeometric(f, x, P, Q, k, m)

解决超几何类型的 RE。

返回：

formula : 表达式

ind : 表达式

独立项。

order : 整数

解释

尝试解决形式为 RE 的方程

Q(k)*a(k + m) - P(k)*a(k)

保持超几何类型的变换：

1. x**n*f(x): b(k + m) = R(k - n)*b(k)
3. f(Ax): b(k + m) = A**mR(k)*b(k)
5. f(x**n): b(k + n*m) = R(k/n)*b(k)
7. f(x**(1/m)): b(k + 1) = R(k*m)*b(k)
9. f’(x): b(k + m) = ((k + m + 1)/(k + 1))*R(k + 1)*b(k)

一些这些变换已被用来解决 RE。

例子

>>> from sympy import exp, ln, S
>>> from sympy.series.formal import rsolve_hypergeometric as rh
>>> from sympy.abc import x, k 

>>> rh(exp(x), x, -S.One, (k + 1), k, 1)
(Piecewise((1/factorial(k), Eq(Mod(k, 1), 0)), (0, True)), 1, 1) 

>>> rh(ln(1 + x), x, k**2, k*(k + 1), k, 1)
(Piecewise(((-1)**(k - 1)*factorial(k - 1)/RisingFactorial(2, k - 1),
 Eq(Mod(k, 1), 0)), (0, True)), x, 2) 

参考文献

[R828]

形式幂级数 - Dominik Gruntz, Wolfram Koepf

[R829]

计算代数中的幂级数 - Wolfram Koepf

sympy.series.formal.solve_de(f, x, DE, order, g, k)

解决 DE。

返回：

formula : 表达式

ind : 表达式

独立项。

order : 整数

解释

尝试通过将其转换为包含两项的 RE 或将其转换为具有常数系数的 DE 来解决 DE。

例子

>>> from sympy import Derivative as D, Function
>>> from sympy import exp, ln
>>> from sympy.series.formal import solve_de
>>> from sympy.abc import x, k
>>> f = Function('f') 

>>> solve_de(exp(x), x, D(f(x), x) - f(x), 1, f, k)
(Piecewise((1/factorial(k), Eq(Mod(k, 1), 0)), (0, True)), 1, 1) 

>>> solve_de(ln(1 + x), x, (x + 1)*D(f(x), x, 2) + D(f(x)), 2, f, k)
(Piecewise(((-1)**(k - 1)*factorial(k - 1)/RisingFactorial(2, k - 1),
 Eq(Mod(k, 1), 0)), (0, True)), x, 2) 

sympy.series.formal.hyper_algorithm(f, x, k, order=4)

用于计算形式幂级数的超几何算法。

解释

步骤：

• 生成 DE

• 将 DE 转换为 RE

• 解决 RE

例子

>>> from sympy import exp, ln
>>> from sympy.series.formal import hyper_algorithm 

>>> from sympy.abc import x, k 

>>> hyper_algorithm(exp(x), x, k)
(Piecewise((1/factorial(k), Eq(Mod(k, 1), 0)), (0, True)), 1, 1) 

>>> hyper_algorithm(ln(1 + x), x, k)
(Piecewise(((-1)**(k - 1)*factorial(k - 1)/RisingFactorial(2, k - 1),
 Eq(Mod(k, 1), 0)), (0, True)), x, 2) 

参见

sympy.series.formal.simpleDE, sympy.series.formal.solve_de