scipy.integrate.

nquad

scipy.integrate.nquad(func, ranges, args=None, opts=None, full_output=False)

多变量积分。

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

参数:

函数{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 是变量和参数的数量。xx 数组包含坐标和额外参数。user_data 是包含在 scipy.LowLevelCallable 中的数据。

范围可迭代对象

ranges 的每个元素可以是两个数字的序列，或者是返回这样一个序列的可调用对象。ranges[0] 对应于对 x0 的积分，依此类推。如果 ranges 的元素是可调用对象，那么它将被调用，并传入所有可用的积分参数，以及任何参数化参数。例如，如果 func = f(x0, x1, x2, t0, t1)，那么 ranges[0] 可以定义为 (a, b) 或 (a, b) = range0(x1, x2, t0, t1)。

参数可迭代对象，可选

附加参数 t0, ... tn，由 func、ranges 和 opts 所需。

选项可迭代对象或字典，可选

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

• epsabs = 1.49e-08

• epsrel = 1.49e-08

• limit = 50

• points = None

• weight = None

• wvar = None

• wopts = None

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

完整输出bool, 可选

scipy.integrate.quad 中 full_output 的部分实现。通过在调用 nquad 时设置 full_output=True，可以获得被积函数评估的次数 neval。

返回:

结果浮动

积分的结果。

abserr浮动

各种积分结果中绝对误差估计的最大值。

out_dictdict, 可选

包含有关集成附加信息的字典。

参见

quad

一维数值积分

dblquad, tplquad

双重和三重积分

fixed_quad

固定顺序的高斯求积

注释

为了得到有效的结果，积分必须收敛；对于发散积分的处理行为不保证。

QUADPACK 级别例程的详细信息

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

QUADPACK 例程	weight	points	无限边界
qagse	无	不	不
qagie	无	不	是
qagpe	无	是	不
qawoe	‘sin’, ‘cos’	不	不
qawfe	‘sin’, ‘cos’	不	要么 a 要么 b
qawse	‘alg*’	不	不
qawce	‘柯西’	不	不

以下为每个例程从 [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: 一个用于自动积分的子程序包。Springer-Verlag. ISBN 978-3-540-12553-2.

示例

Try it in your browser!

计算

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

Go BackOpen In Tab