scipy.integrate.quad#
- scipy.integrate.quad(func, a, b, args=(), full_output=0, epsabs=1.49e-08, epsrel=1.49e-08, limit=50, points=None, weight=None, wvar=None, wopts=None, maxp1=50, limlst=50, complex_func=False)[source]#
Compute a definite integral.
Integrate func from a to b (possibly infinite interval) using a technique from the Fortran library QUADPACK.
- Parameters:
- func{function, scipy.LowLevelCallable}
A Python function or method to integrate. If func takes many arguments, it is integrated along the axis corresponding to the first argument.
If the user desires improved integration performance, then f may be a
scipy.LowLevelCallable
with one of the signatures: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
is the data contained in thescipy.LowLevelCallable
. In the call forms withxx
,n
is the length of thexx
array which containsxx[0] == x
and the rest of the items are numbers contained in theargs
argument of quad.In addition, certain ctypes call signatures are supported for backward compatibility, but those should not be used in new code.
- afloat
Lower limit of integration (use -numpy.inf for -infinity).
- bfloat
Upper limit of integration (use numpy.inf for +infinity).
- argstuple, optional
Extra arguments to pass to func.
- full_outputint, optional
Non-zero to return a dictionary of integration information. If non-zero, warning messages are also suppressed and the message is appended to the output tuple.
- complex_funcbool, optional
Indicate if the function’s (func) return type is real (
complex_func=False
: default) or complex (complex_func=True
). In both cases, the function’s argument is real. If full_output is also non-zero, the infodict, message, and explain for the real and complex components are returned in a dictionary with keys “real output” and “imag output”.
- Returns:
- yfloat
The integral of func from a to b.
- abserrfloat
An estimate of the absolute error in the result.
- infodictdict
A dictionary containing additional information.
- message
A convergence message.
- explain
Appended only with ‘cos’ or ‘sin’ weighting and infinite integration limits, it contains an explanation of the codes in infodict[‘ierlst’]
- Other Parameters:
- epsabsfloat or int, optional
Absolute error tolerance. Default is 1.49e-8.
quad
tries to obtain an accuracy ofabs(i-result) <= max(epsabs, epsrel*abs(i))
wherei
= integral of func from a to b, andresult
is the numerical approximation. See epsrel below.- epsrelfloat or int, optional
Relative error tolerance. Default is 1.49e-8. If
epsabs <= 0
, epsrel must be greater than both 5e-29 and50 * (machine epsilon)
. See epsabs above.- limitfloat or int, optional
An upper bound on the number of subintervals used in the adaptive algorithm.
- points(sequence of floats,ints), optional
A sequence of break points in the bounded integration interval where local difficulties of the integrand may occur (e.g., singularities, discontinuities). The sequence does not have to be sorted. Note that this option cannot be used in conjunction with
weight
.- weightfloat or int, optional
String indicating weighting function. Full explanation for this and the remaining arguments can be found below.
- wvaroptional
Variables for use with weighting functions.
- woptsoptional
Optional input for reusing Chebyshev moments.
- maxp1float or int, optional
An upper bound on the number of Chebyshev moments.
- limlstint, optional
Upper bound on the number of cycles (>=3) for use with a sinusoidal weighting and an infinite end-point.
See also
dblquad
double integral
tplquad
triple integral
nquad
n-dimensional integrals (uses
quad
recursively)fixed_quad
fixed-order Gaussian quadrature
quadrature
adaptive Gaussian quadrature
odeint
ODE integrator
ode
ODE integrator
simpson
integrator for sampled data
romb
integrator for sampled data
scipy.special
for coefficients and roots of orthogonal polynomials
Notes
For valid results, the integral must converge; behavior for divergent integrals is not guaranteed.
Extra information for quad() inputs and outputs
If full_output is non-zero, then the third output argument (infodict) is a dictionary with entries as tabulated below. For infinite limits, the range is transformed to (0,1) and the optional outputs are given with respect to this transformed range. Let M be the input argument limit and let K be infodict[‘last’]. The entries are:
- ‘neval’
The number of function evaluations.
- ‘last’
The number, K, of subintervals produced in the subdivision process.
- ‘alist’
A rank-1 array of length M, the first K elements of which are the left end points of the subintervals in the partition of the integration range.
- ‘blist’
A rank-1 array of length M, the first K elements of which are the right end points of the subintervals.
- ‘rlist’
A rank-1 array of length M, the first K elements of which are the integral approximations on the subintervals.
- ‘elist’
A rank-1 array of length M, the first K elements of which are the moduli of the absolute error estimates on the subintervals.
- ‘iord’
A rank-1 integer array of length M, the first L elements of which are pointers to the error estimates over the subintervals with
L=K
ifK<=M/2+2
orL=M+1-K
otherwise. Let I be the sequenceinfodict['iord']
and let E be the sequenceinfodict['elist']
. ThenE[I[1]], ..., E[I[L]]
forms a decreasing sequence.
If the input argument points is provided (i.e., it is not None), the following additional outputs are placed in the output dictionary. Assume the points sequence is of length P.
- ‘pts’
A rank-1 array of length P+2 containing the integration limits and the break points of the intervals in ascending order. This is an array giving the subintervals over which integration will occur.
- ‘level’
A rank-1 integer array of length M (=limit), containing the subdivision levels of the subintervals, i.e., if (aa,bb) is a subinterval of
(pts[1], pts[2])
wherepts[0]
andpts[2]
are adjacent elements ofinfodict['pts']
, then (aa,bb) has level l if|bb-aa| = |pts[2]-pts[1]| * 2**(-l)
.- ‘ndin’
A rank-1 integer array of length P+2. After the first integration over the intervals (pts[1], pts[2]), the error estimates over some of the intervals may have been increased artificially in order to put their subdivision forward. This array has ones in slots corresponding to the subintervals for which this happens.
Weighting the integrand
The input variables, weight and wvar, are used to weight the integrand by a select list of functions. Different integration methods are used to compute the integral with these weighting functions, and these do not support specifying break points. The possible values of weight and the corresponding weighting functions are.
weight
Weight function used
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 holds the parameter w, (alpha, beta), or c depending on the weight selected. In these expressions, a and b are the integration limits.
For the ‘cos’ and ‘sin’ weighting, additional inputs and outputs are available.
For finite integration limits, the integration is performed using a Clenshaw-Curtis method which uses Chebyshev moments. For repeated calculations, these moments are saved in the output dictionary:
- ‘momcom’
The maximum level of Chebyshev moments that have been computed, i.e., if
M_c
isinfodict['momcom']
then the moments have been computed for intervals of length|b-a| * 2**(-l)
,l=0,1,...,M_c
.- ‘nnlog’
A rank-1 integer array of length M(=limit), containing the subdivision levels of the subintervals, i.e., an element of this array is equal to l if the corresponding subinterval is
|b-a|* 2**(-l)
.- ‘chebmo’
A rank-2 array of shape (25, maxp1) containing the computed Chebyshev moments. These can be passed on to an integration over the same interval by passing this array as the second element of the sequence wopts and passing infodict[‘momcom’] as the first element.
If one of the integration limits is infinite, then a Fourier integral is computed (assuming w neq 0). If full_output is 1 and a numerical error is encountered, besides the error message attached to the output tuple, a dictionary is also appended to the output tuple which translates the error codes in the array
info['ierlst']
to English messages. The output information dictionary contains the following entries instead of ‘last’, ‘alist’, ‘blist’, ‘rlist’, and ‘elist’:- ‘lst’
The number of subintervals needed for the integration (call it
K_f
).- ‘rslst’
A rank-1 array of length M_f=limlst, whose first
K_f
elements contain the integral contribution over the interval(a+(k-1)c, a+kc)
wherec = (2*floor(|w|) + 1) * pi / |w|
andk=1,2,...,K_f
.- ‘erlst’
A rank-1 array of length
M_f
containing the error estimate corresponding to the interval in the same position ininfodict['rslist']
.- ‘ierlst’
A rank-1 integer array of length
M_f
containing an error flag corresponding to the interval in the same position ininfodict['rslist']
. See the explanation dictionary (last entry in the output tuple) for the meaning of the codes.
Details of QUADPACK level routines
quad
calls routines from the FORTRAN library QUADPACK. This section provides details on the conditions for each routine to be called and a short description of each routine. The routine called depends on weight, points and the integration limits a and b.QUADPACK routine
weight
points
infinite bounds
qagse
None
No
No
qagie
None
No
Yes
qagpe
None
Yes
No
qawoe
‘sin’, ‘cos’
No
No
qawfe
‘sin’, ‘cos’
No
either a or b
qawse
‘alg*’
No
No
qawce
‘cauchy’
No
No
The following provides a short description from [1] for each routine.
- qagse
is an integrator based on globally adaptive interval subdivision in connection with extrapolation, which will eliminate the effects of integrand singularities of several types.
- qagie
handles integration over infinite intervals. The infinite range is mapped onto a finite interval and subsequently the same strategy as in
QAGS
is applied.- qagpe
serves the same purposes as QAGS, but also allows the user to provide explicit information about the location and type of trouble-spots i.e. the abscissae of internal singularities, discontinuities and other difficulties of the integrand function.
- qawoe
is an integrator for the evaluation of \(\int^b_a \cos(\omega x)f(x)dx\) or \(\int^b_a \sin(\omega x)f(x)dx\) over a finite interval [a,b], where \(\omega\) and \(f\) are specified by the user. The rule evaluation component is based on the modified Clenshaw-Curtis technique
An adaptive subdivision scheme is used in connection with an extrapolation procedure, which is a modification of that in
QAGS
and allows the algorithm to deal with singularities in \(f(x)\).- qawfe
calculates the Fourier transform \(\int^\infty_a \cos(\omega x)f(x)dx\) or \(\int^\infty_a \sin(\omega x)f(x)dx\) for user-provided \(\omega\) and \(f\). The procedure of
QAWO
is applied on successive finite intervals, and convergence acceleration by means of the \(\varepsilon\)-algorithm is applied to the series of integral approximations.- qawse
approximate \(\int^b_a w(x)f(x)dx\), with \(a < b\) where \(w(x) = (x-a)^{\alpha}(b-x)^{\beta}v(x)\) with \(\alpha,\beta > -1\), where \(v(x)\) may be one of the following functions: \(1\), \(\log(x-a)\), \(\log(b-x)\), \(\log(x-a)\log(b-x)\).
The user specifies \(\alpha\), \(\beta\) and the type of the function \(v\). A globally adaptive subdivision strategy is applied, with modified Clenshaw-Curtis integration on those subintervals which contain a or b.
- qawce
compute \(\int^b_a f(x) / (x-c)dx\) where the integral must be interpreted as a Cauchy principal value integral, for user specified \(c\) and \(f\). The strategy is globally adaptive. Modified Clenshaw-Curtis integration is used on those intervals containing the point \(x = c\).
Integration of Complex Function of a Real Variable
A complex valued function, \(f\), of a real variable can be written as \(f = g + ih\). Similarly, the integral of \(f\) can be written as
\[\int_a^b f(x) dx = \int_a^b g(x) dx + i\int_a^b h(x) dx\]assuming that the integrals of \(g\) and \(h\) exist over the interval \([a,b]\) [2]. Therefore,
quad
integrates complex-valued functions by integrating the real and imaginary components separately.References
[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.
[2]McCullough, Thomas; Phillips, Keith (1973). Foundations of Analysis in the Complex Plane. Holt Rinehart Winston. ISBN 0-03-086370-8
Examples
Calculate \(\int^4_0 x^2 dx\) and compare with an analytic result
>>> 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
Calculate \(\int^\infty_0 e^{-x} dx\)
>>> invexp = lambda x: np.exp(-x) >>> integrate.quad(invexp, 0, np.inf) (1.0, 5.842605999138044e-11)
Calculate \(\int^1_0 a x \,dx\) for \(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
Calculate \(\int^1_0 x^2 + y^2 dx\) with ctypes, holding y parameter as 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
Be aware that pulse shapes and other sharp features as compared to the size of the integration interval may not be integrated correctly using this method. A simplified example of this limitation is integrating a y-axis reflected step function with many zero values within the integrals bounds.
>>> 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)