Finding Integration using scipy.integrate
Numerical Integration is the approximate computation of an integral using numerical techniques. Methods for Integrating function given function object:
- quad – General Purpose Integration
- dblquad – General Purpose Double Integration
- nquad – General Purpose n- fold Integration
- fixed_quad – Gaussian quadrature, order n
- quadrature – Gaussian quadrature to tolerance
- romberg – Romberg integration
- trapz – Trapezoidal rule
- cumtrapz – Trapezoidal rule to cumulatively compute integral
- simps – Simpson’s rule
- romb – Romberg integration
- polyint – Analytical polynomial integration (NumPy)
(1) quad :
The function quad is provided to integrate a function of one variable between two points. The points can be +infinite or – infinite to indicate infinite limits.
Example:
Python3
from scipy.integrate import quad def f(x): return 3.0 * x * x + 1.0 I, err = quad(f, 0 , 1 ) print (I) print (err) |
Output :
2.0
2.220446049250313e-14
(2) dblquad :
This performs Double Integration with 2 arguments.
Example:
Python3
from scipy.integrate import dblquad area = dblquad( lambda x, y: x * y, 0 , 0.5 , lambda x: 0 , lambda x: 1 - 2 * x) print (area) |
Output :
(0.010416666666666668, 4.101620128472366e-16)
(3) nquad :
Performs integration of n variables
Example:
Python3
from scipy.integrate import nquad def f(x, y, z): return x * y * z I = nquad(f, [[ 0 , 1 ], [ 0 , 5 ], [ 0 , 5 ]]) print (I) |
Output :
(78.12499999999999, 8.673617379884033e-13)
(4) fixed_quad :
With the help of scipy.integrate.fixed_quad() method, we can get the computation of a definite integral using fixed order gaussian quadrature
Example:
Python3
# import scipy.integrate from scipy import integrate def func(x): return 3 * x * * 3 # using scipy.integrate.fixed_quad() method # n is the order of integration gfg = integrate.fixed_quad(func, 1.0 , 2.0 , n = 2 ) print (gfg) |
Output:
(11.25, None)
(5) quadrature :
With the help of scipy.integrate.quadrature() method, we can get the computation of definite integral using fixed tolerance gaussian quadrature
Example:
Python3
# import scipy.integrate. from scipy import integrate def f(x): return 3 * x * * 3 # using scipy.integrate.quadrature() method g = integrate.quadrature(f, 0.0 , 1.0 ) print (g) |
Output:
(0.7500000000000001, 2.220446049250313e-16)
(6) romberg :
With the help of scipy.integrate.romberg() method, we can get the romberg integration of a callable function from limit a to b
Example:
Python3
# import numpy and scipy.integrate import numpy as np from scipy import integrate f = lambda x: 3 * (np.pi) * x * * 3 # using scipy.integrate.romberg() g = integrate.romberg(f, 1 , 2 , show = True ) print (g) |
Output:
Romberg integration of <function vectorize1.<locals>.vfunc at 0x0000003C1E212790> from [1, 2]
Steps StepSize Results
1 1.000000 42.411501
2 0.500000 37.110063 35.342917
4 0.250000 35.784704 35.342917 35.342917
The final result is 35.34291735288517 after 5 function evaluations.
35.34291735288517
(7) trapz :
numpy.trapz() function integrate along the given axis using the composite trapezoidal rule.
Python3
# Python program explaining # numpy.trapz() function # importing numpy as geek import numpy as np b = [ 2 , 4 ] a = [ 6 , 8 ] f = np.trapz(b, a) print (f) |
Output:
6.0
(8) cumtraz:
With the help of scipy.integrate.cumtrapz() method, we can get the cumulative integrated value of y(x) using composite trapezoidal rule.
Example:
Python3
# import numpy and scipy.integrate.cumtrapz import numpy as np from scipy import integrate a = np.arange( 0 , 5 ) b = np.arange( 0 , 5 ) # using scipy.integrate.cumtrapz() method f = integrate.cumtrapz(b, a) print (f) |
Output:
[0.5 2. 4.5 8. ]
(9) simps:
With the help of scipy.integrate.simps() method, we can get the integration of y(x) using samples along the axis and composite simpson’s rule.
Example:
Python3
# import numpy and scipy.integrate import numpy as np from scipy import integrate a = np.arange( 0 , 5 ) b = np.arange( 0 , 5 ) # using scipy.integrate.simps() method f = integrate.simps(b, a) print (f) |
Output:
8.0
(10) romb:
With the help of scipy.integrate.romb() method, we can get the romberg integration using samples of a function from limit a to b
Example:
Python3
# import numpy and scipy.integrate import numpy as np from scipy import integrate x = np.arange( 0 , 5 ) # using scipy.integrate.romb() method f = integrate.romb(x) print (f) |
Output:
8.0
(11) polyint:
numpy.polyint(p, m) : Evaluates the anti – derivative of a polynomial with the specified order.
Python3
# Python code explaining # numpy.polyint() # importing libraries import numpy as np # Constructing polynomial p1 = np.poly1d([ 2 , 6 ]) p2 = np.poly1d([ 4 , 8 ]) a = np.polyint(p1, 1 ) b = np.polyint(p2, 2 ) print ( "\n\nUsing polyint" ) print ( "p1 anti-derivative of order = 2 : \n" , a) print ( "p2 anti-derivative of order = 2 : \n" , b) |
Output :
Using polyint
p1 anti-derivative of order = 2 :
2
1 x + 6 x
p2 anti-derivative of order = 2 :
3 2
0.6667 x + 4 x
SciPy – Integration
Scipy is the scientific computing module of Python providing in-built functions on a lot of well-known Mathematical functions. The scipy.integrate sub-package provides several integration techniques including an ordinary differential equation integrator.
Contact Us