**Python SciPy** is a library that has **Python NumPy** and Mathematical algorithms as its building blocks. The Python SciPy library is utilized to a great extent in the field of scientific computations and processing.

## Getting Started with Python Scipy

In order to use the different functions offered by the SciPy library, we need to install it. To serve the purpose, we will use `pip`

command to install the SciPy library.

```
pip install scipy
```

In order to use the functions of this library, we will need to import this library using the following statement:

```
import scipy
```

## Sub-Packages in Python SciPy

There are various sub-modules available in the SciPy library to perform and enhance the efficiency of the scientific calculations.

Some of the popular sub-modules of the SciPy library are listed below:

**special**: This sub-module contains the Special functions to perform a specific task.**constants**: Represents constants.**optimize**: This sub-module contains algorithms for optimization.**integrate**: This sub-module contains functions to perform Mathematical Integration.**interpolate**: Represents functions to perform interpolation.**linalg**: Represents functions to perform operations on linear algebra equations.**io**: It contains functions to perform Input/Output operations on the given input.**fftpack**: Represents functions to perform Discrete Fourier Transform.**signal**: Represents functions and tools for Signal Processing in Python.**sparse**: Represents algorithms to deal with sparse matrices.**cluster**: Represents functions to perform hierarchical clustering.

## Linear Algebra with Python SciPy

Linear Algebra represents linear equations and represents them with the help of matrices.

The `linalg`

sub-module of the SciPy library is used to perform all the functionalities related to linear equations. It takes the object to be converted into a 2-D NumPy array and then performs the task.

### 1. Solving a set of equations

Let us understand the working of the linalg sub-module along with the Linear equations with the help of an example:

**4x+3y=123x+4y=18 **

Consider the above linear equations. Let us solve the equations through the `linalg.solve()`

function.

```
from scipy import linalg
import numpy
X=numpy.array([[4,3],[3,4]])
Y=numpy.array([[12],[18]])
print(linalg.solve(X,Y))
X.dot(linalg.solve(X,Y))-Y
```

In the above snippet of code, we have passed the coefficients and constant values present in the input equations through numpy.array() function.

Further, `linalg. solve()`

function solves the linear equations and displays the x and y value which works for that particular equation. `equation1.dot(linalg.solve())-equation2`

command is used to check the output of the equations.

**Output:**

```
[[-0.85714286]
[ 5.14285714]]
array([[0.],
[0.]])
```

**array([[0.], [0.]])** ensures that the linear equations have been solved rightly.

**[[-0.85714286] [ 5.14285714]]**: These are the x and y values used to solve the linear equations.

### 2. Finding the Determinants of Matrices

The `linalg.det()`

method is used to find the determinant of the input matrix.

**Example**:

```
from scipy import linalg
import numpy
determinant=numpy.array([[2,4],[4,12]])
linalg.det(determinant)
```

**Output:**

```
8.0
```

### 3. Calculating Inverse of a Matrix

The `linalg.inv()`

method is used to calculate the inverse of an input matrix.

**Example:**

```
from scipy import linalg
import numpy
inverse=numpy.array([[2,4],[4,12]])
linalg.inv(inverse)
```

**Output:**

```
array([[ 1.5 , -0.5 ],
[-0.5 , 0.25]])
```

## Performing calculations on Polynomials with Python SciPy

The `poly1d`

sub-module of the SciPy library is used to perform manipulations on 1-d polynomials. It accepts coefficients as input and forms the polynomial objects.

Let’s understand the poly1d sub-module with the help of an example.

**Example:**

```
from numpy import poly1d
# Creation of a polynomial object using coefficients as inputs through poly1d
poly_input = poly1d([2, 4, 6, 8])
print(poly_input)
# Performing integration for value = 4
print("\nIntegration of the input polynomial: \n")
print(poly_input.integ(k=3))
# Performing derivation
print("\nDerivation of the input polynomial: \n")
print(poly_input.deriv())
```

In the above snippet of code, `poly1d()`

is used to accept the coefficients of the polynomial.

Further, `polynomial.integ(value)`

is used to find the integration of the input polynomial around the input scalar value. The `polynomial.deriv() `

function is used to calculate the derivation of the input polynomial.

**Output:**

```
3 2
2 x + 4 x + 6 x + 8
Integration of the input polynomial:
4 3 2
0.5 x + 1.333 x + 3 x + 8 x + 3
Derivation of the input polynomial:
2
6 x + 8 x + 6
```

## Performing Integration with Python SciPy

The `integrate`

sub-module of the SciPy library is used to perform integration on the input equations.

Let’s perform integration on the following equation:

**3*x*2 + 2*x + 6**

```
from scipy import integrate
integrate.quad(lambda x:3*x*2 + 2*x + 6,0,2)
```

In the above piece of code, `integrate.quad()`

function is used to calculate the integration of the input equation. It accepts the following arguments:

**equation****upper limit****lower limit**

**Output:**

```
(28.0, 3.1086244689504383e-13)
```

## Fourier Transforms with Python SciPy

Fourier Transforms enable us to understand and depict functions as a summation of periodic components.

The `fftpack`

sub-module of the SciPy library is used to perform Fourier transforms on the equations.

**Example:**

```
from scipy.fftpack import fft
import numpy as np
# Count of sample points
n = 400
# sample spacing
T = 1.0 / 500.0
x_i = np.linspace(0.0, n*T, n)
y_i = np.tan(70.0 * 2.0*np.pi*x_i) + 0.5*np.tan(70.0 * 2.0*np.pi*x_i)
y_f = fft(y_i)
x_f = np.linspace(0.0, 1.0/(3.0*T), n//2)
# matplotlib for plotting purposes
import matplotlib.pyplot as plt
plt.plot(x_f, 2.0/n * np.abs(y_f[0:n//2]))
plt.show()
```

In the above snippet of code, we have used numpy.linspace() function to get evenly spaced integers. Further, `fft()`

function is used to calculate the Fourier value of the input. We have used the Python matplotlib module to plot the **Tangent** graph.

**Output:**

## Special Functions of Python SciPy

The following is the list of some of the most commonly used Special functions from the `special`

package of SciPy:

**Cubic Root****Exponential Function****Log-Sum Exponential Function****Gamma**

### 1. Cubic Root

The `scipy.special.cbrt()`

function is used to provide the element-wise cube root of the inputs provided.

**Example:**

```
from scipy.special import cbrt
val = cbrt([27, 8])
print(val)
```

**Output:**

```
[3. 2.]
```

### 2. Exponential Function

The `scipy.special.exp10()`

function is used to calculate the element-wise exponent of the given inputs.

**Example:**

```
from scipy.special import exp10
val = exp10([27, 8])
print(val)
```

**Output:**

```
[1.e+27 1.e+08]
```

### 3. **Log-Sum Exponential Function**

The `scipy.special.logsumexp()`

function is used to calculate the logarithmic value of the sum of the exponents of the input elements.

**Example:**

```
from scipy.special import logsumexp
import numpy as np
inp = np.arange(5)
val = logsumexp(inp)
print(val)
```

Here, numpy.arange() function is used to generate a sequence of numbers to be passed as input.

**Output**:

```
4.451914395937593
```

### 4. Gamma Function

Gamma function is used to calculate the gamma value, referred to as generalized factorial because, **gamma(n+1) = n!**

The `scipy.special.gamma()`

function is used to calculate the gamma value of the input element.

**Example:**

```
from scipy.special import gamma
val = gamma([5, 0.8, 2, 0])
print(val)
```

**Output:**

```
[24. 1.16422971 1. inf]
```

## Interpolation Functions

Interpolation is a process to find values between two or more points on a curve, line, etc.

The `scipy.interpolate`

package is used to perform interpolation on a particular graph.

**Example:**

```
import numpy as np
from scipy import interpolate
import matplotlib.pyplot as p
a = np.linspace(0, 4, 12)
b = np.sin(x**2/3+4)
print(a,b)
p.plot(a, b, 'o') # Plotting the graph assuming a and b arrays as x and y dimensions
p.show()
```

In the above snippet of code, we have created a **sine wave**, and have plotted the values using **Python PyPlot** package of **Matplotlib Module**.

**Output:**

```
[0. 0.36363636 0.72727273 1.09090909 1.45454545 1.81818182
2.18181818 2.54545455 2.90909091 3.27272727 3.63636364 4. ] [-0.7568025 -0.78486887 -0.85971727 -0.9505809 -0.9999744 -0.92508408
-0.64146657 -0.12309271 0.51220599 0.96001691 0.85056799 0.09131724]
```

## Conclusion

Thus, in this article, we have understood the functions served by the Python SciPy library.

## References

Recommended read: Python Matplotlib Tutorial and Python NumPy