scipy.integrate.

nquad#

scipy.integrate.nquad(функция, диапазоны, args=None, опции=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 может быть либо последовательностью из 2 чисел, либо вызываемым объектом, возвращающим такую последовательность. ranges[0] соответствует интегрированию по x0 и так далее. Если элемент ranges является вызываемым, то он будет вызван со всеми доступными аргументами интегрирования, а также любыми параметрическими аргументами. Например, если func = f(x0, x1, x2, t0, t1), затем ranges[0] может быть определено как либо (a, b) или как (a, b) = range0(x1, x2, t0, t1).

argsитерируемый объект, опционально

Дополнительные аргументы 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.

full_outputbool, необязательно

Частичная реализация full_output из scipy.integrate.quad. Количество вычислений подынтегральной функции neval может быть получено путём установки full_output=True при вызове nquad.

Возвращает:

результатfloat: Результат интегрирования.
abserrfloat: Максимум оценок абсолютной ошибки в различных результатах интегрирования.
out_dictdict, optional: Словарь, содержащий дополнительную информацию об интегрировании.

Смотрите также

quad: 1-D численное интегрирование
dblquad, tplquad: двойные и тройные интегралы
fixed_quad: гауссова квадратура фиксированного порядка

Примечания

Для корректных результатов интеграл должен сходиться; поведение для расходящихся интегралов не гарантируется.

Подробности о процедурах уровня QUADPACK

nquad вызывает подпрограммы из библиотеки FORTRAN QUADPACK. Этот раздел предоставляет детали об условиях вызова каждой подпрограммы и краткое описание каждой подпрограммы. Вызываемая подпрограмма зависит от вес, точки и пределы интегрирования a и b.

Подпрограмма QUADPACK	вес	точки	бесконечные границы
qagse	None	Нет	Нет
qagie	None	Нет	Да
qagpe	None	Да	Нет
qawoe	'sin', 'cos'	Нет	Нет
qawfe	'sin', 'cos'	Нет	либо a или b
qawse	'alg*'	Нет	Нет
qawce	‘cauchy’	Нет	Нет

Следующее предоставляет краткое описание из [1] для каждой подпрограммы.

qagse

является интегратором, основанным на глобально адаптивном разбиении интервала в сочетании с экстраполяцией, что устраняет эффекты особенностей подынтегральной функции нескольких типов. Интегрирование выполняется с использованием 21-точечной квадратуры Гаусса-Кронрода в каждом подынтервале.

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\) задаются пользователем. Компонент оценки правила основан на модифицированной технике Кленшоу-Кёртиса

Используется адаптивная схема разбиения в сочетании с процедурой экстраполяции, которая является модификацией процедуры из 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.

qawce

вычислить \(\int^b_a f(x) / (x-c)dx\) где интеграл должен интерпретироваться как интеграл в смысле главного значения Коши, для заданного пользователем \(c\) и \(f\). Стратегия является глобально адаптивной. Модифицированное интегрирование Кленшоу-Кёртиса используется на тех интервалах, которые содержат точку \(x = c\).

Ссылки

[1]

Пиесенс, Роберт; де Донкер-Капенга, Элиза; Уберхубер, Кристоф В.; Каханер, Дэвид (1983). QUADPACK: Пакет подпрограмм для автоматического интегрирования. 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)