Classe « NdPPoly »

Informations générales

Héritage

builtins.object
    NdPPoly

Définition

class NdPPoly(builtins.object):

help(NdPPoly)

Piecewise tensor product polynomial

The value at point ``xp = (x', y', z', ...)`` is evaluated by first
computing the interval indices `i` such that::

    x[0][i[0]] <= x' < x[0][i[0]+1]
    x[1][i[1]] <= y' < x[1][i[1]+1]
    ...

and then computing::

    S = sum(c[k0-m0-1,...,kn-mn-1,i[0],...,i[n]]
            * (xp[0] - x[0][i[0]])**m0
            * ...
            * (xp[n] - x[n][i[n]])**mn
            for m0 in range(k[0]+1)
            ...
            for mn in range(k[n]+1))

where ``k[j]`` is the degree of the polynomial in dimension j. This
representation is the piecewise multivariate power basis.

Parameters
----------
c : ndarray, shape (k0, ..., kn, m0, ..., mn, ...)
    Polynomial coefficients, with polynomial order `kj` and
    `mj+1` intervals for each dimension `j`.
x : ndim-tuple of ndarrays, shapes (mj+1,)
    Polynomial breakpoints for each dimension. These must be
    sorted in increasing order.
extrapolate : bool, optional
    Whether to extrapolate to out-of-bounds points based on first
    and last intervals, or to return NaNs. Default: True.

Attributes
----------
x : tuple of ndarrays
    Breakpoints.
c : ndarray
    Coefficients of the polynomials.

Methods
-------
__call__
derivative
antiderivative
integrate
integrate_1d
construct_fast

See also
--------
PPoly : piecewise polynomials in 1D

Notes
-----
High-order polynomials in the power basis can be numerically
unstable.

Constructeur(s)

Signature du constructeur	Description
__init__(self, c, x, extrapolate=None)

Liste des opérateurs

Opérateurs hérités de la classe object

__eq__, __ge__, __gt__, __le__, __lt__, __ne__

Liste des méthodes

Toutes les méthodes Méthodes d'instance Méthodes statiques

Signature de la méthode	Description
__call__(self, x, nu=None, extrapolate=None)
antiderivative(self, nu)
construct_fast(c, x, extrapolate=None)
derivative(self, nu)
integrate(self, ranges, extrapolate=None)
integrate_1d(self, a, b, axis, extrapolate=None)