cupyx.scipy.interpolate.CubicSpline#
- class cupyx.scipy.interpolate.CubicSpline(x, y, axis=0, bc_type='not-a-knot', extrapolate=None)[source]#
Cubic spline data interpolator.
Interpolate data with a piecewise cubic polynomial which is twice continuously differentiable. The result is represented as a PPoly instance with breakpoints matching the given data.
- Parameters:
x (array_like, shape (n,)) – 1-D array containing values of the independent variable. Values must be real, finite and in strictly increasing order.
y (array_like, shape (n,)) – Array containing values of the dependent variable. It can have arbitrary number of dimensions, but the length along
axis
(see below) must match the length ofx
. Values must be finite.axis (int, optional) – Axis along which y is assumed to be varying. Meaning that for
x[i]
the corresponding values arenp.take(y, i, axis=axis)
. Default is 0.bc_type (string or 2-tuple, optional) –
Boundary condition type. Two additional equations, given by the boundary conditions, are required to determine all coefficients of polynomials on each segment.
If bc_type is a string, then the specified condition will be applied at both ends of a spline. Available conditions are:
’not-a-knot’ (default): The first and second segment at a curve end are the same polynomial. It is a good default when there is no information on boundary conditions.
’periodic’: The interpolated functions is assumed to be periodic of period
x[-1] - x[0]
. The first and last value of y must be identical:y[0] == y[-1]
. This boundary condition will result iny'[0] == y'[-1]
andy''[0] == y''[-1]
.’clamped’: The first derivative at curves ends are zero. Assuming a 1D y,
bc_type=((1, 0.0), (1, 0.0))
is the same condition.’natural’: The second derivative at curve ends are zero. Assuming a 1D y,
bc_type=((2, 0.0), (2, 0.0))
is the same condition.
If bc_type is a 2-tuple, the first and the second value will be applied at the curve start and end respectively. The tuple values can be one of the previously mentioned strings (except ‘periodic’) or a tuple (order, deriv_values) allowing to specify arbitrary derivatives at curve ends:
order
: the derivative order, 1 or 2.deriv_value
: array_like containing derivative values, shape must be the same as y, excludingaxis
dimension. For example, if y is 1-D, then deriv_value must be a scalar. If y is 3-D with the shape (n0, n1, n2) and axis=2, then deriv_value must be 2-D and have the shape (n0, n1).
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),
extrapolate
is set to ‘periodic’ forbc_type='periodic'
and to True otherwise.
- Variables:
x (ndarray, shape (n,)) – Breakpoints. The same
x
which was passed to the constructor.c (ndarray, shape (4, n-1, ...)) – Coefficients of the polynomials on each segment. The trailing dimensions match the dimensions of y, excluding
axis
. For example, if y is 1-d, thenc[k, i]
is a coefficient for(x-x[i])**(3-k)
on the segment betweenx[i]
andx[i+1]
.axis (int) – Interpolation axis. The same axis which was passed to the constructor.
See also
Notes
Parameters bc_type and
extrapolate
work independently, i.e. the former controls only construction of a spline, and the latter only evaluation.When a boundary condition is ‘not-a-knot’ and n = 2, it is replaced by a condition that the first derivative is equal to the linear interpolant slope. When both boundary conditions are ‘not-a-knot’ and n = 3, the solution is sought as a parabola passing through given points.
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:
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
andx
must be arrays of the correct shape and type. Thec
array can only be of dtypes float and complex, andx
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:
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)[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:
- 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:
See also
- 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:
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#