SciPy Interpolation

In this article, we will learn Interpolation using the SciPy module in Python. First, we will discuss interpolation and its types with implementation.

Interpolation and Its Types

Interpolation is a technique of constructing data points between given data points. The scipy.interpolate is a module in Python SciPy consisting of classes, spline functions, and univariate and multivariate interpolation classes. Interpolation is done in many ways some of them are :

• 1-D Interpolation
• Spline Interpolation
• Univariate Spline Interpolation
• RBF Interpolation

Let's discuss all the methods one by one and visualize the results.

1-D Interpolation

To create a function based on fixed data points, scipy.interpolate.interp1d is used. It takes data points x and y and returns a function that can be called with new x and returns the corresponding y point.

Syntax: scipy.interpolate.interp1d(x , y , kind , axis , copy , bounds_error , fill_value , assume_sorted)

# Import the required Python libraries
import matplotlib.pyplot as plt
from scipy import interpolate
import numpy as np

# Initialize input values x and y
x = np.arange(0, 10)
y = x**2

# Interpolation
temp = interpolate.interp1d(x, y)
xnew = np.arange(0, 9, 0.2)
ynew = temp(xnew)

plt.title("1-D Interpolation")
plt.plot(x, y, '*', xnew, ynew, '-', color="green")
plt.show()

Output:

Spline Interpolation

In spline interpolation, a spline representation of the curve is computed, and then the spline is computed at the desired points. The function splrep is used to find the spline representation of a curve in a two-dimensional plane.

Note: As of SciPy version 1.15.1, scipy.interpolate.splrep is deprecated in favor of scipy.interpolate.make_splrep. Although splrep is still functional, it is recommended to transition to make_splrep for better long-term support and future compatibility.

• To find the B-spline representation of a 1-D curve, scipy.interpolate.make_splrep is used.

Syntax: scipy.interpolate.make_splrep(x, y, w=None, xb=None, xe=None, k=3, s=None, full_output=0, per=0)

• To compute a B-spline or its derivatives, scipy.interpolate.splev is used.

Syntax: scipy.interpolate.splev(x , tck , der , ext)

# Import the required Python libraries
import numpy as np
import matplotlib.pyplot as plt
from scipy import interpolate

# Initialize the input values
x = np.arange(0, 10)
y = np.cos(x**3)

# Interpolation using make_splrep (updated)
# To find the spline representation of a 
# curve in a 2-D plane using make_splrep
temp = interpolate.make_splrep(x, y, s=0)
xnew = np.arange(0, np.pi**2, np.pi/100)
ynew = interpolate.splev(xnew, temp, der=0)

plt.figure()
plt.plot(x, y, '*', xnew, ynew, xnew, np.cos(xnew), x, y, 'b', color="green")
plt.legend(['Linear', 'Cubic Spline', 'True'])
plt.axis([-0.1, 6.5, -1.1, 1.1])
plt.title('Cubic-spline Interpolation in Python')
plt.show()

Output:

Univariate Spline

It is a 1-D smoothing spline that fits a given group of data points. The scipy.interpolate.UnivariateSpline is used to fit a spline y = spl(x) of degree k to the provided x, y data. s specifies the number of knots by specifying a smoothing condition. The scipy.interpolate.UnivariateSpline. set_smoothing_factor: Spline computation with the given smoothing factor s and with the knots found at the last call.

Syntax: scipy.interpolate.UnivariateSpline( x, y, w, bbox, k, s, ext)

# Import the required libraries
import matplotlib.pyplot as plt
from scipy.interpolate import UnivariateSpline

x = np.linspace(-3, 3, 50)
y = np.exp(-x**2) + 0.1 * np.random.randn(50)
plt.title("Univariate Spline")
plt.plot(x, y, 'g.', ms=8)

# Using the default values for the 
# smoothing parameter
spl = UnivariateSpline(x, y)
xs = np.linspace(-3, 3, 1000)
plt.plot(xs, spl(xs), 'green', lw=3)

# Manually change the amount of smoothing
spl.set_smoothing_factor(0.5)
plt.plot(xs, spl(xs), color='black', lw=3)
plt.show()

Output:

Radial basis function for Interpolation

The scipy.interpolate.Rbf is used for interpolating scattered data in n-dimensions. The radial basis function is defined as corresponding to a fixed reference data point. The scipy.interpolate.Rbf is a class for radial basis function interpolation of functions from N-D scattered data to an M-D domain.

Syntax: scipy.interpolate.Rbf(*args)

# Import the required libraries
import numpy as np
from scipy.interpolate import Rbf
import matplotlib.pyplot as plt

# setup the data values
x = np.linspace(0, 10, 9)
y = np.cos(x/2)
xi = np.linspace(0, 10, 110)

# Interpolation using RBF
rbf = Rbf(x, y)
fi = rbf(xi)

plt.subplot(2, 1, 2)
plt.plot(x, y, '*', color="green")
plt.plot(xi, fi, 'green')
plt.plot(xi, np.sin(xi), 'black')
plt.title('Radial basis function Interpolation')
plt.show()

Output: