# 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.

## 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
• 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)

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

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)

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)

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)

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

Previous
Next