![\"SciPy](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/07\/SciPy-Tutorial-01.jpg\")
<\/a>Python SciPy Tutorial – Linear Algebra, Benefits, Special Functions<\/p><\/div>\n
What is SciPy in Python?<\/h3>\n
Python SciPy is open-source and BSD-licensed. You can pronounce it as Sigh Pie. Here are some shorts on it:<\/p>\n
- \n
- Author:<\/strong> Travis Oliphant, Pearu Peterson, Eric Jones.<\/li>\n
- First Release:<\/strong> 2001<\/li>\n
- Stable Release:<\/strong>\u00a0Version 1.1.0; May, 2018.<\/li>\n
- Written in:<\/strong>\u00a0Fortran, C, C++, Python Programming Language.<\/li>\n<\/ul>\n
Python SciPy has modules for the following tasks:<\/strong><\/p>\n
- \n
- Optimization<\/li>\n
- Linear algebra<\/li>\n
- Integration<\/li>\n
- Interpolation<\/li>\n
- Special functions<\/li>\n
- FFT<\/li>\n
- Signal and Image processing<\/li>\n
- ODE solvers<\/li>\n<\/ul>\n
And as we\u2019ve seen, an important feature of the NumPy module is multidimensional arrays. This is what SciPy uses, too; it will work with NumPy arrays.<\/p>\n
Use Python SciPy when:<\/strong><\/p>\n
- \n
- You need to solve complex equations.<\/li>\n
- You want to optimize performance or integration<\/li>\n
- If you want to conduct an advanced signal processing or a strategic analysis.<\/li>\n<\/ul>\n
SciPy Subpackages<\/h3>\n
In this Python SciPy Tutorial, we will study the following sub-packages of SciPy:<\/p>\n
- \n
- cluster-<\/strong> Hierarchical clustering.<\/li>\n
- constants-<\/strong> Physical constants and factors of conversion.<\/li>\n
- fftpack- <\/strong>Algorithms for Discrete Fourier Transform.<\/li>\n
- integrate-<\/strong> Routines for numerical integration.<\/li>\n
- interpolate-<\/strong> Tools for interpolation.<\/li>\n
- io-<\/strong> Input and Output tools for data.<\/li>\n
- lib-<\/strong> Wrappers to external libraries.<\/li>\n
- linalg-<\/strong> Routines for linear algebra.<\/li>\n
- misc-<\/strong> Miscellaneous utilities like image reading and writing.<\/li>\n
- ndimage-<\/strong> Functions for processing multidimensional images.<\/li>\n
- optimize-<\/strong> Algorithms for optimization.<\/li>\n
- signal-<\/strong> Tools for processing signals.<\/li>\n
- sparse-<\/strong> Algorithms for sparse matrices.<\/li>\n
- spatial-<\/strong> KD-trees, distance functions, nearest neighbors.<\/li>\n
- special-<\/strong> Special functions.<\/li>\n
- stats-<\/strong> Functions to perform statistics.<\/li>\n
- weave-<\/strong> Functionality that lets you write C++\/C code in the form of multiline strings.<\/li>\n<\/ul>\n
Benefits of SciPy<\/h3>\n
- \n
- High-level commands and classes for visualizing and manipulating data.<\/li>\n
- Powerful and interactive sessions with Python.<\/li>\n
- Classes, web, and database routines for parallel programming.<\/li>\n
- Easy and fast.<\/li>\n
- Open-source.<\/li>\n<\/ul>\n
How to Install SciPy?<\/h3>\n
You can use pip to install SciPy-<\/p>\n
pip install scipy<\/pre>\n
You can also use conda for the same-<\/p>\n
conda install \u2013c anaconda scipy<\/pre>\n
Then, you can import SciPy as:<\/p>\n
>>> import scipy<\/pre>\n
You will also want to interact with numpy here. Let\u2019s import that too.<\/p>\n
>>> import numpy\r\n<\/pre>\n
Finally, in some places, we will want to plot our results. We will use matplotlib for that; let\u2019s import it.<\/p>\n
>>> import matplotlib<\/pre>\n
Linear Algebra in SciPy<\/h3>\n
For performing operations of linear algebra in SciPy, we will need to import linalg from scipy-<\/p>\n
>>> from scipy import linalg<\/pre>\n
![\"SciPy](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/07\/Performing-Operations-of-Linear-Algebra-in-SciPy-01.jpg\")
<\/a>SciPy Tutorial – Linear Algebra<\/p><\/div>\n
1. Solving a set of equations<\/h4>\n
Let\u2019s suppose this is the set of equations we want to solve-
\n2x+3y=7
\n3x+4y=10
\nLet\u2019s create input and solution arrays for this.<\/p>\n>>> A=numpy.array([[2,3],[3,4]])\r\n>>> B=numpy.array([[7],[10]])\r\n>>> linalg.solve(A,B)<\/pre>\n
Output<\/strong><\/p>\n
\narray([[ 2.], [ 1.]])<\/p>\n<\/div>\n
This tells us that both equations work for x=2 and y=1. To check the results, we run the following command-<\/p>\n
>>> A.dot(linalg.solve(A,B))-B<\/pre>\n
Output<\/strong><\/p>\n
\narray([[ 0.], [ 0.]])<\/p>\n<\/div>\n
The output confirms the correctness of the computation.<\/p>\n
2. Determinants of Square Matrices<\/h4>\n
To calculate the determinant for a square matrix, we can use the det() method.<\/p>\n
>>>mat=numpy.array([[8,2],[1,4]])\r\n>>>linalg.det(mat)<\/pre>\n
Output<\/strong><\/p>\n
\n30.0<\/p>\n<\/div>\n
3. An inverse of a Square Matrix<\/h4>\n
For this, we use the inv() method.<\/p>\n
>>> linalg.inv(mat)<\/pre>\n
Output<\/strong><\/p>\n
array([[ 0.13333333, -0.06666667],
\n[-0.03333333, 0.26666667]])<\/div>\n4. Singular Value Decomposition<\/h4>\n
This uses the method svd().<\/p>\n
>>> linalg.svd(mat)<\/pre>\n
Output<\/strong><\/p>\n
(array([[-0.9610057 , -0.27652857],
\n[-0.27652857, 0.9610057 ]]),
\narray([ 8.52079729, 3.52079729]),
\narray([[-0.9347217 , -0.35538056],
\n[-0.35538056, 0.9347217 ]]))<\/div>\n5. LU Decomposition<\/h4>\n
To carry out LU decomposition, we can use the lu() method.<\/p>\n
>>> linalg.lu(mat)<\/pre>\n
Output<\/strong><\/p>\n
(array([[ 1., 0.],
\n[ 0., 1.]]), array([[ 1. , 0. ],
\n[ 0.125, 1. ]]), array([[ 8. , 2. ],
\n[ 0. , 3.75]]))<\/div>\nWorking with Polynomials in SciPy<\/h3>\n
SciPy will let us work with polynomials using the poly1d type from numpy:<\/p>\n
>>> from numpy import poly1d\r\n>>> p=poly1d([3,2,4])<\/pre>\n
Output<\/strong><\/p>\n
2
\n3 x + 2 x + 4<\/div>\n>>> p*p<\/pre>\n
Output<\/strong><\/p>\n
4\u00a0 \u00a0 \u00a0 \u00a0 3\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a02
\n9 x + 12 x + 28 x + 16 x + 16<\/div>\n>>> p(5) #Value of polynomial for x=5<\/pre>\n
Output<\/strong><\/p>\n
\n89<\/p>\n<\/div>\n
>>> p.integ(k=6) #Integration<\/pre>\n
Output<\/strong><\/p>\n
\npoly1d([ 1., 1., 4., 6.])<\/p>\n<\/div>\n
>>> p.deriv() #Finding derivatives<\/pre>\n
Output<\/strong><\/p>\n
\npoly1d([6, 2])<\/p>\n<\/div>\n
Integration with Python SciPy<\/h3>\n
To be able to perform integration, we will import the integrate<\/i> subpackage from scipy.<\/p>\n
>>> from scipy import integrate<\/pre>\n
The quad() function will let us integrate a function; let\u2019s use a lambda for this.<\/p>\n
>>> integrate.quad(lambda x:x**2,0,4) #Last two arguments are lower and upper limits<\/pre>\n
Output<\/strong><\/p>\n
\n(21.333333333333336, 2.368475785867001e-13)<\/p>\n<\/div>\n
You can use help() function to find out what else this subpackage can do for you. Here are some more functions:<\/p>\n
- \n
- dblquad-<\/strong> Double integration<\/li>\n
- tplquad-<\/strong> Triple integration<\/li>\n
- nquad-<\/strong> n-dimensional integration<\/li>\n
- fixed_quad-<\/strong> Use Gaussian quadrature of order n to integrate func(x)<\/li>\n
- quadrature-<\/strong> Use Gaussian quadrature to integrate with certain tolerance<\/li>\n
- romberg-<\/strong> Romberg integration<\/li>\n
- quad_explain-<\/strong> Find out about quad<\/li>\n
- newton_cotes-<\/strong> Weights and coefficient of error with Newton-Cotes integration<\/li>\n
- IntegrationWarning-<\/strong> Warning for issues in integration<\/li>\n<\/ul>\n
Vectorizing Functions in SciPy<\/h3>\n
The class vectorizes will let us turn a regular Python function into a vectorized function. Let\u2019s try this out.<\/p>\n
We\u2019ll define a function first. If the first argument is greater than the second, it returns the sum of the two.<\/p>\n
Otherwise, it returns the product of the two.<\/p>\n
def addmul(a,b):\r\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0if a>b:\r\n return a+b\r\nelse:\r\n return a*b<\/pre>\n
Now, let\u2019s vectorize this.<\/p>\n
>>> numpy.vectorize(addmul)([1,4,3,9],[2,3,7,8])<\/pre>\n
Output<\/strong><\/p>\n
\narray([ 2, 7, 21, 17])<\/p>\n<\/div>\n
Fast Fourier Transforms in Python SciPy<\/h3>\n
If you\u2019re familiar with calculus, then there are chances are you may be familiar with Fourier Transforms. This analysis lets you express a function as a sum of periodic components. It is possible to recover the signal from this sum.<\/p>\n
Let\u2019s take an example.<\/p>\n
>>> from scipy.fftpack import fft\r\n>>> N=600\r\n>>> T=1.0\/800.0\r\n>>> x=np.linspace(0.0,N*T,N)\r\n>>> y=numpy.sin(50.0*2.0*numpy.pi*x)+0.5*numpy.sin(80.0*2.0*numpy.pi*x)\r\n>>> yf=fft(y)\r\n>>> xf=numpy.linspace(0.0,1.0\/(2.0*T),N\/\/2)\r\n>>> import matplotlib.pyplot as plt\r\n>>> plt.plot(xf, 2.0\/N * numpy.abs(yf[0:N\/\/2]))<\/pre>\n
Output<\/strong><\/p>\n
\n[<matplotlib.lines.Line2D at 0x7fbb78d65210>]<\/p>\n<\/div>\n
>>> plt.grid()\r\n>>> plt.show()<\/pre>\n
![\"Python](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/07\/fourier.png\")
<\/a>SciPy Tutorial – Fast Fourier Transforms<\/p><\/div>\n
Special Functions of Python SciPy<\/h3>\n
The special<\/i> module holds various transcendental functions that will help us with multiple tasks in mathematics.<\/p>\n
To import it, use the following command-<\/p>\n
>>> from scipy import special<\/pre>\n
We make use of the various functions:<\/p>\n
- tplquad-<\/strong> Triple integration<\/li>\n
- dblquad-<\/strong> Double integration<\/li>\n
- constants-<\/strong> Physical constants and factors of conversion.<\/li>\n
- cluster-<\/strong> Hierarchical clustering.<\/li>\n
- First Release:<\/strong> 2001<\/li>\n