SciPy Cheatsheet

---

---

The SciPy cheatsheet provides the quick reference to all its fundamental topics. This is free open−source library that used for various tasks such as signal processing, statistics, linear algebra, and data analysis. Go through this cheat sheet and learn the SciPy library of Python.

Table of Content

1. Introduction to SciPy

In the introduction section, we will cover the basic definition, installation and learn how to import the SciPy.

i. What is SciPy?

The SciPy is an open-source library of Python that can be used for scientific and technical computing.

ii. Installation

To install the SciPy library of Python, use the following command −

pip install scipy

iii. Importing SciPy

To import the SciPy, use the following lines of code −

import scipy
import numpy as np

2. Special Functions (scipy.special)

The scipy.special module provides a collection of mathematical functions such as gamma functions, beta functions, and error functions.

i. Common Special Functions

The common special function are mostly used in statistics, physics and engineering applications.

from scipy import special

# Gamma function
print(special.gamma(5))  

# Beta function
print(special.beta(2, 3)) 

# Error function 
print(special.erf(1.0))  

ii. Bessel Functions

In SciPy, Bessel functions are reference through scipy.special that calculate the specific order and argument.

# Bessel function of the first kind
from scipy import special
print(special.jn(1, 2.5))  

3. Linear Algebra (scipy.linalg)

The scipy.linalg module provides functions for matrix operations such as solving linear equations, and computing determinants.

i. Solving Linear Equations

To solve the linear equation in SciPy, use the solve function.

from scipy.linalg import solve
import numpy as np
A = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
x = solve(A, b)
print(x)

ii. Matrix Operations

In SciPy, matrix operations can be implemented as 2D list or 2D array. You can perform various operations in matrices such as addition, subtraction, transpose, and inversion of a matrix.

from scipy.linalg import inv
import numpy as np
matrix = np.array([[1, 2], [3, 4]])

# Inverse of a matrix
print(inv(matrix))  

4. Optimization (scipy.optimize)

The scipy.optimize module is used for finding the minimum, maximum, and roots of functions.

i. Minimization of a Function

Minimizing a function is useful in machine learning and mathematical modeling.

from scipy.optimize import minimize

def func(x):
    return x**2 + 5*x + 6

result = minimize(func, x0=0)

# Minimum value
print(result.x)  

ii. Finding Roots of Equations

In SciPy, finding the roots methods helps to locate zeros.

from scipy.optimize import root

def equation(x):
    return x**2 - 4

sol = root(equation, x0=0)
print(sol.x)  # Root of the equation

iii. Curve Fitting (curve_fit)

Curve fitting is used to approximate data using a given function.

from scipy.optimize import curve_fit
import numpy as np
def func(x, a, b):
    return a * x + b

x_data = np.array([1, 2, 3, 4, 5])
y_data = np.array([2, 4, 6, 8, 10])
params, _ = curve_fit(func, x_data, y_data)

# Fitted parameters
print(params) 

5. Integration (scipy.integrate)

The SciPy integration are defined using numerical methods for calculating definite integrals which contains single, double and triple integrals as well as differential equations.

i. Definite and Indefinite Integrals (quad, dblquad)

The quad function measures the definite integral of a function over a given range, while dblquad is used for double integrals.

from scipy.integrate import quad, dblquad

# Single integral
result, error = quad(lambda x: x**2, 0, 2)
print(result)  

# Double integral
double_result, error = dblquad(lambda y, x: x * y, 0, 1, lambda x: 0, lambda x: 2)
print(double_result)  

ii. Solving Ordinary Differential Equations (odeint, solve_ivp)

The odeint and solve_ivp functions are used to solve ordinary differential equations (ODEs).

from scipy.integrate import odeint, solve_ivp
import numpy as np

# Define the function dy/dt = -2y
def model(y, t):
    return -2 * y

t = np.linspace(0, 5, 100)  # Time points
y0 = 1  # Initial condition

# ODE using odeint
y = odeint(model, y0, t)

# Print first few values
print(y[:5]) 

# ODE using solve_ivp
solution = solve_ivp(model, [0, 5], [y0], t_eval=t)

# Print first some values
print(solution.y[0][:5])  

6. Interpolation (scipy.interpolate)

The interpolation calculates the value between two known values.

i. 1D Interpolation (interp1d)

The interp1d function is used for interpolating 1D data.

from scipy.interpolate import interp1d
import numpy as np

# data points
x = np.array([0, 1, 2, 3, 4])
y = np.array([0, 2, 4, 6, 8])

# Create an interpolation function
f = interp1d(x, y, kind='linear')

# Interpolated value at x = 2.5
print(f(2.5))  

ii. 2D and Multivariate Interpolation

The griddata function is used for interpolating 2D and multivariate data.

from scipy.interpolate import griddata
import numpy as np
# data points
points = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
values = np.array([1, 2, 3, 4])

# query point for interpolation
query_point = np.array([[0.5, 0.5]])

# interpolation
result = griddata(points, values, query_point, method='cubic')

# Interpolated value at (0.5, 0.5)
print(result)  

7. Statistics (scipy.stats)

The scipy.stats module provides statistical functions, including mean, variance, and hypothesis testing.

ii. Descriptive Statistics (Mean, Median, Variance)

You can compute mean, median, and variance using SciPy.

# mean
mean_value = stats.tmean(data)	

# median 
median_value = stats.tmedian(data) 

# variance
variance_value = stats.tvar(data) 

iii. Hypothesis Testing (t-test, chi-square test)

The hypothetical testing determine the statistical method to test about a population parameter using sample data.

from scipy.stats import ttest_1samp, chi2_contingency
import numpy as np
data = np.array([1, 2, 3, 4, 5, 6])
t_stat, p_value = ttest_1samp(data, popmean=3.5)
print("T-test p-value:", p_value)

8. Fast Fourier Transform (FFT) (scipy.fft)

The Fast Fourier Transform (FFT) is an efficient method for calculating the Discrete Fourier Transform (DFT) of a signal and its inverse.

i. 1D and 2D Fourier Transforms

The Fast Fourier Transform (FFT) is an algorithm to operates the discrete Fourier transform (DFT) and its inverse. The 1D FFT is used for 1−dimensional data, and the 2D FFT is applied to two−dimensional data such as images.

from scipy.fft import fft, fft2
import numpy as np

# 1D Fourier Transform
x = np.array([0, 1, 2, 3, 4, 5, 6, 7])
fft_result_1d = fft(x)

print("1D FFT result:\n", fft_result_1d)

# 2D Fourier Transform
x_2d = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
fft_result_2d = fft2(x_2d)

print("2D FFT result:\n", fft_result_2d)

ii. Inverse Fourier Transform

In SciPy, inverse FFT transforms the frequency−domain data back to the time or spatial domain.

import numpy as np
from scipy.fft import fft, ifft, fft2, ifft2

# 1D array
data_1d = np.array([1, 2, 3, 4])

# Fourier Transform
fft_result_1d = fft(data_1d)

# Inverse Fourier Transform
ifft_result_1d = ifft(fft_result_1d)
print("1D Inverse FFT result:\n", ifft_result_1d)

# 2D array
data_2d = np.array([[1, 2], [3, 4]])

# 2D Fourier Transform
fft_result_2d = fft2(data_2d)

# 2D Inverse Fourier Transform
ifft_result_2d = ifft2(fft_result_2d)
print("2D Inverse FFT result:\n", ifft_result_2d)

9. Signal Processing (scipy.signal)

In SciPy, signal processing is a part of python library that provides the tools like filtering, Fourier transform and wavelets.

i. Filtering (Low-pass, High-pass)

In SciPy, filtering helps in removing unwanted noise or frequencies from a signal.

from scipy.signal import butter, filtfilt
import numpy as np

# create a low-pass filter
def butter_lowpass(cutoff, fs, order=5):
    nyquist = 0.5 * fs
    normal_cutoff = cutoff / nyquist
    b, a = butter(order, normal_cutoff, btype='low', analog=False)
    return b, a

# sample signal
fs = 100  
signal = np.sin(2 * np.pi * 5 * np.linspace(0, 1, fs)) 

# apply filter
# 10 Hz cutoff frequency
b, a = butter_lowpass(10, fs)  
filtered_signal = filtfilt(b, a, signal)

ii. Convolution and Correlation

In SciPy, convolution and correlation are used for signal processing operations such as filtering and feature detection.

from scipy.signal import convolve, correlate
import numpy as np
x = np.array([1, 2, 3])
h = np.array([0, 1, 0.5])

conv_result = convolve(x, h, mode='full')
corr_result = correlate(x, h, mode='full')

# Convolution result
print(conv_result)
# Correlation result  
print(corr_result)  

iii. Peak Detection

Peak detection is used to find local maxima from the signal.

from scipy.signal import find_peaks
import numpy as np
signal = np.array([0, 1, 0, 2, 1, 3, 1, 0])
peaks, _ = find_peaks(signal, height=1)

# Indices of peaks
print(peaks)  

10. Image Processing (scipy.ndimage)

Image Processing in SciPy defines the signals in the form of pixel data. This is also known as image analysis.

i. Image Filtering (Gaussian, Median)

SciPy provides various image filters such as Gaussian and Median filters for the smooth images.

from scipy.ndimage import gaussian_filter, median_filter
import numpy as np
image = np.random.random((5, 5))

gaussian_filtered = gaussian_filter(image, sigma=1)
median_filtered = median_filter(image, size=2)

# Gaussian filtered image
print(gaussian_filtered)

# Median filtered image  
print(median_filtered)  

ii. Morphological Operations

Morphological operations are used for image processing tasks such as edge detection and noise removal.

from scipy.ndimage import binary_dilation, binary_erosion
import numpy as np

binary_image = np.random.randint(0, 2, (5, 5))

dilated_image = binary_dilation(binary_image)
eroded_image = binary_erosion(binary_image)

print(dilated_image)  # Dilated image
print(eroded_image)  # Eroded image

11. Sparse Matrices (scipy.sparse)

A sparse matrices are the matrix by containing most zero elements.

i. Creating Sparse Matrices

Sparse matrices store only nonzero elements to save memory.

from scipy.sparse import csr_matrix
import numpy as np
dense_matrix = np.array([[0, 0, 1], [1, 0, 0], [0, 2, 0]])
sparse_matrix = csr_matrix(dense_matrix)

print(sparse_matrix)

ii. Sparse Matrix Operations

This is like a matrix multiplication and the conversion can be performed on sparse matrices.

# Transpose
sparse_matrix_T = sparse_matrix.transpose()  

# Matrix multiplication
sparse_matrix_dot = sparse_matrix.dot(sparse_matrix_T)  
print(sparse_matrix_dot)

12. File I/O (scipy.io)

Reading / Writing MATLAB Files

MATLAB files (.mat) can be used to read and write files using SciPy.

from scipy.io import savemat, loadmat
import numpy as np
data = {'array': np.array([1, 2, 3])}
# Save to MATLAB file
savemat("data.mat", data)  

# Load MATLAB file
loaded_data = loadmat("data.mat")  
print(loaded_data)

ii. Reading / Writing WAV Files

SciPy provides functions to read and write audio files in WAV format.

from scipy.io import wavfile
import numpy as np
# Writing a WAV file
fs = 44100
wavfile.write("output.wav", fs, np.random.randint(-32768, 32767, 44100, dtype=np.int16))

# Reading a WAV file
rate, data = wavfile.read("output.wav")
print(rate, data.shape)