scipy.integrate.

quad#

scipy.integrate.quad(функция, a, b, args=(), full_output=0, epsabs=1.49e-08, epsrel=1.49e-08, limit=50, точки=None, вес=None, wvar=None, wopts=None, maxp1=50, limlst=50, complex_func=False)[источник]#

Вычислить определённый интеграл.

Интегрировать func от a to b (возможно бесконечный интервал) с использованием техники из библиотеки Fortran QUADPACK.

Параметры:

функция{function, scipy.LowLevelCallable}

Функция или метод Python для интегрирования. Если функция принимает много аргументов, интегрируется вдоль оси, соответствующей первому аргументу.

Если пользователь желает улучшить производительность интегрирования, то f может быть scipy.LowLevelCallable с одной из сигнатур:

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

The user_data является данными, содержащимися в scipy.LowLevelCallable. В формах вызова с xx, n является длиной xx массив, который содержит xx[0] == x и остальные элементы являются числами, содержащимися в args аргумент quad.

Кроме того, для обратной совместимости поддерживаются определённые сигнатуры вызовов ctypes, но их не следует использовать в новом коде.

afloat

Нижний предел интегрирования (используйте -numpy.inf для -бесконечности).

bfloat

Верхний предел интегрирования (используйте numpy.inf для +бесконечности).

argsкортеж, необязательный

Дополнительные аргументы для передачи в функция.

full_outputint, необязательный

Ненулевое значение для возврата словаря информации об интегрировании. Если ненулевое, предупреждения также подавляются, и сообщение добавляется к выходному кортежу.

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

Указывает, если функция (функция) тип возвращаемого значения является вещественным (complex_func=False: по умолчанию) или комплексный (complex_func=True). В обоих случаях аргумент функции действительный. Если full_output также не равен нулю, infodict, message, и объяснить для вещественной и комплексной компонент возвращаются в словаре с ключами "real output" и "imag output".

Возвращает:

yfloat: Интеграл функции func от a to b.
abserrfloat: Оценка абсолютной ошибки в результате.
infodictdict: Словарь, содержащий дополнительную информацию.
message: Сообщение о сходимости.
объяснить: Добавляется только с весами 'cos' или 'sin' и бесконечными пределами интегрирования, содержит объяснение кодов в infodict['ierlst']

Другие параметры:

epsabsfloat или int, опционально: Допустимая абсолютная погрешность. По умолчанию 1.49e-8. quad пытается достичь точности abs(i-result) <= max(epsabs, epsrel*abs(i)) где i = интеграл от функция из a to b, и result является численным приближением. См. epsrel ниже.
epsrelfloat или int, опционально: Относительный допуск ошибки. По умолчанию 1.49e-8. Если epsabs <= 0, epsrel должно быть больше чем 5e-29 и 50 * (machine epsilon). См. epsabs выше.
limitfloat или int, опционально: Верхняя граница количества подынтервалов, используемых в адаптивном алгоритме.
точки(последовательность floats, ints), опционально: Последовательность точек разрыва в ограниченном интервале интегрирования, где могут возникать локальные трудности подынтегральной функции (например, сингулярности, разрывы). Последовательность не обязательно должна быть отсортирована. Обратите внимание, что эта опция не может использоваться совместно с weight.
весfloat или int, опционально: Строка, указывающая весовую функцию. Полное объяснение этого и остальных аргументов можно найти ниже.
wvarнеобязательный: Переменные для использования с весовыми функциями.
woptsнеобязательный: Необязательный вход для повторного использования моментов Чебышева.
maxp1float или int, опционально: Верхняя граница количества моментов Чебышёва.
limlstint, необязательный: Верхняя граница количества циклов (>=3) для использования с синусоидальным взвешиванием и бесконечной конечной точкой.

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

dblquad: двойной интеграл
tplquad: тройной интеграл
nquad: иерархической кластеризации, определенной матрицей связей quad рекурсивно)
fixed_quad: гауссова квадратура фиксированного порядка
simpson: интегратор для дискретных данных
romb: интегратор для дискретных данных
scipy.special: для коэффициентов и корней ортогональных полиномов

Примечания

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

Дополнительная информация для входных и выходных данных quad()

Если full_output не равен нулю, то третий выходной аргумент (infodict) является словарём с записями, перечисленными ниже. Для бесконечных пределов диапазон преобразуется в (0,1), и дополнительные выходные данные приводятся относительно этого преобразованного диапазона. Пусть M будет входным аргументом limit, а K — infodict['last']. Записи:

‘neval’: Количество вычислений функции.
'last': Число, K, подынтервалов, созданных в процессе разбиения.
'alist': Массив ранга 1 длиной M, первые K элементов которого являются левыми конечными точками подынтервалов в разбиении диапазона интегрирования.
‘blist’: Массив ранга 1 длины M, первые K элементов которого являются правыми конечными точками подынтервалов.
‘rlist’: Массив ранга 1 длиной M, первые K элементов которого являются интегральными приближениями на подынтервалах.
‘elist’: Массив ранга 1 длиной M, первые K элементов которого являются модулями оценок абсолютной погрешности на подынтервалах.
‘iord’: Массив целых чисел ранга 1 длины M, первые L элементов которого являются указателями на оценки ошибок по подынтервалам с L=K if K<=M/2+2 или L=M+1-K в противном случае. Пусть I будет последовательностью infodict['iord'] и пусть E будет последовательностью infodict['elist']. Затем E[I[1]], ..., E[I[L]] образует убывающую последовательность.

Если предоставлен входной аргумент points (т.е. он не None), следующие дополнительные выходные данные помещаются в выходной словарь. Предположим, что последовательность points имеет длину P.

‘pts’: Массив ранга 1 длиной P+2, содержащий пределы интегрирования и точки разрыва интервалов в порядке возрастания. Это массив, задающий подынтервалы, по которым будет происходить интегрирование.
'level': Ранг-1 целочисленный массив длины M (=limit), содержащий уровни подразделения подынтервалов, т.е., если (aa,bb) — это подынтервал (pts[1], pts[2]) где pts[0] и pts[2] являются соседними элементами infodict['pts'], тогда (aa,bb) имеет уровень l, если |bb-aa| = |pts[2]-pts[1]| * 2**(-l).
‘ndin’: Целочисленный массив ранга 1 длиной P+2. После первого интегрирования по интервалам (pts[1], pts[2]) оценки ошибок для некоторых интервалов могли быть искусственно увеличены, чтобы ускорить их дальнейшее разбиение. Этот массив содержит единицы в позициях, соответствующих подынтервалам, для которых это происходит.

Взвешивание подынтегральной функции

Входные переменные, вес и wvar, используются для взвешивания подынтегральной функции выбранным списком функций. Различные методы интегрирования используются для вычисления интеграла с этими весовыми функциями, и они не поддерживают указание точек разрыва. Возможные значения weight и соответствующие весовые функции:

`weight`	Весовая функция, используемая	`wvar`
'cos'	cos(w*x)	wvar = w
‘sin’	sin(w*x)	wvar = w
'alg'	g(x) = ((x-a)*alpha)((b-x)**beta)	wvar = (alpha, beta)
‘alg-loga’	g(x)*log(x-a)	wvar = (alpha, beta)
'alg-logb'	g(x)*log(b-x)	wvar = (alpha, beta)
'alg-log'	g(x)log(x-a)log(b-x)	wvar = (alpha, beta)
‘cauchy’	1/(x-c)	wvar = c

wvar содержит параметр w, (alpha, beta) или c в зависимости от выбранного веса. В этих выражениях a и b — пределы интегрирования.

Для взвешивания ‘cos’ и ‘sin’ доступны дополнительные входные и выходные данные.

Для взвешенных интегралов с конечными пределами интегрирования интегрирование выполняется с использованием метода Кленшоу-Кёртиса, который использует моменты Чебышёва. Для повторных вычислений эти моменты сохраняются в выходном словаре:

'momcom': Максимальный уровень моментов Чебышёва, которые были вычислены, т.е., если M_c является infodict['momcom'] тогда моменты были вычислены для интервалов длиной |b-a| * 2**(-l), l=0,1,...,M_c.
'nnlog': Ранг-1 целочисленный массив длины M(=limit), содержащий уровни подразделения подынтервалов, т.е. элемент этого массива равен l, если соответствующий подынтервал |b-a|* 2**(-l).
'chebmo': Массив ранга 2 формы (25, maxp1), содержащий вычисленные моменты Чебышева. Их можно передать для интегрирования по тому же интервалу, передав этот массив как второй элемент последовательности wopts и передав infodict[‘momcom’] как первый элемент.

Если один из пределов интегрирования бесконечен, то вычисляется интеграл Фурье (предполагая w ≠ 0). Если full_output равен 1 и возникает численная ошибка, помимо сообщения об ошибке, прикреплённого к кортежу вывода, к кортежу вывода также добавляется словарь, который переводит коды ошибок в массиве info['ierlst'] на английские сообщения. Выходной информационный словарь содержит следующие записи вместо 'last', 'alist', 'blist', 'rlist' и 'elist':

'lst': Количество подынтервалов, необходимых для интегрирования (назовём его K_f).
'rslst': Массив ранга 1 длиной M_f=limlst, чей первый K_f элементы содержат интегральный вклад на интервале (a+(k-1)c, a+kc) где c = (2*floor(|w|) + 1) * pi / |w| и k=1,2,...,K_f.
‘erlst’: Массив ранга 1 длиной M_f содержащий оценку ошибки соответствующую интервалу в той же позиции в infodict['rslist'].
‘ierlst’: Ранг-1 целочисленный массив длины M_f содержащий флаг ошибки, соответствующий интервалу в той же позиции в infodict['rslist']. См. словарь объяснений (последняя запись в выходном кортеже) для значения кодов.

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

quad вызывает подпрограммы из библиотеки 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\).

Интегрирование комплексной функции вещественной переменной

Комплекснозначная функция, \(f\), вещественной переменной может быть записана как \(f = g + ih\). Аналогично, интеграл от \(f\) может быть записано как

\[\int_a^b f(x) dx = \int_a^b g(x) dx + i\int_a^b h(x) dx\]

предполагая, что интегралы от \(g\) и \(h\) существуют на интервале \([a,b]\) [2]. Следовательно, quad интегрирует комплекснозначные функции путём раздельного интегрирования вещественной и мнимой компонент.

Ссылки

[1]

Пиесенс, Роберт; де Донкер-Капенга, Элиза; Уберхубер, Кристоф В.; Каханер, Дэвид (1983). QUADPACK: Пакет подпрограмм для автоматического интегрирования. Springer-Verlag. ISBN 978-3-540-12553-2.

[2]

McCullough, Thomas; Phillips, Keith (1973). Foundations of Analysis in the Complex Plane. Holt Rinehart Winston. ISBN 0-03-086370-8

Примеры

Вычислить \(\int^4_0 x^2 dx\) и сравнить с аналитическим результатом

>>> from scipy import integrate
>>> import numpy as np
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)
>>> print(4**3 / 3.)  # analytical result
21.3333333333

Вычислить \(\int^\infty_0 e^{-x} dx\)

>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)

Вычислить \(\int^1_0 a x \,dx\) для \(a = 1, 3\)

>>> f = lambda x, a: a*x
>>> y, err = integrate.quad(f, 0, 1, args=(1,))
>>> y
0.5
>>> y, err = integrate.quad(f, 0, 1, args=(3,))
>>> y
1.5

Вычислить \(\int^1_0 x^2 + y^2 dx\) с использованием ctypes, сохраняя параметр y как 1:

testlib.c =>
    double func(int n, double args[n]){
        return args[0]*args[0] + args[1]*args[1];}
compile to library testlib.*

from scipy import integrate
import ctypes
lib = ctypes.CDLL('/home/.../testlib.*') #use absolute path
lib.func.restype = ctypes.c_double
lib.func.argtypes = (ctypes.c_int,ctypes.c_double)
integrate.quad(lib.func,0,1,(1))
#(1.3333333333333333, 1.4802973661668752e-14)
print((1.0**3/3.0 + 1.0) - (0.0**3/3.0 + 0.0)) #Analytic result
# 1.3333333333333333

Учтите, что импульсные формы и другие резкие особенности по сравнению с размером интервала интегрирования могут быть неправильно проинтегрированы с использованием этого метода. Упрощённый пример этого ограничения — интегрирование отражённой по оси y ступенчатой функции со многими нулевыми значениями в пределах границ интегралов.

>>> y = lambda x: 1 if x<=0 else 0
>>> integrate.quad(y, -1, 1)
(1.0, 1.1102230246251565e-14)
>>> integrate.quad(y, -1, 100)
(1.0000000002199108, 1.0189464580163188e-08)
>>> integrate.quad(y, -1, 10000)
(0.0, 0.0)