# cupyx.scipy.interpolate.Akima1DInterpolator#

class cupyx.scipy.interpolate.Akima1DInterpolator(x, y, axis=0)[source]#

Akima interpolator

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

Parameters
• x (ndarray, shape (m, )) – 1-D array of monotonically increasing real values.

• y (ndarray, shape (m, ...)) – N-D array of real values. The length of `y` along the first axis must be equal to the length of `x`.

• axis (int, optional) – Specifies the axis of `y` along which to interpolate. Interpolation defaults to the first axis of `y`.

`CubicHermiteSpline`

Piecewise-cubic interpolator.

`PchipInterpolator`

PCHIP 1-D monotonic cubic interpolator.

`PPoly`

Piecewise polynomial in terms of coefficients and breakpoints

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.

References

1

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

Methods

__call__(x, nu=0, extrapolate=None)[source]#

Evaluate the piecewise polynomial or its derivative.

Parameters
• x (array_like) – Points to evaluate the interpolant at.

• nu (int, optional) – Order of derivative to evaluate. Must be non-negative.

• 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), use self.extrapolate.

Returns

y – Interpolated values. Shape is determined by replacing the interpolation axis in the original array with the shape of x.

Return type

array_like

Notes

Derivatives are evaluated piecewise for each polynomial segment, even if the polynomial is not differentiable at the breakpoints. The polynomial intervals are considered half-open, `[a, b)`, except for the last interval which is closed `[a, b]`.

antiderivative(nu=1)[source]#

Construct a new piecewise polynomial representing the antiderivative. Antiderivative is also the indefinite integral of the function, and derivative is its inverse operation.

Parameters

nu (int, optional) – Order of antiderivative to evaluate. Default is 1, i.e., compute the first integral. If negative, the derivative is returned.

Returns

pp – Piecewise polynomial of order k2 = k + n representing the antiderivative of this polynomial.

Return type

PPoly

Notes

The antiderivative returned by this function is continuous and continuously differentiable to order n-1, up to floating point rounding error.

If antiderivative is computed and `self.extrapolate='periodic'`, it will be set to False for the returned instance. This is done because the antiderivative is no longer periodic and its correct evaluation outside of the initially given x interval is difficult.

classmethod construct_fast(c, x, extrapolate=None, axis=0)[source]#

Construct the piecewise polynomial without making checks. Takes the same parameters as the constructor. Input arguments `c` and `x` must be arrays of the correct shape and type. The `c` array can only be of dtypes float and complex, and `x` array must have dtype float.

derivative(nu=1)[source]#

Construct a new piecewise polynomial representing the derivative.

Parameters

nu (int, optional) – Order of derivative to evaluate. Default is 1, i.e., compute the first derivative. If negative, the antiderivative is returned.

Returns

pp – Piecewise polynomial of order k2 = k - n representing the derivative of this polynomial.

Return type

PPoly

Notes

Derivatives are evaluated piecewise for each polynomial segment, even if the polynomial is not differentiable at the breakpoints. The polynomial intervals are considered half-open, `[a, b)`, except for the last interval which is closed `[a, b]`.

extend(c, x, right=True)[source]#

Parameters
• c (ndarray, size (k, m, ...)) – Additional coefficients for polynomials in intervals. Note that the first additional interval will be formed using one of the `self.x` end points.

• x (ndarray, size (m,)) – Additional breakpoints. Must be sorted in the same order as `self.x` and either to the right or to the left of the current breakpoints.

classmethod from_bernstein_basis(bp, extrapolate=None)[source]#

Construct a piecewise polynomial in the power basis from a polynomial in Bernstein basis.

Parameters
• bp (BPoly) – A Bernstein basis polynomial, as created by BPoly

• extrapolate (bool or 'periodic', 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. Default is True.

classmethod from_spline(tck, extrapolate=None)[source]#

Construct a piecewise polynomial from a spline

Parameters
• tck – A spline, as a (knots, coefficients, degree) tuple or a BSpline object.

• extrapolate (bool or 'periodic', 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. Default is True.

integrate(a, b, extrapolate=None)[source]#

Compute a definite integral over a piecewise polynomial.

Parameters
• a (float) – Lower integration bound

• b (float) – Upper integration bound

• 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), use self.extrapolate.

Returns

ig – Definite integral of the piecewise polynomial over [a, b]

Return type

array_like

roots(discontinuity=True, extrapolate=None)[source]#

Find real roots of the piecewise polynomial.

Parameters
• discontinuity (bool, optional) – Whether to report sign changes across discontinuities at breakpoints as roots.

• extrapolate ({bool, 'periodic', None}, optional) – If bool, determines whether to return roots from the polynomial extrapolated based on first and last intervals, ‘periodic’ works the same as False. If None (default), use self.extrapolate.

Returns

roots – Roots of the polynomial(s). If the PPoly object describes multiple polynomials, the return value is an object array whose each element is an ndarray containing the roots.

Return type

ndarray

solve(y=0.0, discontinuity=True, extrapolate=None)[source]#

Find real solutions of the equation `pp(x) == y`.

Parameters
• y (float, optional) – Right-hand side. Default is zero.

• discontinuity (bool, optional) – Whether to report sign changes across discontinuities at breakpoints as roots.

• extrapolate ({bool, 'periodic', None}, optional) – If bool, determines whether to return roots from the polynomial extrapolated based on first and last intervals, ‘periodic’ works the same as False. If None (default), use self.extrapolate.

Returns

roots – Roots of the polynomial(s). If the PPoly object describes multiple polynomials, the return value is an object array whose each element is an ndarray containing the roots.

Return type

ndarray

Notes

This routine works only on real-valued polynomials. If the piecewise polynomial contains sections that are identically zero, the root list will contain the start point of the corresponding interval, followed by a `nan` value. If the polynomial is discontinuous across a breakpoint, and there is a sign change across the breakpoint, this is reported if the discont parameter is True.

At the moment, there is not an actual implementation.

__eq__(value, /)#

Return self==value.

__ne__(value, /)#

Return self!=value.

__lt__(value, /)#

Return self<value.

__le__(value, /)#

Return self<=value.

__gt__(value, /)#

Return self>value.

__ge__(value, /)#

Return self>=value.

Attributes

c#
x#
extrapolate#
axis#