scipy.integrate.

nquad#

scipy.integrate.nquad(func, ranges, args=None, opts=None, full_output=False)[源代码]#

对多个变量进行积分。

包装 quad 以实现对多个变量的积分。各种选项可以改进不连续函数的积分，以及使用加权积分，并通常可以更精细地控制积分过程。

参数:

func{callable, scipy.LowLevelCallable}

要积分的函数。具有 x0, ... xn, t0, ... tm 的参数，其中对 x0, ... xn 进行积分，它们必须是浮点数。其中 t0, ... tm 是通过 args 传入的额外参数。函数签名应为 func(x0, x1, ..., xn, t0, t1, ..., tm)。积分按顺序进行。也就是说，对 x0 的积分是最内层的积分，而 xn 是最外层的积分。

如果用户希望提高积分性能，则 f 可以是具有以下签名之一的 scipy.LowLevelCallable

double func(int n, double *xx)
double func(int n, double *xx, void *user_data)

其中 n 是变量和 args 的数量。xx 数组包含坐标和额外的参数。user_data 是 scipy.LowLevelCallable 中包含的数据。

ranges可迭代对象

ranges 的每个元素可以是 2 个数字的序列，也可以是返回此类序列的可调用对象。ranges[0] 对应于对 x0 的积分，依此类推。如果 ranges 的元素是可调用对象，则将使用所有可用的积分参数以及任何参数参数来调用它。例如，如果 func = f(x0, x1, x2, t0, t1)，则 ranges[0] 可以定义为 (a, b)，也可以定义为 (a, b) = range0(x1, x2, t0, t1)。

args可迭代对象，可选

func、ranges 和 opts 所需的额外参数 t0, ... tn。

opts可迭代对象或 dict，可选

要传递给 quad 的选项。可以为空，dict 或 dict 或返回 dict 的函数的序列。如果为空，则使用 scipy.integrate.quad 中的默认选项。如果为 dict，则所有积分级别都使用相同的选项。如果为序列，则序列的每个元素对应于特定的积分。例如，opts[0] 对应于对 x0 的积分，依此类推。如果为可调用对象，则签名必须与 ranges 的签名相同。可用的选项及其默认值为

epsabs = 1.49e-08

epsrel = 1.49e-08

limit = 50

points = None

weight = None

wvar = None

wopts = None

有关这些选项的更多信息，请参阅 quad。

full_outputbool，可选

来自 scipy.integrate.quad 的 full_output 的部分实现。当调用 nquad 时，可以通过设置 full_output=True 来获得被积函数求值的次数 neval。

返回:

resultfloat: 积分的结果。
abserrfloat: 各种积分结果中绝对误差估计的最大值。
out_dictdict，可选: 包含有关积分的附加信息的 dict。

另请参阅

quad: 一维数值积分
dblquad, tplquad: 二重积分和三重积分
fixed_quad: 固定阶高斯求积

注释

为了获得有效的结果，积分必须收敛；不能保证发散积分的行为。

QUADPACK 级别例程的详细信息

nquad 调用 FORTRAN 库 QUADPACK 中的例程。本节提供了关于调用每个例程的条件以及每个例程的简短描述。调用的例程取决于 weight，points 和积分限制 a 和 b。

QUADPACK 例程	权重	点	无限边界
qagse	无	否	否
qagie	无	否	是
qagpe	无	是	否
qawoe	‘sin’，‘cos’	否	否
qawfe	‘sin’，‘cos’	否	任一 a 或 b
qawse	‘alg*’	否	否
qawce	‘cauchy’	否	否

以下提供了来自 [1] 的每个例程的简短描述。

qagse

是一个基于全局自适应区间细分和外推的积分器，它将消除多种类型的被积函数奇点的影响。

qagie

处理无限区间上的积分。无限范围被映射到有限区间，然后应用与 QAGS 中相同的策略。

qagpe

与 QAGS 的用途相同，但也允许用户提供关于麻烦点的明确信息，即被积函数内部奇点、不连续点和其他困难的横坐标。

qawoe

是一个用于评估 \(\int^b_a \cos(\omega x)f(x)dx\) 或 \(\int^b_a \sin(\omega x)f(x)dx\) 在有限区间 [a,b] 上的积分的积分器，其中 \(\omega\) 和 \(f\) 由用户指定。规则评估组件基于修改的 Clenshaw-Curtis 技术

自适应细分方案与外推过程结合使用，它是 QAGS 中的修改版本，允许该算法处理 \(f(x)\) 中的奇点。

qawfe

计算傅里叶变换 \(\int^\infty_a \cos(\omega x)f(x)dx\) 或 \(\int^\infty_a \sin(\omega x)f(x)dx\) 用于用户提供的 \(\omega\) 和 \(f\)。QAWO 的过程应用于连续的有限区间，并通过 \(\varepsilon\) 算法将收敛加速应用于积分近似级数。

qawse

近似 \(\int^b_a w(x)f(x)dx\)，其中 \(a < b\)，其中 \(w(x) = (x-a)^{\alpha}(b-x)^{\beta}v(x)\)，其中 \(\alpha,\beta > -1\)，其中 \(v(x)\) 可以是以下函数之一：\(1\)、\(\log(x-a)\)、\(\log(b-x)\)、\(\log(x-a)\log(b-x)\)。

用户指定 \(\alpha\), \(\beta\) 和函数 \(v\) 的类型。应用全局自适应细分策略，并在包含 a 或 b 的子区间上使用修正的 Clenshaw-Curtis 积分。

qawce

计算 \(\int^b_a f(x) / (x-c)dx\)，其中积分必须解释为柯西主值积分，对于用户指定的 \(c\) 和 \(f\)。该策略是全局自适应的。在包含点 \(x = c\) 的区间上使用修正的 Clenshaw-Curtis 积分。

参考文献

[1]

Piessens, Robert; de Doncker-Kapenga, Elise; Überhuber, Christoph W.; Kahaner, David (1983). QUADPACK: A subroutine package for automatic integration. Springer-Verlag. ISBN 978-3-540-12553-2.

示例

计算

\[\int^{1}_{-0.15} \int^{0.8}_{0.13} \int^{1}_{-1} \int^{1}_{0} f(x_0, x_1, x_2, x_3) \,dx_0 \,dx_1 \,dx_2 \,dx_3 ,\]

其中

\[\begin{split}f(x_0, x_1, x_2, x_3) = \begin{cases} x_0^2+x_1 x_2-x_3^3+ \sin{x_0}+1 & (x_0-0.2 x_3-0.5-0.25 x_1 > 0) \\ x_0^2+x_1 x_2-x_3^3+ \sin{x_0}+0 & (x_0-0.2 x_3-0.5-0.25 x_1 \leq 0) \end{cases} .\end{split}\]

>>> import numpy as np
>>> from scipy import integrate
>>> func = lambda x0,x1,x2,x3 : x0**2 + x1*x2 - x3**3 + np.sin(x0) + (
...                                 1 if (x0-.2*x3-.5-.25*x1>0) else 0)
>>> def opts0(*args, **kwargs):
...     return {'points':[0.2*args[2] + 0.5 + 0.25*args[0]]}
>>> integrate.nquad(func, [[0,1], [-1,1], [.13,.8], [-.15,1]],
...                 opts=[opts0,{},{},{}], full_output=True)
(1.5267454070738633, 2.9437360001402324e-14, {'neval': 388962})

计算

\[\int^{t_0+t_1+1}_{t_0+t_1-1} \int^{x_2+t_0^2 t_1^3+1}_{x_2+t_0^2 t_1^3-1} \int^{t_0 x_1+t_1 x_2+1}_{t_0 x_1+t_1 x_2-1} f(x_0,x_1, x_2,t_0,t_1) \,dx_0 \,dx_1 \,dx_2,\]

其中

\[\begin{split}f(x_0, x_1, x_2, t_0, t_1) = \begin{cases} x_0 x_2^2 + \sin{x_1}+2 & (x_0+t_1 x_1-t_0 > 0) \\ x_0 x_2^2 +\sin{x_1}+1 & (x_0+t_1 x_1-t_0 \leq 0) \end{cases}\end{split}\]

和 \((t_0, t_1) = (0, 1)\) 。

>>> def func2(x0, x1, x2, t0, t1):
...     return x0*x2**2 + np.sin(x1) + 1 + (1 if x0+t1*x1-t0>0 else 0)
>>> def lim0(x1, x2, t0, t1):
...     return [t0*x1 + t1*x2 - 1, t0*x1 + t1*x2 + 1]
>>> def lim1(x2, t0, t1):
...     return [x2 + t0**2*t1**3 - 1, x2 + t0**2*t1**3 + 1]
>>> def lim2(t0, t1):
...     return [t0 + t1 - 1, t0 + t1 + 1]
>>> def opts0(x1, x2, t0, t1):
...     return {'points' : [t0 - t1*x1]}
>>> def opts1(x2, t0, t1):
...     return {}
>>> def opts2(t0, t1):
...     return {}
>>> integrate.nquad(func2, [lim0, lim1, lim2], args=(0,1),
...                 opts=[opts0, opts1, opts2])
(36.099919226771625, 1.8546948553373528e-07)