SymPy-1-13-中文文档-六-

SymPy 1.13 中文文档（六）

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

多周期群

原文：docs.sympy.org/latest/modules/combinatorics/pc_groups.html

介绍

本模块展示了用于计算多周期群（简称 PcGroup）的功能。相应 SymPy 对象的名称为 PolycyclicGroup。这里描述的函数或类是在计算群论下研究的。

功能概述

• 从给定的置换群构造多周期群。

• 计算多周期生成序列（缩写为 pcgs）和多周期系列（pc_series）。

• 计算多周期系列的相对阶实现。

• 类 Collector 的实现，可视为多周期群的基础的实现。

• 多周期群表示（缩写为 pc_presentation）的实现。

• 对于给定的多周期群元素，计算指数向量、深度和领导指数。

对于多周期群的基本算法描述，我们经常使用计算群论手册。

多周期群的构造

给定置换群，通过计算相应的多周期生成序列、多周期系列及其相对阶构造多周期群。

多周期群的属性

• pc_sequence : 多周期序列由在给定置换群的派生系列中邻接群之间的所有缺失生成器收集形成。

• pc_series : 多周期系列由在 der[i] 中添加 der[i+1] 的所有缺失生成器形成，其中 der 表示派生系列。

• relative_order : 一个列表，由 pc_series 中相邻群的比率计算得出。

• collector : 默认情况下为 None。收集器类提供了多周期表示。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> len(PcGroup.pcgs)
4
>>> pc_series = PcGroup.pc_series
>>> pc_series[0].equals(G)  # use equals, not literal `==`
True
>>> gen = pc_series[len(pc_series) - 1].generators[0]
>>> gen.is_identity
True
>>> PcGroup.relative_order
[2, 3, 2, 2] 

构造收集器

收集器是 PolycyclicGroup 类的属性之一。

收集器的属性

收集器具有所有多周期群的属性，此外还有以下定义的几个属性：

• free_group : free_group 将多周期生成序列映射到自由群元素。

• pc_presentation : 借助幂和共轭关系器，提供了多周期群的表示。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> G = SymmetricGroup(3)
>>> PcGroup = G.polycyclic_group()
>>> Collector = PcGroup.collector
>>> Collector.free_group
<free group on the generators (x0, x1)>
>>> Collector.pc_presentation
{x0**2: (), x1**3: (), x0**-1*x1*x0: x1**2} 

计算最小未收集子词

在 pc_group 的自由群生成器上定义的一个词 V，如果 V 是 W 的子词，并且具有以下形式之一，则 V 是 W 的最小未收集子词：

• (v = {x_{i+1}}^{a_j}x_i)

• (v = {x_{i+1}}^{a_j}{x_i})

• (v = {x_i}^{a_j})

(a_j \notin {0, \ldots \mathrm{relative_order}[j]-1})。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics.free_groups import free_group
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> F, x1, x2 = free_group("x1, x2")
>>> word = x2**2*x1**7
>>> collector.minimal_uncollected_subword(word)
((x2, 2),) 

子词索引的计算

对于给定的词和它的子词，subword_index 计算词中子词的起始和结束索引。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics.free_groups import free_group
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> F, x1, x2 = free_group("x1, x2")
>>> word = x2**2*x1**7
>>> w = x2**2*x1
>>> collector.subword_index(word, w)
(0, 3)
>>> w = x1**7
>>> collector.subword_index(word, w)
(2, 9) 

收集词的计算

如果一个词W称为收集的，那么W (= {x_{i_1}}^{a_1} \ldots {x_{i_r}}^{a_r})，其中(i_1 < i_2< \ldots < i_r)且(a_j)在({1 \ldots s_{j-1}})中，其中(s_j)表示相应的相对顺序。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics.perm_groups import PermutationGroup
>>> from sympy.combinatorics.free_groups import free_group
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> F, x0, x1, x2, x3 = free_group("x0, x1, x2, x3")
>>> word = x3*x2*x1*x0
>>> collected_word = collector.collected_word(word)
>>> free_to_perm = {}
>>> free_group = collector.free_group
>>> for sym, gen in zip(free_group.symbols, collector.pcgs):
...     free_to_perm[sym] = gen
>>> G1 = PermutationGroup()
>>> for w in word:
...     sym = w[0]
...     perm = free_to_perm[sym]
...     G1 = PermutationGroup([perm] + G1.generators)
>>> G2 = PermutationGroup()
>>> for w in collected_word:
...     sym = w[0]
...     perm = free_to_perm[sym]
...     G2 = PermutationGroup([perm] + G2.generators) 

这两者不完全相同，但它们是等价的：

>>> G1 == G2
False
>>> G1.equals(G2)
True 

多项式表示的计算

表示的计算从 pcgs 和多项式序列的底部开始。存储来自 pcgs 的所有先前生成器，然后将最后一个生成器作为在列表中作为共轭器的生成器，并共轭所有先前的生成器。

要获得清晰的图像，请以 SymmetricGroup(4)的示例开始。对于 S(4)，在 pcgs 中有 4 个生成器，即([x_0, x_1, x_2, x_3])，相对顺序向量为[2, 3, 2, 2]。从该序列的底部开始，按以下顺序计算表示。

使用pcgs和pc_series[4]中仅使用([x_3])计算：

• (x_3²)

使用pcgs和pc_series[3]中仅使用([x_3])计算：

• (x_2²)

• (x_2^{-1}x_3x_2)

使用pcgs和pc_series[2]中的([x_3, x_2])计算：

• (x_1³)

• (x_1^{-1}x_3x_1)

• (x_1^{-1}x_2x_1)

使用pcgs和pc_series[1]中的([x_3, x_2, x_1])计算：

• (x_0²)

• (x_0^{-1}x_3x_0)

• (x_0^{-1}x_2x_0)

• (x_0^{-1}x_1x_0)

需要注意的是，同一组可能由于不同的派生序列而具有不同的 pcgs，导致不同的多项式表示。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics.permutations import Permutation
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> pcgs = PcGroup.pcgs
>>> len(pcgs)
4
>>> free_group = collector.free_group
>>> pc_resentation = collector.pc_presentation
>>> free_to_perm = {}
>>> for s, g in zip(free_group.symbols, pcgs):
...     free_to_perm[s] = g
>>> for k, v in pc_resentation.items():
...     k_array = k.array_form
...     if v != ():
...        v_array = v.array_form
...     lhs = Permutation()
...     for gen in k_array:
...         s = gen[0]
...         e = gen[1]
...         lhs = lhs*free_to_perm[s]**e
...     if v == ():
...         assert lhs.is_identity
...         continue
...     rhs = Permutation()
...     for gen in v_array:
...         s = gen[0]
...         e = gen[1]
...         rhs = rhs*free_to_perm[s]**e
...     assert lhs == rhs 

指数向量的计算

任何多项式群的生成器都可以借助其多项式生成序列来表示。因此，指数向量的长度等于 pcgs 的长度。

多项式群的给定生成器g可以表示为(g = x_1^{e_1} \ldots x_n^{e_n})，其中(x_i)代表多项式生成器，n是等于 pcgs 长度的自由群中生成器的数量。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics.permutations import Permutation
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> pcgs = PcGroup.pcgs
>>> collector.exponent_vector(G[0])
[1, 0, 0, 0]
>>> exp = collector.exponent_vector(G[1])
>>> g = Permutation()
>>> for i in range(len(exp)):
...     g = g*pcgs[i]**exp[i] if exp[i] else g
>>> assert g == G[1] 

多项式生成器的深度

给定多项式生成器的深度定义为指数向量中第一个非零条目的索引。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> G = SymmetricGroup(3)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> collector.depth(G[0])
2
>>> collector.depth(G[1])
1 

主导指数的计算

主导指数表示上述深度的多项式生成器的指数。

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> G = SymmetricGroup(3)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> collector.leading_exponent(G[1])
1 

参考文献

[Ho05]

Derek F. Holt，《计算群论手册》。在系列‘离散数学及其应用’中，Chapman & Hall/CRC 2005, xvi + 514 p。

函数

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

所有函数都支持以下文档化方法，从继承自sympy.core.function.Function的函数中继承。

class sympy.core.function.Function(*args)

应用数学函数的基类。

它还作为未定义函数类的构造函数。

有关如何子类化Function以及可以定义哪些方法的详细信息，请参见编写自定义函数指南。

示例

未定义函数

要创建未定义函数，请将函数名的字符串传递给Function。

>>> from sympy import Function, Symbol
>>> x = Symbol('x')
>>> f = Function('f')
>>> g = Function('g')(x)
>>> f
f
>>> f(x)
f(x)
>>> g
g(x)
>>> f(x).diff(x)
Derivative(f(x), x)
>>> g.diff(x)
Derivative(g(x), x) 

可以将假设传递给Function，方式与Symbol相同。或者，您可以使用具有函数名和假设的Symbol作为函数名，并且函数将继承与Symbol相关联的名称和假设：

>>> f_real = Function('f', real=True)
>>> f_real(x).is_real
True
>>> f_real_inherit = Function(Symbol('f', real=True))
>>> f_real_inherit(x).is_real
True 

请注意，函数的假设与调用它的变量的假设无关。如果您想要添加关系，请子类化Function并定义自定义假设处理方法。有关详细信息，请参见编写自定义函数指南中的假设部分。

自定义函数子类

编写自定义函数指南有几个完整示例，展示了如何子类化Function以创建自定义函数。

as_base_exp()

返回方法作为二元组（底数，指数）。

fdiff(argindex=1)

返回函数的第一阶导数。

classmethod is_singular(a)

检测参数是本质奇点还是分支点，或者函数是非全纯的。

目录

• 初等函数

• 组合数学

• 枚举

• 特殊函数

基本

原文：docs.sympy.org/latest/modules/functions/elementary.html

该模块实现了如三角函数、双曲函数、平方根等基本函数，以及诸如Abs、Max、Min等函数。

复数函数

class sympy.functions.elementary.complexes.re(arg)

返回表达式的实部。此函数仅执行基本分析，因此无法正确分解更复杂的表达式。如果需要完全简化的结果，则使用Basic.as_real_imag()或在此函数实例上执行复杂展开。

参数：

arg : 表达式

实数或复数表达式。

返回：

expr : 表达式

表达式的实部。

示例

>>> from sympy import re, im, I, E, symbols
>>> x, y = symbols('x y', real=True)
>>> re(2*E)
2*E
>>> re(2*I + 17)
17
>>> re(2*I)
0
>>> re(im(x) + x*I + 2)
2
>>> re(5 + I + 2)
7 

另见

im

as_real_imag(deep=True, **hints)

返回具有零虚部的实数。

class sympy.functions.elementary.complexes.im(arg)

返回表达式的虚部。此函数仅执行基本分析，因此无法正确分解更复杂的表达式。如果需要完全简化的结果，则使用Basic.as_real_imag()或在此函数实例上执行复杂展开。

参数：

arg : 表达式

实数或复数表达式。

返回：

expr : 表达式

表达式的虚部。

示例

>>> from sympy import re, im, E, I
>>> from sympy.abc import x, y
>>> im(2*E)
0
>>> im(2*I + 17)
2
>>> im(x*I)
re(x)
>>> im(re(x) + y)
im(y)
>>> im(2 + 3*I)
3 

另见

re

as_real_imag(deep=True, **hints)

返回具有零实部的虚部。

class sympy.functions.elementary.complexes.sign(arg)

返回表达式的复数符号：

参数：

arg : 表达式

实数或虚数表达式。

返回：

expr : 表达式

表达式的复数符号。

解释

如果表达式为实数，则符号将为：

• 如果表达式为正则返回(1)。
• 如果表达式等于零则返回(0)。
• 如果表达式为负则返回(-1)。

如果表达式为虚数，则符号将为：

• 如果 im(expression)为正则返回(I)。
• 如果 im(expression)为负则返回(-I)。

否则将返回未评估的表达式。一般情况下，当评估时，结果将是cos(arg(expr)) + I*sin(arg(expr))。

示例

>>> from sympy import sign, I 

>>> sign(-1)
-1
>>> sign(0)
0
>>> sign(-3*I)
-I
>>> sign(1 + I)
sign(1 + I)
>>> _.evalf()
0.707106781186548 + 0.707106781186548*I 

另见

Abs, conjugate

class sympy.functions.elementary.complexes.Abs(arg)

返回参数的绝对值。

参数：

arg : 表达式

实数或复数表达式。

返回：

expr : 表达式

返回的绝对值可以是表达式或整数，取决于输入参数。

解释

这是内置函数abs()的扩展，接受符号值。如果将 SymPy 表达式传递给内置的abs()，它将自动传递给Abs()。

示例

>>> from sympy import Abs, Symbol, S, I
>>> Abs(-1)
1
>>> x = Symbol('x', real=True)
>>> Abs(-x)
Abs(x)
>>> Abs(x**2)
x**2
>>> abs(-x) # The Python built-in
Abs(x)
>>> Abs(3*x + 2*I)
sqrt(9*x**2 + 4)
>>> Abs(8*I)
8 

注意 Python 内置函数将根据参数返回 Expr 或 int：

>>> type(abs(-1))
<... 'int'>
>>> type(abs(S.NegativeOne))
<class 'sympy.core.numbers.One'> 

Abs 将始终返回一个 SymPy 对象。

另见

sign, conjugate

fdiff(argindex=1)

获取参数对 Abs()的第一阶导数。

class sympy.functions.elementary.complexes.arg(arg)

返回复数的参数（弧度）。参数按照atan2的一致约定进行评估，其中分支切割沿负实轴进行，arg(z)在区间((-\pi,\pi])内。对于正数，参数始终为 0；负数的参数为(\pi)；0 的参数未定义且返回nan。因此，arg函数永远不会嵌套超过 3 层，因为在第 4 次应用时，结果必须为 nan；对于实数，在第 3 次应用时返回 nan。

参数：

arg：Expr

实数或复数表达式。

返回：

value：Expr

返回以弧度测量的 arg 的反正切。

示例

>>> from sympy import arg, I, sqrt, Dummy
>>> from sympy.abc import x
>>> arg(2.0)
0
>>> arg(I)
pi/2
>>> arg(sqrt(2) + I*sqrt(2))
pi/4
>>> arg(sqrt(3)/2 + I/2)
pi/6
>>> arg(4 + 3*I)
atan(3/4)
>>> arg(0.8 + 0.6*I)
0.643501108793284
>>> arg(arg(arg(arg(x))))
nan
>>> real = Dummy(real=True)
>>> arg(arg(arg(real)))
nan 

class sympy.functions.elementary.complexes.conjugate(arg)

返回复共轭[R276]的参数。在数学中，复数的复共轭是通过改变虚部的符号得到的。

因此，复数(a + ib)（其中(a)和(b)为实数）的共轭是(a - ib)

参数：

arg：Expr

实数或复数表达式。

返回：

arg：Expr

arg 的复共轭作为实数、虚数或混合表达式。

示例

>>> from sympy import conjugate, I
>>> conjugate(2)
2
>>> conjugate(I)
-I
>>> conjugate(3 + 2*I)
3 - 2*I
>>> conjugate(5 - I)
5 + I 

另见

sign, Abs

参考文献

[R276] (1,2)

en.wikipedia.org/wiki/Complex_conjugation

class sympy.functions.elementary.complexes.polar_lift(arg)

将参数提升到对数的黎曼面，使用标准分支。

参数：

arg：Expr

实数或复数表达式。

示例

>>> from sympy import Symbol, polar_lift, I
>>> p = Symbol('p', polar=True)
>>> x = Symbol('x')
>>> polar_lift(4)
4*exp_polar(0)
>>> polar_lift(-4)
4*exp_polar(I*pi)
>>> polar_lift(-I)
exp_polar(-I*pi/2)
>>> polar_lift(I + 2)
polar_lift(2 + I) 

>>> polar_lift(4*x)
4*polar_lift(x)
>>> polar_lift(4*p)
4*p 

另见

sympy.functions.elementary.exponential.exp_polar, periodic_argument

class sympy.functions.elementary.complexes.periodic_argument(ar, period)

表示在对数的黎曼面的商上的参数。也就是说，给定一个周期(P)，始终返回((-P/2, P/2])内的值，通过使用(\exp(PI) = 1)。

参数：

ar：Expr

极坐标数。

period：Expr

周期(P)。

示例

>>> from sympy import exp_polar, periodic_argument
>>> from sympy import I, pi
>>> periodic_argument(exp_polar(10*I*pi), 2*pi)
0
>>> periodic_argument(exp_polar(5*I*pi), 4*pi)
pi
>>> from sympy import exp_polar, periodic_argument
>>> from sympy import I, pi
>>> periodic_argument(exp_polar(5*I*pi), 2*pi)
pi
>>> periodic_argument(exp_polar(5*I*pi), 3*pi)
-pi
>>> periodic_argument(exp_polar(5*I*pi), pi)
0 

另见

sympy.functions.elementary.exponential.exp_polar

polar_lift

将参数提升到对数的黎曼面

principal_branch

class sympy.functions.elementary.complexes.principal_branch(x, period)

表示在对数的黎曼面的商上的主分支的极坐标数。

参数：

x：Expr

极坐标数。

period：Expr

正实数或无穷大。

解释

这是一个两个参数的函数。第一个参数是极坐标数 (z)，第二个是正实数或无穷大，(p)。结果是 z mod exp_polar(I*p)。

示例

>>> from sympy import exp_polar, principal_branch, oo, I, pi
>>> from sympy.abc import z
>>> principal_branch(z, oo)
z
>>> principal_branch(exp_polar(2*pi*I)*3, 2*pi)
3*exp_polar(0)
>>> principal_branch(exp_polar(2*pi*I)*3*z, 2*pi)
3*principal_branch(z, 2*pi) 

另请参阅

sympy.functions.elementary.exponential.exp_polar

polar_lift

将参数提升到对数的黎曼曲面

periodic_argument

三角的

三角函数

class sympy.functions.elementary.trigonometric.sin(arg)

正弦函数。

返回以弧度测量的 x 的正弦值。

解释

当 (x/\pi) 是某个有理数时，此函数将自动评估 [R280]。例如，如果 (x) 是 (\pi) 的倍数，(\pi/2)，(\pi/3)，(\pi/4) 和 (\pi/6)。

示例

>>> from sympy import sin, pi
>>> from sympy.abc import x
>>> sin(x**2).diff(x)
2*x*cos(x**2)
>>> sin(1).diff(x)
0
>>> sin(pi)
0
>>> sin(pi/2)
1
>>> sin(pi/6)
1/2
>>> sin(pi/12)
-sqrt(2)/4 + sqrt(6)/4 

另请参阅

csc, cos, sec, tan, cot, asin, acsc, acos, asec, atan, acot, atan2

参考

[R277]

en.wikipedia.org/wiki/Trigonometric_functions

[R278]

dlmf.nist.gov/4.14

[R279]

functions.wolfram.com/ElementaryFunctions/Sin

[R280] (1,2)

mathworld.wolfram.com/TrigonometryAngles.html

class sympy.functions.elementary.trigonometric.cos(arg)

余弦函数。

返回以弧度测量的 x 的余弦值。

解释

有关自动评估的说明，请参见 sin()。

示例

>>> from sympy import cos, pi
>>> from sympy.abc import x
>>> cos(x**2).diff(x)
-2*x*sin(x**2)
>>> cos(1).diff(x)
0
>>> cos(pi)
-1
>>> cos(pi/2)
0
>>> cos(2*pi/3)
-1/2
>>> cos(pi/12)
sqrt(2)/4 + sqrt(6)/4 

另请参阅

sin, csc, sec, tan, cot, asin, acsc, acos, asec, atan, acot, atan2

参考

[R281]

en.wikipedia.org/wiki/Trigonometric_functions

[R282]

dlmf.nist.gov/4.14

[R283]

functions.wolfram.com/ElementaryFunctions/Cos

class sympy.functions.elementary.trigonometric.tan(arg)

正切函数。

返回 x 的正切值（以弧度为单位）。

解释

有关自动评估的说明，请参见 sin。

示例

>>> from sympy import tan, pi
>>> from sympy.abc import x
>>> tan(x**2).diff(x)
2*x*(tan(x**2)**2 + 1)
>>> tan(1).diff(x)
0
>>> tan(pi/8).expand()
-1 + sqrt(2) 

另请参见

sin, csc, cos, sec, cot, asin, acsc, acos, asec, atan, acot, atan2

参考文献

[R284]

en.wikipedia.org/wiki/Trigonometric_functions

[R285]

dlmf.nist.gov/4.14

[R286]

functions.wolfram.com/ElementaryFunctions/Tan

inverse(argindex=1)

返回此函数的倒数。

class sympy.functions.elementary.trigonometric.cot(arg)

余切函数。

返回 x 的余切（以弧度表示）。

解释

参见sin以获取有关自动评估的说明。

示例

>>> from sympy import cot, pi
>>> from sympy.abc import x
>>> cot(x**2).diff(x)
2*x*(-cot(x**2)**2 - 1)
>>> cot(1).diff(x)
0
>>> cot(pi/12)
sqrt(3) + 2 

另请参阅

sin，csc，cos，sec，tan，asin，acsc，acos，asec，atan，acot，atan2

参考资料

[R287]

en.wikipedia.org/wiki/Trigonometric_functions

[R288]

dlmf.nist.gov/4.14

[R289]

functions.wolfram.com/ElementaryFunctions/Cot

inverse(argindex=1)

返回此函数的倒数。

class sympy.functions.elementary.trigonometric.sec(arg)

正割函数。

返回 x 的正割（以弧度表示）。

解释

有关自动评估的说明，请参阅sin。

示例

>>> from sympy import sec
>>> from sympy.abc import x
>>> sec(x**2).diff(x)
2*x*tan(x**2)*sec(x**2)
>>> sec(1).diff(x)
0 

另见

sin，csc，cos，tan，cot，asin，acsc，acos，asec，atan，acot，atan2

参考文献

[R290]

en.wikipedia.org/wiki/Trigonometric_functions

[R291]

dlmf.nist.gov/4.14

[R292]

functions.wolfram.com/ElementaryFunctions/Sec

class sympy.functions.elementary.trigonometric.csc(arg)

余割函数。

返回 x 的余割（以弧度表示）。

解释

有关自动评估的注释，请参见 sin()。

示例

>>> from sympy import csc
>>> from sympy.abc import x
>>> csc(x**2).diff(x)
-2*x*cot(x**2)*csc(x**2)
>>> csc(1).diff(x)
0 

另请参见

sin, cos, sec, tan, cot, asin, acsc, acos, asec, atan, acot, atan2

参考文献

[R293]

en.wikipedia.org/wiki/Trigonometric_functions

[R294]

dlmf.nist.gov/4.14

[R295]

functions.wolfram.com/ElementaryFunctions/Csc

class sympy.functions.elementary.trigonometric.sinc(arg)

表示未归一化的 sinc 函数：

[\begin{split}\operatorname{sinc}(x) = \begin{cases} \frac{\sin x}{x} & \qquad x \neq 0 \ 1 & \qquad x = 0 \end{cases}\end{split}]

例子

>>> from sympy import sinc, oo, jn
>>> from sympy.abc import x
>>> sinc(x)
sinc(x) 

• 自动评估

>>> sinc(0)
1
>>> sinc(oo)
0 

• 差分

>>> sinc(x).diff()
cos(x)/x - sin(x)/x**2 

• 级数展开

>>> sinc(x).series()
1 - x**2/6 + x**4/120 + O(x**6) 

• 作为零阶球形贝塞尔函数

>>> sinc(x).rewrite(jn)
jn(0, x) 

另请参阅

sin

参考文献

[R296]

en.wikipedia.org/wiki/Sinc_function

三角反函数

class sympy.functions.elementary.trigonometric.asin(arg)

反正弦函数。

返回 x 的反正弦值（弧度）。

解释

asin(x) 将在 (x \in {\infty, -\infty, 0, 1, -1}) 和某些结果为 (\pi) 的有理倍数的情况下自动评估（参见 eval 类方法）。

纯虚数参数将导致 asinh 表达式。

例子

>>> from sympy import asin, oo
>>> asin(1)
pi/2
>>> asin(-1)
-pi/2
>>> asin(-oo)
oo*I
>>> asin(oo)
-oo*I 

另请参阅

sin, csc, cos, sec, tan, cot, acsc, acos, asec, atan, acot, atan2

参考文献

[R297]

反三角函数

[R298]

NIST 4.23

[R299]

ArcSin 函数

inverse(argindex=1)

返回该函数的反函数。

class sympy.functions.elementary.trigonometric.acos(arg)

反余弦函数。

解释

返回 x 的反余弦（以弧度表示）。

acos(x) 在 (x \in {\infty, -\infty, 0, 1, -1}) 的情况下会自动计算，并且在结果为 (\pi) 的有理倍数时也会计算（参见 eval 类方法）。

acos(zoo) 会计算为 zoo（参见 sympy.functions.elementary.trigonometric.asec 的注释）。

纯虚参数将被重写为 asinh。

示例

>>> from sympy import acos, oo
>>> acos(1)
0
>>> acos(0)
pi/2
>>> acos(oo)
oo*I 

另见

sin, csc, cos, sec, tan, cot, asin, acsc, asec, atan, acot, atan2

参考资料

[R300]

反三角函数

[R301]

dlmf.nist.gov/4.23

[R302]

functions.wolfram.com/ElementaryFunctions/ArcCos

inverse(argindex=1)

返回该函数的倒数。

class sympy.functions.elementary.trigonometric.atan(arg)

反正切函数。

返回 x 的反正切（单位为弧度）。

解释

atan(x) 将自动计算在情况 (x \in {\infty, -\infty, 0, 1, -1}) 及某些结果为 (\pi) 的有理倍数时（见 eval 类方法）。

示例

>>> from sympy import atan, oo
>>> atan(0)
0
>>> atan(1)
pi/4
>>> atan(oo)
pi/2 

参见

sin, csc, cos, sec, tan, cot, asin, acsc, acos, asec, acot, atan2

参考文献

[R303]

en.wikipedia.org/wiki/Inverse_trigonometric_functions

[R304]

dlmf.nist.gov/4.23

[R305]

functions.wolfram.com/ElementaryFunctions/ArcTan

inverse(argindex=1)

返回此函数的反函数。

class sympy.functions.elementary.trigonometric.acot(arg)

反余切函数。

返回 x 的反余切（以弧度表示）。

解释

acot(x) 将在 (x \in {\infty, -\infty, \tilde{\infty}, 0, 1, -1}) 的情况下自动评估，并在结果为 (\pi) 的有理倍数之一时进行一些实例（参见 eval 类方法）。

纯虚数参数将导致 acoth 表达式。

acot(x)在 ((-i, i)) 范围内有一个分支切，因此在 0 处不连续。其在实数 (x) 范围内的取值是 ((-\frac{\pi}{2}, \frac{\pi}{2}])。

示例

>>> from sympy import acot, sqrt
>>> acot(0)
pi/2
>>> acot(1)
pi/4
>>> acot(sqrt(3) - 2)
-5*pi/12 

另请参阅

sin, csc, cos, sec, tan, cot, asin, acsc, acos, asec, atan, atan2

参考

[R306]

dlmf.nist.gov/4.23

[R307]

functions.wolfram.com/ElementaryFunctions/ArcCot

inverse(argindex=1)

返回这个函数的反函数。

class sympy.functions.elementary.trigonometric.asec(arg)

反余割函数。

返回 x 的反余割（弧秒，以弧度表示）。

说明

asec(x) 在情况 (x \in {\infty, -\infty, 0, 1, -1}) 时会自动评估，并且在结果是 (\pi) 的有理倍数时（见 eval 类方法）。

asec(x) 在区间 ([-1, 1]) 内有分支切割。对于复数参数，可以定义为 [R311]：

[\operatorname{sec^{-1}}(z) = -i\frac{\log\left(\sqrt{1 - z²} + 1\right)}{z}]

当 x = 0 时，对于正分支切割，极限评估为 zoo。对于负分支切割，极限

[\lim_{z \to 0}-i\frac{\log\left(-\sqrt{1 - z²} + 1\right)}{z}]

简化为 (-i\log\left(z/2 + O\left(z³\right)\right))，最终评估为 zoo。

由于 acos(x) = asec(1/x)，对于 acos(x) 可以给出类似的论证。

例子

>>> from sympy import asec, oo
>>> asec(1)
0
>>> asec(-1)
pi
>>> asec(0)
zoo
>>> asec(-oo)
pi/2 

另见

sin, csc, cos, sec, tan, cot, asin, acsc, acos, atan, acot, atan2

参考

[R308]

en.wikipedia.org/wiki/Inverse_trigonometric_functions

[R309]

dlmf.nist.gov/4.23

[R310]

functions.wolfram.com/ElementaryFunctions/ArcSec

[R311] (1,2)

reference.wolfram.com/language/ref/ArcSec.html

inverse(argindex=1)

返回此函数的反函数。

class sympy.functions.elementary.trigonometric.acsc(arg)

反三角函数。

返回 x 的反余割（以弧度表示）。

解释

acsc(x) 在情况(x \in {\infty, -\infty, 0, 1, -1})时将自动评估，并且在结果是(π)的有理倍数的一些情况下（见eval类方法）。

示例

>>> from sympy import acsc, oo
>>> acsc(1)
pi/2
>>> acsc(-1)
-pi/2
>>> acsc(oo)
0
>>> acsc(-oo) == acsc(oo)
True
>>> acsc(0)
zoo 

参见

sin, csc, cos, sec, tan, cot, asin, acos, asec, atan, acot, atan2

参考文献

[R312]

en.wikipedia.org/wiki/Inverse_trigonometric_functions

[R313]

dlmf.nist.gov/4.23

[R314]

functions.wolfram.com/ElementaryFunctions/ArcCsc

inverse(argindex=1)

返回此函数的反函数。

class sympy.functions.elementary.trigonometric.atan2(y, x)

函数atan2(y, x)计算(\operatorname{atan}(y/x))，并接受两个参数(y)和(x)。考虑(y)和(x)的符号以确定(\operatorname{atan}(y/x))的适当象限。其范围为((-\pi, \pi])。完整的定义如下：

[\begin{split}\operatorname{atan2}(y, x) = \begin{cases} \arctan\left(\frac y x\right) & \qquad x > 0 \ \arctan\left(\frac y x\right) + \pi& \qquad y \ge 0, x < 0 \ \arctan\left(\frac y x\right) - \pi& \qquad y < 0, x < 0 \ +\frac{\pi}{2} & \qquad y > 0, x = 0 \ -\frac{\pi}{2} & \qquad y < 0, x = 0 \ \text{undefined} & \qquad y = 0, x = 0 \end{cases}\end{split}]

注意：注意到两个参数的角色互换。(y)-坐标是第一个参数，(x)-坐标是第二个参数。

如果(x)或(y)是复数：

[\operatorname{atan2}(y, x) = -i\log\left(\frac{x + iy}{\sqrt{x² + y²}}\right)]

例子

逆时针绕原点我们找到以下角度：

>>> from sympy import atan2
>>> atan2(0, 1)
0
>>> atan2(1, 1)
pi/4
>>> atan2(1, 0)
pi/2
>>> atan2(1, -1)
3*pi/4
>>> atan2(0, -1)
pi
>>> atan2(-1, -1)
-3*pi/4
>>> atan2(-1, 0)
-pi/2
>>> atan2(-1, 1)
-pi/4 

这些都是正确的。将其与普通的(\operatorname{atan})函数在点((x, y) = (-1, 1))处的结果进行比较

>>> from sympy import atan, S
>>> atan(S(1)/-1)
-pi/4
>>> atan2(1, -1)
3*pi/4 

只有(\operatorname{atan2})函数返回我们期望的值。我们可以对两个参数分别求导：

>>> from sympy import diff
>>> from sympy.abc import x, y
>>> diff(atan2(y, x), x)
-y/(x**2 + y**2) 

>>> diff(atan2(y, x), y)
x/(x**2 + y**2) 

我们可以用复对数表示 (\operatorname{atan2}) 函数：

>>> from sympy import log
>>> atan2(y, x).rewrite(log)
-I*log((x + I*y)/sqrt(x**2 + y**2)) 

并且用 (\operatorname{atan}) 表示：

>>> from sympy import atan
>>> atan2(y, x).rewrite(atan)
Piecewise((2*atan(y/(x + sqrt(x**2 + y**2))), Ne(y, 0)), (pi, re(x) < 0), (0, Ne(x, 0)), (nan, True)) 

但请注意，此形式在负实轴上是未定义的。

参见

sin, csc, cos, sec, tan, cot, asin, acsc, acos, asec, atan, acot

参考

[R315]

en.wikipedia.org/wiki/Inverse_trigonometric_functions

[R316]

en.wikipedia.org/wiki/Atan2

[R317]

functions.wolfram.com/ElementaryFunctions/ArcTan2

双曲线

双曲函数

class sympy.functions.elementary.hyperbolic.HyperbolicFunction(*args)

双曲函数的基类。

参见

sinh, cosh, tanh, coth

class sympy.functions.elementary.hyperbolic.sinh(arg)

sinh(x) 是 x 的双曲正弦。

双曲正弦函数是 (\frac{e^x - e^{-x}}{2})。

例子

>>> from sympy import sinh
>>> from sympy.abc import x
>>> sinh(x)
sinh(x) 

参见

cosh, tanh, asinh

as_real_imag(deep=True, **hints)

返回此函数的复坐标。

fdiff(argindex=1)

返回此函数的一阶导数。

inverse(argindex=1)

返回此函数的反函数。

static taylor_term(n, x, *previous_terms)

返回泰勒级数展开中的下一个项。

class sympy.functions.elementary.hyperbolic.cosh(arg)

cosh(x) 是 x 的双曲余弦。

双曲余弦函数为 (\frac{e^x + e^{-x}}{2}).

示例

>>> from sympy import cosh
>>> from sympy.abc import x
>>> cosh(x)
cosh(x) 

参见

sinh, tanh, acosh

class sympy.functions.elementary.hyperbolic.tanh(arg)

tanh(x) 是 x 的双曲正切。

双曲正切函数为 (\frac{\sinh(x)}{\cosh(x)}).

示例

>>> from sympy import tanh
>>> from sympy.abc import x
>>> tanh(x)
tanh(x) 

参见

sinh, cosh, atanh

inverse(argindex=1)

返回此函数的反函数。

class sympy.functions.elementary.hyperbolic.coth(arg)

coth(x) 是 x 的双曲余切。

双曲余切函数为 (\frac{\cosh(x)}{\sinh(x)}).

示例

>>> from sympy import coth
>>> from sympy.abc import x
>>> coth(x)
coth(x) 

参见

sinh, cosh, acoth

inverse(argindex=1)

返回此函数的反函数。

class sympy.functions.elementary.hyperbolic.sech(arg)

sech(x) 是 x 的双曲正切。

双曲正切函数为 (\frac{2}{e^x + e^{-x}})

示例

>>> from sympy import sech
>>> from sympy.abc import x
>>> sech(x)
sech(x) 

参见

sinh, cosh, tanh, coth, csch, asinh, acosh

class sympy.functions.elementary.hyperbolic.csch(arg)

csch(x) 是 x 的双曲余切。

双曲余切函数为 (\frac{2}{e^x - e^{-x}})

示例

>>> from sympy import csch
>>> from sympy.abc import x
>>> csch(x)
csch(x) 

参见

sinh, cosh, tanh, sech, asinh, acosh

fdiff(argindex=1)

返回此函数的一阶导数

static taylor_term(n, x, *previous_terms)

返回泰勒级数展开的下一项

双曲反函数

class sympy.functions.elementary.hyperbolic.asinh(arg)

asinh(x) 是 x 的反双曲 sine 函数。

反双曲正弦函数。

例子

>>> from sympy import asinh
>>> from sympy.abc import x
>>> asinh(x).diff(x)
1/sqrt(x**2 + 1)
>>> asinh(1)
log(1 + sqrt(2)) 

参见

acosh, atanh, sinh

inverse(argindex=1)

返回该函数的反函数。

class sympy.functions.elementary.hyperbolic.acosh(arg)

acosh(x) 是 x 的反双曲 cosine 函数。

反双曲余弦函数。

例子

>>> from sympy import acosh
>>> from sympy.abc import x
>>> acosh(x).diff(x)
1/(sqrt(x - 1)*sqrt(x + 1))
>>> acosh(1)
0 

参见

asinh, atanh, cosh

inverse(argindex=1)

返回该函数的反函数。

class sympy.functions.elementary.hyperbolic.atanh(arg)

atanh(x) 是 x 的反双曲 tangent 函数。

反双曲正切函数。

例子

>>> from sympy import atanh
>>> from sympy.abc import x
>>> atanh(x).diff(x)
1/(1 - x**2) 

参见

asinh, acosh, tanh

inverse(argindex=1)

返回该函数的反函数。

class sympy.functions.elementary.hyperbolic.acoth(arg)

acoth(x) 是 x 的反双曲 cotangent 函数。

反双曲 cotangent 函数。

例子

>>> from sympy import acoth
>>> from sympy.abc import x
>>> acoth(x).diff(x)
1/(1 - x**2) 

参见

asinh, acosh, coth

inverse(argindex=1)

返回该函数的反函数。

class sympy.functions.elementary.hyperbolic.asech(arg)

asech(x) 是 x 的反双曲 secant 函数。

反双曲 secant 函数。

例子

>>> from sympy import asech, sqrt, S
>>> from sympy.abc import x
>>> asech(x).diff(x)
-1/(x*sqrt(1 - x**2))
>>> asech(1).diff(x)
0
>>> asech(1)
0
>>> asech(S(2))
I*pi/3
>>> asech(-sqrt(2))
3*I*pi/4
>>> asech((sqrt(6) - sqrt(2)))
I*pi/12 

参见

asinh, atanh, cosh, acoth

参考资料

[R318]

en.wikipedia.org/wiki/Hyperbolic_function

[R319]

dlmf.nist.gov/4.37

[R320]

functions.wolfram.com/ElementaryFunctions/ArcSech/

inverse(argindex=1)

返回该函数的反函数。

class sympy.functions.elementary.hyperbolic.acsch(arg)

acsch(x) 是 x 的反双曲 cosecant 函数。

反双曲 cosecant 函数。

例子

>>> from sympy import acsch, sqrt, I
>>> from sympy.abc import x
>>> acsch(x).diff(x)
-1/(x**2*sqrt(1 + x**(-2)))
>>> acsch(1).diff(x)
0
>>> acsch(1)
log(1 + sqrt(2))
>>> acsch(I)
-I*pi/2
>>> acsch(-2*I)
I*pi/6
>>> acsch(I*(sqrt(6) - sqrt(2)))
-5*I*pi/12 

参见

asinh

参考资料

[R321]

en.wikipedia.org/wiki/Hyperbolic_function

[R322]

dlmf.nist.gov/4.37

[R323]

functions.wolfram.com/ElementaryFunctions/ArcCsch/

inverse(argindex=1)

返回此函数的倒数。

整数函数

class sympy.functions.elementary.integers.ceiling(arg)

Ceiling 是一个一元函数，返回不小于其参数的最小整数值。此实现通过分别取实部和虚部的 ceiling 泛化到复数。

示例

>>> from sympy import ceiling, E, I, S, Float, Rational
>>> ceiling(17)
17
>>> ceiling(Rational(23, 10))
3
>>> ceiling(2*E)
6
>>> ceiling(-Float(0.567))
0
>>> ceiling(I/2)
I
>>> ceiling(S(5)/2 + 5*I/2)
3 + 3*I 

另请参阅

sympy.functions.elementary.integers.floor

参考文献

[R324]

“具体数学”由 Graham，第 87 页

[R325]

mathworld.wolfram.com/CeilingFunction.html

class sympy.functions.elementary.integers.floor(arg)

Floor 是一个一元函数，返回不大于其参数的最大整数值。此实现通过分别取实部和虚部的 floor 泛化到复数。

示例

>>> from sympy import floor, E, I, S, Float, Rational
>>> floor(17)
17
>>> floor(Rational(23, 10))
2
>>> floor(2*E)
5
>>> floor(-Float(0.567))
-1
>>> floor(-I/2)
-I
>>> floor(S(5)/2 + 5*I/2)
2 + 2*I 

另请参阅

sympy.functions.elementary.integers.ceiling

参考文献

[R326]

“具体数学”由 Graham，第 87 页

[R327]

mathworld.wolfram.com/FloorFunction.html

class sympy.functions.elementary.integers.RoundFunction(arg)

用于舍入函数的抽象基类。

class sympy.functions.elementary.integers.frac(arg)

表示 x 的分数部分

对于实数，其定义如 [R328]

[x - \left\lfloor{x}\right\rfloor]

示例

>>> from sympy import Symbol, frac, Rational, floor, I
>>> frac(Rational(4, 3))
1/3
>>> frac(-Rational(4, 3))
2/3 

整数参数返回零

>>> n = Symbol('n', integer=True)
>>> frac(n)
0 

重写为 floor

>>> x = Symbol('x')
>>> frac(x).rewrite(floor)
x - floor(x) 

适用于复数参数

>>> r = Symbol('r', real=True)
>>> t = Symbol('t', real=True)
>>> frac(t + I*r)
I*frac(r) + frac(t) 

另请参阅

sympy.functions.elementary.integers.floor, sympy.functions.elementary.integers.ceiling

参考文献

[R328] (1,2)

en.wikipedia.org/wiki/Fractional_part

[R329]

mathworld.wolfram.com/FractionalPart.html

指数

class sympy.functions.elementary.exponential.exp(arg)

指数函数，(e^x)。

参数：

arg : 表达式

示例

>>> from sympy import exp, I, pi
>>> from sympy.abc import x
>>> exp(x)
exp(x)
>>> exp(x).diff(x)
exp(x)
>>> exp(I*pi)
-1 

另请参阅

log

as_real_imag(deep=True, **hints)

返回此函数作为表示复数的二元组。

示例

>>> from sympy import exp, I
>>> from sympy.abc import x
>>> exp(x).as_real_imag()
(exp(re(x))*cos(im(x)), exp(re(x))*sin(im(x)))
>>> exp(1).as_real_imag()
(E, 0)
>>> exp(I).as_real_imag()
(cos(1), sin(1))
>>> exp(1+I).as_real_imag()
(E*cos(1), E*sin(1)) 

另请参阅

sympy.functions.elementary.complexes.re, sympy.functions.elementary.complexes.im

property base

返回指数函数的底数。

fdiff(argindex=1)

返回此函数的第一阶导数。

static taylor_term(n, x, *previous_terms)

计算泰勒级数展开的下一个项。

class sympy.functions.elementary.exponential.LambertW(x, k=None)

Lambert W 函数 (W(z)) 定义为 (w \exp(w)) 的反函数 [R330]。

解释

换句话说，(W(z)) 的值使得对于任意复数 (z) 都有 (z = W(z) \exp(W(z)))。Lambert W 函数是一个多值函数，有无穷多个分支 (W_k(z))，其中 (k \in \mathbb{Z})。每个分支给出方程 (z = w \exp(w)) 的不同解 (w)。

Lambert W 函数有两个部分实数分支：主分支 ((k = 0)) 在实数 (z > -1/e) 时为实数，(k = -1) 分支在 (-1/e < z < 0) 时为实数。除了 (k = 0) 外，所有分支在 (z = 0) 处有对数奇异性。

示例

>>> from sympy import LambertW
>>> LambertW(1.2)
0.635564016364870
>>> LambertW(1.2, -1).n()
-1.34747534407696 - 4.41624341514535*I
>>> LambertW(-1).is_real
False 

参考文献

[R330] (1,2)

en.wikipedia.org/wiki/Lambert_W_function

fdiff(argindex=1)

返回该函数的一阶导数。

class sympy.functions.elementary.exponential.log(arg, base=None)

自然对数函数 (\ln(x)) 或 (\log(x))。

解释

对数以自然底 (e) 取。要得到不同底数 (b) 的对数，使用 log(x, b)，这本质上是 log(x)/log(b) 的简写。

log 表示自然对数的主分支。因此，它在负实轴上有一个分支切断，并返回复数参数在 ((-\pi, \pi]) 内的值。

示例

>>> from sympy import log, sqrt, S, I
>>> log(8, 2)
3
>>> log(S(8)/3, 2)
-log(3)/log(2) + 3
>>> log(-1 + I*sqrt(3))
log(2) + 2*I*pi/3 

另请参阅

exp

as_base_exp()

以 (base, exponent) 的形式返回该函数。

as_real_imag(deep=True, **hints)

以复数坐标返回该函数。

示例

>>> from sympy import I, log
>>> from sympy.abc import x
>>> log(x).as_real_imag()
(log(Abs(x)), arg(x))
>>> log(I).as_real_imag()
(0, pi/2)
>>> log(1 + I).as_real_imag()
(log(sqrt(2)), pi/4)
>>> log(I*x).as_real_imag()
(log(Abs(x)), arg(I*x)) 

fdiff(argindex=1)

返回该函数的一阶导数。

inverse(argindex=1)

返回 (e^x)，即 (\log(x)) 的反函数。

static taylor_term(n, x, *previous_terms)

返回 (\log(1+x)) 泰勒级数展开的下一个项。

class sympy.functions.elementary.exponential.exp_polar(*args)

表示 极坐标数（请参阅 g-function Sphinx 文档）。

解释

exp_polar 表示函数 (Exp: \mathbb{C} \rightarrow \mathcal{S})，将复数 (z = a + bi) 发送到极坐标数 (r = exp(a), \theta = b)。它是构建极坐标数的主要函数之一。

示例

>>> from sympy import exp_polar, pi, I, exp 

主要区别在于极坐标数不会在 (2 \pi) 处“环绕”：

>>> exp(2*pi*I)
1
>>> exp_polar(2*pi*I)
exp_polar(2*I*pi) 

除此之外，它们的行为大多像经典复数一样：

>>> exp_polar(2)*exp_polar(3)
exp_polar(5) 

另请参阅

sympy.simplify.powsimp.powsimp, polar_lift, periodic_argument, principal_branch

Piecewise

class sympy.functions.elementary.piecewise.ExprCondPair(expr, cond)

表示一个表达式、条件对。

property cond

返回这对的条件。

property expr

返回这对的表达式。

class sympy.functions.elementary.piecewise.Piecewise(*_args)

表示一个分段函数。

用法：

Piecewise( (expr,cond), (expr,cond), … )

• 每个参数都是定义表达式和条件的 2-元组
• 逐个评估条件，返回第一个为True的条件。如果任何评估的条件不明确为False，例如x < 1，则函数以符号形式返回。
• 如果在所有条件均为False的位置评估函数，则将返回nan。
• 如果cond明确为False，则将删除条件为False的对，并且在True条件后出现的对将永远不会被保留。如果只剩下一个带有True条件的对，则将返回它，即使评估为False也是如此。

示例

>>> from sympy import Piecewise, log, piecewise_fold
>>> from sympy.abc import x, y
>>> f = x**2
>>> g = log(x)
>>> p = Piecewise((0, x < -1), (f, x <= 1), (g, True))
>>> p.subs(x,1)
1
>>> p.subs(x,5)
log(5) 

布尔值可以包含分段元素：

>>> cond = (x < y).subs(x, Piecewise((2, x < 0), (3, True))); cond
Piecewise((2, x < 0), (3, True)) < y 

这种折叠版本的结果是一个布尔值的分段函数：

>>> folded_cond = piecewise_fold(cond); folded_cond
Piecewise((2 < y, x < 0), (3 < y, True)) 

当包含分段函数的布尔值（如cond）或带有布尔表达式的分段函数（如folded_cond）被用作条件时，它将转换为等效的ITE对象：

>>> Piecewise((1, folded_cond))
Piecewise((1, ITE(x < 0, y > 2, y > 3))) 

当条件是一个ITE时，它将被转换为简化的布尔表达式：

>>> piecewise_fold(_)
Piecewise((1, ((x >= 0) | (y > 2)) & ((y > 3) | (x < 0)))) 

参见

piecewise_fold, piecewise_exclusive, ITE

_eval_integral(x, _first=True, **kwargs)

返回分段函数的不定积分，使得将 x 替换为一个值后将给出积分的值（不包括积分常数）。要仅积分分段函数的各部分，请使用piecewise_integrate方法。

示例

>>> from sympy import Piecewise
>>> from sympy.abc import x
>>> p = Piecewise((0, x < 0), (1, x < 1), (2, True))
>>> p.integrate(x)
Piecewise((0, x < 0), (x, x < 1), (2*x - 1, True))
>>> p.piecewise_integrate(x)
Piecewise((0, x < 0), (x, x < 1), (2*x, True)) 

参见

Piecewise.piecewise_integrate

as_expr_set_pairs(domain=None)

返回每个 self 参数的元组，给出表达式和其在给定域内包含的有效区间。如果条件无法转换为集合，则会引发错误。假定条件的变量为实数；将返回实值集合。

示例

>>> from sympy import Piecewise, Interval
>>> from sympy.abc import x
>>> p = Piecewise(
...     (1, x < 2),
...     (2,(x > 0) & (x < 4)),
...     (3, True))
>>> p.as_expr_set_pairs()
[(1, Interval.open(-oo, 2)),
 (2, Interval.Ropen(2, 4)),
 (3, Interval(4, oo))]
>>> p.as_expr_set_pairs(Interval(0, 3))
[(1, Interval.Ropen(0, 2)),
 (2, Interval(2, 3))] 

doit(**hints)

评估这个分段函数。

classmethod eval(*_args)

要么返回参数的修改版本，或者如果没有进行修改，则返回None。

在这里进行的修改：

1. 关系被规范化

2. 丢弃任何False条件

3. 忽略任何重复的先前条件

4. 任何带有真条件的参数均被丢弃

如果没有剩余的参数，则将返回nan。如果有一个带有True条件的单个参数，则将返回其对应的表达式。

示例

>>> from sympy import Piecewise
>>> from sympy.abc import x
>>> cond = -x < -1
>>> args = [(1, cond), (4, cond), (3, False), (2, True), (5, x < 1)]
>>> Piecewise(*args, evaluate=False)
Piecewise((1, -x < -1), (4, -x < -1), (2, True))
>>> Piecewise(*args)
Piecewise((1, x > 1), (2, True)) 

piecewise_integrate(x, **kwargs)

返回每个表达式的反导数的分段函数。要获得连续的反导数，请使用integrate()函数或方法。

示例

>>> from sympy import Piecewise
>>> from sympy.abc import x
>>> p = Piecewise((0, x < 0), (1, x < 1), (2, True))
>>> p.piecewise_integrate(x)
Piecewise((0, x < 0), (x, x < 1), (2*x, True)) 

注意这并不会产生连续函数，例如在 x = 1 处应用第三个条件，其原函数为 2*x，因此原函数的值为 2：

>>> anti = _
>>> anti.subs(x, 1)
2 

连续导数考虑到感兴趣点之前的积分 部分，然而：

>>> p.integrate(x)
Piecewise((0, x < 0), (x, x < 1), (2*x - 1, True))
>>> _.subs(x, 1)
1 

另请参见

Piecewise._eval_integral

sympy.functions.elementary.piecewise.piecewise_exclusive(expr, *, skip_nan=False, deep=True)

重写 Piecewise 以具有互斥条件。

参数：

expr: SymPy 表达式。

表达式中的任何 Piecewise 将被重写。

skip_nan: bool (默认 False)

如果 skip_nan 设置为 True，则最终不会包括 NaN 情况。

deep: bool (默认 True)

如果 deep 为 True，则 piecewise_exclusive() 将重写 expr 中的任何 Piecewise 子表达式，而不仅仅是重写 expr 本身。

返回：

一个与 expr 等价的表达式，但所有 Piecewise 都具有

已使用互斥条件重写。

解释

SymPy 以 “if-elif” 方式表示 Piecewise 的条件，允许多个条件同时为真。解释是首个为真的条件即为符合条件。虽然这在计算上是一个有用的表示，但这不是数学文本中典型显示分段函数的方式。可以使用 piecewise_exclusive() 函数将任何具有更典型互斥条件的 Piecewise 重写。

请注意，进一步处理结果的 Piecewise，例如简化它，很可能会使它变得非排他。因此，这主要是一个与打印 Piecewise 结合使用的函数，或者如果想要重新排序表达式条件对时使用的函数。

如果不能确定不同情况下的所有可能性都被Piecewise覆盖，则最终将明确包含NaN情况。可以通过传递skip_nan=True来防止这种情况。

示例

>>> from sympy import piecewise_exclusive, Symbol, Piecewise, S
>>> x = Symbol('x', real=True)
>>> p = Piecewise((0, x < 0), (S.Half, x <= 0), (1, True))
>>> piecewise_exclusive(p)
Piecewise((0, x < 0), (1/2, Eq(x, 0)), (1, x > 0))
>>> piecewise_exclusive(Piecewise((2, x > 1)))
Piecewise((2, x > 1), (nan, x <= 1))
>>> piecewise_exclusive(Piecewise((2, x > 1)), skip_nan=True)
Piecewise((2, x > 1)) 

另见

Piecewise, piecewise_fold

sympy.functions.elementary.piecewise.piecewise_fold(expr, evaluate=True)

获取包含分段函数的表达式并以分段形式返回表达式。此外，任何 ITE 条件都将被重写为否定标准形式并简化。

默认情况下评估最终的 Piecewise，但如果需要原始形式，请发送evaluate=False；如果需要平凡评估，请发送evaluate=None，并处理 True 和 False 的重复条件和处理。

示例

>>> from sympy import Piecewise, piecewise_fold, S
>>> from sympy.abc import x
>>> p = Piecewise((x, x < 1), (1, S(1) <= x))
>>> piecewise_fold(x*p)
Piecewise((x**2, x < 1), (x, True)) 

另见

Piecewise, piecewise_exclusive

杂项

class sympy.functions.elementary.miscellaneous.IdentityFunction

恒等函数

示例

>>> from sympy import Id, Symbol
>>> x = Symbol('x')
>>> Id(x)
x 

class sympy.functions.elementary.miscellaneous.Min(*args)

返回列表的最小值，如果可能的话。它被命名为Min而不是min，以避免与内置函数min冲突。

示例

>>> from sympy import Min, Symbol, oo
>>> from sympy.abc import x, y
>>> p = Symbol('p', positive=True)
>>> n = Symbol('n', negative=True) 

>>> Min(x, -2)
Min(-2, x)
>>> Min(x, -2).subs(x, 3)
-2
>>> Min(p, -3)
-3
>>> Min(x, y)
Min(x, y)
>>> Min(n, 8, p, -7, p, oo)
Min(-7, n) 

另见

Max

查找最大值

class sympy.functions.elementary.miscellaneous.Max(*args)

返回列表的最大值，如果可能的话。

当参数数量等于一时，返回该参数。

当参数数量等于两时，返回(a, b)中较大的值。

通常情况下，当列表长度大于 2 时，任务更加复杂。如果可能确定方向关系，则仅返回大于其他参数的参数。

如果无法确定这样的关系，则返回部分评估结果。

决策也使用假设。

同时，只允许可比较的参数。

它被命名为Max而不是max，以避免与内置函数max冲突。

示例

>>> from sympy import Max, Symbol, oo
>>> from sympy.abc import x, y, z
>>> p = Symbol('p', positive=True)
>>> n = Symbol('n', negative=True) 

>>> Max(x, -2)
Max(-2, x)
>>> Max(x, -2).subs(x, 3)
3
>>> Max(p, -2)
p
>>> Max(x, y)
Max(x, y)
>>> Max(x, y) == Max(y, x)
True
>>> Max(x, Max(y, z))
Max(x, y, z)
>>> Max(n, 8, p, 7, -oo)
Max(8, p)
>>> Max (1, x, oo)
oo 

• 算法

该任务可以被视为在有向完全偏序集合中寻找最小上界[R331]。

源值按顺序分配给孤立子集，在其中搜索最小上界并作为 Max 参数返回。

如果结果的最小上界是唯一的，则返回该值。

孤立的子集是在当前集合中只能相互比较的值的集合。例如，自然数可以相互比较，但不能与符号(x)比较。另一个例子：带有负假设的符号(x)可以与自然数比较。

还有“最小”元素，它们与所有其他元素可比，并具有零属性（所有元素的最大或最小值）。例如，在(\infty)的情况下，分配操作终止，只返回此值。

假设：

• 如果(A > B > C)，则(A > C)

• 如果(A = B)，则可以删除(B)

另请参阅

Min

查找最小值

参考

[R331] (1,2)

zh.wikipedia.org/wiki/定向完全偏序

[R332]

zh.wikipedia.org/wiki/格 _(數學)

sympy.functions.elementary.miscellaneous.root(arg, n, k=0, evaluate=None)

返回arg的第k个第n个根。

参数：

k：int，可选

应为({0, 1, ..., n-1})中的整数。如果(0)，则默认为主根。

evaluate：bool，可选

此参数确定是否应评估表达式。如果为None，则其值来自global_parameters.evaluate。

示例

>>> from sympy import root, Rational
>>> from sympy.abc import x, n 

>>> root(x, 2)
sqrt(x) 

>>> root(x, 3)
x**(1/3) 

>>> root(x, n)
x**(1/n) 

>>> root(x, -Rational(2, 3))
x**(-3/2) 

要获取第 k 个 n 次根，指定 k：

>>> root(-2, 3, 2)
-(-1)**(2/3)*2**(1/3) 

要获得所有n个根，可以使用 rootof 函数。以下示例显示了 n 等于 2、3 和 4 时的单位根：

>>> from sympy import rootof 

>>> [rootof(x**2 - 1, i) for i in range(2)]
[-1, 1] 

>>> [rootof(x**3 - 1,i) for i in range(3)]
[1, -1/2 - sqrt(3)*I/2, -1/2 + sqrt(3)*I/2] 

>>> [rootof(x**4 - 1,i) for i in range(4)]
[-1, 1, -I, I] 

SymPy 与其他符号代数系统一样，返回负数的复根。这是主根，与可能期望的教科书结果不同。例如，-8 的立方根不会返回为-2：

>>> root(-8, 3)
2*(-1)**(1/3) 

real_root 函数可用于使主要结果变为实数（或直接返回实根）：

>>> from sympy import real_root
>>> real_root(_)
-2
>>> real_root(-32, 5)
-2 

或者，可以使用 root 来计算负数的第 n//2 个 n 次根：

>>> root(-32, 5, 5//2)
-2 

另请参阅

sympy.polys.rootoftools.rootof, sympy.core.intfunc.integer_nthroot, sqrt, real_root

参考

[R333]

zh.wikipedia.org/wiki/平方根

[R334]

zh.wikipedia.org/wiki/实根

[R335]

zh.wikipedia.org/wiki/单位根

[R336]

zh.wikipedia.org/wiki/主值

[R337]

zh.wikipedia.org/wiki/立方根

sympy.functions.elementary.miscellaneous.sqrt(arg, evaluate=None)

返回主平方根。

参数：

evaluate：bool，可选

此参数确定是否应评估表达式。如果为None，则其值来自global_parameters.evaluate。

示例

>>> from sympy import sqrt, Symbol, S
>>> x = Symbol('x') 

>>> sqrt(x)
sqrt(x) 

>>> sqrt(x)**2
x 

请注意，sqrt(x**2)不简化为 x。

>>> sqrt(x**2)
sqrt(x**2) 

这是因为一般情况下两者不相等。例如，考虑(x == -1)：

>>> from sympy import Eq
>>> Eq(sqrt(x**2), x).subs(x, -1)
False 

这是因为 sqrt 计算主方根，因此平方可能将参数放在不同的分支中。如果 x 为正数，则此恒等式成立：

>>> y = Symbol('y', positive=True)
>>> sqrt(y**2)
y 

您可以通过将 force 选项设置为 True 来强制使用 powdenest()函数进行此简化：

>>> from sympy import powdenest
>>> sqrt(x**2)
sqrt(x**2)
>>> powdenest(sqrt(x**2), force=True)
x 

要获取平方根的两个分支，可以使用rootof函数：

>>> from sympy import rootof 

>>> [rootof(x**2-3,i) for i in (0,1)]
[-sqrt(3), sqrt(3)] 

虽然打印了sqrt，但没有sqrt函数，因此在表达式中查找sqrt将失败：

>>> from sympy.utilities.misc import func_name
>>> func_name(sqrt(x))
'Pow'
>>> sqrt(x).has(sqrt)
False 

要查找sqrt，请查找带有指数1/2的Pow：

>>> (x + 1/sqrt(x)).find(lambda i: i.is_Pow and abs(i.exp) is S.Half)
{1/sqrt(x)} 

另请参阅

sympy.polys.rootoftools.rootof，root，real_root

参考

[R338]

en.wikipedia.org/wiki/Square_root

[R339]

en.wikipedia.org/wiki/Principal_value

sympy.functions.elementary.miscellaneous.cbrt(arg, evaluate=None)

返回主立方根。

参数：

evaluate：布尔值，可选

参数确定是否应该评估表达式。如果为None，其值将从global_parameters.evaluate中获取。

示例

>>> from sympy import cbrt, Symbol
>>> x = Symbol('x') 

>>> cbrt(x)
x**(1/3) 

>>> cbrt(x)**3
x 

注意，cbrt(x**3)不简化为 x。

>>> cbrt(x**3)
(x**3)**(1/3) 

这是因为一般情况下两者不相等。例如，考虑(x == -1)：

>>> from sympy import Eq
>>> Eq(cbrt(x**3), x).subs(x, -1)
False 

这是因为 cbrt 计算主立方根，如果(x)为正数，则此恒等式成立：

>>> y = Symbol('y', positive=True)
>>> cbrt(y**3)
y 

另请参阅

sympy.polys.rootoftools.rootof，root，real_root

参考

[R340]

en.wikipedia.org/wiki/Cube_root

[R341]

en.wikipedia.org/wiki/Principal_value

sympy.functions.elementary.miscellaneous.real_root(arg, n=None, evaluate=None)

返回arg的实数第n次根（如果可能）。

参数：

n：整数或None，可选

如果n为None，则所有((-n)^{{1/\text{odd}})的实例将更改为(-n}{1/\text{odd}})。这仅会创建主根的实根。其他因素的存在可能导致结果不是实数。

evaluate：布尔值，可选

参数确定是否应该评估表达式。如果为None，其值将从global_parameters.evaluate中获取。

示例

>>> from sympy import root, real_root 

>>> real_root(-8, 3)
-2
>>> root(-8, 3)
2*(-1)**(1/3)
>>> real_root(_)
-2 

如果创建非主根并应用real_root，则结果将不是实数（因此请谨慎使用）：

>>> root(-8, 3, 2)
-2*(-1)**(2/3)
>>> real_root(_)
-2*(-1)**(2/3) 

另请参阅

sympy.polys.rootoftools.rootof, sympy.core.intfunc.integer_nthroot, root, sqrt

组合学

原文：docs.sympy.org/latest/modules/functions/combinatorial.html

本模块实现了各种组合函数。

class sympy.functions.combinatorial.numbers.bell(n, k_sym=None, symbols=None)

贝尔数 / 贝尔多项式

贝尔数满足 (B_0 = 1) 和

[B_n = \sum_{k=0}^{n-1} \binom{n-1}{k} B_k.]

它们也可以表示为：

[B_n = \frac{1}{e} \sum_{k=0}^{\infty} \frac{k^n}{k!}.]

贝尔多项式定义为 (B_0(x) = 1) 和

[B_n(x) = x \sum_{k=1}^{n-1} \binom{n-1}{k-1} B_{k-1}(x).]

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

[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) 给出第 (n) 个贝尔数，(B_n)。

• bell(n, x) 给出第 (n) 个贝尔多项式，(B_n(x))。

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

注意事项

不要与伯努利数和伯努利多项式混淆，它们使用相同的符号。

示例

>>> from sympy import bell, Symbol, symbols 

>>> [bell(n) for n in range(11)]
[1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147, 115975]
>>> bell(30)
846749014511809332450147
>>> bell(4, Symbol('t'))
t**4 + 6*t**3 + 7*t**2 + t
>>> bell(6, 2, symbols('x:6')[1:])
6*x1*x5 + 15*x2*x4 + 10*x3**2 

另见

bernoulli, catalan, euler, fibonacci, harmonic, lucas, genocchi, partition, tribonacci

参考文献

[R207]

en.wikipedia.org/wiki/Bell_number

[R208]

mathworld.wolfram.com/BellNumber.html

[R209]

mathworld.wolfram.com/BellPolynomial.html

class sympy.functions.combinatorial.numbers.bernoulli(n, x=None)

伯努利数 / 伯努利多项式 / 伯努利函数

伯努利数是由 (B_0 = 1) 和递归关系定义的一系列有理数：

[n+1 = \sum_{k=0}^n \binom{n+1}{k} B_k]

它们也通常由其指数生成函数定义，即 (\frac{x}{1 - e^{-x}})。对于大于 1 的奇数索引，伯努利数为零。

伯努利多项式满足类似的公式：

[B_n(x) = \sum_{k=0}^n (-1)^k \binom{n}{k} B_k x^{n-k}]

伯努利数和伯努利多项式之间的关系为 (B_n(1) = B_n)。

广义伯努利函数 (\operatorname{B}(s, a)) 定义在任意复数 (s) 和 (a) 上，除了 (a) 是非正整数且 (s) 不是非负整数。对于固定的 (a)，它是 (s) 的整函数，与胡尔维兹塞塔函数相关联，方法如下：

[\begin{split}\operatorname{B}(s, a) = \begin{cases} -s \zeta(1-s, a) & s \ne 0 \ 1 & s = 0 \end{cases}\end{split}]

当 (s) 是非负整数时，此函数简化为伯努利多项式：(\operatorname{B}(n, x) = B_n(x))。当省略 (a) 时，默认为 1，得到（普通的）伯努利函数，它插值了伯努利数，并与黎曼塞塔函数相关联。

我们使用拉马努金公式计算伯努利数：

[B_n = \frac{A(n) - S(n)}{\binom{n+3}{n}}]

其中：

[\begin{split}A(n) = \begin{cases} \frac{n+3}{3} & n \equiv 0\ \text{or}\ 2 \pmod{6} \ -\frac{n+3}{6} & n \equiv 4 \pmod{6} \end{cases}\end{split}]

并且：

[S(n) = \sum_{k=1}^{[n/6]} \binom{n+3}{n-6k} B_{n-6k}]

此公式类似于定义中给出的和，但删去了 (\frac{2}{3}) 的项。对于伯努利多项式，我们使用阿佩尔序列。

对于非负整数 (n) 和任意复数 (s)、(a)、(x)，

• bernoulli(n) 给出第 n 个伯努利数，(B_n)

• bernoulli(s) 给出伯努利函数 (\operatorname{B}(s))

• bernoulli(n, x) 给出第 n 个伯努利多项式在 (x) 中的值，(B_n(x))

• bernoulli(s, a) 给出广义伯努利函数 (\operatorname{B}(s, a))

自版本 1.12 更改：bernoulli(1)现在返回 (+\frac{1}{2}) 而非 (-\frac{1}{2})。此选择的值具有几个理论优势[R214]，包括此函数现在实现的对复参数的扩展描述。先前的行为仅对非负整数 (n) 定义，可通过 (-1)**n*bernoulli(n) 获得。

示例

>>> from sympy import bernoulli
>>> from sympy.abc import x
>>> [bernoulli(n) for n in range(11)]
[1, 1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0, 5/66]
>>> bernoulli(1000001)
0
>>> bernoulli(3, x)
x**3 - 3*x**2/2 + x/2 

另见

andre, bell, catalan, euler, fibonacci, harmonic, lucas, genocchi, partition, tribonacci, sympy.polys.appellseqs.bernoulli_poly

参考

[R210]

en.wikipedia.org/wiki/Bernoulli_number

[R211]

en.wikipedia.org/wiki/Bernoulli_polynomial

[R212]

mathworld.wolfram.com/BernoulliNumber.html

[R213]

mathworld.wolfram.com/BernoulliPolynomial.html

[R214] (1,2)

彼得·卢什尼，“伯努利宣言”，luschny.de/math/zeta/The-Bernoulli-Manifesto.html

[R215]

彼得·卢什尼，“伯努利函数简介”，arxiv.org/abs/2009.06743

class sympy.functions.combinatorial.factorials.binomial(n, k)

实现二项式系数。它可以根据所需的解释方式分为两种定义：

[\binom{n}{k} = \frac{n!}{k!(n-k)!}\ \text{或}\ \binom{n}{k} = \frac{(n)_k}{k!}]

首先，在严格的组合意义上，它定义了从 (n) 个元素的集合中选择 (k) 个元素的方式数。在这种情况下，两个参数都是非负整数，并且使用基于素因子分解的高效算法计算二项式系数。

另一种定义是任意 (n) 的泛化，但 (k) 也必须是非负的。在求和时这种情况非常有用。

为了方便起见，对于负整数 (k)，无论其他参数如何，此函数将返回零。

当(n)为符号时，要扩展二项式，请使用expand_func()或expand(func=True)。前者将保持多项式的分解形式，而后者将展开多项式本身。详见示例以获取详细信息。

例子

>>> from sympy import Symbol, Rational, binomial, expand_func
>>> n = Symbol('n', integer=True, positive=True) 

>>> binomial(15, 8)
6435 

>>> binomial(n, -1)
0 

帕斯卡三角形的行可以使用二项式函数生成：

>>> for N in range(8):
...     print([binomial(N, i) for i in range(N + 1)])
...
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1] 

例如给定的对角线，如第 4 个对角线：

>>> N = -4
>>> [binomial(N, i) for i in range(1 - N)]
[1, -4, 10, -20, 35] 

>>> binomial(Rational(5, 4), 3)
-5/128
>>> binomial(Rational(-5, 4), 3)
-195/128 

>>> binomial(n, 3)
binomial(n, 3) 

>>> binomial(n, 3).expand(func=True)
n**3/6 - n**2/2 + n/3 

>>> expand_func(binomial(n, 3))
n*(n - 2)*(n - 1)/6 

在许多情况下，我们还可以使用 Lucas 定理（参见 R217）快速计算素数 p 的二项式系数，尽管我们需要包含(evaluate=False)来延迟评估：

>>> from sympy import Mod
>>> Mod(binomial(156675, 4433, evaluate=False), 10**5 + 3)
28625 

使用 Granville 给出的 Lucas 定理的一般化（参见 R218），我们可以将其扩展到任意的 n：

>>> Mod(binomial(10**18, 10**12, evaluate=False), (10**5 + 3)**2)
3744312326 

参考文献

[R216]

www.johndcook.com/blog/binomial_coefficients/

[R217] (1,2)

en.wikipedia.org/wiki/Lucas%27s_theorem

[R218] (1,2)

素数幂的二项式系数，Andrew Granville，可获取：web.archive.org/web/20170202003812/http://www.dms.umontreal.ca/~andrew/PDF/BinCoeff.pdf

class sympy.functions.combinatorial.numbers.catalan(n)

卡特兰数

第(n)个卡特兰数由以下公式给出：

[C_n = \frac{1}{n+1} \binom{2n}{n}]

• catalan(n) 给出第(n)个卡特兰数，(C_n)

例子

>>> from sympy import (Symbol, binomial, gamma, hyper,
...     catalan, diff, combsimp, Rational, I) 

>>> [catalan(i) for i in range(1,10)]
[1, 2, 5, 14, 42, 132, 429, 1430, 4862] 

>>> n = Symbol("n", integer=True) 

>>> catalan(n)
catalan(n) 

卡特兰数可以转化为几个其他相同的表达式，涉及其他数学函数

>>> catalan(n).rewrite(binomial)
binomial(2*n, n)/(n + 1) 

>>> catalan(n).rewrite(gamma)
4**n*gamma(n + 1/2)/(sqrt(pi)*gamma(n + 2)) 

>>> catalan(n).rewrite(hyper)
hyper((-n, 1 - n), (2,), 1) 

对于一些非整数值的 n，我们可以通过重新写成伽玛函数的形式得到闭合形式表达式：

>>> catalan(Rational(1, 2)).rewrite(gamma)
8/(3*pi) 

我们可以在 n 中将卡特兰数 C(n)解释为连续实函数时进行微分：

>>> diff(catalan(n), n)
(polygamma(0, n + 1/2) - polygamma(0, n + 2) + log(4))*catalan(n) 

作为一个更高级的例子，考虑以下连续数之间的比率：

>>> combsimp((catalan(n + 1)/catalan(n)).rewrite(binomial))
2*(2*n + 1)/(n + 2) 

卡特兰数可以推广到复数：

>>> catalan(I).rewrite(gamma)
4**I*gamma(1/2 + I)/(sqrt(pi)*gamma(2 + I)) 

并且可以进行任意精度的评估：

>>> catalan(I).evalf(20)
0.39764993382373624267 - 0.020884341620842555705*I 

另请参阅

andre, bell, bernoulli, euler, fibonacci, harmonic, lucas, genocchi, partition, tribonacci, sympy.functions.combinatorial.factorials.binomial

参考

[R219]

en.wikipedia.org/wiki/Catalan_number

[R220]

mathworld.wolfram.com/CatalanNumber.html

[R221]

functions.wolfram.com/GammaBetaErf/CatalanNumber/

[R222]

geometer.org/mathcircles/catalan.pdf

class sympy.functions.combinatorial.numbers.euler(n, x=None)

欧拉数 / 欧拉多项式 / 欧拉函数

欧拉数由以下给出：

[E_{2n} = I \sum_{k=1}^{2n+1} \sum_{j=0}^k \binom{k}{j} \frac{(-1)^j (k-2j)^{2n+1}}{2k I^k k}][E_{2n+1} = 0]

欧拉数和欧拉多项式之间的关系为：

[E_n = 2^n E_n\left(\frac{1}{2}\right).]

我们使用 Appell 序列计算符号欧拉多项式，但是使用 mpmath 库可以更高效（并且更准确地）计算欧拉多项式的数值评估。

欧拉多项式是广义欧拉函数的特殊情况，与 Genocchi 函数相关如下：

[\operatorname{E}(s, a) = -\frac{\operatorname{G}(s+1, a)}{s+1}]

当 (s = -1) 时，限制为 (\psi\left(\frac{a+1}{2}\right) - \psi\left(\frac{a}{2}\right))。插值欧拉函数 (E(s)) 如下所得：(\operatorname{E}(s) = 2^s \operatorname{E}\left(s, \frac{1}{2}\right))。

• euler(n) 给出第 n 个欧拉数 (E_n)。

• euler(s) 给出欧拉函数 (\operatorname{E}(s))。

• euler(n, x) 给出第 n 个欧拉多项式 (E_n(x))。

• euler(s, a) 给出广义欧拉函数 (\operatorname{E}(s, a))。

示例

>>> from sympy import euler, Symbol, S
>>> [euler(n) for n in range(10)]
[1, 0, -1, 0, 5, 0, -61, 0, 1385, 0]
>>> [2**n*euler(n,1) for n in range(10)]
[1, 1, 0, -2, 0, 16, 0, -272, 0, 7936]
>>> n = Symbol("n")
>>> euler(n + 2*n)
euler(3*n) 

>>> x = Symbol("x")
>>> euler(n, x)
euler(n, x) 

>>> euler(0, x)
1
>>> euler(1, x)
x - 1/2
>>> euler(2, x)
x**2 - x
>>> euler(3, x)
x**3 - 3*x**2/2 + 1/4
>>> euler(4, x)
x**4 - 2*x**3 + x 

>>> euler(12, S.Half)
2702765/4096
>>> euler(12)
2702765 

另请参见

andre, bell, bernoulli, catalan, fibonacci, harmonic, lucas, genocchi, partition, tribonacci, sympy.polys.appellseqs.euler_poly

参考资料

[R223]

en.wikipedia.org/wiki/Euler_numbers

[R224]

mathworld.wolfram.com/EulerNumber.html

[R225]

en.wikipedia.org/wiki/Alternating_permutation

[R226]

mathworld.wolfram.com/AlternatingPermutation.html

class sympy.functions.combinatorial.factorials.factorial(n)

针对非负整数的阶乘函数的实现。按照约定（与伽玛函数和二项式系数一致），负整数的阶乘被定义为复数无穷。

阶乘在组合学中非常重要，用于计算 (n) 个对象的排列方式数量。它还出现在微积分、概率论、数论等领域。

阶乘与伽玛函数有严格的关系。事实上，对于非负整数，(n! = gamma(n+1))。这种重写在组合简化中非常有用。

阶乘的计算使用两种算法。对于小输入，使用预先计算的查找表。但对于更大的输入，使用 Prime-Swing 算法。这是已知最快的算法，通过对称称为‘Swing Numbers’的特殊数字的质因数分解来计算 (n!)。

示例

>>> from sympy import Symbol, factorial, S
>>> n = Symbol('n', integer=True) 

>>> factorial(0)
1 

>>> factorial(7)
5040 

>>> factorial(-2)
zoo 

>>> factorial(n)
factorial(n) 

>>> factorial(2*n)
factorial(2*n) 

>>> factorial(S(1)/2)
factorial(1/2) 

另请参阅

factorial2, RisingFactorial, FallingFactorial

class sympy.functions.combinatorial.factorials.subfactorial(arg)

子阶乘计算 (n) 项的错位排列，并定义为非负整数：

[\begin{split}!n = \begin{cases} 1 & n = 0 \ 0 & n = 1 \ (n-1)(!(n-1) + !(n-2)) & n > 1 \end{cases}\end{split}]

它还可以写成 int(round(n!/exp(1)))，但是此函数实现了具有缓存的递归定义。

一个有趣的解析表达式如下 [R228]

[!x = \Gamma(x + 1, -1)/e]

适用于非负整数 (x)。上述公式在非整数情况下并不是很有用。(\Gamma(x + 1, -1)) 仅在整数参数 (x) 上是单值的，在正实轴上有无限多个分支，其中没有一个是实数。

示例

>>> from sympy import subfactorial
>>> from sympy.abc import n
>>> subfactorial(n + 1)
subfactorial(n + 1)
>>> subfactorial(5)
44 

另见

factorial, uppergamma, sympy.utilities.iterables.generate_derangements

参考

[R227]

en.wikipedia.org/wiki/Subfactorial

[R228] (1,2)

mathworld.wolfram.com/Subfactorial.html

class sympy.functions.combinatorial.factorials.factorial2(arg)

双阶乘 (n!!)，不要与 ((n!)!) 混淆

双阶乘对非负整数和奇负整数定义如下：

[\begin{split}n!! = \begin{cases} 1 & n = 0 \ n(n-2)(n-4) \cdots 1 & n\ \text{为正奇数} \ n(n-2)(n-4) \cdots 2 & n\ \text{为正偶数} \ (n+2)!!/(n+2) & n\ \text{为负奇数} \end{cases}\end{split}]

示例

>>> from sympy import factorial2, var
>>> n = var('n')
>>> n
n
>>> factorial2(n + 1)
factorial2(n + 1)
>>> factorial2(5)
15
>>> factorial2(-1)
1
>>> factorial2(-5)
1/3 

另见

factorial, RisingFactorial, FallingFactorial

参考

[R229]

en.wikipedia.org/wiki/Double_factorial

class sympy.functions.combinatorial.factorials.FallingFactorial(x, k)

降阶乘（与升阶乘相关）是在具体数学、超几何函数和级数展开中出现的双值函数。它由以下定义：

[\texttt{ff(x, k)} = (x)_k = x \cdot (x-1) \cdots (x-k+1)]

其中 (x) 可以是任意表达式，(k) 是整数。更多信息请查阅格雷厄姆的《具体数学》第 66 页或 [R230]。

当 (x) 是单变量具有度数 (\ge 1) 的 (~.Poly) 实例时，((x)_k = x(y) \cdot x(y-1) \cdots x(y-k+1))，其中 (y) 是 (x) 的变量。这如同描述在

>>> from sympy import ff, Poly, Symbol
>>> from sympy.abc import x
>>> n = Symbol('n', integer=True) 

>>> ff(x, 0)
1
>>> ff(5, 5)
120
>>> ff(x, 5) == x*(x - 1)*(x - 2)*(x - 3)*(x - 4)
True
>>> ff(Poly(x**2, x), 2)
Poly(x**4 - 2*x**3 + x**2, x, domain='ZZ')
>>> ff(n, n)
factorial(n) 

除非已知参数之间的关系，否则重新编写将会很复杂，但是阶乘下降可以通过伽玛，阶乘和二项式重写上升阶乘。

>>> from sympy import factorial, rf, gamma, binomial, Symbol
>>> n = Symbol('n', integer=True, positive=True)
>>> F = ff(n, n - 2)
>>> for i in (rf, ff, factorial, binomial, gamma):
...  F.rewrite(i)
...
RisingFactorial(3, n - 2)
FallingFactorial(n, n - 2)
factorial(n)/2
binomial(n, n - 2)*factorial(n - 2)
gamma(n + 1)/2 

参见

factorial, factorial2, RisingFactorial

参考文献

[R230] (1,2)

mathworld.wolfram.com/FallingFactorial.html

[R231]

Peter Paule, “最大阶乘分解和符号求和”, 《符号计算期刊》, vol. 20, pp. 235-268, 1995.

class sympy.functions.combinatorial.numbers.fibonacci(n, sym=None)

斐波那契数列 / 斐波那契多项式

斐波那契数列是由初始项 (F_0 = 0), (F_1 = 1) 和两项递推关系 (F_n = F_{n-1} + F_{n-2}) 定义的整数序列。此定义可扩展到任意实数和复数参数使用下列公式

[F_z = \frac{\phi^z - \cos(\pi z) \phi^{-z}}{\sqrt 5}]

斐波那契多项式由 (F_1(x) = 1), (F_2(x) = x), 以及对于 (n > 2) 的 (F_n(x) = x*F_{n-1}(x) + F_{n-2}(x)) 定义。对于所有正整数 (n), (F_n(1) = F_n)。

• fibonacci(n) 给出第 (n) 个斐波那契数 (F_n)

• fibonacci(n, x) 给出 (n^{th}) 斐波那契多项式 (F_n(x))

示例

>>> from sympy import fibonacci, Symbol 

>>> [fibonacci(x) for x in range(11)]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
>>> fibonacci(5, Symbol('t'))
t**4 + 3*t**2 + 1 

参见

bell, bernoulli, catalan, euler, harmonic, lucas, genocchi, partition, tribonacci

参考文献

[R233]

en.wikipedia.org/wiki/Fibonacci_number

[R234]

mathworld.wolfram.com/FibonacciNumber.html

class sympy.functions.combinatorial.numbers.tribonacci(n, sym=None)

泰波那契数 / 泰波那契多项式

泰波那契数列由初始项定义为 (T_0 = 0)，(T_1 = 1)，(T_2 = 1)，并具有三项递推关系 (T_n = T_{n-1} + T_{n-2} + T_{n-3})。

泰波那契多项式由 (T_0(x) = 0)，(T_1(x) = 1)，(T_2(x) = x²) 定义，并对 (n > 2) 有递推关系 (T_n(x) = x² T_{n-1}(x) + x T_{n-2}(x) + T_{n-3}(x))。对于所有正整数 (n)，(T_n(1) = T_n)。

• tribonacci(n) 给出第 (n) 个泰波那契数，(T_n)

• tribonacci(n, x) 给出在 (x) 中的第 (n) 个泰波那契多项式，(T_n(x))

例子

>>> from sympy import tribonacci, Symbol 

>>> [tribonacci(x) for x in range(11)]
[0, 1, 1, 2, 4, 7, 13, 24, 44, 81, 149]
>>> tribonacci(5, Symbol('t'))
t**8 + 3*t**5 + 3*t**2 

参见

bell，bernoulli，catalan，euler，fibonacci，harmonic，lucas，genocchi，partition

参考

[R235]

en.wikipedia.org/wiki/Generalizations_of_Fibonacci_numbers#Tribonacci_numbers

[R236]

mathworld.wolfram.com/TribonacciNumber.html

[R237]

oeis.org/A000073

class sympy.functions.combinatorial.numbers.harmonic(n, m=None)

调和数

第 (n) 个调和数由 (\operatorname{H}_{n} = 1 + \frac{1}{2} + \frac{1}{3} + \ldots + \frac{1}{n}) 给出。

更一般地说：

[\operatorname{H}{n,m} = \sum^{n} \frac{1}{k^m}]

当 (n \rightarrow \infty) 时，(\operatorname{H}_{n,m} \rightarrow \zeta(m))，黎曼 zeta 函数。

• harmonic(n) 给出第 (n) 个调和数，(\operatorname{H}_n)

• harmonic(n, m) 给出第 (m) 阶广义调和数的第 (n) 个，(\operatorname{H}_{n,m})，其中 harmonic(n) == harmonic(n, 1)

此函数可扩展至复数 (n) 和非负整数 (m)，其中 (n) 不是负整数或 (m) 是非正整数。

[\begin{split}\operatorname{H}_{n,m} = \begin{cases} \zeta(m) - \zeta(m, n+1) & m \ne 1 \ \psi(n+1) + \gamma & m = 1 \end{cases}\end{split}]

示例

>>> from sympy import harmonic, oo 

>>> [harmonic(n) for n in range(6)]
[0, 1, 3/2, 11/6, 25/12, 137/60]
>>> [harmonic(n, 2) for n in range(6)]
[0, 1, 5/4, 49/36, 205/144, 5269/3600]
>>> harmonic(oo, 2)
pi**2/6 

>>> from sympy import Symbol, Sum
>>> n = Symbol("n") 

>>> harmonic(n).rewrite(Sum)
Sum(1/_k, (_k, 1, n)) 

我们可以评估所有整数和正有理数参数的调和数：

>>> from sympy import S, expand_func, simplify
>>> harmonic(8)
761/280
>>> harmonic(11)
83711/27720 

>>> H = harmonic(1/S(3))
>>> H
harmonic(1/3)
>>> He = expand_func(H)
>>> He
-log(6) - sqrt(3)*pi/6 + 2*Sum(log(sin(_k*pi/3))*cos(2*_k*pi/3), (_k, 1, 1))
 + 3*Sum(1/(3*_k + 1), (_k, 0, 0))
>>> He.doit()
-log(6) - sqrt(3)*pi/6 - log(sqrt(3)/2) + 3
>>> H = harmonic(25/S(7))
>>> He = simplify(expand_func(H).doit())
>>> He
log(sin(2*pi/7)**(2*cos(16*pi/7))/(14*sin(pi/7)**(2*cos(pi/7))*cos(pi/14)**(2*sin(pi/14)))) + pi*tan(pi/14)/2 + 30247/9900
>>> He.n(40)
1.983697455232980674869851942390639915940
>>> harmonic(25/S(7)).n(40)
1.983697455232980674869851942390639915940 

我们可以用多项式函数重新表达调和数：

>>> from sympy import digamma, polygamma
>>> m = Symbol("m", integer=True, positive=True) 

>>> harmonic(n).rewrite(digamma)
polygamma(0, n + 1) + EulerGamma 

>>> harmonic(n).rewrite(polygamma)
polygamma(0, n + 1) + EulerGamma 

>>> harmonic(n,3).rewrite(polygamma)
polygamma(2, n + 1)/2 + zeta(3) 

>>> simplify(harmonic(n,m).rewrite(polygamma))
Piecewise((polygamma(0, n + 1) + EulerGamma, Eq(m, 1)),
(-(-1)**m*polygamma(m - 1, n + 1)/factorial(m - 1) + zeta(m), True)) 

参数中的整数偏移可以被拆出：

>>> from sympy import expand_func 

>>> expand_func(harmonic(n+4))
harmonic(n) + 1/(n + 4) + 1/(n + 3) + 1/(n + 2) + 1/(n + 1) 

>>> expand_func(harmonic(n-4))
harmonic(n) - 1/(n - 1) - 1/(n - 2) - 1/(n - 3) - 1/n 

一些极限也可以计算出来：

>>> from sympy import limit, oo 

>>> limit(harmonic(n), n, oo)
oo 

>>> limit(harmonic(n, 2), n, oo)
pi**2/6 

>>> limit(harmonic(n, 3), n, oo)
zeta(3) 

对于(m > 1)，(H_{n,m})在(n)趋向无穷时趋于(\zeta(m))：

>>> m = Symbol("m", positive=True)
>>> limit(harmonic(n, m+1), n, oo)
zeta(m + 1) 

参见

bell, bernoulli, catalan, euler, fibonacci, lucas, genocchi, partition, tribonacci

参考

[R238]

en.wikipedia.org/wiki/Harmonic_number

[R239]

functions.wolfram.com/GammaBetaErf/HarmonicNumber/

[R240]

functions.wolfram.com/GammaBetaErf/HarmonicNumber2/

class sympy.functions.combinatorial.numbers.lucas(n)

卢卡斯数

卢卡斯数满足与斐波那契数列类似的递推关系，其中每一项是前两项的和。它们由选择初始值(L_0 = 2)和(L_1 = 1)生成。

• lucas(n) 给出第(n)个卢卡斯数

示例

>>> from sympy import lucas 

>>> [lucas(x) for x in range(11)]
[2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123] 

参见

bell, bernoulli, catalan, euler, fibonacci, harmonic, genocchi, partition, tribonacci

参考

[R241]

en.wikipedia.org/wiki/Lucas_number

[R242]

mathworld.wolfram.com/LucasNumber.html

class sympy.functions.combinatorial.numbers.genocchi(n, x=None)

Genocchi 数字 / Genocchi 多项式 / Genocchi 函数

Genocchi 数字是满足以下关系的整数序列 (G_n)：

[\frac{-2t}{1 + e^{-t}} = \sum_{n=0}^\infty \frac{G_n t^n}{n!}]

他们与伯努利数相关，如下所示

[G_n = 2 (1 - 2^n) B_n]

并且像伯努利数一样推广到 Genocchi 多项式和函数

[\operatorname{G}(s, a) = 2 \left(\operatorname{B}(s, a) - 2^s \operatorname{B}\left(s, \frac{a+1}{2}\right)\right)]

版本 1.12 中更改：genocchi(1)结果为(-1)而不是(1)

示例

>>> from sympy import genocchi, Symbol
>>> [genocchi(n) for n in range(9)]
[0, -1, -1, 0, 1, 0, -3, 0, 17]
>>> n = Symbol('n', integer=True, positive=True)
>>> genocchi(2*n + 1)
0
>>> x = Symbol('x')
>>> genocchi(4, x)
-4*x**3 + 6*x**2 - 1 

参见

bell, bernoulli, catalan, euler, fibonacci, harmonic, lucas, partition, tribonacci, sympy.polys.appellseqs.genocchi_poly

参考

[R243]

zh.wikipedia.org/wiki/格诺奇数

[R244]

mathworld.wolfram.com/GenocchiNumber.html

[R245]

彼得·卢施尼，“伯努利函数简介”，arxiv.org/abs/2009.06743

class sympy.functions.combinatorial.numbers.andre(n)

安德列数 / 安德列函数

安德列数 (\mathcal{A}_n) 是卢施尼对于 (n) 个元素上 交替排列 数的称呼，其中排列是交替的，如果从左到右相邻元素交替比较“较大”和“较小”。例如，(2 < 3 > 1 < 4) 是一个交替排列。

此序列是 OEIS 中的 A000111，分配了“上升/下降数”和“欧拉锯齿数”的名称。它满足类似于卡塔兰数的递归关系，其中 (\mathcal{A}_0 = 1) 和

[2 \mathcal{A}{n+1} = \sum^n \binom{n}{k} \mathcal{A}k \mathcal{A}]

伯努利数和欧拉数是该序列的奇偶索引元素的有符号变换：

[\operatorname{B}{2k} = \frac{2k \mathcal{A}{2k-1}}{(-4)^k - (-16)^k}][\operatorname{E}{2k} = (-1)^k \mathcal{A}]

类似于伯努利数和欧拉数，安德列数被整个安德列函数插值：

[\begin{split}\mathcal{A}(s) = (-i)^{s+1} \operatorname{Li}{-s}(i) + i^{s+1} \operatorname{Li}(-i) = \ \frac{2 \Gamma(s+1)}{(2\pi)^{s+1}} (\zeta(s+1, 1/4) - \zeta(s+1, 3/4) \cos{\pi s})\end{split}]

例子

>>> from sympy import andre, euler, bernoulli
>>> [andre(n) for n in range(11)]
[1, 1, 1, 2, 5, 16, 61, 272, 1385, 7936, 50521]
>>> [(-1)**k * andre(2*k) for k in range(7)]
[1, -1, 5, -61, 1385, -50521, 2702765]
>>> [euler(2*k) for k in range(7)]
[1, -1, 5, -61, 1385, -50521, 2702765]
>>> [andre(2*k-1) * (2*k) / ((-4)**k - (-16)**k) for k in range(1, 8)]
[1/6, -1/30, 1/42, -1/30, 5/66, -691/2730, 7/6]
>>> [bernoulli(2*k) for k in range(1, 8)]
[1/6, -1/30, 1/42, -1/30, 5/66, -691/2730, 7/6] 

参见

bernoulli, catalan, euler, sympy.polys.appellseqs.andre_poly

参考文献

[R246]

en.wikipedia.org/wiki/Alternating_permutation

[R247]

mathworld.wolfram.com/EulerZigzagNumber.html

[R248]

彼得·卢施尼，“伯努利函数简介”，arxiv.org/abs/2009.06743

class sympy.functions.combinatorial.numbers.partition(n)

划分数

划分数是整数序列 (p_n)，代表了将 (n) 表示为自然数和的不同方式数量（顺序无关）。划分数的生成函数如下：

[\sum_{n=0}^\infty p_n x^n = \prod_{k=1}^\infty (1 - x^k)]

例子

>>> from sympy import partition, Symbol
>>> [partition(n) for n in range(9)]
[1, 1, 2, 3, 5, 7, 11, 15, 22]
>>> n = Symbol('n', integer=True, negative=True)
>>> partition(n)
0 

参见

bell, bernoulli, catalan, euler, fibonacci, harmonic, lucas, genocchi, tribonacci

参考文献

[R249]

[en.wikipedia.org/wiki/Partition_(number_theory%29](https://en.wikipedia.org/wiki/Partition_(number_theory))

[R250]

en.wikipedia.org/wiki/Pentagonal_number_theorem

class sympy.functions.combinatorial.numbers.divisor_sigma(n, k=1)

计算正整数 n 的除数函数 (\sigma_k(n))

divisor_sigma(n, k) 等于 sum([x**k for x in divisors(n)])

若 n 的质因数分解为：

[n = \prod_{i=1}^\omega p_i^{m_i},]

那么

[\sigma_k(n) = \prod_{i=1}^\omega (1+p_i^k+p_i+\cdots + p_i^{m_ik}).]

示例

>>> from sympy.functions.combinatorial.numbers import divisor_sigma
>>> divisor_sigma(18, 0)
6
>>> divisor_sigma(39, 1)
56
>>> divisor_sigma(12, 2)
210
>>> divisor_sigma(37)
38 

另见

sympy.ntheory.factor_.divisor_count, totient, sympy.ntheory.factor_.divisors, sympy.ntheory.factor_.factorint

参考文献

[R251]

en.wikipedia.org/wiki/Divisor_function

class sympy.functions.combinatorial.numbers.udivisor_sigma(n, k=1)

计算正整数 n 的单位除数函数 (\sigma_k^*(n))

udivisor_sigma(n, k) 等于 sum([x**k for x in udivisors(n)])

若 n 的质因数分解为：

[n = \prod_{i=1}^\omega p_i^{m_i},]

那么

[\sigma_k^*(n) = \prod_{i=1}^\omega (1+ p_i^{m_ik}).]

参数：

k : 求和中的除数的幂次

对于 k = 0, 1: udivisor_sigma(n, 0) 等于 udivisor_count(n) udivisor_sigma(n, 1) 等于 sum(udivisors(n))

k 的默认值为 1.

示例

>>> from sympy.functions.combinatorial.numbers import udivisor_sigma
>>> udivisor_sigma(18, 0)
4
>>> udivisor_sigma(74, 1)
114
>>> udivisor_sigma(36, 3)
47450
>>> udivisor_sigma(111)
152 

另见

sympy.ntheory.factor_.divisor_count, totient, sympy.ntheory.factor_.divisors, sympy.ntheory.factor_.udivisors, sympy.ntheory.factor_.udivisor_count, divisor_sigma, sympy.ntheory.factor_.factorint

参考文献

[R252]

mathworld.wolfram.com/UnitaryDivisorFunction.html

class sympy.functions.combinatorial.numbers.legendre_symbol(a, p)

返回 Legendre 符号((a / p))。

对于整数a和奇素数p，Legendre 符号定义为

[\begin{split}\genfrac(){}{}{a}{p} = \begin{cases} 0 & \text{if } p \text{ divides } a\ 1 & \text{if } a \text{ is a quadratic residue modulo } p\ -1 & \text{if } a \text{ is a quadratic nonresidue modulo } p \end{cases}\end{split}]

示例

>>> from sympy.functions.combinatorial.numbers import legendre_symbol
>>> [legendre_symbol(i, 7) for i in range(7)]
[0, 1, 1, -1, 1, -1, -1]
>>> sorted(set([i**2 % 7 for i in range(7)]))
[0, 1, 2, 4] 

参见

sympy.ntheory.residue_ntheory.is_quad_residue, jacobi_symbol

class sympy.functions.combinatorial.numbers.jacobi_symbol(m, n)

返回 Jacobi 符号((m / n))。

对于任意整数m和任意正奇整数n，Jacobi 符号定义为n的素因子对应的 Legendre 符号的乘积：

[\genfrac(){}{}{m}{n} = \genfrac(){}{}{m}{p^{1}} \genfrac(){}{}{m}{p^{2}} ... \genfrac(){}{}{m}{p^{k}} \text{ where } n = p_1^{\alpha_1} p_2^{\alpha_2} ... p_k^{\alpha_k}]

与 Legendre 符号类似，如果 Jacobi 符号(\genfrac(){}{}{m}{n} = -1)，则m是模n的二次非剩余。

但与 Legendre 符号不同，如果 Jacobi 符号(\genfrac(){}{}{m}{n} = 1)，则m可能是模n的二次剩余，也可能不是。

示例

>>> from sympy.functions.combinatorial.numbers import jacobi_symbol, legendre_symbol
>>> from sympy import S
>>> jacobi_symbol(45, 77)
-1
>>> jacobi_symbol(60, 121)
1 

jacobi_symbol与legendre_symbol之间的关系如下所示：

>>> L = legendre_symbol
>>> S(45).factors()
{3: 2, 5: 1}
>>> jacobi_symbol(7, 45) == L(7, 3)**2 * L(7, 5)**1
True 

参见

sympy.ntheory.residue_ntheory.is_quad_residue, legendre_symbol

class sympy.functions.combinatorial.numbers.kronecker_symbol(a, n)

返回 Kronecker 符号((a / n))。

示例

>>> from sympy.functions.combinatorial.numbers import kronecker_symbol
>>> kronecker_symbol(45, 77)
-1
>>> kronecker_symbol(13, -120)
1 

参见

jacobi_symbol, legendre_symbol

参考文献

[R253]

en.wikipedia.org/wiki/Kronecker_symbol

class sympy.functions.combinatorial.numbers.mobius(n)

莫比乌斯函数将自然数映射到{-1, 0, 1}。

它的定义如下：

1. (1) 如果 (n = 1)。

2. (0) 如果 (n) 含有平方素数因子。

3. ((-1)^k) 如果 (n) 是一个无平方素数因子的正整数，其中 (k) 是素数因子的数量。

它是数论和组合数学中重要的乘性函数。它在数学级数、代数数论以及物理学（费米子算符与莫比乌斯函数模型有具体的实现）中都有应用。

示例

>>> from sympy.functions.combinatorial.numbers import mobius
>>> mobius(13*7)
1
>>> mobius(1)
1
>>> mobius(13*7*5)
-1
>>> mobius(13**2)
0 

即使在符号的情况下，如果它明显包含平方素因子，它将为零。

>>> from sympy import Symbol
>>> n = Symbol("n", integer=True, positive=True)
>>> mobius(4*n)
0
>>> mobius(n**2)
0 

参考文献

[R254]

en.wikipedia.org/wiki/M%C3%B6bius_function

[R255]

Thomas Koshy 的《Elementary Number Theory with Applications》

[R256]

oeis.org/A008683

class sympy.functions.combinatorial.numbers.primenu(n)

计算正整数 n 的不同素因子数量。

如果 n 的素因数分解为：

[n = \prod_{i=1}^k p_i^{m_i},]

那么 primenu(n) 或 (\nu(n)) 是：

[\nu(n) = k.]

示例

>>> from sympy.functions.combinatorial.numbers import primenu
>>> primenu(1)
0
>>> primenu(30)
3 

参见

sympy.ntheory.factor_.factorint

参考文献

[R257]

mathworld.wolfram.com/PrimeFactor.html

[R258]

oeis.org/A001221

class sympy.functions.combinatorial.numbers.primeomega(n)

计算正整数 n 的素因子数量，包括重复计数。

如果 n 的素因数分解为：

[n = \prod_{i=1}^k p_i^{m_i},]

那么 primeomega(n) 或 (\Omega(n)) 是：

[\Omega(n) = \sum_{i=1}^k m_i.]

示例

>>> from sympy.functions.combinatorial.numbers import primeomega
>>> primeomega(1)
0
>>> primeomega(20)
3 

参见

sympy.ntheory.factor_.factorint

参考文献

[R259]

mathworld.wolfram.com/PrimeFactor.html

[R260]

oeis.org/A001222

class sympy.functions.combinatorial.numbers.totient(n)

计算欧拉 totient 函数 phi(n)

totient(n) 或 (\phi(n)) 是不大于 n 的与 n 互质的正整数的数量。

示例

>>> from sympy.functions.combinatorial.numbers import totient
>>> totient(1)
1
>>> totient(25)
20
>>> totient(45) == totient(5)*totient(9)
True 

参见

sympy.ntheory.factor_.divisor_count

参考文献

[R261]

en.wikipedia.org/wiki/Euler%27s_totient_function

[R262]

mathworld.wolfram.com/TotientFunction.html

[R263]

oeis.org/A000010

class sympy.functions.combinatorial.numbers.reduced_totient(n)

计算 Carmichael 减小的欧拉 totient 函数 lambda(n)

reduced_totient(n)或(\lambda(n))是满足对于所有与 n 互质的 k，(k^m \equiv 1 \mod n)的最小 m > 0。

Examples

>>> from sympy.functions.combinatorial.numbers import reduced_totient
>>> reduced_totient(1)
1
>>> reduced_totient(8)
2
>>> reduced_totient(30)
4 

See also

totient

References

[R264]

en.wikipedia.org/wiki/Carmichael_function

[R265]

mathworld.wolfram.com/CarmichaelFunction.html

[R266]

oeis.org/A002322

class sympy.functions.combinatorial.numbers.primepi(n)

表示素数计数函数 pi(n) = 小于或等于 n 的素数的数量。

Examples

>>> from sympy.functions.combinatorial.numbers import primepi
>>> from sympy import prime, prevprime, isprime
>>> primepi(25)
9 

因此，小于或等于 25 的素数有 9 个。25 是素数吗？

>>> isprime(25)
False 

它不是。所以小于 25 的第一个素数必须是第 9 个素数：

>>> prevprime(25) == prime(9)
True 

See also

sympy.ntheory.primetest.isprime

测试 n 是否为素数

sympy.ntheory.generate.primerange

生成给定范围内的所有素数

sympy.ntheory.generate.prime

返回第 n 个素数

References

[R267]

oeis.org/A000720

class sympy.functions.combinatorial.factorials.MultiFactorial(*args)

class sympy.functions.combinatorial.factorials.RisingFactorial(x, k)

上升阶乘（也称为 Pochhammer 符号[R268]）是在具体数学、超几何函数和级数展开中出现的双值函数。它的定义是：

[\texttt{rf(y, k)} = (x)^k = x \cdot (x+1) \cdots (x+k-1)]

其中(x)可以是任意表达式，(k)是整数。欲了解更多信息，请参阅 Graham 的《Concrete mathematics》第 66 页或访问mathworld.wolfram.com/RisingFactorial.html页面。

当(x)是具有单一变量的(~.Poly)实例的次数为(\ge 1)时，((x)^k = x(y) \cdot x(y+1) \cdots x(y+k-1))，其中(y)是(x)的变量。这如同[R269]中描述的那样。

Examples

>>> from sympy import rf, Poly
>>> from sympy.abc import x
>>> rf(x, 0)
1
>>> rf(1, 5)
120
>>> rf(x, 5) == x*(1 + x)*(2 + x)*(3 + x)*(4 + x)
True
>>> rf(Poly(x**3, x), 2)
Poly(x**6 + 3*x**5 + 3*x**4 + x**3, x, domain='ZZ') 

除非已知参数之间的关系，否则重写是复杂的，但上升阶乘可以用 gamma、阶乘、二项式和下降阶乘来重写。

>>> from sympy import Symbol, factorial, ff, binomial, gamma
>>> n = Symbol('n', integer=True, positive=True)
>>> R = rf(n, n + 2)
>>> for i in (rf, ff, factorial, binomial, gamma):
...  R.rewrite(i)
...
RisingFactorial(n, n + 2)
FallingFactorial(2*n + 1, n + 2)
factorial(2*n + 1)/factorial(n - 1)
binomial(2*n + 1, n + 2)*factorial(n + 2)
gamma(2*n + 2)/gamma(n) 

See also

factorial, factorial2, FallingFactorial

References

[R268] (1,2)

en.wikipedia.org/wiki/Pochhammer_symbol

[R269] (1,2)

Peter Paule，《Greatest Factorial Factorization and Symbolic Summation》，《符号计算杂志》，第 20 卷，第 235-268 页，1995 年。

sympy.functions.combinatorial.numbers.stirling(n, k, d=None, kind=2, signed=False)

返回第一或第二（默认）种类的斯特林数 (S(n, k))。

对于 k = 1 到 n 的所有第二种斯特林数的总和是 bell(n)。这些数的递归关系是：

[{0 \brace 0} = 1; {n \brace 0} = {0 \brace k} = 0;][{{n+1} \brace k} = j {n \brace k} + {n \brace {k-1}}]

其中 (j) 是：

第一种斯特林数，第一种符号斯特林数为 (-n)，第二种斯特林数为 k。

第一种斯特林数计算具有 k 个循环的 n 个不同项的排列数；第二种斯特林数计算将 n 个不同项划分为 k 个部分的方式。如果给定 d，则返回“降维第二种斯特林数”：(S^{d}(n, k) = S(n - d + 1, k - d + 1))，其中 (n \ge k \ge d)。（这计算了将 n 个连续整数分成 k 组，使得任意两数的差至少为 d。见下面的示例。）

要获取第一种符号斯特林数，请使用关键字 signed=True。使用此关键字会自动将 kind 设置为 1。

示例

>>> from sympy.functions.combinatorial.numbers import stirling, bell
>>> from sympy.combinatorics import Permutation
>>> from sympy.utilities.iterables import multiset_partitions, permutations 

第一种（默认为无符号）：

>>> [stirling(6, i, kind=1) for i in range(7)]
[0, 120, 274, 225, 85, 15, 1]
>>> perms = list(permutations(range(4)))
>>> [sum(Permutation(p).cycles == i for p in perms) for i in range(5)]
[0, 6, 11, 6, 1]
>>> [stirling(4, i, kind=1) for i in range(5)]
[0, 6, 11, 6, 1] 

第一种（符号化）：

>>> [stirling(4, i, signed=True) for i in range(5)]
[0, -6, 11, -6, 1] 

第二种情况：

>>> [stirling(10, i) for i in range(12)]
[0, 1, 511, 9330, 34105, 42525, 22827, 5880, 750, 45, 1, 0]
>>> sum(_) == bell(10)
True
>>> len(list(multiset_partitions(range(4), 2))) == stirling(4, 2)
True 

降维第二种情况：

>>> from sympy import subsets, oo
>>> def delta(p):
...    if len(p) == 1:
...        return oo
...    return min(abs(i[0] - i[1]) for i in subsets(p, 2))
>>> parts = multiset_partitions(range(5), 3)
>>> d = 2
>>> sum(1 for p in parts if all(delta(i) >= d for i in p))
7
>>> stirling(5, 3, 2)
7 

另请参阅

sympy.utilities.iterables.multiset_partitions

参考

[R270]

en.wikipedia.org/wiki/Stirling_numbers_of_the_first_kind

[R271]

en.wikipedia.org/wiki/Stirling_numbers_of_the_second_kind

枚举

提供了三个函数。每个函数尝试为给定的集合或多集高效计算给定的组合数量，集合或多集可以输入为整数、序列或多集（字典，元素为键，重复次数为值）。参数 k 表示要选择的元素数（或要进行的分区数）。当 k 为 None 时，返回所有 n 项目数的从 0 到 k 的枚举总和。组合和排列识别 replacement 参数；这表示任何项目可以以原始集合中项目数量的最高复制数出现。

>>> from sympy.functions.combinatorial.numbers import nC, nP, nT
>>> items = 'baby' 

sympy.functions.combinatorial.numbers.nC(n, k=None, replacement=False)

返回从 n 个项目中取 k 个项目的组合数。

n 的可能值：

整数 - 长度为 n 的集合

序列 - 在内部转换为多集

多集 -

如果 k 为 None，则将返回长度为 0 到 n 项目数的所有组合的总和。

如果replacement为 True，则给定的项目可以在k个项目中出现多次。（例如，对于长度为 2 的‘ab’集合，包括‘aa’、‘ab’和‘bb’。）当replacement为 True 时，n中元素的多重度被忽略，但考虑元素总数，因为没有元素可以比n中的元素出现更多次。

示例

>>> from sympy.functions.combinatorial.numbers import nC
>>> from sympy.utilities.iterables import multiset_combinations
>>> nC(3, 2)
3
>>> nC('abc', 2)
3
>>> nC('aab', 2)
2 

当replacement为 True 时，每个项目的多重度可以等于由n表示的长度：

>>> nC('aabc', replacement=True)
35
>>> [len(list(multiset_combinations('aaaabbbbcccc', i))) for i in range(5)]
[1, 3, 6, 10, 15]
>>> sum(_)
35 

如果有k个项目，多重度为m_1, m_2, ..., m_k，则长度为 0 到k的所有组合的总数是乘积(m_1 + 1)*(m_2 + 1)*...*(m_k + 1)。当每个项目的多重度为 1 时（即 k 个唯一项目），则有 2**k 个组合。例如，如果有 4 个唯一项目，则组合的总数为 16：

>>> sum(nC(4, i) for i in range(5))
16 

另请参阅

sympy.utilities.iterables.multiset_combinations

参考资料

[R272]

en.wikipedia.org/wiki/Combination

[R273]

tinyurl.com/cep849r

sympy.functions.combinatorial.numbers.nP(n, k=None, replacement=False)

返回n个项目的排列数，每次取k个。

n的可能值：

整数 - 长度为n的集合

序列 - 内部转换为多重集合

多重集合 -

如果k为 None，则返回长度从 0 到由n表示的项目数的所有排列的总数。

如果replacement为 True，则给定的项目可以在k个项目中出现多次。（例如，对于长度为 2 的‘ab’排列将包括‘aa’、‘ab’、‘ba’和‘bb’。）当replacement为 True 时，n中元素的多重度被忽略，但考虑元素总数，因为没有元素可以比n中的元素出现更多次。

示例

>>> from sympy.functions.combinatorial.numbers import nP
>>> from sympy.utilities.iterables import multiset_permutations, multiset
>>> nP(3, 2)
6
>>> nP('abc', 2) == nP(multiset('abc'), 2) == 6
True
>>> nP('aab', 2)
3
>>> nP([1, 2, 2], 2)
3
>>> [nP(3, i) for i in range(4)]
[1, 3, 6, 6]
>>> nP(3) == sum(_)
True 

当replacement为 True 时，每个项目的多重度可以等于由n表示的长度：

>>> nP('aabc', replacement=True)
121
>>> [len(list(multiset_permutations('aaaabbbbcccc', i))) for i in range(5)]
[1, 3, 9, 27, 81]
>>> sum(_)
121 

另请参阅

sympy.utilities.iterables.multiset_permutations

参考资料

[R274]

en.wikipedia.org/wiki/Permutation

sympy.functions.combinatorial.numbers.nT(n, k=None)

返回n个项目的k大小分区的数量。

n的可能值：

整数 - n个相同的项目

序列 - 内部转换为多重集合

多重集合 -

注意：这里nT的约定与nC和nP的约定不同，这里整数表示n 相同 项目，而不是长度为n的集合；这与partitions函数相符，它将其整数n输入视为n个 1 的列表。可以使用range(n)表示n以指示n个不同的项目。

如果k为 None，则返回表示n中元素的分区方式的总数。

示例

>>> from sympy.functions.combinatorial.numbers import nT 

给定多重集合的分区：

>>> [nT('aabbc', i) for i in range(1, 7)]
[1, 8, 11, 5, 1, 0]
>>> nT('aabbc') == sum(_)
True 

>>> [nT("mississippi", i) for i in range(1, 12)]
[1, 74, 609, 1521, 1768, 1224, 579, 197, 50, 9, 1] 

当所有项都相同时的分区：

>>> [nT(5, i) for i in range(1, 6)]
[1, 2, 2, 1, 1]
>>> nT('1'*5) == sum(_)
True 

当所有项都不同时：

>>> [nT(range(5), i) for i in range(1, 6)]
[1, 15, 25, 10, 1]
>>> nT(range(5)) == sum(_)
True 

一个整数的分区，表示为正整数的和：

>>> from sympy import partition
>>> partition(4)
5
>>> nT(4, 1) + nT(4, 2) + nT(4, 3) + nT(4, 4)
5
>>> nT('1'*4)
5 

另请参见

sympy.utilities.iterables.partitions, sympy.utilities.iterables.multiset_partitions, sympy.functions.combinatorial.numbers.partition

参考文献

[R275]

web.archive.org/web/20210507012732/https://teaching.csse.uwa.edu.au/units/CITS7209/partition.pdf

特殊

原文：SymPy 文档

Dirac Delta 和相关的不连续函数

class sympy.functions.special.delta_functions.DiracDelta(arg, k=0)

DiracDelta 函数及其导数。

解释

DiracDelta 不是普通函数。它可以严格地定义为分布或测度之一。

DiracDelta 只在定积分中有意义，特别是在形如 Integral(f(x)*DiracDelta(x - x0), (x, a, b)) 的积分中，当 a <= x0 <= b 时，结果为 f(x0)，否则为 0。形式上，DiracDelta 在某些方面表现得像是一个在除了 0 外都是 0 的函数，但在许多方面又不是这样。在形式化地处理 Delta 函数时通常很有用，构建和操作包含 Delta 函数的表达式（最终可能被积分），但需要小心不要将其视为真实函数。SymPy 的 oo 类似，它只在某些上下文中形式上有意义（如积分限），但 SymPy 允许在任何地方使用它，并且它尝试在其上执行操作时保持一致性（如 1/oo），但如果过度将 oo 视为数字，则很容易出错并得到错误的结果。类似地，如果过度将 DiracDelta 视为函数，则很容易得到错误或无意义的结果。

DiracDelta 函数具有以下特性：

1. (\frac{d}{d x} \theta(x) = \delta(x))

2. (\int_{-\infty}^\infty \delta(x - a)f(x), dx = f(a))，以及 (\int_{a- \epsilon}^{a+\epsilon} \delta(x - a)f(x), dx = f(a))

3. (\delta(x) = 0)，对所有的 (x \neq 0)

4. (\delta(g(x)) = \sum_i \frac{\delta(x - x_i)}{|g'(x_i)|})，其中 (x_i) 是 (g) 的根

5. (\delta(-x) = \delta(x))

DiracDelta 的第k阶导数具有以下特性：

1. (\delta(x, k) = 0)，对所有的 (x \neq 0)

2. (\delta(-x, k) = -\delta(x, k))，对于奇数 (k)

3. (\delta(-x, k) = \delta(x, k))，对于偶数 (k)

示例

>>> from sympy import DiracDelta, diff, pi
>>> from sympy.abc import x, y 

>>> DiracDelta(x)
DiracDelta(x)
>>> DiracDelta(1)
0
>>> DiracDelta(-1)
0
>>> DiracDelta(pi)
0
>>> DiracDelta(x - 4).subs(x, 4)
DiracDelta(0)
>>> diff(DiracDelta(x))
DiracDelta(x, 1)
>>> diff(DiracDelta(x - 1), x, 2)
DiracDelta(x - 1, 2)
>>> diff(DiracDelta(x**2 - 1), x, 2)
2*(2*x**2*DiracDelta(x**2 - 1, 2) + DiracDelta(x**2 - 1, 1))
>>> DiracDelta(3*x).is_simple(x)
True
>>> DiracDelta(x**2).is_simple(x)
False
>>> DiracDelta((x**2 - 1)*y).expand(diracdelta=True, wrt=x)
DiracDelta(x - 1)/(2*Abs(y)) + DiracDelta(x + 1)/(2*Abs(y)) 

另请参阅

Heaviside, sympy.simplify.simplify.simplify, is_simple, sympy.functions.special.tensor_functions.KroneckerDelta

参考资料

[R342]

数学世界

classmethod eval(arg, k=0)

返回 DiracDelta 对象传递的参数的简化形式或值。

参数：

k：整数

导数的阶数

arg：传递给 DiracDelta 的参数

解释

当DiracDelta类即将实例化时，eval()方法会自动调用并返回简化的实例或未评估的实例，具体取决于传递的参数。换句话说，不需要显式调用eval()方法，一旦调用对象即会被调用和评估。

示例

>>> from sympy import DiracDelta, S
>>> from sympy.abc import x 

>>> DiracDelta(x)
DiracDelta(x) 

>>> DiracDelta(-x, 1)
-DiracDelta(x, 1) 

>>> DiracDelta(1)
0 

>>> DiracDelta(5, 1)
0 

>>> DiracDelta(0)
DiracDelta(0) 

>>> DiracDelta(-1)
0 

>>> DiracDelta(S.NaN)
nan 

>>> DiracDelta(x - 100).subs(x, 5)
0 

>>> DiracDelta(x - 100).subs(x, 100)
DiracDelta(0) 

fdiff(argindex=1)

返回 DiracDelta 函数的第一阶导数。

参数：

argindex : 整数

导数的程度

解释

diff()与fdiff()的区别在于：diff()是用户级函数，而fdiff()是对象方法。fdiff()是Function类中的便利方法，用于返回不考虑链式法则的函数导数。diff(function, x)调用Function._eval_derivative，后者在内部调用fdiff()来计算函数的导数。

示例

>>> from sympy import DiracDelta, diff
>>> from sympy.abc import x 

>>> DiracDelta(x).fdiff()
DiracDelta(x, 1) 

>>> DiracDelta(x, 1).fdiff()
DiracDelta(x, 2) 

>>> DiracDelta(x**2 - 1).fdiff()
DiracDelta(x**2 - 1, 1) 

>>> diff(DiracDelta(x, 1)).fdiff()
DiracDelta(x, 3) 

is_simple(x)

判断 DiracDelta 的参数(args[0])是否是x的线性表达式。

参数：

x : 可以是一个符号

示例

>>> from sympy import DiracDelta, cos
>>> from sympy.abc import x, y 

>>> DiracDelta(x*y).is_simple(x)
True
>>> DiracDelta(x*y).is_simple(y)
True 

>>> DiracDelta(x**2 + x - 2).is_simple(x)
False 

>>> DiracDelta(cos(x)).is_simple(x)
False 

另见

sympy.simplify.simplify.simplify, DiracDelta

class sympy.functions.special.delta_functions.Heaviside(arg, H0=1 / 2)

Heaviside 阶跃函数。

解释

海维赛德阶跃函数具有以下特性：

1. (\frac{d}{d x} \theta(x) = \delta(x))

2. (\theta(x) = \begin{cases} 0 & \text{for}: x < 0 \ \frac{1}{2} & \text{for}: x = 0 \1 & \text{for}: x > 0 \end{cases})

3. (\frac{d}{d x} \max(x, 0) = \theta(x))

当 SymPy LaTeX 打印机将 Heaviside(x)打印为(\theta(x))时。

在不同领域中 0 处的值设置不同。SymPy 使用 1/2，这是来自电子学和信号处理的约定，并且与通过 Fourier 变换和卷积求解不适当积分一致。

要在x=0处指定不同值的 Heaviside，可以提供第二个参数。使用Heaviside(x, nan)会给出一个在x=0时评估为 nan 的表达式。

从版本 1.9 开始更改：Heaviside(0)现在返回 1/2（之前为未定义）

示例

>>> from sympy import Heaviside, nan
>>> from sympy.abc import x
>>> Heaviside(9)
1
>>> Heaviside(-9)
0
>>> Heaviside(0)
1/2
>>> Heaviside(0, nan)
nan
>>> (Heaviside(x) + 1).replace(Heaviside(x), Heaviside(x, 1))
Heaviside(x, 1) + 1 

另见

DiracDelta

参考文献

[R343]

mathworld.wolfram.com/HeavisideStepFunction.html

[R344]

dlmf.nist.gov/1.16#iv

classmethod eval(arg, H0=1 / 2)

返回由 Heaviside 对象传递的参数的简化形式或 Heaviside 的值。

参数：

arg : 由 Heaviside 对象传递的参数

H0 : Heaviside(0)的值

解释

当 Heaviside 类即将实例化时，eval() 方法会自动调用，并返回根据传递的参数而确定的某些简化实例或未评估的实例。换句话说，不需要显式调用 eval() 方法，它在调用对象时被调用和评估。

示例

>>> from sympy import Heaviside, S
>>> from sympy.abc import x 

>>> Heaviside(x)
Heaviside(x) 

>>> Heaviside(19)
1 

>>> Heaviside(0)
1/2 

>>> Heaviside(0, 1)
1 

>>> Heaviside(-5)
0 

>>> Heaviside(S.NaN)
nan 

>>> Heaviside(x - 100).subs(x, 5)
0 

>>> Heaviside(x - 100).subs(x, 105)
1 

fdiff(argindex=1)

返回 Heaviside 函数的第一阶导数。

参数：

argindex : 整数

导数的顺序

示例

>>> from sympy import Heaviside, diff
>>> from sympy.abc import x 

>>> Heaviside(x).fdiff()
DiracDelta(x) 

>>> Heaviside(x**2 - 1).fdiff()
DiracDelta(x**2 - 1) 

>>> diff(Heaviside(x)).fdiff()
DiracDelta(x, 1) 

property pargs

Args 没有默认值 S.Half

class sympy.functions.special.singularity_functions.SingularityFunction(variable, offset, exponent)

奇异函数是一类不连续函数。

解释

奇异函数以变量、偏移量和指数作为参数。这些函数用 Macaulay 括号表示为：

SingularityFunction(x, a, n) := <x - a>^n

如果 n < 0，奇异函数将自动评估为 Derivative(DiracDelta(x - a), x, -n - 1)，如果 n >= 0，则为 (x - a)**n*Heaviside(x - a, 1)。

示例

>>> from sympy import SingularityFunction, diff, Piecewise, DiracDelta, Heaviside, Symbol
>>> from sympy.abc import x, a, n
>>> SingularityFunction(x, a, n)
SingularityFunction(x, a, n)
>>> y = Symbol('y', positive=True)
>>> n = Symbol('n', nonnegative=True)
>>> SingularityFunction(y, -10, n)
(y + 10)**n
>>> y = Symbol('y', negative=True)
>>> SingularityFunction(y, 10, n)
0
>>> SingularityFunction(x, 4, -1).subs(x, 4)
oo
>>> SingularityFunction(x, 10, -2).subs(x, 10)
oo
>>> SingularityFunction(4, 1, 5)
243
>>> diff(SingularityFunction(x, 1, 5) + SingularityFunction(x, 1, 4), x)
4*SingularityFunction(x, 1, 3) + 5*SingularityFunction(x, 1, 4)
>>> diff(SingularityFunction(x, 4, 0), x, 2)
SingularityFunction(x, 4, -2)
>>> SingularityFunction(x, 4, 5).rewrite(Piecewise)
Piecewise(((x - 4)**5, x >= 4), (0, True))
>>> expr = SingularityFunction(x, a, n)
>>> y = Symbol('y', positive=True)
>>> n = Symbol('n', nonnegative=True)
>>> expr.subs({x: y, a: -10, n: n})
(y + 10)**n 

方法 rewrite(DiracDelta)，rewrite(Heaviside) 和 rewrite('HeavisideDiracDelta') 返回相同的输出。可以根据需要使用这些方法中的任何一个。

>>> expr = SingularityFunction(x, 4, 5) + SingularityFunction(x, -3, -1) - SingularityFunction(x, 0, -2)
>>> expr.rewrite(Heaviside)
(x - 4)**5*Heaviside(x - 4, 1) + DiracDelta(x + 3) - DiracDelta(x, 1)
>>> expr.rewrite(DiracDelta)
(x - 4)**5*Heaviside(x - 4, 1) + DiracDelta(x + 3) - DiracDelta(x, 1)
>>> expr.rewrite('HeavisideDiracDelta')
(x - 4)**5*Heaviside(x - 4, 1) + DiracDelta(x + 3) - DiracDelta(x, 1) 

另见

DiracDelta，Heaviside

参考文献

[R345]

en.wikipedia.org/wiki/Singularity_function

classmethod eval(variable, offset, exponent)

根据对象传递的参数，返回奇异函数的简化形式或值。

解释

当 SingularityFunction 类即将实例化时，eval() 方法会自动调用，并返回根据传递的参数而确定的某些简化实例或未评估的实例。换句话说，不需要显式调用 eval() 方法，它在调用对象时被调用和评估。

示例

>>> from sympy import SingularityFunction, Symbol, nan
>>> from sympy.abc import x, a, n
>>> SingularityFunction(x, a, n)
SingularityFunction(x, a, n)
>>> SingularityFunction(5, 3, 2)
4
>>> SingularityFunction(x, a, nan)
nan
>>> SingularityFunction(x, 3, 0).subs(x, 3)
1
>>> SingularityFunction(4, 1, 5)
243
>>> x = Symbol('x', positive = True)
>>> a = Symbol('a', negative = True)
>>> n = Symbol('n', nonnegative = True)
>>> SingularityFunction(x, a, n)
(-a + x)**n
>>> x = Symbol('x', negative = True)
>>> a = Symbol('a', positive = True)
>>> SingularityFunction(x, a, n)
0 

fdiff(argindex=1)

返回 DiracDelta 函数的第一阶导数。

解释

diff() 和 fdiff() 的区别是：diff() 是用户级函数，fdiff() 是对象方法。fdiff() 是 Function 类中可用的便捷方法。它返回函数的导数，而不考虑链式法则。diff(function, x) 调用 Function._eval_derivative，后者又在内部调用 fdiff() 来计算函数的导数。

Gamma, Beta and Related Functions

class sympy.functions.special.gamma_functions.gamma(arg)

gamma 函数

[\Gamma(x) := \int^{\infty}_{0} t^{x-1} e^{-t} \mathrm{d}t.]

解释

gamma 函数实现了阶乘函数的值（即，当 n 是整数时，(\Gamma(n) = (n - 1)!)）。更一般地，(\Gamma(z)) 在整个复平面上定义，除了负整数处有简单极点。

示例

>>> from sympy import S, I, pi, gamma
>>> from sympy.abc import x 

已知几个特殊值：

>>> gamma(1)
1
>>> gamma(4)
6
>>> gamma(S(3)/2)
sqrt(pi)/2 

gamma 函数遵循镜像对称性：

>>> from sympy import conjugate
>>> conjugate(gamma(x))
gamma(conjugate(x)) 

支持相对于 (x) 的微分：

>>> from sympy import diff
>>> diff(gamma(x), x)
gamma(x)*polygamma(0, x) 

还支持级数展开：

>>> from sympy import series
>>> series(gamma(x), x, 0, 3)
1/x - EulerGamma + x*(EulerGamma**2/2 + pi**2/12) + x**2*(-EulerGamma*pi**2/12 - zeta(3)/3 - EulerGamma**3/6) + O(x**3) 

我们可以在整个复平面上任意精度地数值计算gamma函数：

>>> gamma(pi).evalf(40)
2.288037795340032417959588909060233922890
>>> gamma(1+I).evalf(20)
0.49801566811835604271 - 0.15494982830181068512*I 

请参阅

lowergamma

下不完全伽玛函数。

uppergamma

上不完全伽玛函数。

polygamma

多对数函数。

loggamma

对数伽玛函数。

digamma

Digamma 函数。

trigamma

三对数函数。

sympy.functions.special.beta_functions.beta

欧拉贝塔函数。

参考文献

[R346]

伽玛函数

[R347]

dlmf.nist.gov/5

[R348]

mathworld.wolfram.com/GammaFunction.html

[R349]

functions.wolfram.com/GammaBetaErf/Gamma/

class sympy.functions.special.gamma_functions.loggamma(z)

loggamma函数实现伽玛函数的对数（即，(\log\Gamma(x)))。

示例

已知几个特殊值。对于数值积分参数，我们有：

>>> from sympy import loggamma
>>> loggamma(-2)
oo
>>> loggamma(0)
oo
>>> loggamma(1)
0
>>> loggamma(2)
0
>>> loggamma(3)
log(2) 

以及符号值：

>>> from sympy import Symbol
>>> n = Symbol("n", integer=True, positive=True)
>>> loggamma(n)
log(gamma(n))
>>> loggamma(-n)
oo 

对于半整数值：

>>> from sympy import S
>>> loggamma(S(5)/2)
log(3*sqrt(pi)/4)
>>> loggamma(n/2)
log(2**(1 - n)*sqrt(pi)*gamma(n)/gamma(n/2 + 1/2)) 

和一般的有理参数：

>>> from sympy import expand_func
>>> L = loggamma(S(16)/3)
>>> expand_func(L).doit()
-5*log(3) + loggamma(1/3) + log(4) + log(7) + log(10) + log(13)
>>> L = loggamma(S(19)/4)
>>> expand_func(L).doit()
-4*log(4) + loggamma(3/4) + log(3) + log(7) + log(11) + log(15)
>>> L = loggamma(S(23)/7)
>>> expand_func(L).doit()
-3*log(7) + log(2) + loggamma(2/7) + log(9) + log(16) 

loggamma函数在无穷大时有以下极限：

>>> from sympy import oo
>>> loggamma(oo)
oo
>>> loggamma(-oo)
zoo 

如果 (x \in \mathbb{C} \setminus {-\infty, 0})，loggamma函数遵循镜像对称性：

>>> from sympy.abc import x
>>> from sympy import conjugate
>>> conjugate(loggamma(x))
loggamma(conjugate(x)) 

支持对 (x) 的微分：

>>> from sympy import diff
>>> diff(loggamma(x), x)
polygamma(0, x) 

还支持级数展开：

>>> from sympy import series
>>> series(loggamma(x), x, 0, 4).cancel()
-log(x) - EulerGamma*x + pi**2*x**2/12 - x**3*zeta(3)/3 + O(x**4) 

我们可以在整个复平面上任意精度地数值计算loggamma函数：

>>> from sympy import I
>>> loggamma(5).evalf(30)
3.17805383034794561964694160130
>>> loggamma(I).evalf(20)
-0.65092319930185633889 - 1.8724366472624298171*I 

请参阅

gamma

伽玛函数。

lowergamma

下不完全伽玛函数。

uppergamma

上不完全伽玛函数。

polygamma

多对数函数。

digamma

Digamma 函数。

trigamma

Trigamma 函数。

sympy.functions.special.beta_functions.beta

欧拉贝塔函数。

参考文献

[R350]

en.wikipedia.org/wiki/Gamma_function

[R351]

dlmf.nist.gov/5

[R352]

mathworld.wolfram.com/LogGammaFunction.html

[R353]

functions.wolfram.com/GammaBetaErf/LogGamma/

class sympy.functions.special.gamma_functions.polygamma(n, z)

函数 polygamma(n, z) 返回 log(gamma(z)).diff(n + 1)。

解释

它是 (\mathbb{C}) 上的亚黎曼函数，并定义为伽玛函数对数的第 ((n+1)) 阶导数：

[\psi^{(n)} (z) := \frac{\mathrm{d}^{n+1}}{\mathrm{d} z^{n+1}} \log\Gamma(z).]

对于 (n) 不是非负整数，使用 Espinosa 和 Moll 的推广[R358]：

[\psi(s,z) = \frac{\zeta'(s+1, z) + (\gamma + \psi(-s)) \zeta(s+1, z)} {\Gamma(-s)}]

示例

已知几个特殊值：

>>> from sympy import S, polygamma
>>> polygamma(0, 1)
-EulerGamma
>>> polygamma(0, 1/S(2))
-2*log(2) - EulerGamma
>>> polygamma(0, 1/S(3))
-log(3) - sqrt(3)*pi/6 - EulerGamma - log(sqrt(3))
>>> polygamma(0, 1/S(4))
-pi/2 - log(4) - log(2) - EulerGamma
>>> polygamma(0, 2)
1 - EulerGamma
>>> polygamma(0, 23)
19093197/5173168 - EulerGamma 

>>> from sympy import oo, I
>>> polygamma(0, oo)
oo
>>> polygamma(0, -oo)
oo
>>> polygamma(0, I*oo)
oo
>>> polygamma(0, -I*oo)
oo 

支持对 (x) 的微分：

>>> from sympy import Symbol, diff
>>> x = Symbol("x")
>>> diff(polygamma(0, x), x)
polygamma(1, x)
>>> diff(polygamma(0, x), x, 2)
polygamma(2, x)
>>> diff(polygamma(0, x), x, 3)
polygamma(3, x)
>>> diff(polygamma(1, x), x)
polygamma(2, x)
>>> diff(polygamma(1, x), x, 2)
polygamma(3, x)
>>> diff(polygamma(2, x), x)
polygamma(3, x)
>>> diff(polygamma(2, x), x, 2)
polygamma(4, x) 

>>> n = Symbol("n")
>>> diff(polygamma(n, x), x)
polygamma(n + 1, x)
>>> diff(polygamma(n, x), x, 2)
polygamma(n + 2, x) 

我们可以用调和数来重写 polygamma 函数：

>>> from sympy import harmonic
>>> polygamma(0, x).rewrite(harmonic)
harmonic(x - 1) - EulerGamma
>>> polygamma(2, x).rewrite(harmonic)
2*harmonic(x - 1, 3) - 2*zeta(3)
>>> ni = Symbol("n", integer=True)
>>> polygamma(ni, x).rewrite(harmonic)
(-1)**(n + 1)*(-harmonic(x - 1, n + 1) + zeta(n + 1))*factorial(n) 

另见

gamma

Gamma 函数。

lowergamma

下不完全伽玛函数。

uppergamma

上不完全伽玛函数。

loggamma

对数伽玛函数。

digamma

Digamma 函数。

trigamma

Trigamma 函数。

sympy.functions.special.beta_functions.beta

欧拉贝塔函数。

参考文献

[R354]

en.wikipedia.org/wiki/Polygamma_function

[R355]

mathworld.wolfram.com/PolygammaFunction.html

[R356]

functions.wolfram.com/GammaBetaErf/PolyGamma/

[R357]

functions.wolfram.com/GammaBetaErf/PolyGamma2/

[R358] (1,2)

O. Espinosa 和 V. Moll，“广义多次伽玛函数”，积分变换与特殊函数（2004），101-115。

class sympy.functions.special.gamma_functions.digamma(z)

digamma函数是loggamma函数的一阶导数。

[\psi(x) := \frac{\mathrm{d}}{\mathrm{d} z} \log\Gamma(z) = \frac{\Gamma'(z)}{\Gamma(z) }.]

在这种情况下，digamma(z) = polygamma(0, z)。

示例

>>> from sympy import digamma
>>> digamma(0)
zoo
>>> from sympy import Symbol
>>> z = Symbol('z')
>>> digamma(z)
polygamma(0, z) 

保持digamma不变：

>>> digamma(0, evaluate=False)
digamma(0)
>>> digamma(z, evaluate=False)
digamma(z) 

另见

gamma

Gamma 函数。

lowergamma

下不完全伽玛函数。

uppergamma

上不完全伽玛函数。

polygamma

多次伽玛函数。

loggamma

对数 Gamma 函数。

trigamma

三次伽玛函数。

sympy.functions.special.beta_functions.beta

欧拉贝塔函数。

参考文献

[R359]

en.wikipedia.org/wiki/Digamma_function

[R360]

mathworld.wolfram.com/DigammaFunction.html

[R361]

functions.wolfram.com/GammaBetaErf/PolyGamma2/

class sympy.functions.special.gamma_functions.trigamma(z)

trigamma函数是loggamma函数的二阶导数。

[\psi^{(1)}(z) := \frac{\mathrm{d}^{2}}{\mathrm{d} z^{2}} \log\Gamma(z).]

在这种情况下，trigamma(z) = polygamma(1, z)。

示例

>>> from sympy import trigamma
>>> trigamma(0)
zoo
>>> from sympy import Symbol
>>> z = Symbol('z')
>>> trigamma(z)
polygamma(1, z) 

保持trigamma不变：

>>> trigamma(0, evaluate=False)
trigamma(0)
>>> trigamma(z, evaluate=False)
trigamma(z) 

另见

gamma

Gamma 函数。

lowergamma

下不完全伽玛函数。

uppergamma

上不完全伽玛函数。

polygamma

多次伽玛函数。

loggamma

对数 Gamma 函数。

digamma

Digamma 函数。

sympy.functions.special.beta_functions.beta

欧拉贝塔函数。

参考

[R362]

en.wikipedia.org/wiki/Trigamma_function

[R363]

mathworld.wolfram.com/TrigammaFunction.html

[R364]

functions.wolfram.com/GammaBetaErf/PolyGamma2/

class sympy.functions.special.gamma_functions.uppergamma(a, z)

上不完全伽玛函数。

解释

它可以定义为

[\Gamma(s, x) := \int_x^\infty t^{s-1} e^{-t} \mathrm{d}t = \Gamma(s) - \gamma(s, x).]

其中 (\gamma(s, x)) 是下不完全伽玛函数，lowergamma。这可以证明与

[\Gamma(s, x) = \Gamma(s) - \frac{x^s}{s} {}_1F_1\left({s \atop s+1} \middle| -x\right),]

其中 ({}_1F_1) 是超几何函数。

上不完全伽玛函数也基本等同于广义指数积分：

[\operatorname{E}{n}(x) = \int^{{\infty}{\frac{e}{-xt}}{t^n} , dt} = x^{n-1}\Gamma(1-n,x).]

示例

>>> from sympy import uppergamma, S
>>> from sympy.abc import s, x
>>> uppergamma(s, x)
uppergamma(s, x)
>>> uppergamma(3, x)
2*(x**2/2 + x + 1)*exp(-x)
>>> uppergamma(-S(1)/2, x)
-2*sqrt(pi)*erfc(sqrt(x)) + 2*exp(-x)/sqrt(x)
>>> uppergamma(-2, x)
expint(3, x)/x**2 

参见

gamma

伽玛函数。

lowergamma

下不完全伽玛函数。

polygamma

Polygamma 函数。

loggamma

对数伽玛函数。

digamma

Digamma 函数。

trigamma

Trigamma 函数。

sympy.functions.special.beta_functions.beta

欧拉贝塔函数。

参考

[R365]

en.wikipedia.org/wiki/Incomplete_gamma_function#Upper_incomplete_gamma_function

[R366]

Abramowitz, Milton; Stegun, Irene A., eds. (1965), Chapter 6, Section 5, Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables

[R367]

dlmf.nist.gov/8

[R368]

functions.wolfram.com/GammaBetaErf/Gamma2/

[R369]

functions.wolfram.com/GammaBetaErf/Gamma3/

[R370]

en.wikipedia.org/wiki/Exponential_integral#Relation_with_other_functions

class sympy.functions.special.gamma_functions.lowergamma(a, x)

下不完全伽玛函数.

说明

它可以定义为

[\gamma(s, x) := \int_0^x t^{s-1} e^{-t} \mathrm{d}t = \Gamma(s) - \Gamma(s, x).]

这可以表明是相同的

[\gamma(s, x) = \frac{x^s}{s} {}_1F_1\left({s \atop s+1} \middle| -x\right),]

其中 ({}_1F_1) 是（合流）超几何函数.

例子

>>> from sympy import lowergamma, S
>>> from sympy.abc import s, x
>>> lowergamma(s, x)
lowergamma(s, x)
>>> lowergamma(3, x)
-2*(x**2/2 + x + 1)*exp(-x) + 2
>>> lowergamma(-S(1)/2, x)
-2*sqrt(pi)*erf(sqrt(x)) - 2*exp(-x)/sqrt(x) 

参见

gamma

伽玛函数.

uppergamma

上不完全伽玛函数.

polygamma

多次伽玛函数.

loggamma

对数伽玛函数.

digamma

二阶Ψ函数.

trigamma

三角函数.

sympy.functions.special.beta_functions.beta

欧拉贝塔函数.

参考

[R371]

en.wikipedia.org/wiki/Incomplete_gamma_function#Lower_incomplete_gamma_function

[R372]

Abramowitz, Milton; Stegun, Irene A., eds. (1965), Chapter 6, Section 5, Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables

[R373]

dlmf.nist.gov/8

[R374]

functions.wolfram.com/GammaBetaErf/Gamma2/

[R375]

functions.wolfram.com/GammaBetaErf/Gamma3/

class sympy.functions.special.gamma_functions.multigamma(x, p)

多元伽玛函数是伽玛函数的一般化

[\Gamma_p(z) = \pi^{{p(p-1)/4}\prod_{k=1}}p \Gamma[z + (1 - k)/2].]

在一个特殊情况下，multigamma(x, 1) = gamma(x)。

参数：

p：多元伽玛函数的阶数或维度

例子

>>> from sympy import S, multigamma
>>> from sympy import Symbol
>>> x = Symbol('x')
>>> p = Symbol('p', positive=True, integer=True) 

>>> multigamma(x, p)
pi**(p*(p - 1)/4)*Product(gamma(-_k/2 + x + 1/2), (_k, 1, p)) 

已知几个特殊值：

>>> multigamma(1, 1)
1
>>> multigamma(4, 1)
6
>>> multigamma(S(3)/2, 1)
sqrt(pi)/2 

将 multigamma 表示为 gamma 函数：

>>> multigamma(x, 1)
gamma(x) 

>>> multigamma(x, 2)
sqrt(pi)*gamma(x)*gamma(x - 1/2) 

>>> multigamma(x, 3)
pi**(3/2)*gamma(x)*gamma(x - 1)*gamma(x - 1/2) 

参见

gamma, lowergamma, uppergamma, polygamma, loggamma, digamma, trigamma, sympy.functions.special.beta_functions.beta

参考文献

[R376]

en.wikipedia.org/wiki/Multivariate_gamma_function

class sympy.functions.special.beta_functions.beta(x, y=None)

贝塔积分被 Legendre 称为第一类欧拉积分：

[\mathrm{B}(x,y) \int^{1}_{0} t^{x-1} (1-t)^{y-1} \mathrm{d}t.]

说明

贝塔函数或欧拉第一积分与伽玛函数密切相关。贝塔函数通常用于概率论和数理统计。它满足如下特性：

[\begin{split}\mathrm{B}(a,1) = \frac{1}{a} \ \mathrm{B}(a,b) = \mathrm{B}(b,a) \ \mathrm{B}(a,b) = \frac{\Gamma(a) \Gamma(b)}{\Gamma(a+b)}\end{split}]

因此对于(a)和(b)的整数值：

[\mathrm{B} = \frac{(a-1)! (b-1)!}{(a+b-1)!}]

当(x = y)时贝塔函数的特殊情况是中心贝塔函数。它具有如下特性：

[\mathrm{B}(x) = 2^{1 - 2x}\mathrm{B}(x, \frac{1}{2}) \mathrm{B}(x) = 2^{1 - 2x} cos(\pi x) \mathrm{B}(\frac{1}{2} - x, x) \mathrm{B}(x) = \int_{0}^{1} \frac{t^x}{(1 + t)^{2x}} dt \mathrm{B}(x) = \frac{2}{x} \prod_{n = 1}^{\infty} \frac{n(n + 2x)}{(n + x)²}]

例子

>>> from sympy import I, pi
>>> from sympy.abc import x, y 

贝塔函数遵循镜像对称性：

>>> from sympy import beta, conjugate
>>> conjugate(beta(x, y))
beta(conjugate(x), conjugate(y)) 

支持对(x)和(y)的微分：

>>> from sympy import beta, diff
>>> diff(beta(x, y), x)
(polygamma(0, x) - polygamma(0, x + y))*beta(x, y) 

>>> diff(beta(x, y), y)
(polygamma(0, y) - polygamma(0, x + y))*beta(x, y) 

>>> diff(beta(x), x)
2*(polygamma(0, x) - polygamma(0, 2*x))*beta(x, x) 

我们可以对复数(x)和(y)任意精确评估贝塔函数：

>>> from sympy import beta
>>> beta(pi).evalf(40)
0.02671848900111377452242355235388489324562 

>>> beta(1 + I).evalf(20)
-0.2112723729365330143 - 0.7655283165378005676*I 

另请参阅

gamma

伽玛函数。

uppergamma

上不完全伽玛函数。

lowergamma

下不完全伽玛函数。

polygamma

多元伽玛函数。

loggamma

对数伽马函数。

digamma

三角斐函数。

trigamma

三角伽马函数。

参考文献

[R377]

en.wikipedia.org/wiki/Beta_function

[R378]

mathworld.wolfram.com/BetaFunction.html

[R379]

dlmf.nist.gov/5.12 ## 误差函数与菲涅尔积分

class sympy.functions.special.error_functions.erf(arg)

高斯误差函数。

解释

此函数定义为：

[\mathrm{erf}(x) = \frac{2}{\sqrt{\pi}} \int_0^x e^{-t²} \mathrm{d}t.]

例子

>>> from sympy import I, oo, erf
>>> from sympy.abc import z 

已知几个特殊值：

>>> erf(0)
0
>>> erf(oo)
1
>>> erf(-oo)
-1
>>> erf(I*oo)
oo*I
>>> erf(-I*oo)
-oo*I 

一般来说，可以从参数中提取因子-1 和(I)：

>>> erf(-z)
-erf(z) 

误差函数遵循镜像对称性：

>>> from sympy import conjugate
>>> conjugate(erf(z))
erf(conjugate(z)) 

支持对(z)的微分：

>>> from sympy import diff
>>> diff(erf(z), z)
2*exp(-z**2)/sqrt(pi) 

我们可以在整个复平面上对误差函数进行任意精度的数值评估：

>>> erf(4).evalf(30)
0.999999984582742099719981147840 

>>> erf(-4*I).evalf(30)
-1296959.73071763923152794095062*I 

另请参阅

erfc

补充误差函数。

erfi

虚数误差函数。

erf2

二参数误差函数。

erfinv

误差函数的反函数。

erfcinv

补充误差函数的反函数。

erf2inv

二参数误差函数的反函数。

参考文献

[R380]

en.wikipedia.org/wiki/Error_function

[R381]

dlmf.nist.gov/7

[R382]

mathworld.wolfram.com/Erf.html

[R383]

functions.wolfram.com/GammaBetaErf/Erf

inverse(argindex=1)

返回该函数的反函数。

class sympy.functions.special.error_functions.erfc(arg)

补充误差函数。

解释

此函数定义为：

[\mathrm{erfc}(x) = \frac{2}{\sqrt{\pi}} \int_x^\infty e^{-t²} \mathrm{d}t]

例子

>>> from sympy import I, oo, erfc
>>> from sympy.abc import z 

已知几个特殊值：

>>> erfc(0)
1
>>> erfc(oo)
0
>>> erfc(-oo)
2
>>> erfc(I*oo)
-oo*I
>>> erfc(-I*oo)
oo*I 

误差函数遵循镜像对称性：

>>> from sympy import conjugate
>>> conjugate(erfc(z))
erfc(conjugate(z)) 

支持对(z)的微分：

>>> from sympy import diff
>>> diff(erfc(z), z)
-2*exp(-z**2)/sqrt(pi) 

也遵循

>>> erfc(-z)
2 - erfc(z) 

我们可以在整个复平面上对补充误差函数进行任意精度的数值评估：

>>> erfc(4).evalf(30)
0.0000000154172579002800188521596734869 

>>> erfc(4*I).evalf(30)
1.0 - 1296959.73071763923152794095062*I 

另请参阅

erf

高斯误差函数。

erfi

虚误差函数。

erf2

二参数误差函数。

erfinv

逆误差函数。

erfcinv

逆补充误差函数。

erf2inv

逆二参数误差函数。

参考文献

[R384]

en.wikipedia.org/wiki/Error_function

[R385]

dlmf.nist.gov/7

[R386]

mathworld.wolfram.com/Erfc.html

[R387]

functions.wolfram.com/GammaBetaErf/Erfc

inverse(argindex=1)

返回此函数的逆。

class sympy.functions.special.error_functions.erfi(z)

虚误差函数。

解释

函数 erfi 定义为：

[\mathrm{erfi}(x) = \frac{2}{\sqrt{\pi}} \int_0^x e^{t²} \mathrm{d}t]

示例

>>> from sympy import I, oo, erfi
>>> from sympy.abc import z 

已知几个特殊值：

>>> erfi(0)
0
>>> erfi(oo)
oo
>>> erfi(-oo)
-oo
>>> erfi(I*oo)
I
>>> erfi(-I*oo)
-I 

通常可以从参数中提取出因子 -1 和 (I) ：

>>> erfi(-z)
-erfi(z) 

>>> from sympy import conjugate
>>> conjugate(erfi(z))
erfi(conjugate(z)) 

对 (z) 的微分受支持：

>>> from sympy import diff
>>> diff(erfi(z), z)
2*exp(z**2)/sqrt(pi) 

我们可以在整个复平面上对虚误差函数进行任意精度的数值评估：

>>> erfi(2).evalf(30)
18.5648024145755525987042919132 

>>> erfi(-2*I).evalf(30)
-0.995322265018952734162069256367*I 

另见

erf

高斯误差函数。

erfc

补充误差函数。

erf2

二参数误差函数。

erfinv

逆误差函数。

erfcinv

逆补充误差函数。

erf2inv

逆二参数误差函数。

参考文献

[R388]

en.wikipedia.org/wiki/Error_function

[R389]

mathworld.wolfram.com/Erfi.html

[R390]

functions.wolfram.com/GammaBetaErf/Erfi

class sympy.functions.special.error_functions.erf2(x, y)

二参数误差函数。

解释

此函数定义为：

[\mathrm{erf2}(x, y) = \frac{2}{\sqrt{\pi}} \int_x^y e^{-t²} \mathrm{d}t]

示例

>>> from sympy import oo, erf2
>>> from sympy.abc import x, y 

已知几个特殊值：

>>> erf2(0, 0)
0
>>> erf2(x, x)
0
>>> erf2(x, oo)
1 - erf(x)
>>> erf2(x, -oo)
-erf(x) - 1
>>> erf2(oo, y)
erf(y) - 1
>>> erf2(-oo, y)
erf(y) + 1 

通常可以从参数中提取出因子 -1：

>>> erf2(-x, -y)
-erf2(x, y) 

误差函数服从镜像对称性：

>>> from sympy import conjugate
>>> conjugate(erf2(x, y))
erf2(conjugate(x), conjugate(y)) 

支持关于(x)、(y)的微分：

>>> from sympy import diff
>>> diff(erf2(x, y), x)
-2*exp(-x**2)/sqrt(pi)
>>> diff(erf2(x, y), y)
2*exp(-y**2)/sqrt(pi) 

另请参阅

erf

高斯误差函数。

erfc

互补误差函数。

erfi

虚误差函数。

erfinv

逆误差函数。

erfcinv

逆互补误差函数。

erf2inv

逆二参数误差函数。

参考

[R391]

functions.wolfram.com/GammaBetaErf/Erf2/

class sympy.functions.special.error_functions.erfinv(z)

逆误差函数。erfinv 函数定义为:

[\mathrm{erf}(x) = y \quad \Rightarrow \quad \mathrm{erfinv}(y) = x]

示例

>>> from sympy import erfinv
>>> from sympy.abc import x 

已知几个特殊值：

>>> erfinv(0)
0
>>> erfinv(1)
oo 

支持关于(x)的微分：

>>> from sympy import diff
>>> diff(erfinv(x), x)
sqrt(pi)*exp(erfinv(x)**2)/2 

我们可以在[-1, 1]上数值评估逆误差函数到任意精度：

>>> erfinv(0.2).evalf(30)
0.179143454621291692285822705344 

另请参阅

erf

高斯误差函数。

erfc

互补误差函数。

erfi

虚误差函数。

erf2

二参数误差函数。

erfcinv

逆互补误差函数。

erf2inv

逆二参数误差函数。

参考

[R392]

en.wikipedia.org/wiki/Error_function#Inverse_functions

[R393]

functions.wolfram.com/GammaBetaErf/InverseErf/

inverse(argindex=1)

返回该函数的逆。

class sympy.functions.special.error_functions.erfcinv(z)

逆互补误差函数。erfcinv 函数定义为：

[\mathrm{erfc}(x) = y \quad \Rightarrow \quad \mathrm{erfcinv}(y) = x]

示例

>>> from sympy import erfcinv
>>> from sympy.abc import x 

已知几个特殊值：

>>> erfcinv(1)
0
>>> erfcinv(0)
oo 

支持关于(x)的微分：

>>> from sympy import diff
>>> diff(erfcinv(x), x)
-sqrt(pi)*exp(erfcinv(x)**2)/2 

另请参阅

erf

高斯误差函数。

erfc

互补误差函数。

erfi

虚误差函数。

erf2

双参数误差函数。

erfinv

逆误差函数。

erf2inv

双参数逆误差函数。

参考文献

[R394]

en.wikipedia.org/wiki/Error_function#Inverse_functions

[R395]

functions.wolfram.com/GammaBetaErf/InverseErfc/

inverse(argindex=1)

返回此函数的逆。

class sympy.functions.special.error_functions.erf2inv(x, y)

双参数逆误差函数。erf2inv 函数定义如下：

[\mathrm{erf2}(x, w) = y \quad \Rightarrow \quad \mathrm{erf2inv}(x, y) = w]

示例

>>> from sympy import erf2inv, oo
>>> from sympy.abc import x, y 

已知几个特殊值：

>>> erf2inv(0, 0)
0
>>> erf2inv(1, 0)
1
>>> erf2inv(0, 1)
oo
>>> erf2inv(0, y)
erfinv(y)
>>> erf2inv(oo, y)
erfcinv(-y) 

支持对 (x) 和 (y) 的微分：

>>> from sympy import diff
>>> diff(erf2inv(x, y), x)
exp(-x**2 + erf2inv(x, y)**2)
>>> diff(erf2inv(x, y), y)
sqrt(pi)*exp(erf2inv(x, y)**2)/2 

参见

erf

高斯误差函数。

erfc

互补误差函数。

erfi

虚误差函数。

erf2

双参数误差函数。

erfinv

逆误差函数。

erfcinv

逆互补误差函数。

参考文献

[R396]

functions.wolfram.com/GammaBetaErf/InverseErf2/

class sympy.functions.special.error_functions.FresnelIntegral(z)

Fresnel 积分的基类。

class sympy.functions.special.error_functions.fresnels(z)

Fresnel 积分 S。

解释

此函数由以下定义

[\operatorname{S}(z) = \int_0^z \sin{\frac{\pi}{2} t²} \mathrm{d}t.]

它是一个整函数。

示例

>>> from sympy import I, oo, fresnels
>>> from sympy.abc import z 

已知几个特殊值：

>>> fresnels(0)
0
>>> fresnels(oo)
1/2
>>> fresnels(-oo)
-1/2
>>> fresnels(I*oo)
-I/2
>>> fresnels(-I*oo)
I/2 

一般来说，可以从参数中提取因子 -1 和 (i)：

>>> fresnels(-z)
-fresnels(z)
>>> fresnels(I*z)
-I*fresnels(z) 

Fresnel S 积分遵循镜像对称性 (\overline{S(z)} = S(\bar{z})):

>>> from sympy import conjugate
>>> conjugate(fresnels(z))
fresnels(conjugate(z)) 

支持对 (z) 的微分：

>>> from sympy import diff
>>> diff(fresnels(z), z)
sin(pi*z**2/2) 

通过积分定义 Fresnel 函数：

>>> from sympy import integrate, pi, sin, expand_func
>>> integrate(sin(pi*z**2/2), z)
3*fresnels(z)*gamma(3/4)/(4*gamma(7/4))
>>> expand_func(integrate(sin(pi*z**2/2), z))
fresnels(z) 

我们可以在整个复平面上对 Fresnel 积分进行任意精度的数值评估：

>>> fresnels(2).evalf(30)
0.343415678363698242195300815958 

>>> fresnels(-2*I).evalf(30)
0.343415678363698242195300815958*I 

参见

fresnelc

Fresnel 余弦积分。

参考文献

[R397]

en.wikipedia.org/wiki/Fresnel_integral

[R398]

dlmf.nist.gov/7

[R399]

mathworld.wolfram.com/FresnelIntegrals.html

[R400]

functions.wolfram.com/GammaBetaErf/FresnelS

[R401]

由 John W. Wrench Jr.和 Vicki Alley 推导的 Fresnel 积分的收敛因子

class sympy.functions.special.error_functions.fresnelc(z)

Fresnel 积分 C。

解释

此函数由以下定义：

[\operatorname{C}(z) = \int_0^z \cos{\frac{\pi}{2} t²} \mathrm{d}t.]

这是一个整函数。

例子

>>> from sympy import I, oo, fresnelc
>>> from sympy.abc import z 

已知几个特殊值：

>>> fresnelc(0)
0
>>> fresnelc(oo)
1/2
>>> fresnelc(-oo)
-1/2
>>> fresnelc(I*oo)
I/2
>>> fresnelc(-I*oo)
-I/2 

通常可以从参数中提取出-1 和(i)的因子：

>>> fresnelc(-z)
-fresnelc(z)
>>> fresnelc(I*z)
I*fresnelc(z) 

Fresnel C 积分遵守镜像对称性 (\overline{C(z)} = C(\bar{z}))：

>>> from sympy import conjugate
>>> conjugate(fresnelc(z))
fresnelc(conjugate(z)) 

支持对(z)微分：

>>> from sympy import diff
>>> diff(fresnelc(z), z)
cos(pi*z**2/2) 

通过积分定义 Fresnel 函数：

>>> from sympy import integrate, pi, cos, expand_func
>>> integrate(cos(pi*z**2/2), z)
fresnelc(z)*gamma(1/4)/(4*gamma(5/4))
>>> expand_func(integrate(cos(pi*z**2/2), z))
fresnelc(z) 

我们可以在整个复平面上对 Fresnel 积分进行任意精度的数值评估：

>>> fresnelc(2).evalf(30)
0.488253406075340754500223503357 

>>> fresnelc(-2*I).evalf(30)
-0.488253406075340754500223503357*I 

参见

fresnels

Fresnel 正弦积分。

参考文献

[R402]

en.wikipedia.org/wiki/Fresnel_integral

[R403]

dlmf.nist.gov/7

[R404]

mathworld.wolfram.com/FresnelIntegrals.html

[R405]

functions.wolfram.com/GammaBetaErf/FresnelC

[R406]

由 John W. Wrench Jr.和 Vicki Alley 推导的 Fresnel 积分的收敛因子

指数、对数和三角积分

class sympy.functions.special.error_functions.Ei(z)

经典指数积分。

解释

用于 SymPy，此函数定义如下：

[\operatorname{Ei}(x) = \sum_{n=1}^\infty \frac{x^n}{n, n!} + \log(x) + \gamma,]

其中(\gamma)是欧拉-马斯切罗尼常数。

如果(x)是极坐标数，则在对数的 Riemann 面上定义了一个解析函数。否则，在割面(\mathbb{C} \setminus (-\infty, 0])中定义了一个解析函数。

背景

指数积分的名称来源于以下声明：

[\operatorname{Ei}(x) = \int_{-\infty}^x \frac{e^t}{t} \mathrm{d}t]

如果将积分解释为柯西主值，则对于(x > 0)和上述定义的(\operatorname{Ei}(x))，此声明成立。

例子

>>> from sympy import Ei, polar_lift, exp_polar, I, pi
>>> from sympy.abc import x 

>>> Ei(-1)
Ei(-1) 

这产生一个实数值：

>>> Ei(-1).n(chop=True)
-0.219383934395520 

另一方面，解析延拓并非实数：

>>> Ei(polar_lift(-1)).n(chop=True)
-0.21938393439552 + 3.14159265358979*I 

指数积分在原点有对数分支点：

>>> Ei(x*exp_polar(2*I*pi))
Ei(x) + 2*I*pi 

支持微分：

>>> Ei(x).diff(x)
exp(x)/x 

指数积分与许多其他特殊函数相关联。例如：

>>> from sympy import expint, Shi
>>> Ei(x).rewrite(expint)
-expint(1, x*exp_polar(I*pi)) - I*pi
>>> Ei(x).rewrite(Shi)
Chi(x) + Shi(x) 

参见

expint

广义指数积分。

E1

广义指数积分的特殊情况。

li

对数积分。

Li

偏移对数积分。

Si

正弦积分。

Ci

余弦积分。

Shi

双曲正弦积分。

Chi

双曲余弦积分。

uppergamma

上不完全 Gamma 函数。

参考文献

[R407]

dlmf.nist.gov/6.6

[R408]

en.wikipedia.org/wiki/Exponential_integral

[R409]

Abramowitz & Stegun, section 5: web.archive.org/web/20201128173312/http://people.math.sfu.ca/~cbm/aands/page_228.htm

class sympy.functions.special.error_functions.expint(nu, z)

广义指数积分。

解释

此函数定义为

[\operatorname{E}_\nu(z) = z^{\nu - 1} \Gamma(1 - \nu, z),]

其中 (\Gamma(1 - \nu, z)) 是上不完全 Gamma 函数 (uppergamma)。

因此对于具有正实部的 (z) 我们有

[\operatorname{E}_\nu(z) = \int_1^\infty \frac{e^{-zt}}{t\nu} \mathrm{d}t,]

这解释了其名称。

表示为不完全 Gamma 函数提供了 (\operatorname{E}_\nu(z)) 的解析延拓。如果 (\nu) 是非正整数，则指数积分是 (z) 的一个非分支函数，否则在原点有一个分支点。详细的分支行为请参考不完全 Gamma 函数的文档。

示例

>>> from sympy import expint, S
>>> from sympy.abc import nu, z 

支持微分。对 (z) 的微分进一步解释了名称：对于整数阶，指数积分是指数函数的迭代积分。

>>> expint(nu, z).diff(z)
-expint(nu - 1, z) 

对于 (\nu) 的微分没有经典表达式：

>>> expint(nu, z).diff(nu)
-z**(nu - 1)*meijerg(((), (1, 1)), ((0, 0, 1 - nu), ()), z) 

在非正整数阶时，指数积分简化为指数函数：

>>> expint(0, z)
exp(-z)/z
>>> expint(-1, z)
exp(-z)/z + exp(-z)/z**2 

在半整数处，它简化为误差函数：

>>> expint(S(1)/2, z)
sqrt(pi)*erfc(sqrt(z))/sqrt(z) 

在正整数阶时，它可以用指数形式和 expint(1, z) 重写。使用 expand_func() 来完成这一点：

>>> from sympy import expand_func
>>> expand_func(expint(5, z))
z**4*expint(1, z)/24 + (-z**3 + z**2 - 2*z + 6)*exp(-z)/24 

广义指数积分本质上等同于不完全 Gamma 函数：

>>> from sympy import uppergamma
>>> expint(nu, z).rewrite(uppergamma)
z**(nu - 1)*uppergamma(1 - nu, z) 

因此它在原点处分支：

>>> from sympy import exp_polar, pi, I
>>> expint(4, z*exp_polar(2*pi*I))
I*pi*z**3/3 + expint(4, z)
>>> expint(nu, z*exp_polar(2*pi*I))
z**(nu - 1)*(exp(2*I*pi*nu) - 1)*gamma(1 - nu) + expint(nu, z) 

另见

Ei

另一个相关的称为指数积分的函数。

E1

经典情况，返回expint(1, z)。

li

对数积分。

Li

偏移对数积分。

Si

正弦积分。

Ci

余弦积分。

Shi

双曲正弦积分。

Chi

双曲余弦积分。

uppergamma

参考文献

[R410]

dlmf.nist.gov/8.19

[R411]

functions.wolfram.com/GammaBetaErf/ExpIntegralE/

[R412]

en.wikipedia.org/wiki/Exponential_integral

sympy.functions.special.error_functions.E1(z)

广义指数积分的经典情况。

解释

这等同于expint(1, z)。

示例

>>> from sympy import E1
>>> E1(0)
expint(1, 0) 

>>> E1(5)
expint(1, 5) 

另请参阅

Ei

指数积分。

expint

广义指数积分。

li

对数积分。

Li

偏移对数积分。

Si

正弦积分。

Ci

余弦积分。

Shi

双曲正弦积分。

Chi

双曲余弦积分。

class sympy.functions.special.error_functions.li(z)

经典对数积分。

解释

在 SymPy 中使用，该函数定义为

[\operatorname{li}(x) = \int_0^x \frac{1}{\log(t)} \mathrm{d}t ,.]

示例

>>> from sympy import I, oo, li
>>> from sympy.abc import z 

已知几个特殊值：

>>> li(0)
0
>>> li(1)
-oo
>>> li(oo)
oo 

支持对(z)的微分：

>>> from sympy import diff
>>> diff(li(z), z)
1/log(z) 

通过积分定义li函数： >>> from sympy import integrate >>> integrate(li(z)) zli(z) - Ei(2log(z))

>>> integrate(li(z),z)
z*li(z) - Ei(2*log(z)) 

对数积分也可以用Ei定义：

>>> from sympy import Ei
>>> li(z).rewrite(Ei)
Ei(log(z))
>>> diff(li(z).rewrite(Ei), z)
1/log(z) 

我们可以在整个复平面上（除了奇点）对对数积分进行任意精度的数值计算：

>>> li(2).evalf(30)
1.04516378011749278484458888919 

>>> li(2*I).evalf(30)
1.0652795784357498247001125598 + 3.08346052231061726610939702133*I 

我们甚至可以通过 mpmath 计算 Soldner 常数：

>>> from mpmath import findroot
>>> findroot(li, 2)
1.45136923488338 

进一步的变换包括用三角积分 Si、Ci、Shi 和 Chi 重写 li：

>>> from sympy import Si, Ci, Shi, Chi
>>> li(z).rewrite(Si)
-log(I*log(z)) - log(1/log(z))/2 + log(log(z))/2 + Ci(I*log(z)) + Shi(log(z))
>>> li(z).rewrite(Ci)
-log(I*log(z)) - log(1/log(z))/2 + log(log(z))/2 + Ci(I*log(z)) + Shi(log(z))
>>> li(z).rewrite(Shi)
-log(1/log(z))/2 + log(log(z))/2 + Chi(log(z)) - Shi(log(z))
>>> li(z).rewrite(Chi)
-log(1/log(z))/2 + log(log(z))/2 + Chi(log(z)) - Shi(log(z)) 

另见

Li

偏移对数积分。

Ei

指数积分。

expint

广义指数积分。

E1

广义指数积分的特殊情况。

Si

正弦积分。

Ci

余弦积分。

Shi

双曲正弦积分。

Chi

双曲余弦积分。

参考文献

[R413]

对数积分的广义指数积分。

[R414]

对数积分。

[R415]

dlmf.nist.gov/6

[R416]

Soldner 常数。

class sympy.functions.special.error_functions.Li(z)

偏移对数积分。

说明

对于 SymPy 使用，此函数被定义为

[\operatorname{Li}(x) = \operatorname{li}(x) - \operatorname{li}(2)]

示例

>>> from sympy import Li
>>> from sympy.abc import z 

已知以下特殊值：

>>> Li(2)
0 

支持对 (z) 的微分：

>>> from sympy import diff
>>> diff(Li(z), z)
1/log(z) 

偏移对数积分可以用 (li(z)) 的形式来表示：

>>> from sympy import li
>>> Li(z).rewrite(li)
li(z) - li(2) 

我们可以在整个复平面上（除了奇点）对对数积分进行任意精度的数值计算：

>>> Li(2).evalf(30)
0 

>>> Li(4).evalf(30)
1.92242131492155809316615998938 

另见

li

对数积分。

Ei

指数积分。

expint

广义指数积分。

E1

广义指数积分的特殊情况。

Si

正弦积分。

Ci

余弦积分。

Shi

双曲正弦积分。

Chi

双曲余弦积分。

参考文献

[R417]

en.wikipedia.org/wiki/Logarithmic_integral

[R418]

mathworld.wolfram.com/LogarithmicIntegral.html

[R419]

dlmf.nist.gov/6

class sympy.functions.special.error_functions.Si(z)

正弦积分。

说明

这个函数由

[\operatorname{Si}(z) = \int_0^z \frac{\sin{t}}{t} \mathrm{d}t.]

这是一个整函数。

示例

>>> from sympy import Si
>>> from sympy.abc import z 

正弦积分是( \sin(z)/z )的一个原函数：

>>> Si(z).diff(z)
sin(z)/z 

它是无分支的：

>>> from sympy import exp_polar, I, pi
>>> Si(z*exp_polar(2*I*pi))
Si(z) 

正弦积分在乘以I后表现得像普通正弦一样：

>>> Si(I*z)
I*Shi(z)
>>> Si(-z)
-Si(z) 

它还可以用指数积分的形式表达，但请注意后者是分支的：

>>> from sympy import expint
>>> Si(z).rewrite(expint)
-I*(-expint(1, z*exp_polar(-I*pi/2))/2 +
 expint(1, z*exp_polar(I*pi/2))/2) + pi/2 

它可以用 sinc 函数的形式重写（按定义）：

>>> from sympy import sinc
>>> Si(z).rewrite(sinc)
Integral(sinc(_t), (_t, 0, z)) 

另请参见

Ci

余弦积分。

Shi

双曲正弦积分。

Chi

双曲余弦积分。

Ei

指数积分。

expint

广义指数积分。

sinc

未归一化的 sinc 函数

E1

广义指数积分的特殊情况。

li

对数积分。

Li

偏移对数积分。

参考文献

[R420]

en.wikipedia.org/wiki/Trigonometric_integral

class sympy.functions.special.error_functions.Ci(z)

余弦积分。

说明

这个函数对正(x)值定义为

[\operatorname{Ci}(x) = \gamma + \log{x} + \int_0^x \frac{\cos{t} - 1}{t} \mathrm{d}t = -\int_x^\infty \frac{\cos{t}}{t} \mathrm{d}t,]

这里(\gamma)是欧拉-马歇罗尼常数。

我们有

[\operatorname{Ci}(z) = -\frac{\operatorname{E}_1\left(e^{i\pi/2} z\right) + \operatorname{E}_1\left(e^{-i \pi/2} z\right)}{2}]

这适用于所有极坐标(z)，因此提供了对数的黎曼曲面的解析延拓。

对于复数域(z \in \mathbb{C})，当(\Re(z) > 0)时，该公式也适用。通过提升到主分支，我们在割裂复平面上得到一个解析函数。

示例

>>> from sympy import Ci
>>> from sympy.abc import z 

余弦积分是(\cos(z)/z)的一个原始函数：

>>> Ci(z).diff(z)
cos(z)/z 

它在原点处有一个对数分支点：

>>> from sympy import exp_polar, I, pi
>>> Ci(z*exp_polar(2*I*pi))
Ci(z) + 2*I*pi 

余弦积分在乘以(i)后的行为类似于普通的(\cos)：

>>> from sympy import polar_lift
>>> Ci(polar_lift(I)*z)
Chi(z) + I*pi/2
>>> Ci(polar_lift(-1)*z)
Ci(z) + I*pi 

它也可以用指数积分的术语表达：

>>> from sympy import expint
>>> Ci(z).rewrite(expint)
-expint(1, z*exp_polar(-I*pi/2))/2 - expint(1, z*exp_polar(I*pi/2))/2 

另请参阅

Si

正弦积分。

Shi

双曲正弦积分。

Chi

双曲余弦积分。

Ei

指数积分。

expint

广义指数积分。

E1

广义指数积分的特殊情况。

li

对数积分。

Li

偏移对数积分。

参考文献

[R421]

en.wikipedia.org/wiki/Trigonometric_integral

class sympy.functions.special.error_functions.Shi(z)

双曲正弦积分。

解释

此函数的定义为

[\operatorname{Shi}(z) = \int_0^z \frac{\sinh{t}}{t} \mathrm{d}t.]

它是一个整函数。

示例

>>> from sympy import Shi
>>> from sympy.abc import z 

双曲正弦积分是(\sinh(z)/z)的一个原始函数：

>>> Shi(z).diff(z)
sinh(z)/z 

它是无分支的：

>>> from sympy import exp_polar, I, pi
>>> Shi(z*exp_polar(2*I*pi))
Shi(z) 

(\sinh)积分在乘以(i)后的行为类似于普通的(\sinh)：

>>> Shi(I*z)
I*Si(z)
>>> Shi(-z)
-Shi(z) 

它也可以用指数积分的术语表达，但要注意后者是分支的：

>>> from sympy import expint
>>> Shi(z).rewrite(expint)
expint(1, z)/2 - expint(1, z*exp_polar(I*pi))/2 - I*pi/2 

另请参阅

Si

正弦积分。

Ci

余弦积分。

Chi

双曲余弦积分。

Ei

指数积分。

expint

广义指数积分。

E1

广义指数积分的特殊情况。

li

对数积分。

Li

偏移对数积分。

参考文献

[R422]

en.wikipedia.org/wiki/Trigonometric_integral

class sympy.functions.special.error_functions.Chi(z)

双曲余弦积分。

解释

此函数对正 (x) 定义为

[\operatorname{Chi}(x) = \gamma + \log{x} + \int_0^x \frac{\cosh{t} - 1}{t} \mathrm{d}t,]

这里 (\gamma) 是欧拉-马歇罗尼常数。

我们有

[\operatorname{Chi}(z) = \operatorname{Ci}\left(e^{i \pi/2}z\right) - i\frac{\pi}{2},]

对所有极坐标 (z) 都成立，并且因此在对数的黎曼面上提供了解析延拓。通过提升到主支，我们在切割复平面上获得了解析函数。

示例

>>> from sympy import Chi
>>> from sympy.abc import z 

双曲余弦积分是 (\cosh(z)/z) 的原函数：

>>> Chi(z).diff(z)
cosh(z)/z 

它在原点有一个对数分支点：

>>> from sympy import exp_polar, I, pi
>>> Chi(z*exp_polar(2*I*pi))
Chi(z) + 2*I*pi 

双曲余弦积分在乘以 (i) 后的行为有些像普通的双曲余弦：

>>> from sympy import polar_lift
>>> Chi(polar_lift(I)*z)
Ci(z) + I*pi/2
>>> Chi(polar_lift(-1)*z)
Chi(z) + I*pi 

它也可以用指数积分的形式表示：

>>> from sympy import expint
>>> Chi(z).rewrite(expint)
-expint(1, z)/2 - expint(1, z*exp_polar(I*pi))/2 - I*pi/2 

另见

Si

正弦积分。

Ci

余弦积分。

Shi

双曲正弦积分。

Ei

指数积分。

expint

广义指数积分。

E1

广义指数积分的特殊情况。

li

对数积分。

Li

偏移对数积分。

参考文献

[R423]

en.wikipedia.org/wiki/Trigonometric_integral

贝塞尔类型函数

class sympy.functions.special.bessel.BesselBase(nu, z)

贝塞尔类型函数的抽象基类。

这个类旨在减少代码重复。所有贝塞尔类型函数都可以：1）被微分，其导数用类似函数表达，以及 2）用其他贝塞尔类型函数重写。

这里假设贝塞尔类型函数有一个复参数。

要使用这个基类，定义类属性 _a 和 _b，使得 2*F_n' = -_a*F_{n+1} + b*F_{n-1}。

property argument

贝塞尔类型函数的参数。

property order

贝塞尔类型函数的阶数。

class sympy.functions.special.bessel.besselj(nu, z)

第一类贝塞尔函数。

解释

阶数为 (\nu) 的贝塞尔 (J) 函数被定义为满足贝塞尔微分方程的函数

[z² \frac{\mathrm{d}² w}{\mathrm{d}z²} + z \frac{\mathrm{d}w}{\mathrm{d}z} + (z² - \nu²) w = 0,]

拉朗日展开

[J_\nu(z) = z^\nu \left(\frac{1}{\Gamma(\nu + 1) 2^\nu} + O(z²) \right),]

如果 (\nu) 不是负整数。如果 (\nu=-n \in \mathbb{Z}_{<0}) 是 负整数，则定义为

[J_{-n}(z) = (-1)^n J_n(z).]

例子

创建一个贝塞尔函数对象：

>>> from sympy import besselj, jn
>>> from sympy.abc import z, n
>>> b = besselj(n, z) 

对其进行微分：

>>> b.diff(z)
besselj(n - 1, z)/2 - besselj(n + 1, z)/2 

用球贝塞尔函数重新表述：

>>> b.rewrite(jn)
sqrt(2)*sqrt(z)*jn(n - 1/2, z)/sqrt(pi) 

访问参数和参数：

>>> b.order
n
>>> b.argument
z 

另请参阅

bessely, besseli, besselk

参考文献

[R424]

Abramowitz, Milton; Stegun, Irene A., eds. (1965), “第九章”, Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables

[R425]

Luke, Y. L. (1969), The Special Functions and Their Approximations, Volume 1

[R426]

en.wikipedia.org/wiki/Bessel_function

[R427]

functions.wolfram.com/Bessel-TypeFunctions/BesselJ/

class sympy.functions.special.bessel.bessely(nu, z)

第二类贝塞尔函数。

解释

阶数为 (\nu) 的贝塞尔 (Y) 函数定义如下：

[Y_\nu(z) = \lim_{\mu \to \nu} \frac{J_\mu(z) \cos(\pi \mu) - J_{-\mu}(z)}{\sin(\pi \mu)},]

其中 (J_\mu(z)) 是第一类贝塞尔函数。

它是贝塞尔方程的解，且与 (J_\nu) 线性无关。

例子

>>> from sympy import bessely, yn
>>> from sympy.abc import z, n
>>> b = bessely(n, z)
>>> b.diff(z)
bessely(n - 1, z)/2 - bessely(n + 1, z)/2
>>> b.rewrite(yn)
sqrt(2)*sqrt(z)*yn(n - 1/2, z)/sqrt(pi) 

另请参阅

besselj, besseli, besselk

参考文献

[R428]

functions.wolfram.com/Bessel-TypeFunctions/BesselY/

class sympy.functions.special.bessel.besseli(nu, z)

第一类修正贝塞尔函数。

解释

贝塞尔 (I) 函数是修正贝塞尔方程的解

[z² \frac{\mathrm{d}² w}{\mathrm{d}z²} + z \frac{\mathrm{d}w}{\mathrm{d}z} + (z² + \nu²)² w = 0.]

它可以定义为

[I_\nu(z) = i^{-\nu} J_\nu(iz),]

其中 (J_\nu(z)) 是第一类贝塞尔函数。

例子

>>> from sympy import besseli
>>> from sympy.abc import z, n
>>> besseli(n, z).diff(z)
besseli(n - 1, z)/2 + besseli(n + 1, z)/2 

另请参阅

besselj, bessely, besselk

参考文献

[R429]

functions.wolfram.com/Bessel-TypeFunctions/BesselI/

class sympy.functions.special.bessel.besselk(nu, z)

第二类修正贝塞尔函数。

解释

第(K)类贝塞尔函数的阶数(\nu)被定义为

[K_\nu(z) = \lim_{\mu \to \nu} \frac{\pi}{2} \frac{I_{-\mu}(z) -I_\mu(z)}{\sin(\pi \mu)},]

其中(I_\mu(z))是修正第一类贝塞尔函数。

它是修正贝塞尔方程的解，且与(Y_\nu)线性无关。

例子

>>> from sympy import besselk
>>> from sympy.abc import z, n
>>> besselk(n, z).diff(z)
-besselk(n - 1, z)/2 - besselk(n + 1, z)/2 

参见

besselj, besseli, bessely

参考文献

[R430]

functions.wolfram.com/Bessel-TypeFunctions/BesselK/

class sympy.functions.special.bessel.hankel1(nu, z)

第一类汉克尔函数。

解释

此函数被定义为

[H_\nu^{(1)} = J_\nu(z) + iY_\nu(z),]

其中(J_\nu(z))是第一类贝塞尔函数，(Y_\nu(z))是第二类贝塞尔函数。

它是贝塞尔方程的解。

例子

>>> from sympy import hankel1
>>> from sympy.abc import z, n
>>> hankel1(n, z).diff(z)
hankel1(n - 1, z)/2 - hankel1(n + 1, z)/2 

参见

hankel2, besselj, bessely

参考文献

[R431]

functions.wolfram.com/Bessel-TypeFunctions/HankelH1/

class sympy.functions.special.bessel.hankel2(nu, z)

第二类汉克尔函数。

解释

此函数被定义为

[H_\nu^{(2)} = J_\nu(z) - iY_\nu(z),]

其中(J_\nu(z))是第一类贝塞尔函数，(Y_\nu(z))是第二类贝塞尔函数。

它是贝塞尔方程的解，且与(H_\nu^{(1)})线性无关。

例子

>>> from sympy import hankel2
>>> from sympy.abc import z, n
>>> hankel2(n, z).diff(z)
hankel2(n - 1, z)/2 - hankel2(n + 1, z)/2 

参见

hankel1, besselj, bessely

参考文献

[R432]

functions.wolfram.com/Bessel-TypeFunctions/HankelH2/

class sympy.functions.special.bessel.jn(nu, z)

第一类球贝塞尔函数。

解释

此函数是球形贝塞尔方程的解

[z² \frac{\mathrm{d}² w}{\mathrm{d}z²} + 2z \frac{\mathrm{d}w}{\mathrm{d}z} + (z² - \nu(\nu + 1)) w = 0.]

可定义为

[j_\nu(z) = \sqrt{\frac{\pi}{2z}} J_{\nu + \frac{1}{2}}(z),]

其中(J_\nu(z))是第一类贝塞尔函数。

整数阶球贝塞尔函数使用以下公式计算：

[j_n(z) = f_n(z) \sin{z} + (-1)^{n+1} f_{-n-1}(z) \cos{z},]

其中系数 (f_n(z)) 可以通过sympy.polys.orthopolys.spherical_bessel_fn() 获得。

示例

>>> from sympy import Symbol, jn, sin, cos, expand_func, besselj, bessely
>>> z = Symbol("z")
>>> nu = Symbol("nu", integer=True)
>>> print(expand_func(jn(0, z)))
sin(z)/z
>>> expand_func(jn(1, z)) == sin(z)/z**2 - cos(z)/z
True
>>> expand_func(jn(3, z))
(-6/z**2 + 15/z**4)*sin(z) + (1/z - 15/z**3)*cos(z)
>>> jn(nu, z).rewrite(besselj)
sqrt(2)*sqrt(pi)*sqrt(1/z)*besselj(nu + 1/2, z)/2
>>> jn(nu, z).rewrite(bessely)
(-1)**nu*sqrt(2)*sqrt(pi)*sqrt(1/z)*bessely(-nu - 1/2, z)/2
>>> jn(2, 5.2+0.3j).evalf(20)
0.099419756723640344491 - 0.054525080242173562897*I 

另请参阅

besselj, bessely, besselk, yn

参考文献

[R433]

dlmf.nist.gov/10.47

class sympy.functions.special.bessel.yn(nu, z)

第二类球贝塞尔函数。

解释

此函数是球贝塞尔方程的另一解，与(j_n)线性无关。可以定义为

[y_\nu(z) = \sqrt{\frac{\pi}{2z}} Y_{\nu + \frac{1}{2}}(z),]

其中(Y_\nu(z))是第二类贝塞尔函数。

对于整数阶(n)，使用以下公式计算(y_n)：

[y_n(z) = (-1)^{n+1} j_{-n-1}(z)]

示例

>>> from sympy import Symbol, yn, sin, cos, expand_func, besselj, bessely
>>> z = Symbol("z")
>>> nu = Symbol("nu", integer=True)
>>> print(expand_func(yn(0, z)))
-cos(z)/z
>>> expand_func(yn(1, z)) == -cos(z)/z**2-sin(z)/z
True
>>> yn(nu, z).rewrite(besselj)
(-1)**(nu + 1)*sqrt(2)*sqrt(pi)*sqrt(1/z)*besselj(-nu - 1/2, z)/2
>>> yn(nu, z).rewrite(bessely)
sqrt(2)*sqrt(pi)*sqrt(1/z)*bessely(nu + 1/2, z)/2
>>> yn(2, 5.2+0.3j).evalf(20)
0.18525034196069722536 + 0.014895573969924817587*I 

另请参阅

besselj, bessely, besselk, jn

参考文献

[R434]

dlmf.nist.gov/10.47

sympy.functions.special.bessel.jn_zeros(n, k, method='sympy', dps=15)

第一类球贝塞尔函数的零点。

参数：

n : 整数

贝塞尔函数的阶数

k : 整数

返回的零点数

解释

这返回一个包含(jn)的零点数组，直到第(k)个零点。

• method = “sympy”: 使用mpmath.besseljzero

• method = “scipy”: 使用SciPy 的 sph_jn 和newton来找到所有根，比使用一般数值求解器计算零点更快，但需要 SciPy，并且仅适用于低精度浮点数。（在使用 method=”sympy” 的函数之前，mpmath 使用一般求解器。）

示例

>>> from sympy import jn_zeros
>>> jn_zeros(2, 4, dps=5)
[5.7635, 9.095, 12.323, 15.515] 

另请参阅

jn, yn, besselj, besselk, bessely

class sympy.functions.special.bessel.marcumq(m, a, b)

Marcum Q-函数。

解释

Marcum Q-函数由球贝塞尔方程的亚纯延拓定义

[Q_m(a, b) = a^{- m + 1} \int_{b}^{\infty} x^{m} e^{- \frac{a^{2}}{2} - \frac{x^{2}}{2}} I_{m - 1}\left(a x\right), dx]

示例

>>> from sympy import marcumq
>>> from sympy.abc import m, a, b
>>> marcumq(m, a, b)
marcumq(m, a, b) 

特殊值：

>>> marcumq(m, 0, b)
uppergamma(m, b**2/2)/gamma(m)
>>> marcumq(0, 0, 0)
0
>>> marcumq(0, a, 0)
1 - exp(-a**2/2)
>>> marcumq(1, a, a)
1/2 + exp(-a**2)*besseli(0, a**2)/2
>>> marcumq(2, a, a)
1/2 + exp(-a**2)*besseli(0, a**2)/2 + exp(-a**2)*besseli(1, a**2) 

支持对 (a) 和 (b) 的微分：

>>> from sympy import diff
>>> diff(marcumq(m, a, b), a)
a*(-marcumq(m, a, b) + marcumq(m + 1, a, b))
>>> diff(marcumq(m, a, b), b)
-a**(1 - m)*b**m*exp(-a**2/2 - b**2/2)*besseli(m - 1, a*b) 

参考文献

[R435]

en.wikipedia.org/wiki/Marcum_Q-function

[R436]

mathworld.wolfram.com/MarcumQ-Function.html

Airy 函数

class sympy.functions.special.bessel.AiryBase(*args)

Airy 函数的抽象基类。

这个类旨在减少代码重复。

class sympy.functions.special.bessel.airyai(arg)

Airy 函数 (\operatorname{Ai}) 的第一种形式。

说明

Airy 函数 (\operatorname{Ai}(z)) 被定义为满足 Airy 微分方程的函数

[\frac{\mathrm{d}² w(z)}{\mathrm{d}z²} - z w(z) = 0.]

同样地，对于实数 (z)

[\operatorname{Ai}(z) := \frac{1}{\pi} \int_0^\infty \cos\left(\frac{t³}{3} + z t\right) \mathrm{d}t.]

示例

创建一个 Airy 函数对象：

>>> from sympy import airyai
>>> from sympy.abc import z 

>>> airyai(z)
airyai(z) 

已知若干特殊值：

>>> airyai(0)
3**(1/3)/(3*gamma(2/3))
>>> from sympy import oo
>>> airyai(oo)
0
>>> airyai(-oo)
0 

Airy 函数遵循镜像对称性：

>>> from sympy import conjugate
>>> conjugate(airyai(z))
airyai(conjugate(z)) 

支持对 (z) 的微分：

>>> from sympy import diff
>>> diff(airyai(z), z)
airyaiprime(z)
>>> diff(airyai(z), z, 2)
z*airyai(z) 

系列展开也支持：

>>> from sympy import series
>>> series(airyai(z), z, 0, 3)
3**(5/6)*gamma(1/3)/(6*pi) - 3**(1/6)*z*gamma(2/3)/(2*pi) + O(z**3) 

我们可以在整个复平面上对 Airy 函数进行任意精度的数值评估：

>>> airyai(-2).evalf(50)
0.22740742820168557599192443603787379946077222541710 

重写 (\operatorname{Ai}(z)) 以超几何函数表示：

>>> from sympy import hyper
>>> airyai(z).rewrite(hyper)
-3**(2/3)*z*hyper((), (4/3,), z**3/9)/(3*gamma(1/3)) + 3**(1/3)*hyper((), (2/3,), z**3/9)/(3*gamma(2/3)) 

参见

airybi

Airy 函数的第二种形式。

airyaiprime

Airy 函数的第一种形式的导数。

airybiprime

Airy 函数的第二种形式的导数。

参考文献

[R437]

en.wikipedia.org/wiki/Airy_function

[R438]

dlmf.nist.gov/9

[R439]

encyclopediaofmath.org/wiki/Airy_functions

[R440]

mathworld.wolfram.com/AiryFunctions.html

class sympy.functions.special.bessel.airybi(arg)

Airy 函数 (\operatorname{Bi}) 的第二种形式。

说明

Airy 函数 (\operatorname{Bi}(z)) 被定义为满足 Airy 微分方程的函数

[\frac{\mathrm{d}² w(z)}{\mathrm{d}z²} - z w(z) = 0.]

同样地，对于实数 (z)

[\operatorname{Bi}(z) := \frac{1}{\pi} \int_0^\infty \exp\left(-\frac{t³}{3} + z t\right) + \sin\left(\frac{t³}{3} + z t\right) \mathrm{d}t.]

示例

创建一个 Airy 函数对象：

>>> from sympy import airybi
>>> from sympy.abc import z 

>>> airybi(z)
airybi(z) 

已知若干特殊值：

>>> airybi(0)
3**(5/6)/(3*gamma(2/3))
>>> from sympy import oo
>>> airybi(oo)
oo
>>> airybi(-oo)
0 

Airy 函数遵循镜像对称性：

>>> from sympy import conjugate
>>> conjugate(airybi(z))
airybi(conjugate(z)) 

支持对 (z) 的微分：

>>> from sympy import diff
>>> diff(airybi(z), z)
airybiprime(z)
>>> diff(airybi(z), z, 2)
z*airybi(z) 

系列展开也支持：

>>> from sympy import series
>>> series(airybi(z), z, 0, 3)
3**(1/3)*gamma(1/3)/(2*pi) + 3**(2/3)*z*gamma(2/3)/(2*pi) + O(z**3) 

我们可以在整个复平面上对 Airy 函数进行任意精度的数值评估：

>>> airybi(-2).evalf(50)
-0.41230258795639848808323405461146104203453483447240 

重写 (\operatorname{Bi}(z)) 以超几何函数表示：

>>> from sympy import hyper
>>> airybi(z).rewrite(hyper)
3**(1/6)*z*hyper((), (4/3,), z**3/9)/gamma(1/3) + 3**(5/6)*hyper((), (2/3,), z**3/9)/(3*gamma(2/3)) 

参见

airyai

艾里函数第一类。

airyaiprime

艾里函数第一类的导数。

airybiprime

艾里函数第二类的导数。

参考文献

[R441]

en.wikipedia.org/wiki/Airy_function

[R442]

dlmf.nist.gov/9

[R443]

encyclopediaofmath.org/wiki/Airy_functions

[R444]

mathworld.wolfram.com/AiryFunctions.html

class sympy.functions.special.bessel.airyaiprime(arg)

艾里函数第一类的导数(\operatorname{Ai}^\prime)。

说明

艾里函数(\operatorname{Ai}^\prime(z))定义为函数

[\operatorname{Ai}^\prime(z) := \frac{\mathrm{d} \operatorname{Ai}(z)}{\mathrm{d} z}.]

示例

创建一个艾里函数对象：

>>> from sympy import airyaiprime
>>> from sympy.abc import z 

>>> airyaiprime(z)
airyaiprime(z) 

已知多个特殊值：

>>> airyaiprime(0)
-3**(2/3)/(3*gamma(1/3))
>>> from sympy import oo
>>> airyaiprime(oo)
0 

艾里函数遵循镜像对称性：

>>> from sympy import conjugate
>>> conjugate(airyaiprime(z))
airyaiprime(conjugate(z)) 

支持关于(z)的微分：

>>> from sympy import diff
>>> diff(airyaiprime(z), z)
z*airyai(z)
>>> diff(airyaiprime(z), z, 2)
z*airyaiprime(z) + airyai(z) 

级数展开也是支持的：

>>> from sympy import series
>>> series(airyaiprime(z), z, 0, 3)
-3**(2/3)/(3*gamma(1/3)) + 3**(1/3)*z**2/(6*gamma(2/3)) + O(z**3) 

我们可以在整个复平面上对艾里函数进行任意精度的数值评估：

>>> airyaiprime(-2).evalf(50)
0.61825902074169104140626429133247528291577794512415 

将(\operatorname{Ai}^\prime(z))重写为超几何函数的形式：

>>> from sympy import hyper
>>> airyaiprime(z).rewrite(hyper)
3**(1/3)*z**2*hyper((), (5/3,), z**3/9)/(6*gamma(2/3)) - 3**(2/3)*hyper((), (1/3,), z**3/9)/(3*gamma(1/3)) 

另请参阅

airyai

艾里函数第一类。

airybi

艾里函数第二类。

airybiprime

艾里函数第二类的导数。

参考文献

[R445]

en.wikipedia.org/wiki/Airy_function

[R446]

dlmf.nist.gov/9

[R447]

encyclopediaofmath.org/wiki/Airy_functions

[R448]

mathworld.wolfram.com/AiryFunctions.html

class sympy.functions.special.bessel.airybiprime(arg)

艾里函数第一类的导数(\operatorname{Bi}^\prime)。

说明

艾里函数(\operatorname{Bi}^\prime(z))定义为函数

[\operatorname{Bi}^\prime(z) := \frac{\mathrm{d} \operatorname{Bi}(z)}{\mathrm{d} z}.]

示例

创建一个艾里函数对象：

>>> from sympy import airybiprime
>>> from sympy.abc import z 

>>> airybiprime(z)
airybiprime(z) 

已知多个特殊值：

>>> airybiprime(0)
3**(1/6)/gamma(1/3)
>>> from sympy import oo
>>> airybiprime(oo)
oo
>>> airybiprime(-oo)
0 

艾里函数遵循镜像对称性：

>>> from sympy import conjugate
>>> conjugate(airybiprime(z))
airybiprime(conjugate(z)) 

支持关于(z)的微分：

>>> from sympy import diff
>>> diff(airybiprime(z), z)
z*airybi(z)
>>> diff(airybiprime(z), z, 2)
z*airybiprime(z) + airybi(z) 

级数展开也是支持的：

>>> from sympy import series
>>> series(airybiprime(z), z, 0, 3)
3**(1/6)/gamma(1/3) + 3**(5/6)*z**2/(6*gamma(2/3)) + O(z**3) 

我们可以在整个复平面上对艾里函数进行任意精度的数值评估：

>>> airybiprime(-2).evalf(50)
0.27879516692116952268509756941098324140300059345163 

重写(\operatorname{Bi}^\prime(z))以超几何函数的形式：

>>> from sympy import hyper
>>> airybiprime(z).rewrite(hyper)
3**(5/6)*z**2*hyper((), (5/3,), z**3/9)/(6*gamma(2/3)) + 3**(1/6)*hyper((), (1/3,), z**3/9)/gamma(1/3) 

参见

airyai

Airy 函数的第一种。

airybi

Airy 函数的第二种。

airyaiprime

Airy 函数的第一种的导数。

参考资料

[R449]

en.wikipedia.org/wiki/Airy_function

[R450]

dlmf.nist.gov/9

[R451]

encyclopediaofmath.org/wiki/Airy_functions

[R452]

mathworld.wolfram.com/AiryFunctions.html

B 样条

sympy.functions.special.bsplines.bspline_basis(d, knots, n, x)

在给定结点knots处的阶为d的第n个 B 样条。

参数：

d：整数

B 样条的度数

knots：整数值列表

B 样条的结节点列表。

n：整数

第n个 B 样条

x：符号

说明

B 样条是阶为d的分段多项式。它们定义在结点的集合上，这些结点是整数或浮点数序列。

示例

第 0 阶样条在单个区间上的值为 1：

>>> from sympy import bspline_basis
>>> from sympy.abc import x
>>> d = 0
>>> knots = tuple(range(5))
>>> bspline_basis(d, knots, 0, x)
Piecewise((1, (x >= 0) & (x <= 1)), (0, True)) 

对于给定的(d, knots)，定义了len(knots)-d-1个 B 样条，其由索引n（从 0 开始）索引。

这是一个三次 B 样条的示例：

>>> bspline_basis(3, tuple(range(5)), 0, x)
Piecewise((x**3/6, (x >= 0) & (x <= 1)),
 (-x**3/2 + 2*x**2 - 2*x + 2/3,
 (x >= 1) & (x <= 2)),
 (x**3/2 - 4*x**2 + 10*x - 22/3,
 (x >= 2) & (x <= 3)),
 (-x**3/6 + 2*x**2 - 8*x + 32/3,
 (x >= 3) & (x <= 4)),
 (0, True)) 

通过重复结节点，可以在 B 样条及其导数中引入不连续性：

>>> d = 1
>>> knots = (0, 0, 2, 3, 4)
>>> bspline_basis(d, knots, 0, x)
Piecewise((1 - x/2, (x >= 0) & (x <= 2)), (0, True)) 

构造和评估 B 样条非常耗时。如果需要多次评估 B 样条，最好先对它们进行 lambdify 处理：

>>> from sympy import lambdify
>>> d = 3
>>> knots = tuple(range(10))
>>> b0 = bspline_basis(d, knots, 0, x)
>>> f = lambdify(x, b0)
>>> y = f(0.5) 

参见

bspline_basis_set

参考资料

[R453]

en.wikipedia.org/wiki/B-spline

sympy.functions.special.bsplines.bspline_basis_set(d, knots, x)

返回在knots处的阶为d的B-splines的len(knots)-d-1个。

参数：

d：整数

B 样条的度数

knots：整数列表

B 样条的结节点列表

x：符号

说明

此函数返回一个多段多项式列表，这些多项式是给定结点knots的度数为d的len(knots)-d-1个 B 样条。该函数为不同的n值调用bspline_basis(d, knots, n, x)。

示例

>>> from sympy import bspline_basis_set
>>> from sympy.abc import x
>>> d = 2
>>> knots = range(5)
>>> splines = bspline_basis_set(d, knots, x)
>>> splines
[Piecewise((x**2/2, (x >= 0) & (x <= 1)),
 (-x**2 + 3*x - 3/2, (x >= 1) & (x <= 2)),
 (x**2/2 - 3*x + 9/2, (x >= 2) & (x <= 3)),
 (0, True)),
Piecewise((x**2/2 - x + 1/2, (x >= 1) & (x <= 2)),
 (-x**2 + 5*x - 11/2, (x >= 2) & (x <= 3)),
 (x**2/2 - 4*x + 8, (x >= 3) & (x <= 4)),
 (0, True))] 

参见

bspline_basis

sympy.functions.special.bsplines.interpolating_spline(d, x, X, Y)

返回通过给定X和Y值的d度样条。

参数：

d：整数

Bspline 的度数严格大于等于一

x：符号

X：严格递增的实数值列表

通过样条通过的 X 坐标列表

Y：实数值列表

通过样条通过的对应 Y 坐标列表

说明

此函数返回一个分段函数，每个部分都是不大于 d 的多项式。d 的值必须大于或等于 1，而 X 的值必须严格增加。

示例

>>> from sympy import interpolating_spline
>>> from sympy.abc import x
>>> interpolating_spline(1, x, [1, 2, 4, 7], [3, 6, 5, 7])
Piecewise((3*x, (x >= 1) & (x <= 2)),
 (7 - x/2, (x >= 2) & (x <= 4)),
 (2*x/3 + 7/3, (x >= 4) & (x <= 7)))
>>> interpolating_spline(3, x, [-2, 0, 1, 3, 4], [4, 2, 1, 1, 3])
Piecewise((7*x**3/117 + 7*x**2/117 - 131*x/117 + 2, (x >= -2) & (x <= 1)),
 (10*x**3/117 - 2*x**2/117 - 122*x/117 + 77/39, (x >= 1) & (x <= 4))) 

另请参见

bspline_basis_set，interpolating_poly

黎曼 Zeta 函数及相关函数

class sympy.functions.special.zeta_functions.zeta(s, a=None)

赫维茨 zeta 函数（或黎曼 zeta 函数）。

说明

对于 (\operatorname{Re}(a) > 0) 和 (\operatorname{Re}(s) > 1)，此函数定义为

[\zeta(s, a) = \sum_{n=0}^\infty \frac{1}{(n + a)^s},]

其中使用了 (n + a) 的标准参数选择。对于固定的 (a)，非正整数的赫维茨 zeta 函数在整个 (\mathbb{C}) 上都有亚纯延拓；它是一个无分支函数，在 (s = 1) 处有一个简单极点。

赫维茨 zeta 函数是勒让德超越函数的一个特例：

[\zeta(s, a) = \Phi(1, s, a).]

此公式为所有可能的 (s) 和 (a) 值（也包括 (\operatorname{Re}(a) < 0)）定义了解析延拓，请参阅 lerchphi 的文档以了解分支行为的描述。

如果没有为 (a) 传递值，则假定默认值为 (a = 1)，从而得到黎曼 zeta 函数。

示例

对于 (a = 1)，赫维茨 zeta 函数简化为著名的黎曼 zeta 函数：

[\zeta(s, 1) = \zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s}.]

>>> from sympy import zeta
>>> from sympy.abc import s
>>> zeta(s, 1)
zeta(s)
>>> zeta(s)
zeta(s) 

黎曼 zeta 函数也可以用狄利克雷 eta 函数表示：

>>> from sympy import dirichlet_eta
>>> zeta(s).rewrite(dirichlet_eta)
dirichlet_eta(s)/(1 - 2**(1 - s)) 

非负偶数和负整数值处的黎曼 zeta 函数与伯努利数和多项式相关：

>>> zeta(2)
pi**2/6
>>> zeta(4)
pi**4/90
>>> zeta(0)
-1/2
>>> zeta(-1)
-1/12
>>> zeta(-4)
0 

特定公式如下：

[\zeta(2n) = -\frac{(2\pi i)^{2n} B_{2n}}{2(2n)!}][\zeta(-n,a) = -\frac{B_{n+1}(a)}{n+1}]

正奇整数没有已知的闭式表达式，但可以进行数值评估：

>>> zeta(3).n()
1.20205690315959 

可计算 (\zeta(s, a)) 关于 (a) 的导数：

>>> from sympy.abc import a
>>> zeta(s, a).diff(a)
-s*zeta(s + 1, a) 

然而，对于 (s) 的导数没有有用的闭式表达式：

>>> zeta(s, a).diff(s)
Derivative(zeta(s, a), s) 

赫维茨 zeta 函数可以用勒让德超越函数表达，lerchphi：

>>> from sympy import lerchphi
>>> zeta(s, a).rewrite(lerchphi)
lerchphi(1, s, a) 

另请参见

dirichlet_eta，lerchphi，polylog

参考

[R454]

dlmf.nist.gov/25.11

[R455]

en.wikipedia.org/wiki/Hurwitz_zeta_function

class sympy.functions.special.zeta_functions.dirichlet_eta(s, a=None)

狄利克雷 eta 函数。

解释

对于(\operatorname{Re}(s) > 0)和(0 < x \le 1)，此函数定义为

[\eta(s, a) = \sum_{n=0}^\infty \frac{(-1)^n}{(n+a)s}.]

对于任意固定的(a)不是非正整数，它在(\mathbb{C})中具有唯一的解析延拓。它是一个整体的，无分支的函数。

它可以用 Hurwitz 塞塔函数表示为

[\eta(s, a) = \zeta(s,a) - 2^{1-s} \zeta\left(s, \frac{a+1}{2}\right)]

并使用广义 Genocchi 函数表示为

[\eta(s, a) = \frac{G(1-s, a)}{2(s-1)}.]

在这两种情况下，当(s = 1)时使用的极限值为(\log2 - \psi(a) + \psi\left(\frac{a+1}{2}\right))。

示例

>>> from sympy import dirichlet_eta, zeta
>>> from sympy.abc import s
>>> dirichlet_eta(s).rewrite(zeta)
Piecewise((log(2), Eq(s, 1)), ((1 - 2**(1 - s))*zeta(s), True)) 

另请参阅

zeta

参考文献

[R456]

en.wikipedia.org/wiki/Dirichlet_eta_function

[R457]

彼得·鲁施尼，“伯努利函数简介”，arxiv.org/abs/2009.06743

class sympy.functions.special.zeta_functions.polylog(s, z)

多对数函数。

解释

对于(|z| < 1)和(s \in \mathbb{C})，多对数函数定义为

[\operatorname{Li}s(z) = \sum^\infty \frac{z^n}{ns},]

对于(n)使用参数的标准分支。它允许解析延拓，分支点在(z=1)（显然不是在初始定义的表面上），(z=0)和(z=\infty)。

多对数的名称来源于当(s=1)时，多对数与普通对数相关（参见示例），并且

[\operatorname{Li}_{s+1}(z) = \int_0^z \frac{\operatorname{Li}_s(t)}{t} \mathrm{d}t.]

多对数函数是勒让函数的一个特例：

[\operatorname{Li}_{s}(z) = z \Phi(z, s, 1).]

示例

对于(z \in {0, 1, -1})，多对数函数会自动用其他函数表达：

>>> from sympy import polylog
>>> from sympy.abc import s
>>> polylog(s, 0)
0
>>> polylog(s, 1)
zeta(s)
>>> polylog(s, -1)
-dirichlet_eta(s) 

如果(s)是负整数，(0)或(1)，则多对数函数可以用初等函数表达。这可以通过expand_func()完成：

>>> from sympy import expand_func
>>> from sympy.abc import z
>>> expand_func(polylog(1, z))
-log(1 - z)
>>> expand_func(polylog(0, z))
z/(1 - z) 

对(z)的导数可以通过封闭形式计算：

>>> polylog(s, z).diff(z)
polylog(s - 1, z)/z 

多对数函数可以用勒让函数表示为：

>>> from sympy import lerchphi
>>> polylog(s, z).rewrite(lerchphi)
z*lerchphi(z, s, 1) 

另请参阅

zeta, lerchphi

class sympy.functions.special.zeta_functions.lerchphi(*args)

勒让函数（勒让 phi 函数）。

解释

对于(\operatorname{Re}(a) > 0)，( |z| < 1 )和(s \in \mathbb{C})，勒让函数被定义为

[\Phi(z, s, a) = \sum_{n=0}^\infty \frac{z^n}{(n + a)^s},]

采用参数的标准分支对(n + a)进行使用，并通过解析延拓适用于其他参数值。

一个常用的相关函数是勒让塞塔函数，定义如下：

[L(q, s, a) = \Phi(e^{2\pi i q}, s, a).]

解析延拓与分支行为

可以证明

[\Phi(z, s, a) = z\Phi(z, s, a+1) + a^{-s}.]

这提供了对 (\operatorname{Re}(a) \le 0) 的解析延拓。

现在假设 (\operatorname{Re}(a) > 0)。积分表示

[\Phi_0(z, s, a) = \int_0^\infty \frac{t^{s-1} e^{-at}}{1 - ze^{-t}} \frac{\mathrm{d}t}{\Gamma(s)}]

提供了对 (\mathbb{C} - [1, \infty)) 的解析延拓。最后，对于 (x \in (1, \infty))，我们找到

[\lim_{\epsilon \to 0^+} \Phi_0(x + i\epsilon, s, a) -\lim_{\epsilon \to 0^+} \Phi_0(x - i\epsilon, s, a) = \frac{2\pi i \log^{s-1}{x}}{xa \Gamma(s)},]

使用 (\log{x}) 和 (\log{\log{x}}) 的标准分支（(\log{\log{x}}) 的分支需要用于计算 (\log{x}^{s-1})）。这结束了解析延拓。因此，勒让德超越函数在 (z \in {0, 1, \infty}) 和 (a \in \mathbb{Z}_{\le 0}) 处分支。对于固定的 (z, a) 超出这些分支点，它是 (s) 的整个函数。

例子

勒让德超越函数是一个相当通用的函数，因此它不会自动计算为更简单的函数。使用 expand_func() 可以实现这一点。

如果 (z=1)，则勒让德超越函数简化为 Hurwitz zeta 函数：

>>> from sympy import lerchphi, expand_func
>>> from sympy.abc import z, s, a
>>> expand_func(lerchphi(1, s, a))
zeta(s, a) 

更一般地，如果 (z) 是单位根，则勒让德超越函数简化为 Hurwitz zeta 函数之和：

>>> expand_func(lerchphi(-1, s, a))
zeta(s, a/2)/2**s - zeta(s, a/2 + 1/2)/2**s 

如果 (a=1)，则勒让德超越函数简化为多对数函数：

>>> expand_func(lerchphi(z, s, 1))
polylog(s, z)/z 

更一般地，如果 (a) 是有理数，勒让德超越函数简化为多对数函数之和：

>>> from sympy import S
>>> expand_func(lerchphi(z, s, S(1)/2))
2**(s - 1)*(polylog(s, sqrt(z))/sqrt(z) -
 polylog(s, sqrt(z)*exp_polar(I*pi))/sqrt(z))
>>> expand_func(lerchphi(z, s, S(3)/2))
-2**s/z + 2**(s - 1)*(polylog(s, sqrt(z))/sqrt(z) -
 polylog(s, sqrt(z)*exp_polar(I*pi))/sqrt(z))/z 

关于 (z) 和 (a) 的导数可以通过闭合形式计算：

>>> lerchphi(z, s, a).diff(z)
(-a*lerchphi(z, s, a) + lerchphi(z, s - 1, a))/z
>>> lerchphi(z, s, a).diff(a)
-s*lerchphi(z, s + 1, a) 

另请参见

polylog, zeta

参考文献

[R458]

Bateman, H.; Erdelyi, A. (1953), Higher Transcendental Functions, Vol. I, New York: McGraw-Hill. Section 1.11.

[R459]

dlmf.nist.gov/25.14

[R460]

en.wikipedia.org/wiki/Lerch_transcendent

class sympy.functions.special.zeta_functions.stieltjes(n, a=None)

代表黎曼ζ函数的 Laurent 级数展开中出现的斯蒂尔切斯常数，(\gamma_{k})。

例子

>>> from sympy import stieltjes
>>> from sympy.abc import n, m
>>> stieltjes(n)
stieltjes(n) 

第零斯蒂尔切斯常数：

>>> stieltjes(0)
EulerGamma
>>> stieltjes(0, 1)
EulerGamma 

对于广义斯蒂尔切斯常数：

>>> stieltjes(n, m)
stieltjes(n, m) 

常数仅对整数 >= 0 定义：

>>> stieltjes(-1)
zoo 

参考文献

[R461]

en.wikipedia.org/wiki/Stieltjes_constants

超几何函数

class sympy.functions.special.hyper.hyper(ap, bq, z)

广义超几何函数由一个级数定义，其中连续项的比值是求和指数的有理函数。当收敛时，它在解析地延拓到最大可能的域。

解释

超几何函数依赖于两个参数向量，称为分子参数 (a_p) 和分母参数 (b_q)。它还有一个参数 (z)。级数定义为

[\begin{split}{}pF_q\left(\begin{matrix} a_1, \cdots, a_p \ b_1, \cdots, b_q \end{matrix} \middle| z \right) = \sum^\infty \frac{(a_1)_n \cdots (a_p)_n}{(b_1)_n \cdots (b_q)_n} \frac{z^n}{n!},\end{split}]

这里 ((a)_n = (a)(a+1)\cdots(a+n-1)) 表示升阶乘。

如果 (b_q) 中有一个是非正整数，则除非 (a_p) 中有一个更大（即绝对值更小）的非正整数，否则级数是未定义的。如果 (b_q) 中没有一个是非正整数，而 (a_p) 中有一个是非正整数，则级数化简为多项式。为简化以下讨论，我们假设 (a_p) 和 (b_q) 都不是非正整数。更多细节请参见参考文献。

如果 (p \le q)，则级数对所有 (z) 收敛，因此在这种情况下定义了一个整个单值函数。如果 (p = q+1)，则级数在 (|z| < 1) 收敛，并可以在半平面内解析地延拓。如果 (p > q+1)，则级数在所有 (z) 上发散。

请注意，超几何函数构造器目前不检查参数是否实际产生一个良定义的函数。

示例

参数 (a_p) 和 (b_q) 可以作为任意可迭代对象传递，例如：

>>> from sympy import hyper
>>> from sympy.abc import x, n, a
>>> h = hyper((1, 2, 3), [3, 4], x); h
hyper((1, 2), (4,), x)
>>> hyper((3, 1, 2), [3, 4], x, evaluate=False)  # don't remove duplicates
hyper((1, 2, 3), (3, 4), x) 

还有漂亮的打印（使用 Unicode 看起来更好）：

>>> from sympy import pprint
>>> pprint(h, use_unicode=False)
 _
 |_  /1, 2 |  \
 |   |     | x|
2  1 \  4  |  / 

参数必须始终是可迭代的，即使它们是长度为一或零的向量：

>>> hyper((1, ), [], x)
hyper((1,), (), x) 

但当然它们可能是变量（但如果它们依赖于 (x)，那么不应期望有太多实现的功能）：

>>> hyper((n, a), (n**2,), x)
hyper((a, n), (n**2,), x) 

超几何函数推广了许多命名特殊函数。函数 hyperexpand() 尝试使用命名特殊函数来表达超几何函数。例如：

>>> from sympy import hyperexpand
>>> hyperexpand(hyper([], [], x))
exp(x) 

您也可以使用 expand_func()：

>>> from sympy import expand_func
>>> expand_func(x*hyper([1, 1], [2], -x))
log(x + 1) 

更多例子：

>>> from sympy import S
>>> hyperexpand(hyper([], [S(1)/2], -x**2/4))
cos(x)
>>> hyperexpand(x*hyper([S(1)/2, S(1)/2], [S(3)/2], x**2))
asin(x) 

有时我们也可以使用 hyperexpand() 参数化函数：

>>> from sympy.abc import a
>>> hyperexpand(hyper([-a], [], x))
(1 - x)**a 

另见

sympy.simplify.hyperexpand, gamma, meijerg

参考文献

[R462]

Luke, Y. L. (1969), The Special Functions and Their Approximations, Volume 1

[R463]

广义超几何函数的收敛相关数量。

property ap

超几何函数的分子参数。

property argument

超几何函数的参数。

property bq

超几何函数的分母参数。

property convergence_statement

返回一个关于 (z) 的条件，使得级数收敛。

property eta

与级数收敛性相关的数量。

property radius_of_convergence

计算定义级数的收敛半径。

解释

请注意，即使这不是 oo，函数仍可以通过解析延拓在收敛半径之外进行评估。但如果这是零，那么函数实际上在任何其他地方都未定义。

示例

>>> from sympy import hyper
>>> from sympy.abc import z
>>> hyper((1, 2), [3], z).radius_of_convergence
1
>>> hyper((1, 2, 3), [4], z).radius_of_convergence
0
>>> hyper((1, 2), (3, 4), z).radius_of_convergence
oo 

class sympy.functions.special.hyper.meijerg(*args)

Meijer G 函数由类似逆 Mellin 变换的 Mellin-Barnes 类型积分定义。它推广了超几何函数。

解释

Meijer G 函数依赖于四组参数。有“分子参数” (a_1, \ldots, a_n) 和 (a_{n+1}, \ldots, a_p)，以及“分母参数” (b_1, \ldots, b_m) 和 (b_{m+1}, \ldots, b_q)。令人困惑的是，传统上它被表示如下（注意 (m)、(n)、(p)、(q) 的位置及它们与四个参数向量的长度的关系）：

[\begin{split}G_{p,q}^{m,n} \left(\begin{matrix}a_1, \cdots, a_n & a_{n+1}, \cdots, a_p \ b_1, \cdots, b_m & b_{m+1}, \cdots, b_q \end{matrix} \middle| z \right).\end{split}]

然而，在 SymPy 中，四个参数向量始终可以单独使用（参见示例），因此无需跟踪 G 符号上的装饰式和上标。

G 函数被定义为以下积分：

[\frac{1}{2 \pi i} \int_L \frac{\prod_{j=1}^m \Gamma(b_j - s) \prod_{j=1}^n \Gamma(1 - a_j + s)}{\prod_{j=m+1}^q \Gamma(1- b_j +s) \prod_{j=n+1}^p \Gamma(a_j - s)} z^s \mathrm{d}s,]

这里 (\Gamma(z)) 是 gamma 函数。有三种可能的轮廓我们不在此详细描述（参见参考文献）。如果积分沿着其中多于一条路径收敛，则定义是一致的。所有轮廓都将 (\Gamma(1-a_j+s)) 的极点与 (\Gamma(b_k-s)) 的极点分开，因此特别地，如果对于某些 (j \le n) 和 (k \le m)，(a_j - b_k \in \mathbb{Z}_{>0})，则 G 函数是未定义的。

一个轮廓产生收敛积分的条件非常复杂，我们不在此声明，请参见参考文献。

请注意，目前 Meijer G 函数构造器 不 检查任何收敛条件。

例子

您可以将参数作为四个单独的向量传递：

>>> from sympy import meijerg, Tuple, pprint
>>> from sympy.abc import x, a
>>> pprint(meijerg((1, 2), (a, 4), (5,), [], x), use_unicode=False)
 __1, 2 /1, 2  4, a |  \
/__     |           | x|
\_|4, 1 \ 5         |  / 

或者作为两个嵌套向量：

>>> pprint(meijerg([(1, 2), (3, 4)], ([5], Tuple()), x), use_unicode=False)
 __1, 2 /1, 2  3, 4 |  \
/__     |           | x|
\_|4, 1 \ 5         |  / 

与超几何函数类似，参数可以作为任意可迭代对象传递。长度为零和一的向量也必须作为可迭代对象传递。参数不必是常数，但如果它们依赖于参数，则不应期望实现太多功能。

所有参数的子向量都可用：

>>> from sympy import pprint
>>> g = meijerg([1], [2], [3], [4], x)
>>> pprint(g, use_unicode=False)
 __1, 1 /1  2 |  \
/__     |     | x|
\_|2, 2 \3  4 |  /
>>> g.an
(1,)
>>> g.ap
(1, 2)
>>> g.aother
(2,)
>>> g.bm
(3,)
>>> g.bq
(3, 4)
>>> g.bother
(4,) 

Meijer G 函数推广了超几何函数。在某些情况下，它可以用超几何函数的术语表示，使用 Slater 定理。例如：

>>> from sympy import hyperexpand
>>> from sympy.abc import a, b, c
>>> hyperexpand(meijerg([a], [], [c], [b], x), allow_hyper=True)
x**c*gamma(-a + c + 1)*hyper((-a + c + 1,),
 (-b + c + 1,), -x)/gamma(-b + c + 1) 

因此，Meijer G 函数也包含许多命名函数作为特殊情况。您可以使用 expand_func() 或 hyperexpand() 来（尝试）将 Meijer G 函数重写为命名特殊函数。例如：

>>> from sympy import expand_func, S
>>> expand_func(meijerg([[],[]], [[0],[]], -x))
exp(x)
>>> hyperexpand(meijerg([[],[]], [[S(1)/2],[0]], (x/2)**2))
sin(x)/sqrt(pi) 

另请参见

hyper, sympy.simplify.hyperexpand

参考文献

[R464]

Luke, Y. L. (1969), The Special Functions and Their Approximations, Volume 1

[R465]

en.wikipedia.org/wiki/Meijer_G-function

property an

第一组分子参数。

property aother

第二组分子参数。

property ap

组合的分子参数。

property argument

Meijer G-函数的参数。

property bm

第一组分母参数。

property bother

第二组分母参数。

property bq

组合的分母参数。

property delta

与积分的收敛区域相关的量，请参见参考文献。

get_period()

返回一个数 (P)，使得 (G(xexp(IP)) == G(x))。

例子

>>> from sympy import meijerg, pi, S
>>> from sympy.abc import z 

>>> meijerg([1], [], [], [], z).get_period()
2*pi
>>> meijerg([pi], [], [], [], z).get_period()
oo
>>> meijerg([1, 2], [], [], [], z).get_period()
oo
>>> meijerg([1,1], [2], [1, S(1)/2, S(1)/3], [1], z).get_period()
12*pi 

integrand(s)

获取定义的被积函数 D(s)。

property is_number

如果表达式仅包含数值数据，则返回 true。

property nu

与积分的收敛区域相关的量，请参见参考文献。

class sympy.functions.special.hyper.appellf1(a, b1, b2, c, x, y)

这是两个变量的 Appell 超几何函数，如下：

[F_1(a,b_1,b_2,c,x,y) = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty} \frac{(a)_{m+n} (b_1)_m (b_2)n}{(c){m+n}} \frac{x^m y^n}{m! n!}.]

例子

>>> from sympy import appellf1, symbols
>>> x, y, a, b1, b2, c = symbols('x y a b1 b2 c')
>>> appellf1(2., 1., 6., 4., 5., 6.)
0.0063339426292673
>>> appellf1(12., 12., 6., 4., 0.5, 0.12)
172870711.659936
>>> appellf1(40, 2, 6, 4, 15, 60)
appellf1(40, 2, 6, 4, 15, 60)
>>> appellf1(20., 12., 10., 3., 0.5, 0.12)
15605338197184.4
>>> appellf1(40, 2, 6, 4, x, y)
appellf1(40, 2, 6, 4, x, y)
>>> appellf1(a, b1, b2, c, x, y)
appellf1(a, b1, b2, c, x, y) 

参考文献

[R466]

en.wikipedia.org/wiki/Appell_series

[R467]

functions.wolfram.com/HypergeometricFunctions/AppellF1/

椭圆积分

class sympy.functions.special.elliptic_integrals.elliptic_k(m)

第一类完全椭圆积分由以下定义

[K(m) = F\left(\tfrac{\pi}{2}\middle| m\right)]

其中 (F\left(z\middle| m\right)) 是第一类勒让德不完全椭圆积分。

解释

函数 (K(m)) 在复平面上是单值函数，其分支切割沿着区间 ((1, \infty))。

注意，我们的符号学定义中用参数 (m) 而不是椭圆模数（偏心率） (k) 来定义不完全椭圆积分。在这种情况下，参数 (m) 被定义为 (m=k²)。

例子

>>> from sympy import elliptic_k, I
>>> from sympy.abc import m
>>> elliptic_k(0)
pi/2
>>> elliptic_k(1.0 + I)
1.50923695405127 + 0.625146415202697*I
>>> elliptic_k(m).series(n=3)
pi/2 + pi*m/8 + 9*pi*m**2/128 + O(m**3) 

参见

elliptic_f

参考文献

[R468]

en.wikipedia.org/wiki/Elliptic_integrals

[R469]

functions.wolfram.com/EllipticIntegrals/EllipticK

class sympy.functions.special.elliptic_integrals.elliptic_f(z, m)

第一类勒让德不完全椭圆积分，由以下定义

[F\left(z\middle| m\right) = \int_0^z \frac{dt}{\sqrt{1 - m \sin² t}}]

解释

当 (z = \pi/2) 时，此函数简化为第一类完全椭圆积分 (K(m))。

注意，我们的符号学定义中用参数 (m) 而不是椭圆模数（偏心率） (k) 来定义不完全椭圆积分。在这种情况下，参数 (m) 被定义为 (m=k²)。

例子

>>> from sympy import elliptic_f, I
>>> from sympy.abc import z, m
>>> elliptic_f(z, m).series(z)
z + z**5*(3*m**2/40 - m/30) + m*z**3/6 + O(z**6)
>>> elliptic_f(3.0 + I/2, 1.0 + I)
2.909449841483 + 1.74720545502474*I 

参见

elliptic_k

参考文献

[R470]

en.wikipedia.org/wiki/Elliptic_integrals

[R471]

functions.wolfram.com/EllipticIntegrals/EllipticF

class sympy.functions.special.elliptic_integrals.elliptic_e(m, z=None)

以两个参数(z) 和(m) 调用，评估由下式定义的第二类不完全椭圆积分：

[E\left(z\middle| m\right) = \int_0^z \sqrt{1 - m \sin² t} dt]

以单个参数(m) 调用，评估第二类 Legendre 完全椭圆积分。

[E(m) = E\left(\tfrac{\pi}{2}\middle| m\right)]

解释

函数(E(m)) 是复平面上的单值函数，其分支沿着区间((1, \infty))。

注意，我们的符号表示中将不完全椭圆积分定义为参数(m)，而非椭圆模（偏心率）(k)。在此情况下，参数(m) 定义为(m=k²)。

示例

>>> from sympy import elliptic_e, I
>>> from sympy.abc import z, m
>>> elliptic_e(z, m).series(z)
z + z**5*(-m**2/40 + m/30) - m*z**3/6 + O(z**6)
>>> elliptic_e(m).series(n=4)
pi/2 - pi*m/8 - 3*pi*m**2/128 - 5*pi*m**3/512 + O(m**4)
>>> elliptic_e(1 + I, 2 - I/2).n()
1.55203744279187 + 0.290764986058437*I
>>> elliptic_e(0)
pi/2
>>> elliptic_e(2.0 - I)
0.991052601328069 + 0.81879421395609*I 

参考文献

[R472]

en.wikipedia.org/wiki/Elliptic_integrals

[R473]

functions.wolfram.com/EllipticIntegrals/EllipticE2

[R474]

functions.wolfram.com/EllipticIntegrals/EllipticE

class sympy.functions.special.elliptic_integrals.elliptic_pi(n, m, z=None)

以三个参数(n)、(z) 和(m) 调用，评估由下式定义的 Legendre 不完全椭圆积分：

[\Pi\left(n; z\middle| m\right) = \int_0^z \frac{dt} {\left(1 - n \sin² t\right) \sqrt{1 - m \sin² t}}]

以两个参数(n) 和(m) 调用，评估第三类完全椭圆积分：

[\Pi\left(n\middle| m\right) = \Pi\left(n; \tfrac{\pi}{2}\middle| m\right)]

解释

注意，我们的符号表示中将不完全椭圆积分定义为参数(m)，而非椭圆模（偏心率）(k)。在此情况下，参数(m) 定义为(m=k²)。

示例

>>> from sympy import elliptic_pi, I
>>> from sympy.abc import z, n, m
>>> elliptic_pi(n, z, m).series(z, n=4)
z + z**3*(m/6 + n/3) + O(z**4)
>>> elliptic_pi(0.5 + I, 1.0 - I, 1.2)
2.50232379629182 - 0.760939574180767*I
>>> elliptic_pi(0, 0)
pi/2
>>> elliptic_pi(1.0 - I/3, 2.0 + I)
3.29136443417283 + 0.32555634906645*I 

参考文献

[R475]

en.wikipedia.org/wiki/Elliptic_integrals

[R476]

functions.wolfram.com/EllipticIntegrals/EllipticPi3

[R477]

functions.wolfram.com/EllipticIntegrals/EllipticPi ## Mathieu 函数

class sympy.functions.special.mathieu_functions.MathieuBase(*args)

Mathieu 函数的抽象基类。

此类旨在减少代码重复。

class sympy.functions.special.mathieu_functions.mathieus(a, q, z)

Mathieu 正弦函数(S(a,q,z))。

解释

此函数是 Mathieu 微分方程的一个解：

[y(x)^{\prime\prime} + (a - 2 q \cos(2 x)) y(x) = 0]

另一个解是 Mathieu 余弦函数。

示例

>>> from sympy import diff, mathieus
>>> from sympy.abc import a, q, z 

>>> mathieus(a, q, z)
mathieus(a, q, z) 

>>> mathieus(a, 0, z)
sin(sqrt(a)*z) 

>>> diff(mathieus(a, q, z), z)
mathieusprime(a, q, z) 

另请参阅

mathieuc

Mathieu 余弦函数。

mathieusprime

Mathieu 正弦函数的导数。

mathieucprime

Mathieu 余弦函数的导数。

参考文献

[R478]

en.wikipedia.org/wiki/Mathieu_function

[R479]

dlmf.nist.gov/28

[R480]

mathworld.wolfram.com/MathieuFunction.html

[R481]

functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuS/

class sympy.functions.special.mathieu_functions.mathieuc(a, q, z)

Mathieu 余弦函数 (C(a,q,z))。

解释

这个函数是 Mathieu 微分方程的一个解：

[y(x)^{\prime\prime} + (a - 2 q \cos(2 x)) y(x) = 0]

另一个解是 Mathieu 正弦函数。

示例

>>> from sympy import diff, mathieuc
>>> from sympy.abc import a, q, z 

>>> mathieuc(a, q, z)
mathieuc(a, q, z) 

>>> mathieuc(a, 0, z)
cos(sqrt(a)*z) 

>>> diff(mathieuc(a, q, z), z)
mathieucprime(a, q, z) 

另请参阅

mathieus

Mathieu 正弦函数

mathieusprime

Mathieu 正弦函数的导数

mathieucprime

Mathieu 余弦函数的导数

参考文献

[R482]

en.wikipedia.org/wiki/Mathieu_function

[R483]

dlmf.nist.gov/28

[R484]

mathworld.wolfram.com/MathieuFunction.html

[R485]

functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuC/

class sympy.functions.special.mathieu_functions.mathieusprime(a, q, z)

Mathieu 正弦函数的导数(S^{\prime}(a,q,z))。

解释

这个函数是 Mathieu 微分方程的一个解：

[y(x)^{\prime\prime} + (a - 2 q \cos(2 x)) y(x) = 0]

另一个解是 Mathieu 余弦函数。

示例

>>> from sympy import diff, mathieusprime
>>> from sympy.abc import a, q, z 

>>> mathieusprime(a, q, z)
mathieusprime(a, q, z) 

>>> mathieusprime(a, 0, z)
sqrt(a)*cos(sqrt(a)*z) 

>>> diff(mathieusprime(a, q, z), z)
(-a + 2*q*cos(2*z))*mathieus(a, q, z) 

另请参阅

mathieus

Mathieu 正弦函数

mathieuc

Mathieu 余弦函数

mathieucprime

Mathieu 余弦函数的导数

参考文献

[R486]

en.wikipedia.org/wiki/Mathieu_function

[R487]

dlmf.nist.gov/28

[R488]

mathworld.wolfram.com/MathieuFunction.html

[R489]

functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuSPrime/

class sympy.functions.special.mathieu_functions.mathieucprime(a, q, z)

马修余弦函数的导数 (C^{\prime}(a,q,z))。

解释

该函数是马修微分方程的一个解：

[y(x)^{\prime\prime} + (a - 2 q \cos(2 x)) y(x) = 0]

另一个解是马修正弦函数。

示例

>>> from sympy import diff, mathieucprime
>>> from sympy.abc import a, q, z 

>>> mathieucprime(a, q, z)
mathieucprime(a, q, z) 

>>> mathieucprime(a, 0, z)
-sqrt(a)*sin(sqrt(a)*z) 

>>> diff(mathieucprime(a, q, z), z)
(-a + 2*q*cos(2*z))*mathieuc(a, q, z) 

另请参见

mathieus

马修正弦函数

mathieuc

马修余弦函数

mathieusprime

马修正弦函数的导数

参考文献

[R490]

en.wikipedia.org/wiki/Mathieu_function

[R491]

dlmf.nist.gov/28

[R492]

mathworld.wolfram.com/MathieuFunction.html

[R493]

functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuCPrime/ ## 正交多项式

该模块主要实现特殊正交多项式。

另请参见包含一些组合多项式的函数.combinatorial.numbers。

雅各比多项式

class sympy.functions.special.polynomials.jacobi(n, a, b, x)

雅各比多项式 (P_n^{\left(\alpha, \beta\right)}(x))。

解释

jacobi(n, alpha, beta, x) 给出 (x) 中的第 (n) 个雅各比多项式，(P_n^{\left(\alpha, \beta\right)}(x))。

雅各比多项式在 ([-1, 1]) 上相对于权重 (\left(1-x\right)^\alpha \left(1+x\right)^\beta) 正交。

示例

>>> from sympy import jacobi, S, conjugate, diff
>>> from sympy.abc import a, b, n, x 

>>> jacobi(0, a, b, x)
1
>>> jacobi(1, a, b, x)
a/2 - b/2 + x*(a/2 + b/2 + 1)
>>> jacobi(2, a, b, x)
a**2/8 - a*b/4 - a/8 + b**2/8 - b/8 + x**2*(a**2/8 + a*b/4 + 7*a/8 + b**2/8 + 7*b/8 + 3/2) + x*(a**2/4 + 3*a/4 - b**2/4 - 3*b/4) - 1/2 

>>> jacobi(n, a, b, x)
jacobi(n, a, b, x) 

>>> jacobi(n, a, a, x)
RisingFactorial(a + 1, n)*gegenbauer(n,
 a + 1/2, x)/RisingFactorial(2*a + 1, n) 

>>> jacobi(n, 0, 0, x)
legendre(n, x) 

>>> jacobi(n, S(1)/2, S(1)/2, x)
RisingFactorial(3/2, n)*chebyshevu(n, x)/factorial(n + 1) 

>>> jacobi(n, -S(1)/2, -S(1)/2, x)
RisingFactorial(1/2, n)*chebyshevt(n, x)/factorial(n) 

>>> jacobi(n, a, b, -x)
(-1)**n*jacobi(n, b, a, x) 

>>> jacobi(n, a, b, 0)
gamma(a + n + 1)*hyper((-n, -b - n), (a + 1,), -1)/(2**n*factorial(n)*gamma(a + 1))
>>> jacobi(n, a, b, 1)
RisingFactorial(a + 1, n)/factorial(n) 

>>> conjugate(jacobi(n, a, b, x))
jacobi(n, conjugate(a), conjugate(b), conjugate(x)) 

>>> diff(jacobi(n,a,b,x), x)
(a/2 + b/2 + n/2 + 1/2)*jacobi(n - 1, a + 1, b + 1, x) 

另请参见

gegenbauer, chebyshevt_root, chebyshevu, chebyshevu_root, legendre, assoc_legendre, hermite, hermite_prob, laguerre, assoc_laguerre, sympy.polys.orthopolys.jacobi_poly, sympy.polys.orthopolys.gegenbauer_poly, sympy.polys.orthopolys.chebyshevt_poly, sympy.polys.orthopolys.chebyshevu_poly, sympy.polys.orthopolys.hermite_poly, sympy.polys.orthopolys.legendre_poly, sympy.polys.orthopolys.laguerre_poly

参考文献

[R494]

en.wikipedia.org/wiki/Jacobi_polynomials

[R495]

mathworld.wolfram.com/JacobiPolynomial.html

[R496]

functions.wolfram.com/Polynomials/JacobiP/

sympy.functions.special.polynomials.jacobi_normalized(n, a, b, x)

Jacobi 多项式 (P_n^{\left(\alpha, \beta\right)}(x)).

参数:

n : 多项式的整数次数

a : alpha 值

b : beta 值

x : 符号

说明

jacobi_normalized(n, alpha, beta, x) 给出在 (x) 上的第 (n) 个 Jacobi 多项式，(P_n^{\left(\alpha, \beta\right)}(x)).

Jacobi 多项式在 ([-1, 1]) 区间上是关于权重 (\left(1-x\right)^\alpha \left(1+x\right)^\beta) 正交的。

该函数返回归一化的多项式：

[\int_{-1}^{1} P_m^{\left(\alpha, \beta\right)}(x) P_n^{\left(\alpha, \beta\right)}(x) (1-x)^{\alpha} (1+x)^{\beta} \mathrm{d}x = \delta_{m,n}]

示例

>>> from sympy import jacobi_normalized
>>> from sympy.abc import n,a,b,x 

>>> jacobi_normalized(n, a, b, x)
jacobi(n, a, b, x)/sqrt(2**(a + b + 1)*gamma(a + n + 1)*gamma(b + n + 1)/((a + b + 2*n + 1)*factorial(n)*gamma(a + b + n + 1))) 

另请参见

gegenbauer, chebyshevt_root, chebyshevu, chebyshevu_root, legendre, assoc_legendre, hermite, hermite_prob, laguerre, assoc_laguerre, sympy.polys.orthopolys.jacobi_poly, sympy.polys.orthopolys.gegenbauer_poly, sympy.polys.orthopolys.chebyshevt_poly, sympy.polys.orthopolys.chebyshevu_poly, sympy.polys.orthopolys.hermite_poly, sympy.polys.orthopolys.legendre_poly, sympy.polys.orthopolys.laguerre_poly

参考文献

[R497]

en.wikipedia.org/wiki/Jacobi_polynomials

[R498]

mathworld.wolfram.com/JacobiPolynomial.html

[R499]

functions.wolfram.com/Polynomials/JacobiP/

Gegenbauer 多项式

class sympy.functions.special.polynomials.gegenbauer(n, a, x)

Gegenbauer 多项式 (C_n^{\left(\alpha\right)}(x))。

解释

gegenbauer(n, alpha, x) 给出(x)中的第(n)个 Gegenbauer 多项式，(C_n^{\left(\alpha\right)}(x))。

根据权重 (\left(1-x²\right)^{\alpha-\frac{1}{2}}) 在区间 ([-1, 1]) 上与 Gegenbauer 多项式正交。

举例

>>> from sympy import gegenbauer, conjugate, diff
>>> from sympy.abc import n,a,x
>>> gegenbauer(0, a, x)
1
>>> gegenbauer(1, a, x)
2*a*x
>>> gegenbauer(2, a, x)
-a + x**2*(2*a**2 + 2*a)
>>> gegenbauer(3, a, x)
x**3*(4*a**3/3 + 4*a**2 + 8*a/3) + x*(-2*a**2 - 2*a) 

>>> gegenbauer(n, a, x)
gegenbauer(n, a, x)
>>> gegenbauer(n, a, -x)
(-1)**n*gegenbauer(n, a, x) 

>>> gegenbauer(n, a, 0)
2**n*sqrt(pi)*gamma(a + n/2)/(gamma(a)*gamma(1/2 - n/2)*gamma(n + 1))
>>> gegenbauer(n, a, 1)
gamma(2*a + n)/(gamma(2*a)*gamma(n + 1)) 

>>> conjugate(gegenbauer(n, a, x))
gegenbauer(n, conjugate(a), conjugate(x)) 

>>> diff(gegenbauer(n, a, x), x)
2*a*gegenbauer(n - 1, a + 1, x) 

亦参见

jacobi, chebyshevt_root, chebyshevu, chebyshevu_root, legendre, assoc_legendre, hermite, hermite_prob, laguerre, assoc_laguerre, sympy.polys.orthopolys.jacobi_poly, sympy.polys.orthopolys.gegenbauer_poly, sympy.polys.orthopolys.chebyshevt_poly, sympy.polys.orthopolys.chebyshevu_poly, sympy.polys.orthopolys.hermite_poly, sympy.polys.orthopolys.hermite_prob_poly, sympy.polys.orthopolys.legendre_poly, sympy.polys.orthopolys.laguerre_poly

参考文献

[R500]

en.wikipedia.org/wiki/Gegenbauer_polynomials

[R501]

mathworld.wolfram.com/GegenbauerPolynomial.html

[R502]

functions.wolfram.com/Polynomials/GegenbauerC3/

切比雪夫多项式

class sympy.functions.special.polynomials.chebyshevt(n, x)

第一类切比雪夫多项式，(T_n(x))。

解释

chebyshevt(n, x) 在(x)处给出第(n)个切比雪夫多项式（第一类），记为(T_n(x))。

第一类切比雪夫多项式在([-1, 1])上相对于权重(\frac{1}{\sqrt{1-x²}})是正交的。

示例

>>> from sympy import chebyshevt, diff
>>> from sympy.abc import n,x
>>> chebyshevt(0, x)
1
>>> chebyshevt(1, x)
x
>>> chebyshevt(2, x)
2*x**2 - 1 

>>> chebyshevt(n, x)
chebyshevt(n, x)
>>> chebyshevt(n, -x)
(-1)**n*chebyshevt(n, x)
>>> chebyshevt(-n, x)
chebyshevt(n, x) 

>>> chebyshevt(n, 0)
cos(pi*n/2)
>>> chebyshevt(n, -1)
(-1)**n 

>>> diff(chebyshevt(n, x), x)
n*chebyshevu(n - 1, x) 

另见

jacobi, gegenbauer, chebyshevt_root, chebyshevu, chebyshevu_root, legendre, assoc_legendre, hermite, hermite_prob, laguerre, assoc_laguerre, sympy.polys.orthopolys.jacobi_poly, sympy.polys.orthopolys.gegenbauer_poly, sympy.polys.orthopolys.chebyshevt_poly, sympy.polys.orthopolys.chebyshevu_poly, sympy.polys.orthopolys.hermite_poly, sympy.polys.orthopolys.hermite_prob_poly, sympy.polys.orthopolys.legendre_poly, sympy.polys.orthopolys.laguerre_poly

参考文献

[R503]

en.wikipedia.org/wiki/Chebyshev_polynomial的切比雪夫多项式

[R504]

mathworld.wolfram.com/ChebyshevPolynomialoftheFirstKind.html

[R505]

mathworld.wolfram.com/ChebyshevPolynomialoftheSecondKind.html

[R506]

functions.wolfram.com/Polynomials/ChebyshevT/

[R507]

functions.wolfram.com/Polynomials/ChebyshevU/

class sympy.functions.special.polynomials.chebyshevu(n, x)

第二类切比雪夫多项式，(U_n(x))。

解释

chebyshevu(n, x) 给出(n)阶第二类切比雪夫多项式在(x)处的值，记作(U_n(x))。

第二类切比雪夫多项式在([-1, 1])上以权重(\sqrt{1-x²})正交。

示例

>>> from sympy import chebyshevu, diff
>>> from sympy.abc import n,x
>>> chebyshevu(0, x)
1
>>> chebyshevu(1, x)
2*x
>>> chebyshevu(2, x)
4*x**2 - 1 

>>> chebyshevu(n, x)
chebyshevu(n, x)
>>> chebyshevu(n, -x)
(-1)**n*chebyshevu(n, x)
>>> chebyshevu(-n, x)
-chebyshevu(n - 2, x) 

>>> chebyshevu(n, 0)
cos(pi*n/2)
>>> chebyshevu(n, 1)
n + 1 

>>> diff(chebyshevu(n, x), x)
(-x*chebyshevu(n, x) + (n + 1)*chebyshevt(n + 1, x))/(x**2 - 1) 

另见

jacobi, gegenbauer, chebyshevt, chebyshevt_root, chebyshevu_root, legendre, assoc_legendre, hermite, hermite_prob, laguerre, assoc_laguerre, sympy.polys.orthopolys.jacobi_poly, sympy.polys.orthopolys.gegenbauer_poly, sympy.polys.orthopolys.chebyshevt_poly, sympy.polys.orthopolys.chebyshevu_poly, sympy.polys.orthopolys.hermite_poly, sympy.polys.orthopolys.hermite_prob_poly, sympy.polys.orthopolys.legendre_poly, sympy.polys.orthopolys.laguerre_poly

References

[R508]

en.wikipedia.org/wiki/Chebyshev_polynomial

[R509]

mathworld.wolfram.com/ChebyshevPolynomialoftheFirstKind.html

[R510]

mathworld.wolfram.com/ChebyshevPolynomialoftheSecondKind.html

[R511]

functions.wolfram.com/Polynomials/ChebyshevT/

[R512]

functions.wolfram.com/Polynomials/ChebyshevU/

class sympy.functions.special.polynomials.chebyshevt_root(n, k)

chebyshev_root(n, k) 返回第一类 Chebyshev 多项式的第(n)个 Chebyshev 多项式的第(k)个根（从零开始索引）；即，如果(0 \le k < n)，则 chebyshevt(n, chebyshevt_root(n, k)) == 0。

示例

>>> from sympy import chebyshevt, chebyshevt_root
>>> chebyshevt_root(3, 2)
-sqrt(3)/2
>>> chebyshevt(3, chebyshevt_root(3, 2))
0 

另请参见

jacobi, gegenbauer, chebyshevt, chebyshevu, chebyshevu_root, legendre, assoc_legendre, hermite, hermite_prob, laguerre, assoc_laguerre, sympy.polys.orthopolys.jacobi_poly, sympy.polys.orthopolys.gegenbauer_poly, sympy.polys.orthopolys.chebyshevt_poly, sympy.polys.orthopolys.chebyshevu_poly, sympy.polys.orthopolys.hermite_poly, sympy.polys.orthopolys.hermite_prob_poly, sympy.polys.orthopolys.legendre_poly, sympy.polys.orthopolys.laguerre_poly

class sympy.functions.special.polynomials.chebyshevu_root(n, k)

chebyshevu_root(n, k) 返回第 (n) 个第二类 Chebyshev 多项式的第 (k) 个根（从零开始索引）；即，如果 (0 \le k < n)，则 chebyshevu(n, chebyshevu_root(n, k)) == 0。

示例

>>> from sympy import chebyshevu, chebyshevu_root
>>> chebyshevu_root(3, 2)
-sqrt(2)/2
>>> chebyshevu(3, chebyshevu_root(3, 2))
0 

参见

chebyshevt, chebyshevt_root, chebyshevu, legendre, assoc_legendre, hermite, hermite_prob, laguerre, assoc_laguerre, sympy.polys.orthopolys.jacobi_poly, sympy.polys.orthopolys.gegenbauer_poly, sympy.polys.orthopolys.chebyshevt_poly, sympy.polys.orthopolys.chebyshevu_poly, sympy.polys.orthopolys.hermite_poly, sympy.polys.orthopolys.hermite_prob_poly, sympy.polys.orthopolys.legendre_poly, sympy.polys.orthopolys.laguerre_poly

Legendre 多项式

class sympy.functions.special.polynomials.legendre(n, x)

legendre(n, x) 给出 (x) 的第 (n) 个 Legendre 多项式，(P_n(x))

说明

Legendre 多项式在([-1, 1])上相对于常数权重 1 是正交的。它们满足 (P_n(1) = 1) 对于所有 (n)；此外，对于奇数 (n)，(P_n) 是奇函数，对于偶数 (n)，(P_n) 是偶函数。

示例

>>> from sympy import legendre, diff
>>> from sympy.abc import x, n
>>> legendre(0, x)
1
>>> legendre(1, x)
x
>>> legendre(2, x)
3*x**2/2 - 1/2
>>> legendre(n, x)
legendre(n, x)
>>> diff(legendre(n,x), x)
n*(x*legendre(n, x) - legendre(n - 1, x))/(x**2 - 1) 

参见

jacobi, gegenbauer, chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root, assoc_legendre, hermite, hermite_prob, laguerre, assoc_laguerre, sympy.polys.orthopolys.jacobi_poly, sympy.polys.orthopolys.gegenbauer_poly, sympy.polys.orthopolys.chebyshevt_poly, sympy.polys.orthopolys.chebyshevu_poly, sympy.polys.orthopolys.hermite_poly, sympy.polys.orthopolys.hermite_prob_poly, sympy.polys.orthopolys.legendre_poly, sympy.polys.orthopolys.laguerre_poly

References

[R513]

en.wikipedia.org/wiki/Legendre_polynomial

[R514]

mathworld.wolfram.com/LegendrePolynomial.html

[R515]

functions.wolfram.com/Polynomials/LegendreP/

[R516]

functions.wolfram.com/Polynomials/LegendreP2/

class sympy.functions.special.polynomials.assoc_legendre(n, m, x)

assoc_legendre(n, m, x) 给出(P_n^m(x))，其中(n)和(m)分别是次数和顺序或与 n 阶 Legendre 多项式(P_n(x))相关的表达式方式：

[P_n^m(x) = (-1)^m (1 - x²)^{\frac{m}{2}} \frac{\mathrm{d}^m P_n(x)}{\mathrm{d} x^m}]

解释

相关的 Legendre 多项式在([-1, 1])上正交，具有：

• 对于相同的(m)和不同的(n)，权重(= 1)。

• 对于相同的(n)和不同的(m)，权重(= \frac{1}{1-x²})。

示例

>>> from sympy import assoc_legendre
>>> from sympy.abc import x, m, n
>>> assoc_legendre(0,0, x)
1
>>> assoc_legendre(1,0, x)
x
>>> assoc_legendre(1,1, x)
-sqrt(1 - x**2)
>>> assoc_legendre(n,m,x)
assoc_legendre(n, m, x) 

另请参阅

jacobi, gegenbauer, chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root, legendre, hermite, hermite_prob, laguerre, assoc_laguerre, sympy.polys.orthopolys.jacobi_poly, sympy.polys.orthopolys.gegenbauer_poly, sympy.polys.orthopolys.chebyshevt_poly, sympy.polys.orthopolys.chebyshevu_poly, sympy.polys.orthopolys.hermite_poly, sympy.polys.orthopolys.hermite_prob_poly, sympy.polys.orthopolys.legendre_poly, sympy.polys.orthopolys.laguerre_poly

参考

[R517]

en.wikipedia.org/wiki/Associated_Legendre_polynomials

[R518]

mathworld.wolfram.com/LegendrePolynomial.html

[R519]

functions.wolfram.com/Polynomials/LegendreP/

[R520]

functions.wolfram.com/Polynomials/LegendreP2/

厄米多项式

class sympy.functions.special.polynomials.hermite(n, x)

hermite(n, x)给出(x)中的第(n)个厄米多项式，(H_n(x))。

解释

厄米特多项式在((-\infty, \infty))上相对于权重(\exp\left(-x²\right))正交。

例子

>>> from sympy import hermite, diff
>>> from sympy.abc import x, n
>>> hermite(0, x)
1
>>> hermite(1, x)
2*x
>>> hermite(2, x)
4*x**2 - 2
>>> hermite(n, x)
hermite(n, x)
>>> diff(hermite(n,x), x)
2*n*hermite(n - 1, x)
>>> hermite(n, -x)
(-1)**n*hermite(n, x) 

参见

jacobi, gegenbauer, chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root, legendre, assoc_legendre, hermite_prob, laguerre, assoc_laguerre, sympy.polys.orthopolys.jacobi_poly, sympy.polys.orthopolys.gegenbauer_poly, sympy.polys.orthopolys.chebyshevt_poly, sympy.polys.orthopolys.chebyshevu_poly, sympy.polys.orthopolys.hermite_poly, sympy.polys.orthopolys.hermite_prob_poly, sympy.polys.orthopolys.legendre_poly, sympy.polys.orthopolys.laguerre_poly

参考文献

[R521]

en.wikipedia.org/wiki/Hermite_polynomial

[R522]

mathworld.wolfram.com/HermitePolynomial.html

[R523]

functions.wolfram.com/Polynomials/HermiteH/

class sympy.functions.special.polynomials.hermite_prob(n, x)

hermite_prob(n, x) 给出第 (n) 个概率厄米多项式 (He_n(x))。

解释

概率学家的 Hermite 多项式在 ((-\infty, \infty)) 范围内，相对于权重 (\exp\left(-\frac{x²}{2}\right)) 是正交的。它们是首一多项式，与普通 Hermite 多项式 (hermite) 相关。

[He_n(x) = 2^{-n/2} H_n(x/\sqrt{2})]

例子

>>> from sympy import hermite_prob, diff, I
>>> from sympy.abc import x, n
>>> hermite_prob(1, x)
x
>>> hermite_prob(5, x)
x**5 - 10*x**3 + 15*x
>>> diff(hermite_prob(n,x), x)
n*hermite_prob(n - 1, x)
>>> hermite_prob(n, -x)
(-1)**n*hermite_prob(n, x) 

(He_n(x))的系数绝对值之和等于完全图 (K_n) 或电话号码中的匹配数，OEIS 中的 A000085：

>>> [hermite_prob(n,I) / I**n for n in range(11)]
[1, 1, 2, 4, 10, 26, 76, 232, 764, 2620, 9496] 

另请参阅

jacobi, gegenbauer, chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root, legendre, assoc_legendre, hermite, laguerre, assoc_laguerre, sympy.polys.orthopolys.jacobi_poly, sympy.polys.orthopolys.gegenbauer_poly, sympy.polys.orthopolys.chebyshevt_poly, sympy.polys.orthopolys.chebyshevu_poly, sympy.polys.orthopolys.hermite_poly, sympy.polys.orthopolys.hermite_prob_poly, sympy.polys.orthopolys.legendre_poly, sympy.polys.orthopolys.laguerre_poly

参考文献

[R524]

en.wikipedia.org/wiki/Hermite_polynomial

[R525]

mathworld.wolfram.com/HermitePolynomial.html

拉盖尔多项式

class sympy.functions.special.polynomials.laguerre(n, x)

返回在(x)中的第(n)个拉盖尔多项式，(L_n(x))。

参数：

n : 整数

拉盖尔多项式的次数。必须满足(n \ge 0)。

示例

>>> from sympy import laguerre, diff
>>> from sympy.abc import x, n
>>> laguerre(0, x)
1
>>> laguerre(1, x)
1 - x
>>> laguerre(2, x)
x**2/2 - 2*x + 1
>>> laguerre(3, x)
-x**3/6 + 3*x**2/2 - 3*x + 1 

>>> laguerre(n, x)
laguerre(n, x) 

>>> diff(laguerre(n, x), x)
-assoc_laguerre(n - 1, 1, x) 

另见

jacobi, gegenbauer, chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root, legendre, assoc_legendre, hermite, hermite_prob, assoc_laguerre, sympy.polys.orthopolys.jacobi_poly, sympy.polys.orthopolys.gegenbauer_poly, sympy.polys.orthopolys.chebyshevt_poly, sympy.polys.orthopolys.chebyshevu_poly, sympy.polys.orthopolys.hermite_poly, sympy.polys.orthopolys.hermite_prob_poly, sympy.polys.orthopolys.legendre_poly, sympy.polys.orthopolys.laguerre_poly

参考资料

[R526]

en.wikipedia.org/wiki/Laguerre_polynomial

[R527]

mathworld.wolfram.com/LaguerrePolynomial.html

[R528]

functions.wolfram.com/Polynomials/LaguerreL/

[R529]

functions.wolfram.com/Polynomials/LaguerreL3/

class sympy.functions.special.polynomials.assoc_laguerre(n, alpha, x)

返回(x)中第(n)个广义 Laguerre 多项式，(L_n(x))。

参数：

n : int

Laguerre 多项式的次数。必须满足(n \ge 0)。

alpha : Expr

任意表达式。对于alpha=0，将生成常规的 Laguerre 多项式。

示例

>>> from sympy import assoc_laguerre, diff
>>> from sympy.abc import x, n, a
>>> assoc_laguerre(0, a, x)
1
>>> assoc_laguerre(1, a, x)
a - x + 1
>>> assoc_laguerre(2, a, x)
a**2/2 + 3*a/2 + x**2/2 + x*(-a - 2) + 1
>>> assoc_laguerre(3, a, x)
a**3/6 + a**2 + 11*a/6 - x**3/6 + x**2*(a/2 + 3/2) +
 x*(-a**2/2 - 5*a/2 - 3) + 1 

>>> assoc_laguerre(n, a, 0)
binomial(a + n, a) 

>>> assoc_laguerre(n, a, x)
assoc_laguerre(n, a, x) 

>>> assoc_laguerre(n, 0, x)
laguerre(n, x) 

>>> diff(assoc_laguerre(n, a, x), x)
-assoc_laguerre(n - 1, a + 1, x) 

>>> diff(assoc_laguerre(n, a, x), a)
Sum(assoc_laguerre(_k, a, x)/(-a + n), (_k, 0, n - 1)) 

另见

jacobi, gegenbauer, chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root, legendre, assoc_legendre, hermite, hermite_prob, laguerre, sympy.polys.orthopolys.jacobi_poly, sympy.polys.orthopolys.gegenbauer_poly, sympy.polys.orthopolys.chebyshevt_poly, sympy.polys.orthopolys.chebyshevu_poly, sympy.polys.orthopolys.hermite_poly, sympy.polys.orthopolys.hermite_prob_poly, sympy.polys.orthopolys.legendre_poly, sympy.polys.orthopolys.laguerre_poly

参考文献

[R530]

en.wikipedia.org/wiki/Laguerre_polynomial#Generalized_Laguerre_polynomials

[R531]

mathworld.wolfram.com/AssociatedLaguerrePolynomial.html

[R532]

functions.wolfram.com/Polynomials/LaguerreL/

[R533]

functions.wolfram.com/Polynomials/LaguerreL3/

球谐函数

class sympy.functions.special.spherical_harmonics.Ynm(n, m, theta, phi)

定义为球谐函数

[Y_n^m(\theta, \varphi) := \sqrt{\frac{(2n+1)(n-m)!}{4\pi(n+m)!}} \exp(i m \varphi) \mathrm{P}_n^m\left(\cos(\theta)\right)]

解释

Ynm() 给出在球坐标 (\theta) 和 (\varphi) 中的阶数为 (n) 和 (m) 的球谐函数，(Y_n^m(\theta, \varphi))。这四个参数如下：(n \geq 0) 是整数，(m) 是整数满足 (-n \leq m \leq n)。这两个角度是实数，(\theta \in [0, \pi])，(\varphi \in [0, 2\pi])。

例子

>>> from sympy import Ynm, Symbol, simplify
>>> from sympy.abc import n,m
>>> theta = Symbol("theta")
>>> phi = Symbol("phi") 

>>> Ynm(n, m, theta, phi)
Ynm(n, m, theta, phi) 

已知有多种对称性，例如：

>>> Ynm(n, -m, theta, phi)
(-1)**m*exp(-2*I*m*phi)*Ynm(n, m, theta, phi) 

同样适用于角度：

>>> Ynm(n, m, -theta, phi)
Ynm(n, m, theta, phi) 

>>> Ynm(n, m, theta, -phi)
exp(-2*I*m*phi)*Ynm(n, m, theta, phi) 

对于特定的整数 (n) 和 (m)，我们可以评估谐波到更有用的表达式：

>>> simplify(Ynm(0, 0, theta, phi).expand(func=True))
1/(2*sqrt(pi)) 

>>> simplify(Ynm(1, -1, theta, phi).expand(func=True))
sqrt(6)*exp(-I*phi)*sin(theta)/(4*sqrt(pi)) 

>>> simplify(Ynm(1, 0, theta, phi).expand(func=True))
sqrt(3)*cos(theta)/(2*sqrt(pi)) 

>>> simplify(Ynm(1, 1, theta, phi).expand(func=True))
-sqrt(6)*exp(I*phi)*sin(theta)/(4*sqrt(pi)) 

>>> simplify(Ynm(2, -2, theta, phi).expand(func=True))
sqrt(30)*exp(-2*I*phi)*sin(theta)**2/(8*sqrt(pi)) 

>>> simplify(Ynm(2, -1, theta, phi).expand(func=True))
sqrt(30)*exp(-I*phi)*sin(2*theta)/(8*sqrt(pi)) 

>>> simplify(Ynm(2, 0, theta, phi).expand(func=True))
sqrt(5)*(3*cos(theta)**2 - 1)/(4*sqrt(pi)) 

>>> simplify(Ynm(2, 1, theta, phi).expand(func=True))
-sqrt(30)*exp(I*phi)*sin(2*theta)/(8*sqrt(pi)) 

>>> simplify(Ynm(2, 2, theta, phi).expand(func=True))
sqrt(30)*exp(2*I*phi)*sin(theta)**2/(8*sqrt(pi)) 

我们可以分别对两个角度进行函数的微分：

>>> from sympy import Ynm, Symbol, diff
>>> from sympy.abc import n,m
>>> theta = Symbol("theta")
>>> phi = Symbol("phi") 

>>> diff(Ynm(n, m, theta, phi), theta)
m*cot(theta)*Ynm(n, m, theta, phi) + sqrt((-m + n)*(m + n + 1))*exp(-I*phi)*Ynm(n, m + 1, theta, phi) 

>>> diff(Ynm(n, m, theta, phi), phi)
I*m*Ynm(n, m, theta, phi) 

进一步，我们可以计算复共轭：

>>> from sympy import Ynm, Symbol, conjugate
>>> from sympy.abc import n,m
>>> theta = Symbol("theta")
>>> phi = Symbol("phi") 

>>> conjugate(Ynm(n, m, theta, phi))
(-1)**(2*m)*exp(-2*I*m*phi)*Ynm(n, m, theta, phi) 

为了恢复球坐标中的著名表达式，我们使用全面展开：

>>> from sympy import Ynm, Symbol, expand_func
>>> from sympy.abc import n,m
>>> theta = Symbol("theta")
>>> phi = Symbol("phi") 

>>> expand_func(Ynm(n, m, theta, phi))
sqrt((2*n + 1)*factorial(-m + n)/factorial(m + n))*exp(I*m*phi)*assoc_legendre(n, m, cos(theta))/(2*sqrt(pi)) 

参见也

Ynm_c, Znm

References

[R534]

en.wikipedia.org/wiki/Spherical_harmonics

[R535]

mathworld.wolfram.com/SphericalHarmonic.html

[R536]

functions.wolfram.com/Polynomials/SphericalHarmonicY/

[R537]

dlmf.nist.gov/14.30

sympy.functions.special.spherical_harmonics.Ynm_c(n, m, theta, phi)

共轭球谐函数定义为

[\overline{Y_n^m(\theta, \varphi)} := (-1)^m Y_n^{-m}(\theta, \varphi).]

例子

>>> from sympy import Ynm_c, Symbol, simplify
>>> from sympy.abc import n,m
>>> theta = Symbol("theta")
>>> phi = Symbol("phi")
>>> Ynm_c(n, m, theta, phi)
(-1)**(2*m)*exp(-2*I*m*phi)*Ynm(n, m, theta, phi)
>>> Ynm_c(n, m, -theta, phi)
(-1)**(2*m)*exp(-2*I*m*phi)*Ynm(n, m, theta, phi) 

对于特定的整数 (n) 和 (m)，我们可以评估谐波到更有用的表达式：

>>> simplify(Ynm_c(0, 0, theta, phi).expand(func=True))
1/(2*sqrt(pi))
>>> simplify(Ynm_c(1, -1, theta, phi).expand(func=True))
sqrt(6)*exp(I*(-phi + 2*conjugate(phi)))*sin(theta)/(4*sqrt(pi)) 

参见也

Ynm, Znm

参考

[R538]

en.wikipedia.org/wiki/Spherical_harmonics

[R539]

mathworld.wolfram.com/SphericalHarmonic.html

[R540]

functions.wolfram.com/Polynomials/SphericalHarmonicY/

class sympy.functions.special.spherical_harmonics.Znm(n, m, theta, phi)

定义为实球谐函数

[\begin{split}Z_n^m(\theta, \varphi) := \begin{cases} \frac{Y_n^m(\theta, \varphi) + \overline{Y_n^m(\theta, \varphi)}}{\sqrt{2}} &\quad m > 0 \ Y_n^m(\theta, \varphi) &\quad m = 0 \ \frac{Y_n^m(\theta, \varphi) - \overline{Y_n^m(\theta, \varphi)}}{i \sqrt{2}} &\quad m < 0 \ \end{cases}\end{split}]

这在简化形式中给出

[\begin{split}Z_n^m(\theta, \varphi) = \begin{cases} \frac{Y_n^m(\theta, \varphi) + (-1)^m Y_n^{-m}(\theta, \varphi)}{\sqrt{2}} &\quad m > 0 \ Y_n^m(\theta, \varphi) &\quad m = 0 \ \frac{Y_n^m(\theta, \varphi) - (-1)^m Y_n^{-m}(\theta, \varphi)}{i \sqrt{2}} &\quad m < 0 \ \end{cases}\end{split}]

示例

>>> from sympy import Znm, Symbol, simplify
>>> from sympy.abc import n, m
>>> theta = Symbol("theta")
>>> phi = Symbol("phi")
>>> Znm(n, m, theta, phi)
Znm(n, m, theta, phi) 

对于特定的整数 (n) 和 (m)，我们可以评估谐波以获得更有用的表达式：

>>> simplify(Znm(0, 0, theta, phi).expand(func=True))
1/(2*sqrt(pi))
>>> simplify(Znm(1, 1, theta, phi).expand(func=True))
-sqrt(3)*sin(theta)*cos(phi)/(2*sqrt(pi))
>>> simplify(Znm(2, 1, theta, phi).expand(func=True))
-sqrt(15)*sin(2*theta)*cos(phi)/(4*sqrt(pi)) 

参见

Ynm, Ynm_c

参考文献

[R541]

球谐函数

[R542]

球谐函数

[R543]

球谐函数 Y

张量函数

sympy.functions.special.tensor_functions.Eijk(*args, **kwargs)

表示利维-奇维塔符号。

这是对 LeviCivita() 的兼容性包装。

参见

LeviCivita

sympy.functions.special.tensor_functions.eval_levicivita(*args)

评估利维-奇维塔符号。

class sympy.functions.special.tensor_functions.LeviCivita(*args)

表示利维-奇维塔符号。

解释

对于指标的偶排列返回 1，对于奇排列返回 -1，对于其他情况（重复指标）返回 0。

因此它表示一个交替的伪张量。

示例

>>> from sympy import LeviCivita
>>> from sympy.abc import i, j, k
>>> LeviCivita(1, 2, 3)
1
>>> LeviCivita(1, 3, 2)
-1
>>> LeviCivita(1, 2, 2)
0
>>> LeviCivita(i, j, k)
LeviCivita(i, j, k)
>>> LeviCivita(i, j, i)
0 

参见

Eijk

class sympy.functions.special.tensor_functions.KroneckerDelta(i, j, delta_range=None)

离散或克罗内克 δ 函数。

参数：

i : 数字，符号

δ 函数的第一个指标。

j : 数字，符号

δ 函数的第二个指标。

解释

一个接受两个整数 (i) 和 (j) 的函数。如果 (i) 和 (j) 不相等则返回 (0)，如果相等则返回 (1)。

示例

带有整数指标的例子：

>>> from sympy import KroneckerDelta
>>> KroneckerDelta(1, 2)
0
>>> KroneckerDelta(3, 3)
1 

符号指标：

>>> from sympy.abc import i, j, k
>>> KroneckerDelta(i, j)
KroneckerDelta(i, j)
>>> KroneckerDelta(i, i)
1
>>> KroneckerDelta(i, i + 1)
0
>>> KroneckerDelta(i, i + 1 + k)
KroneckerDelta(i, i + k + 1) 

参见

eval, DiracDelta

参考文献

[R544]

克罗内克 δ 函数

classmethod eval(i, j, delta_range=None)

评估离散 δ 函数。

示例

>>> from sympy import KroneckerDelta
>>> from sympy.abc import i, j, k 

>>> KroneckerDelta(i, j)
KroneckerDelta(i, j)
>>> KroneckerDelta(i, i)
1
>>> KroneckerDelta(i, i + 1)
0
>>> KroneckerDelta(i, i + 1 + k)
KroneckerDelta(i, i + k + 1) 

间接 doctest

property indices_contain_equal_information

如果指标都在费米面上方或下方则返回 True。

示例

>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, q).indices_contain_equal_information
True
>>> KroneckerDelta(p, q+1).indices_contain_equal_information
True
>>> KroneckerDelta(i, p).indices_contain_equal_information
False 

property is_above_fermi

若 Delta 在费米面上方可以非零。

示例

>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, a).is_above_fermi
True
>>> KroneckerDelta(p, i).is_above_fermi
False
>>> KroneckerDelta(p, q).is_above_fermi
True 

参见

is_below_fermi, is_only_below_fermi, is_only_above_fermi

property is_below_fermi

如果 Delta 可以在费米能级以下非零，则为真。

示例

>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, a).is_below_fermi
False
>>> KroneckerDelta(p, i).is_below_fermi
True
>>> KroneckerDelta(p, q).is_below_fermi
True 

另请参阅

is_above_fermi, is_only_above_fermi, is_only_below_fermi

property is_only_above_fermi

如果 Delta 受到费米能级以上的限制，则为真。

示例

>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, a).is_only_above_fermi
True
>>> KroneckerDelta(p, q).is_only_above_fermi
False
>>> KroneckerDelta(p, i).is_only_above_fermi
False 

另请参阅

is_above_fermi, is_below_fermi, is_only_below_fermi

property is_only_below_fermi

如果 Delta 受到费米能级以下的限制，则为真。

示例

>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, i).is_only_below_fermi
True
>>> KroneckerDelta(p, q).is_only_below_fermi
False
>>> KroneckerDelta(p, a).is_only_below_fermi
False 

另请参阅

is_above_fermi, is_below_fermi, is_only_above_fermi

property killable_index

返回在最终表达式中优先替换的索引。

解释

要替换的索引是具有关于费米能级更少信息的索引。如果索引包含相同信息，则“a”优先于“b”。

示例

>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> j = Symbol('j', below_fermi=True)
>>> p = Symbol('p')
>>> KroneckerDelta(p, i).killable_index
p
>>> KroneckerDelta(p, a).killable_index
p
>>> KroneckerDelta(i, j).killable_index
j 

另请参阅

preferred_index

property preferred_index

返回在最终表达式中保留的优先索引。

解释

首选索引是具有关于费米能级更多信息的索引。如果索引包含相同信息，则“a”优先于“b”。

示例

>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> j = Symbol('j', below_fermi=True)
>>> p = Symbol('p')
>>> KroneckerDelta(p, i).preferred_index
i
>>> KroneckerDelta(p, a).preferred_index
a
>>> KroneckerDelta(i, j).preferred_index
i 

另请参阅

killable_index