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

# PPoly

class scipy.interpolate.PPoly(c, x, extrapolate=None, axis=0)

  Piecewise polynomial in the power basis.

  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+1, m, …)

      Polynomial coefficients, degree k and m intervals.

    x ndarray, shape (m+1,)

      Polynomial breakpoints. Must be sorted in either increasing or decreasing order.

    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 True. See Out-of-bounds behavior.

    axis int, optional

      Interpolation axis. Default is zero.

  Attributes:
    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.

  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.
  `extend`(c, x) | Add additional breakpoints and coefficients to the polynomial.
  `from_spline`(tck[, extrapolate]) | Construct a piecewise polynomial from a spline
  `from_bernstein_basis`(bp[, extrapolate]) | Construct a piecewise polynomial in the power basis from a polynomial in Bernstein basis.
  `construct_fast`(c, x[, extrapolate, axis]) | Construct the piecewise polynomial without making checks.

  See also

  `BPoly`

    piecewise polynomials in the Bernstein basis

  Notes

  High-order polynomials in the power basis can be numerically unstable. Precision problems can start to appear for orders larger than 20-30.

  Array API Standard Support

  `PPoly` 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 | ⚠️ no JIT | ⛔
  Dask | ⛔ | n/a

  The methods `solve` and `roots` are currently not supported with CuPy. `solve` and `roots` with `c.ndim > 2` are currently only supported with NumPy.

  If a ppoly object is called on an input array `x` with namespace different from the namespace `xp` of the breakpoints and coefficients with which the ppoly object was instantiated, an attempt will be made to coerce `x` to the `xp` namespace. If the conversion succeeds, the output will be an array from the `xp` namespace. Mixing namespaces in this way is not recommended.

  See Support for the array API standard for more information.