特殊的 #

https://mathworld.wolfram.com/Erf.html

[R382]

[R383]

https://functions.wolfram.com/GammaBetaErf/Erf

inverse(argindex=1)[源代码]#: Returns the inverse of this function.

class sympy.functions.special.error_functions.erfc(arg)[源代码]#

互补误差函数。

解释

函数定义为：

\[\mathrm{erfc}（x）=\frac{2}{\sqrt{\pi}\int}x^\infty e^{-t^2}\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]

https://en.wikipedia.org/wiki/Error_function

[R385]

https://mathworld.wolfram.com/Erfc.html

[R386]

[R387]

https://functions.wolfram.com/GammaBetaErf/Erfc

inverse(argindex=1)[源代码]#: Returns the inverse of this function.

class sympy.functions.special.error_functions.erfi(z)[源代码]#

虚误差函数。

解释

函数erfi定义为：

\[\mathrm{erfi}（x）=\frac{2}{\sqrt{\pi}\int}0^x e^{t^2}\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]

https://en.wikipedia.org/wiki/Error_function

[R389]

https://mathworld.wolfram.com/Erfi.html

[R390]

https://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^2}\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]

https://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]

https://en.wikipedia.org/wiki/Error_函数#逆函数

[R393]

https://functions.wolfram.com/GammaBetaErf/InverseErf/

inverse(argindex=1)[源代码]#: Returns the inverse of this function.

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]

https://en.wikipedia.org/wiki/Error_函数#逆函数

[R395]

https://functions.wolfram.com/GammaBetaErf/InverseErfc/

inverse(argindex=1)[源代码]#: Returns the inverse of this function.

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]

https://functions.wolfram.com/GammaBetaErf/InverseErf2/

class sympy.functions.special.error_functions.FresnelIntegral(z)[源代码]#: 菲涅耳积分的基类。

class sympy.functions.special.error_functions.fresnels(z)[源代码]#

菲涅耳积分S。

解释

此函数由定义

\[\运算符名称{S}（z）=\int_0^z\sin{\frac{\pi}{2}t^2}\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)

菲涅耳积分服从镜像对称$\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)

通过积分定义菲涅耳函数：

>>> 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)

我们可以在整个复平面上以任意精度数值计算菲涅耳积分：

>>> fresnels(2).evalf(30)
0.343415678363698242195300815958

>>> fresnels(-2*I).evalf(30)
0.343415678363698242195300815958*I

参见

fresnelc: 菲涅耳余弦积分。

工具书类

[R397]

https://en.wikipedia.org/wiki/Fresnel_integral

[R398]

https://mathworld.wolfram.com/FresnelIntegrals.html

[R399]

[R400]

https://functions.wolfram.com/GammaBetaErf/FresnelS

[R401]

fresnel积分的收敛因子

class sympy.functions.special.error_functions.fresnelc(z)[源代码]#

菲涅耳积分C。

解释

此函数由定义

\[\运算符名称{C}（z）=\int_0^z\cos{\frac{\pi}{2}t^2}\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)

菲涅耳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)

通过积分定义菲涅耳函数：

>>> 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)

我们可以在整个复平面上以任意精度数值计算菲涅耳积分：

>>> fresnelc(2).evalf(30)
0.488253406075340754500223503357

>>> fresnelc(-2*I).evalf(30)
-0.488253406075340754500223503357*I

参见

fresnels: 菲涅耳正弦积分。

工具书类

[R402]

https://en.wikipedia.org/wiki/Fresnel_integral

[R403]

https://mathworld.wolfram.com/FresnelIntegrals.html

[R404]

[R405]

https://functions.wolfram.com/GammaBetaErf/FresnelC

[R406]

fresnel积分的收敛因子

指数积分、对数积分和三角积分#

class sympy.functions.special.error_functions.Ei(z)[源代码]#

经典的指数积分。

解释

对于在SymPy中使用，此函数定义为

\[\运算符名称{Ei}（x）=\sum{n=1}^\infty\frac{x^n}{n\，n！}\]

其中$\gamma$是Euler Mascheroni常数。

如果$x$是极数，则在对数的黎曼曲面上定义了一个解析函数。否则，将在剖切面$\mathbb{C}\setminus（-\infty，0]$）中定义一个分析函数。

Background

指数积分的名称来源于以下语句：

\[\运算符名称{Ei}（x）=\int{-\infty}^x\frac{e^t}{t}\mathrm{d}t\]

如果积分被解释为一个Cauchy主值，则此语句适用于上面定义的$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: 上不完全伽马函数。

工具书类

[R407]

https://dlmf.nist.gov/6.6

[R408]

https://en.wikipedia.org/wiki/Exponential_integral

[R409]

Abramowitz & Stegun, section 5: https://web.archive.org/web/20201128173312/http://people.math.sfu.ca/~cbm/aands/page_228.htm

class sympy.functions.special.error_functions.expint(nu, z)[源代码]#

广义指数积分。

解释

此函数定义为

\[\运算符名称{E}\nu（z）=z^{\nu-1}\Gamma（1-\nu，z），\]

其中$\Gamma（1-\nu，z）$是上不完全Gamma函数 (uppergamma ）

因此对于有正实部的$z$我们有

\[\运算符名称{E}\nu（z）\]

这就解释了这个名字。

不完整伽马函数的表示为$\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

广义指数积分本质上等价于不完全伽马函数：

>>> 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]

https://dlmf.nist.gov/8.19

[R411]

https://functions.wolfram.com/GammaBetaErf/ExpIntegralE/

[R412]

https://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中使用，此函数定义为

\[\运算符名称{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 通过积分函数：>>>来自sympy import integrate>>>integrate（li（z））z li(z) - Ei(2 对数（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计算索德纳常数：

>>> from mpmath import findroot
>>> findroot(li, 2)
1.45136923488338

进一步的转换包括重写 li 关于三角积分 Si ， Ci ， Shi 和 Chi ：

>>> 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]

https://en.wikipedia.org/wiki/Logarithmic_integral

[R414]

https://mathworld.wolfram.com/LogarithmicIntegral.html

[R415]

https://dlmf.nist.gov/6

[R416]

https://mathworld.wolfram.com/SoldnersConstant.html

class sympy.functions.special.error_functions.Li(z)[源代码]#

偏移对数积分。

解释

对于在SymPy中使用，此函数定义为

\[\运算符名称{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]

https://en.wikipedia.org/wiki/Logarithmic_integral

[R418]

https://mathworld.wolfram.com/LogarithmicIntegral.html

[R419]

https://dlmf.nist.gov/6

class sympy.functions.special.error_functions.Si(z)[源代码]#

正弦积分。

解释

此函数由定义

\[\运算符名称{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]

https://en.wikipedia.org/wiki/Trigonometric_integral

class sympy.functions.special.error_functions.Ci(z)[源代码]#

余弦积分。

解释

此函数由定义为正$x$

\[\运算符名称{Ci}（x）=\gamma+\log{x}\]

其中$\gamma$是Euler Mascheroni常数。

我们有

\[\运算符名称{Ci}（z）=\]

它适用于所有极坐标$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

余弦积分的行为有点像普通的$\cos$乘以$i$：

>>> 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]

https://en.wikipedia.org/wiki/Trigonometric_integral

class sympy.functions.special.error_functions.Shi(z)[源代码]#

Sinh积分。

解释

此函数由定义

\[\运算符名称{Shi}（z）=\int_0^z\frac{\sinh{t}}{t}\mathrm{d}t。\]

它是一个完整的函数。

实例

>>> from sympy import Shi
>>> from sympy.abc import z

Sinh积分是$\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$积分与普通的$\sinh$在乘以$i$时的行为非常相似：

>>> 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]

https://en.wikipedia.org/wiki/Trigonometric_integral

class sympy.functions.special.error_functions.Chi(z)[源代码]#

Cosh积分。

解释

此函数由定义为正$x$

\[\运算符名称{Chi}（x）=\gamma+\log{x}\]

其中$\gamma$是Euler Mascheroni常数。

我们有

\[\运算符名称{Chi}（z）=\operatorname{Ci}\左（e^{i\pi/2}z\右）\]

它适用于所有极坐标$z$，因此提供了对数的黎曼曲面的解析延拓。通过对主分支的提升，我们得到了切复平面上的一个解析函数。

实例

>>> from sympy import Chi
>>> from sympy.abc import z

$\cosh$积分是$\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$相乘的情况下，$\cosh$积分的行为有点像普通的$\cosh$：

>>> 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]

https://en.wikipedia.org/wiki/Trigonometric_integral

贝塞尔型函数#

class sympy.functions.special.bessel.BesselBase(nu, z)[源代码]#

贝塞尔型函数的抽象基类。

这个类是为了减少代码重复。用sel型函数的所有可微项表示为sel型函数。

这里，贝塞尔型函数假定有一个复参数。

若要使用此基类，请定义类属性 _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$阶贝塞尔函数定义为满足贝塞尔微分方程的函数

\[z^2\frac{\mathrm{d}^2 w}{\mathrm{d}z^2}\]

劳伦特展开

\[J\nu（z）=z^\nu\左（\frac{1}{\Gamma（\nu+1）2^\nu}+O（z^2）\right），\]

if $\nu$ is not a negative integer. If $\nu=-n \in \mathbb{Z}_{<0}$ is a negative integer, then the definition is

\[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年），“第9章”，数学函数手册，包括公式、图表和数学表格

[R425]

Luke，Y.L.（1969），《特殊函数及其逼近》，第1卷

[R426]

https://en.wikipedia.org/wiki/Bessel_function

[R427]

https://functions.wolfram.com/Bessel-TypeFunctions/BesselJ/

class sympy.functions.special.bessel.bessely(nu, z)[源代码]#

第二类贝塞尔函数。

解释

订单$\nu$的Bessel$Y$函数定义为

\[Y\nu（z）=\lim{\mu\到\nu}\frac{J\mu（z）\cos（\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]

https://functions.wolfram.com/Bessel-TypeFunctions/BesselY/

class sympy.functions.special.bessel.besseli(nu, z)[源代码]#

第一类修正贝塞尔函数。

解释

贝塞尔函数是修正贝塞尔方程的解

\[z^2\frac{\mathrm{d}^2 w}{\mathrm{d}z^2}\]

它可以定义为

\[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]

https://functions.wolfram.com/Bessel-TypeFunctions/BesselI/

class sympy.functions.special.bessel.besselk(nu, z)[源代码]#

第二类修正贝塞尔函数。

解释

订单$\nu$的Bessel$K$函数定义为

\[K\nu（z）=\lim{\mu\ to\nu}\frac{\pi}{2}\]

其中，$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]

https://functions.wolfram.com/Bessel-TypeFunctions/BesselK/

class sympy.functions.special.bessel.hankel1(nu, z)[源代码]#

第一类Hankel函数。

解释

此函数定义为

\[（1）}=J\nu（z）+iY\nu（z），\]

其中，$J_2;u（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]

https://functions.wolfram.com/Bessel-TypeFunctions/HankelH1/

class sympy.functions.special.bessel.hankel2(nu, z)[源代码]#

第二类汉克尔函数。

解释

此函数定义为

\[H\nu ^{（2）}=J\nu（z）-iY\nu（z），\]

其中，$J_2;u（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]

https://functions.wolfram.com/Bessel-TypeFunctions/HankelH2/

class sympy.functions.special.bessel.jn(nu, z)[源代码]#

第一类球面贝塞尔函数。

解释

这个函数是球面贝塞尔方程的解

\[z^2\frac{\mathrm{d}^2 w}{\mathrm{d}z^2}\]

它可以定义为

\[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]

https://dlmf.nist.gov/10.47

class sympy.functions.special.bessel.yn(nu, z)[源代码]#

第二类球面贝塞尔函数。

解释

这个函数是球面Bessel方程的另一个解，与$j_n$线性无关。它可以定义为

\[y\nu（z）=\sqrt{\frac{\pi}{2z}}y{\nu+\frac{1}{2}}（z），\]

其中，$Y\nu（z）$是第二类贝塞尔函数。

对于整型订单$n$，$y\u 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]

https://dlmf.nist.gov/10.47

sympy.functions.special.bessel.jn_zeros(n, k, method='sympy', dps=15)[源代码]#

第一类球面贝塞尔函数的零点。

参数:

n ：整数

贝塞尔函数阶

k ：整数

要返回的0数

解释

这将返回一个从$jn$到$k$-th零的零数组。

method = "sympy": uses mpmath.besseljzero
method = "scipy": uses the SciPy's sph_jn and newton to find all roots, which is faster than computing the zeros using a general numerical solver, but it requires SciPy and only works with low precision floating point numbers. (The function used with method="sympy" is a recent addition to mpmath; before that a general solver was used.)

实例

>>> 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)[源代码]#

马尔库姆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}\左（a x\右）\，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]

https://en.wikipedia.org/wiki/Marcum_Q-function

[R436]

https://mathworld.wolfram.com/MarcumQ-Function.html

艾利函数#

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}^2 w（z）}{\mathrm{d}z^2}-zw（z）=0。\]

相当于，真的$z$

\[\运算符名称{Ai}（z）：=\frac{1}{\pi}\]

实例

创建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]

[R438]

[R439]

[R440]

class sympy.functions.special.bessel.airybi(arg)[源代码]#

第二种类型的Airy函数$\operatorname{Bi}$。

解释

Airy函数$\operatorname{Bi}（z）$定义为满足Airy微分方程的函数

\[\frac{\mathrm{d}^2 w（z）}{\mathrm{d}z^2}-zw（z）=0。\]

相当于，真的$z$

\[\运算符名称{Bi}（z）：=\frac{1}{\pi}\]

实例

创建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: 第一类Airy函数。
airyaiprime: 第一类Airy函数的导数。
airybiprime: 第二类Airy函数的导数。

工具书类

[R441]

[R442]

[R443]

[R444]

class sympy.functions.special.bessel.airyaiprime(arg)[源代码]#

第一类Airy函数的导数$\operatorname{Ai}^\prime$。

解释

Airy函数$\operatorname{Ai}^\prime（z）$定义为函数

\[\运算符名称{Ai}^\prime（z）：=\frac{\mathrm{d}\operatorname{Ai}（z）}{\mathrm{d}z}。\]

实例

创建Airy函数对象：

>>> 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

Airy函数遵循镜像对称性：

>>> 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)

我们可以在整个复平面上对Airy函数进行任意精度的数值计算：

>>> 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: 第一类Airy函数。
airybi: 第二类Airy函数。
airybiprime: 第二类Airy函数的导数。

工具书类

[R445]

[R446]

[R447]

[R448]

class sympy.functions.special.bessel.airybiprime(arg)[源代码]#

第一类Airy函数的导数$\operatorname{Bi}^\prime$。

解释

Airy函数$\operatorname{Bi}^\prime（z）$定义为函数

\[\operatiorName{Bi}^\prime（z）：=\frac{\mathrm{d}\operatiorName{Bi}（z）{\mathrm{d}z}。\]

实例

创建Airy函数对象：

>>> 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

Airy函数遵循镜像对称性：

>>> 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)

我们可以在整个复平面上对Airy函数进行任意精度的数值计算：

>>> 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]

[R450]

[R451]

[R452]

https://en.wikipedia.org/wiki/B-spline

B样条曲线#

sympy.functions.special.bsplines.bspline_basis(d, knots, n, x)#

第n$-条B样条，每节$x$度$d$。

参数:

d ：整数

bspline度数

结：整数值列表

bspline节点列表

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]

sympy.functions.special.bsplines.bspline_basis_set(d, knots, x)[源代码]#

返回 len(knots)-d-1 B样条曲线 x 程度的 d 具有结 .

参数:

d ：整数

bspline度数

结：整数列表

bspline节点列表

x ：符号

解释

此函数返回分段多项式的列表 len(knots)-d-1 次B样条 d 对于给定的结。此函数调用 bspline_basis(d, knots, n, x) 对于不同的值 n .

实例

>>> 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)[源代码]#

度返回样条 d ，穿过给定的 X 和 Y 价值观。

参数:

d ：整数

Bspline的度严格大于等于1

x ：符号

X : list of strictly increasing real values

样条曲线通过的X坐标列表

Y : list of real values

list of corresponding Y coordinates through which the spline passes

解释

此函数返回一个分段函数，使每个部分都是不大于 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

Riemann-Zeta及其相关函数#

class sympy.functions.special.zeta_functions.zeta(s, a=None)[源代码]#

Hurwitz-zeta函数（或Riemann-zeta函数）。

解释

对于$\operatorname{Re}（a）>0$和$\operatorname{Re}（s）>1$，此函数定义为

\[\zeta（s，a）=\sum{n=0}^\infty\frac{1}{（n+a）^s}，\]

where the standard choice of argument for $n + a$ is used. For fixed $a$ not a nonpositive integer the Hurwitz zeta function admits a meromorphic continuation to all of $\mathbb{C}$; it is an unbranched function with a simple pole at $s = 1$.

Hurwitz-zeta函数是Lerch超验的一个特例：

\[\zeta（s，a）=\Phi（1，s，a）。\]

此公式为$s$和$a$（也为$\operatorname{Re}（a）<0$）的所有可能值定义了分析延续，请参阅的文档 lerchphi 以获取分支行为的描述。

If no value is passed for $a$ a default value of $a = 1$ is assumed, yielding the Riemann zeta function.

实例

对于$a=1$，Hurwitz-zeta函数可简化为著名的Riemann-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)

Riemann-zeta函数也可以用Dirichlet-eta函数表示：

>>> from sympy import dirichlet_eta
>>> zeta(s).rewrite(dirichlet_eta)
dirichlet_eta(s)/(1 - 2**(1 - s))

The Riemann zeta function at nonnegative even and negative integer values is related to the Bernoulli numbers and polynomials:

>>> 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)

Hurwitz-zeta函数可以用Lerch超验来表示， lerchphi ：

>>> from sympy import lerchphi
>>> zeta(s, a).rewrite(lerchphi)
lerchphi(1, s, a)

参见

dirichlet_eta, lerchphi, polylog

工具书类

[R454]

https://dlmf.nist.gov/25.11

[R455]

https://en.wikipedia.org/wiki/Hurwitz_zeta_function

class sympy.functions.special.zeta_functions.dirichlet_eta(s, a=None)[源代码]#

Dirichlet-eta函数。

解释

For $\operatorname{Re}(s) > 0$ and $0 < x \le 1$, this function is defined as

\[\eta(s, a) = \sum_{n=0}^\infty \frac{(-1)^n}{(n+a)^s}.\]

It admits a unique analytic continuation to all of $\mathbb{C}$ for any fixed $a$ not a nonpositive integer. It is an entire, unbranched function.

It can be expressed using the Hurwitz zeta function as

\[\eta(s, a) = \zeta(s,a) - 2^{1-s} \zeta\left(s, \frac{a+1}{2}\right)\]

and using the generalized Genocchi function as

\[\eta(s, a) = \frac{G(1-s, a)}{2(s-1)}.\]

In both cases the limiting value of $\log2 - \psi(a) + \psi\left(\frac{a+1}{2}\right)$ is used when $s = 1$.

实例

>>> 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]

https://en.wikipedia.org/wiki/Dirichlet_eta_function

[R457]

Peter Luschny, "An introduction to the Bernoulli function", https://arxiv.org/abs/2009.06743

class sympy.functions.special.zeta_functions.polylog(s, z)[源代码]#

多段对数函数。

解释

For $|z| < 1$ and $s \in \mathbb{C}$, the polylogarithm is defined by

\[\运算符名称{Li}}us（z）=\sum{n=1}^\infty\frac{z^n}{n^s}，\]

其中参数的标准分支用于$n$。它允许在$z=1$（特别是不在初始定义表上）、$z=0$和$z=\infty$处分支的分析延拓。

polylogarithm的名称来自这样一个事实：对于$s=1$，polylogarithm与普通对数相关（参见示例），并且

\[\运算符名称{Li}}{s+1}（z）=\]

多段法则是Lerch先验论的一个特例：

\[\运算符名{Li}{s}（z）=z\Phi（z，s，1）。\]

实例

对于\{0，1，-1\}$中的$z\，多段对数将使用其他函数自动表示：

>>> 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)[源代码]#

Lerch超越（Lerch phi函数）。

解释

For $\operatorname{Re}(a) > 0$, $|z| < 1$ and $s \in \mathbb{C}$, the Lerch transcendent is defined as

\[\Phi（z，s，a）=\sum{n=0}^\infty\frac{z^n}{（n+a）^s}，\]

其中参数的标准分支用于$n+a$，并通过解析延续用于参数的其他值。

一个常用的相关函数是Lerch zeta函数，由

\[L（q，s，a）=\Phi（e^{2\pi iq}，s，a）。\]

解析延拓与分枝行为

可以证明

\[\φ（z，s，a）=z\Phi（z，s，a+1）+a^{-s}。\]

这提供了对$\operatorname{Re}（a）\le 0$的分析延续。

现在假设$\operatorname{Re}（a）>0$。积分表示

\[\φ0（z，s，a）=\int\0^\infty\frac{t^{s-1}e^-at}{1-ze^{-t}}\]

提供$\mathbb{C}-[1，\infty）$的分析延续。最后，对于（1，\infty）$中的$x\我们发现

\[\lim{\epsilon\到0^+}\Phi_0（x+i\epsilon，s，a）\]

对$\log{x}$和$\log{\log{x}$使用标准分支（需要使用$\log{\log{x}}$的分支来计算$\log{x}^{s-1}$）。这就是解析延拓的结论。因此，Lerch超越在\{0，1，infty\}$和$a\ in\mathbb{z}{\le0}$中分支。对于固定的$z，在这些分支点之外的$z，它是$s$的一个完整函数。

实例

Lerch超越函数是一个相当普遍的函数，因此它不会自动求值为更简单的函数。使用 expand_func() 为了达到这个目的。

如果$z=1$，则Lerch超验约化为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$是统一的根，那么Lerch超越可以归结为Hurwitz-zeta函数的总和：

>>> expand_func(lerchphi(-1, s, a))
zeta(s, a/2)/2**s - zeta(s, a/2 + 1/2)/2**s

如果$a=1$，则Lerch Superivate简化为多段对数：

>>> expand_func(lerchphi(z, s, 1))
polylog(s, z)/z

更一般地说，如果$a$是理性的，那么Lerch Superivate可以归结为多段对数的总和：

>>> 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），高等超越函数，第一卷，纽约：麦格劳-希尔。第1.11条。

[R459]

https://dlmf.nist.gov/25.14

[R460]

https://en.wikipedia.org/wiki/Lerch_transcendent

class sympy.functions.special.zeta_functions.stieltjes(n, a=None)[源代码]#

表示Stieltjes常数，$\gamma{k}$，出现在Riemann-zeta函数的Laurent级数展开中。

实例

>>> from sympy import stieltjes
>>> from sympy.abc import n, m
>>> stieltjes(n)
stieltjes(n)

第零个stieltjes常数：

>>> stieltjes(0)
EulerGamma
>>> stieltjes(0, 1)
EulerGamma

对于广义stieltjes常数：

>>> stieltjes(n, m)
stieltjes(n, m)

常量仅为大于等于0的整数定义：

>>> stieltjes(-1)
zoo

工具书类

[R461]

https://en.wikipedia.org/wiki/Stieltjes_constants

超几何函数#

class sympy.functions.special.hyper.hyper(ap, bq, z)[源代码]#

广义超几何函数由一系列定义，其中连续项的比值是求和指数的有理函数。当收敛时，它继续解析到最大的可能域。

解释

超几何函数依赖于两个参数向量，称为分子参数$a_p$，分母参数$b_q$。$z也有一个参数。系列的定义是

\[\begin{split}{}}u pF_q\左（\begin{matrix}a_1，\cdots，a_p\\b_1，\cdots，b_q\end{matrix}\end{split}\]

其中$（a）_n=（a）（a+1）\cdots（a+n-1）$表示上升阶乘。

如果$b_q$中的一个是非正整数，则该系列是未定义的，除非$a_q$中的一个是更大（即大小较小）的非正整数。如果$b_q$中没有一个是非正整数，而$a_q$中有一个是非正整数，则级数将缩减为多项式。为了简化下面的讨论，我们假设$a_p$或$b_q$都不是非正整数。有关详细信息，请参阅参考资料。

对于所有$z$if$p\le q$，级数收敛，因此在本例中定义了一个完整的单值函数。如果$p=q+1$，则级数收敛于$ |z| <1$，并可继续解析为半平面。如果$p>q+1$，则所有$z$的级数是发散的。

请注意超几何函数构造函数当前所做的 not 检查参数是否实际产生定义良好的函数。

实例

参数$a_p$和$b_q$可以作为任意ITerable传递，例如：

>>> 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  |  /

参数必须始终是ITerable，即使它们是长度为1或0的向量：

>>> 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），《特殊函数及其逼近》，第1卷

[R463]

https://en.wikipedia.org/wiki/Generalized_hypergeometric_function

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型积分定义。它推广了超几何函数。

解释

The Meijer G-function depends on four sets of parameters. There are "numerator parameters" $a_1, \ldots, a_n$ and $a_{n+1}, \ldots, a_p$, and there are "denominator parameters" $b_1, \ldots, b_m$ and $b_{m+1}, \ldots, b_q$. Confusingly, it is traditionally denoted as follows (note the position of $m$, $n$, $p$, $q$, and how they relate to the lengths of the four parameter vectors):

\[\begin{split}G{p，q}^{m，n}\左（\begin{matrix}au 1），\cdots，a_n&a{n+1}，\ cdots，a_p\\\end{split}\]

然而，在SymPy中，四个参数向量始终是单独可用的（参见示例），因此不需要跟踪G符号上的装饰子脚本和超级脚本。

G函数定义为以下积分：

\[\frac{1}{2\pii}\int}L\frac{\prod{j=1}^m\Gamma（b_j-s）\]

其中$\Gamma（z）$是伽马函数。有三种可能的轮廓，我们在这里将不作详细描述（见参考文献）。如果积分沿着其中一个以上的方向收敛，则定义一致。这些等高线都将$\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函数构造函数 not 检查所有收敛条件。

实例

您可以传递四个参数：

>>> 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         |  /

与超几何函数一样，参数可以作为任意的Iterable传递。长度为0和1的向量也必须作为Iterable传递。参数不需要是常量，但是如果它们依赖于参数，那么就不需要太多实现的功能。

参数的所有子向量都可用：

>>> 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），《特殊函数及其逼近》，第1卷

[R465]

https://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#: 与积分收敛区域有关的量，c.f.参考文献。

get_period()[源代码]#

返回一个数字$P$，这样$G（x 实验（一） P））==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#: 与积分收敛区域有关的量，c.f.参考文献。

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}\]

实例

>>> 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]

https://en.wikipedia.org/wiki/Appell_series

[R467]

https://functions.wolfram.com/HypergeometricFunctions/AppellF1/

椭圆积分#

class sympy.functions.special.elliptic_integrals.elliptic_k(m)[源代码]#

第一类完全椭圆积分，由

\[K（m）=F\左（\tfrac{\pi}{2}\middle | m\右）\]

其中，$F\ left（z\ middle | m\ right）$是第一类勒让德不完全椭圆积分。

解释

函数$K（m）$是复平面上沿区间$（1，\infty）$分支切割的单值函数。

注意，我们的符号用参数$m$而不是椭圆模（偏心率）$k$来定义不完全椭圆积分。在本例中，参数$m$定义为$m=k^2$。

实例

>>> 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]

https://functions.wolfram.com/EllipticIntegrals/EllipticK

[R469]

class sympy.functions.special.elliptic_integrals.elliptic_f(z, m)[源代码]#

第一类Legendre不完全椭圆积分，由

\[左（z\中| m\右）=\]

解释

当$z=\pi/2$时，此函数可化为第一类完整的椭圆积分，$K（m）$。

注意，我们的符号用参数$m$而不是椭圆模（偏心率）$k$来定义不完全椭圆积分。在本例中，参数$m$定义为$m=k^2$。

实例

>>> 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]

https://functions.wolfram.com/EllipticIntegrals/EllipticF

[R471]

class sympy.functions.special.elliptic_integrals.elliptic_e(m, z=None)[源代码]#

使用两个参数$z$和$m$调用，计算第二类不完整椭圆积分，由

\[E\左（z\中| m\右）=\int_0^z\sqrt{1-m\sin^2 t}dt\]

使用单个参数$m$调用，计算第二类Legendre完全椭圆积分

\[E（m）=E\左（\tfrac{\pi}{2}\middle | m\右）\]

解释

函数$E（m）$是复平面上沿区间$（1，\infty）$分支切割的单值函数。

注意，我们的符号用参数$m$而不是椭圆模（偏心率）$k$来定义不完全椭圆积分。在本例中，参数$m$定义为$m=k^2$。

实例

>>> 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]

https://functions.wolfram.com/EllipticIntegrals/EllipticE2

[R473]

[R474]

https://functions.wolfram.com/EllipticIntegrals/EllipticE

class sympy.functions.special.elliptic_integrals.elliptic_pi(n, m, z=None)[源代码]#

用三个参数$n$、$z$和$m$调用，计算第三类Legendre不完全椭圆积分，由

\[\Pi\左（n；z\中| m\右）=\int_0^z\frac{dt}\]

使用两个参数$n$和$m$调用，计算第三种完整的椭圆积分：

\[\左（n\中| m\右）=\]

解释

注意，我们的符号用参数$m$而不是椭圆模（偏心率）$k$来定义不完全椭圆积分。在本例中，参数$m$定义为$m=k^2$。

实例

>>> 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]

https://functions.wolfram.com/EllipticIntegrals/EllipticPi3

[R476]

[R477]

https://functions.wolfram.com/EllipticIntegrals/EllipticPi

马修函数#

class sympy.functions.special.mathieu_functions.MathieuBase(*args)[源代码]#

Mathieu函数的抽象基类。

这个类是为了减少代码重复。

class sympy.functions.special.mathieu_functions.mathieus(a, q, z)[源代码]#

马修正弦函数$S（a，q，z）$。

解释

该函数是Mathieu微分方程的一个解：

\[y（x）^{\prime\prime}+（a-2q\cos（2x））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: 马修余弦函数。
mathieusprime: 马修正弦函数的导数。
mathieucprime: 余弦函数的导数。

工具书类

[R478]

[R479]

[R480]

https://functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuS/

[R481]

class sympy.functions.special.mathieu_functions.mathieuc(a, q, z)[源代码]#

Mathieu余弦函数$C（a，q，z）$。

解释

该函数是Mathieu微分方程的一个解：

\[y（x）^{\prime\prime}+（a-2q\cos（2x））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: 马修正弦函数
mathieusprime: 马修正弦函数的导数
mathieucprime: Mathieu余弦函数的导数

工具书类

[R482]

[R483]

[R484]

https://functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuC/

[R485]

class sympy.functions.special.mathieu_functions.mathieusprime(a, q, z)[源代码]#

Mathieu Sine函数的导数$S^{\prime}（a，q，z）$。

解释

该函数是Mathieu微分方程的一个解：

\[y（x）^{\prime\prime}+（a-2q\cos（2x））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: 马修正弦函数
mathieuc: 马修余弦函数
mathieucprime: Mathieu余弦函数的导数

工具书类

[R486]

[R487]

[R488]

https://functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuSPrime/

[R489]

class sympy.functions.special.mathieu_functions.mathieucprime(a, q, z)[源代码]#

Mathieu余弦函数的导数$C^{\prime}（a，q，z）$。

解释

该函数是Mathieu微分方程的一个解：

\[y（x）^{\prime\prime}+（a-2q\cos（2x））y（x）=0\]

另一个解决方案是Mathieu正弦函数。

实例

>>> 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]

[R491]

[R492]