`scipy.interpolate._cubic:Akima1DInterpolator`

source: build-install/usr/lib/python3.14/site-packages/scipy/interpolate/_cubic.py:416

Signature

class Akima1DInterpolator(x, y, axis = 0, *, method: Literal['akima', 'makima'] = akima, extrapolate: bool | None = None)

Members

Summary

Akima "visually pleasing" interpolator (C1 smooth).

Extended Summary

Fit piecewise cubic polynomials, given vectors x and y. The interpolation method by Akima uses a continuously differentiable sub-spline built from piecewise cubic polynomials. The resultant curve passes through the given data points and will appear smooth and natural.

Parameters

x : ndarray, shape (npoints, ): 1-D array of monotonically increasing real values.
y : ndarray, shape (..., npoints, ...): N-D array of real values. The length of y along the interpolation axis must be equal to the length of x. Use the axis parameter to select the interpolation axis.
axis : int, optional: Axis in the y array corresponding to the x-coordinate values. Defaults to axis=0.
method : {'akima', 'makima'}, optional: If "makima", use the modified Akima interpolation ^[2]. Defaults to "akima", use the Akima interpolation ^[1].
versionadded 1.13.0
extrapolate : {bool, 'periodic', None}, optional: If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. If None (default), it is set to False. See tutorial-interpolate_out_of_bounds.

Methods

__call__
derivative
antiderivative
integrate
solve
roots

Notes

Use only for precise data, as the fitted curve passes through the given points exactly. This routine is useful for plotting a pleasingly smooth curve through a few given points for purposes of plotting.

Let $δ_{i} = (y_{i + 1} - y_{i}) / (x_{i + 1} - x_{i})$ be the slopes of the interval $[x_{i}, x_{i + 1})$ . Akima's derivative at $x_{i}$ is defined as:

d_{i} = \frac{w _{1}}{w _{1} + w _{2}} δ_{i - 1} + \frac{w _{2}}{w _{1} + w _{2}} δ_{i}

In the Akima interpolation ^[1] (method="akima"), the weights are:

w_{1} w_{2} = ∣ δ_{i + 1} - δ_{i} ∣ = ∣ δ_{i - 1} - δ_{i - 2} ∣

In the modified Akima interpolation ^[2] (method="makima"), to eliminate overshoot and avoid edge cases of both numerator and denominator being equal to 0, the weights are modified as follows:

w_{1} w_{2} = ∣ δ_{i + 1} - δ_{i} ∣ + ∣ δ_{i + 1} + δ_{i} ∣/2 = ∣ δ_{i - 1} - δ_{i - 2} ∣ + ∣ δ_{i - 1} + δ_{i - 2} ∣/2

Examples

Comparison of ``method="akima"`` and ``method="makima"``:

import numpy as np
from scipy.interpolate import Akima1DInterpolator
import matplotlib.pyplot as plt
x = np.linspace(1, 7, 7)
y = np.array([-1, -1, -1, 0, 1, 1, 1])
xs = np.linspace(min(x), max(x), num=100)
y_akima = Akima1DInterpolator(x, y, method="akima")(xs)
y_makima = Akima1DInterpolator(x, y, method="makima")(xs)

✓

fig, ax = plt.subplots()

✓

ax.plot(x, y, "o", label="data")
ax.plot(xs, y_akima, label="akima")
ax.plot(xs, y_makima, label="makima")
ax.legend()

✗

<matplotlib.legend.Legend object at 0x7f3f601c0c20>

fig.show()

✓

The overshoot that occurred in ``"akima"`` has been avoided in ``"makima"``.

Aliases

scipy.interpolate.Akima1DInterpolator