Linear 1-D Interpolation in SciPy

Linear 1-D Interpolation in SciPy is a method for estimating unknown values between two known data points in a single dimension. It achieves this by assuming a linear (straight-line) relationship between adjacent data points. This technique is particularly valuable when working with discrete datasets and the goal is to create a smooth function to approximate intermediate values.

SciPy provides the interp1d() function within the scipy.interpolate module to perform 1-D interpolation, offering various methods including linear, cubic, nearest-neighbor, and quadratic.

How Linear Interpolation Works

Linear interpolation estimates the value of a function at an unknown point x that lies between two known data points, (x0, y0) and (x1, y1). It does this by assuming a straight-line relationship between these two points. The interpolated value y is calculated using the following formula:

$y = y_0 + (x - x_0) \frac{y_1 - y_0}{x_1 - x_0}$

This method is computationally efficient and straightforward. However, it assumes a constant rate of change between points, which may not be ideal for datasets exhibiting highly non-linear patterns.

SciPy's scipy.interpolate.interp1d() Function

The primary function for 1-D interpolation in SciPy is interp1d().

Syntax

scipy.interpolate.interp1d(x, y, kind='linear', axis=-1, copy=True,
                           bounds_error=None, fill_value=np.nan,
                           assume_sorted=False)

Key Parameters

• x: An array of independent data points.
• y: An array of dependent data points. It must have the same length as x.
• kind: Specifies the type of interpolation to perform. Common options include:
  • 'linear' (default)
  • 'nearest'
  • 'quadratic'
  • 'cubic'
• axis: The axis of the y array along which to perform the interpolation. Defaults to the last axis (-1).
• copy: If True, a copy of the input arrays x and y is made. If False, the input arrays may be modified.
• bounds_error: If True, an error will be raised when attempting to interpolate outside the input data range (x). If False, the behavior is controlled by fill_value.
• fill_value: Determines the value to use when interpolating outside the input data range. Can be a scalar, a tuple of scalars, or 'extrapolate' to use extrapolation. Defaults to np.nan.
• assume_sorted: If True, it is assumed that the input array x is already sorted. This can improve performance. If False (default), the function will sort x internally.

Linear 1-D Interpolation Example in SciPy

This example demonstrates how to use interp1d for linear interpolation and visualize the results.

import numpy as np
import matplotlib.pyplot as plt
from scipy.interpolate import interp1d

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

# Create a linear interpolation function
f_linear = interp1d(x, y, kind='linear')

# Generate new points for interpolation
x_new = np.linspace(0, 4, 100)
y_new = f_linear(x_new)

# Plot the original data points and the interpolated line
plt.figure(figsize=(8, 5))
plt.plot(x, y, 'o', label='Data Points')
plt.plot(x_new, y_new, '-', label='Linear Interpolation')
plt.legend()
plt.title('Linear 1-D Interpolation in SciPy')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.grid(True)
plt.show()

Other Types of 1-D Interpolation in SciPy

SciPy's interp1d() function supports several other interpolation methods:

1. Cubic Interpolation: Fits a cubic polynomial to data points. This results in a smoother curve than linear interpolation, capturing more complex trends.

   cubic_interp = interp1d(x, y, kind='cubic', fill_value='extrapolate')

2. Nearest-Neighbor Interpolation: Assigns the value of the closest known data point to any unknown point. This is a simple but often "blocky" interpolation.

   nearest_interp = interp1d(x, y, kind='nearest', fill_value='extrapolate')

3. Quadratic Interpolation: Fits a second-degree polynomial to data points. It offers a balance between the simplicity of linear interpolation and the smoothness of cubic interpolation.

   quadratic_interp = interp1d(x, y, kind='quadratic', fill_value='extrapolate')

Comparison of 1-D Interpolation Methods

Benefits of Using SciPy Linear 1-D Interpolation

• Simplicity and Speed: It is easy to implement and computationally efficient, making it suitable for real-time applications.
• Good for Approximation: Works well when the underlying data trend is approximately linear.
• Flexibility with interp1d(): The interp1d() function allows for easy switching between linear and other interpolation methods with minimal code changes.

Limitations of Linear 1-D Interpolation

• Not Ideal for Highly Nonlinear Data: It struggles to accurately capture curves, inflection points, or rapid changes in the data trend.
• Piecewise Discontinuities in Derivative: The derivative of the interpolated function may be discontinuous at the original data points, leading to sharp transitions or "kinks" in the interpolated curve.

Conclusion

Linear 1-D interpolation in SciPy, implemented via scipy.interpolate.interp1d(), is a practical and efficient method for estimating unknown data points. It offers a straightforward way to create smoother representations of discrete data when a linear trend is a reasonable assumption. The interp1d() function's flexibility allows users to easily explore other interpolation techniques like cubic, quadratic, and nearest-neighbor, catering to a wider range of data characteristics and accuracy requirements.