Skip to main content
`Ctrl`+`K`
scipy.interpolate.

# Akima1DInterpolator

class scipy.interpolate.Akima1DInterpolator(x, y, axis=0, *, method='akima', extrapolate=None)

  Akima “visually pleasing” interpolator (C1 smooth).

  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].

      Added in version 1.13.0.

    extrapolate{bool, None}, optional

      If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If None, `extrapolate` is set to False.

  Attributes:
    axis
    c
    extrapolate
    x

  Methods

  `__call__`(x[, nu, extrapolate]) | Evaluate the piecewise polynomial or its derivative.
  `derivative`([nu]) | Construct a new piecewise polynomial representing the derivative.
  `antiderivative`([nu]) | Construct a new piecewise polynomial representing the antiderivative.
  `integrate`(a, b[, extrapolate]) | Compute a definite integral over a piecewise polynomial.
  `solve`([y, discontinuity, extrapolate]) | Find real solutions of the equation `pp(x) == y`.
  `roots`([discontinuity, extrapolate]) | Find real roots of the piecewise polynomial.

  See also

  `PchipInterpolator`

    PCHIP 1-D monotonic cubic interpolator.

  `CubicSpline`

    Cubic spline data interpolator.

  `PPoly`

    Piecewise polynomial in terms of coefficients and breakpoints

  Notes

  Added in version 0.14.

  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 \(\delta_i = (y_{i+1} - y_i) / (x_{i+1} - x_i)\) be the slopes of the interval \(\left[x_i, x_{i+1}\right)\). Akima’s derivative at \(x_i\) is defined as:

  \[d_i = \frac{w_1}{w_1 + w_2}\delta_{i-1} + \frac{w_2}{w_1 + w_2}\delta_i\]

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

  \[\begin{split}\begin{aligned} w_1 &= |\delta_{i+1} - \delta_i| \\ w_2 &= |\delta_{i-1} - \delta_{i-2}| \end{aligned}\end{split}\]

  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:

  \[\begin{split}\begin{align*} w_1 &= |\delta_{i+1} - \delta_i| + |\delta_{i+1} + \delta_i| / 2 \\ w_2 &= |\delta_{i-1} - \delta_{i-2}| + |\delta_{i-1} + \delta_{i-2}| / 2 \end{align*}\end{split}\]

  Array API Standard Support

  `Akima1DInterpolator` has experimental support for Python Array API Standard compatible backends in addition to NumPy. Please consider testing these features by setting an environment variable `SCIPY_ARRAY_API=1` and providing CuPy, PyTorch, JAX, or Dask arrays as array arguments. The following combinations of backend and device (or other capability) are supported.

  Library | CPU | GPU
  --- | --- | ---
  NumPy | ✅ | n/a
  CuPy | n/a | ⛔
  PyTorch | ✅ | ⛔
  JAX | ⛔ | ⛔
  Dask | ⛔ | n/a

  > See Support for the array API standard for more information.

  References

  [1] (1,2)

  A new method of interpolation and smooth curve fitting based on local procedures. Hiroshi Akima, J. ACM, October 1970, 17(4), 589-602. DOI:10.1145/321607.321609

  [2] (1,2)

  Makima Piecewise Cubic Interpolation. Cleve Moler and Cosmin Ionita, 2019. https://blogs.mathworks.com/cleve/2019/04/29/makima-piecewise-cubic-interpolation/

  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()
      >>> fig.show()

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