cupyx.scipy.interpolate.PPoly#

class cupyx.scipy.interpolate.PPoly(c, x, extrapolate=None, axis=0)[source]#

Piecewise polynomial in terms of coefficients and breakpoints The polynomial between x[i] and x[i + 1] is written in the local power basis:

S = sum(c[m, i] * (xp - x[i]) ** (k - m) for m in range(k + 1))

where k is the degree of the polynomial.

Parameters:

c (ndarray, shape (k, m, ...)) – Polynomial coefficients, order k and m intervals.
x (ndarray, shape (m+1,)) – Polynomial breakpoints. Must be sorted in either increasing or decreasing order.
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.
axis (int, optional) – Interpolation axis. Default is zero.

Variables:

x (ndarray) – Breakpoints.
c (ndarray) – Coefficients of the polynomials. They are reshaped to a 3-D array with the last dimension representing the trailing dimensions of the original coefficient array.
axis (int) – Interpolation axis.

See also

scipy.interpolate.BSpline

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

extend(c, x)[source]#

Add additional breakpoints and coefficients to the polynomial.

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