newton_polynomial#

Notes

Algorithm:

The Newton basis is in general not closed under addition because Newton monomials depend on the underlying grid’s generating points. When grids differ, the monomials differ, requiring transformation through the Lagrange basis:

Evaluate both Newton polynomials at the union grid’s unisolvent nodes to obtain Lagrange coefficients
Sum the Lagrange coefficients
Transform back to Newton coefficients on the union grid

Special cases (monomials addition used instead):

Compatible grids: If both operand grids are compatible with the result grid, their Newton monomials are identical, allowing direct coefficient addition.
Scalar operand: If one operand is a constant (multi-index set contains only \((0, \ldots, 0)\)), it can be added directly regardless of grid compatibility.

Preconditions:

This function assumes the caller has verified: both polynomials are in the Newton basis, both are initialized, their domains match, and they have the same number of polynomial instances.
The provided multi_index may differ from grid.multi_index when the polynomial multi-index set is a subset of the grid multi-index set (i.e., separated indices). The coefficients are computed with respect to the provided multi_index.

static _sub(*args, **kwargs)#

A placeholder function to indicate a feature that is not supported.

Warning

This feature is not implemented yet!

Raises:: NotImplementedError – Any time this function or method is called.
Return type:: None

static _mul(poly_1, poly_2, multi_index, grid)#

Multiply instances of polynomials in the Newton basis.

This is the concrete implementation of _mul() method in the MultivariatePolynomialSingleABC abstract class specifically for polynomials in the Newton basis.

Parameters:

poly_1 (NewtonPolynomial) – Left operand of the multiplication.
poly_2 (NewtonPolynomial) – Right operand of the multiplication.
multi_index (MultiIndexSet) – The multi-index set of the resulting polynomial, i.e., the product of the multi-index sets of the operands.
grid (Grid) – The grid of the resulting polynomial, i.e., the product of the grids of the two operands.

Returns:

The product of two polynomials in the Newton basis as a new instance of polynomial.

Return type:

Notes

Algorithm:

The Newton basis is in general not closed under multiplication because the product of Newton monomials does not result in a Newton monomial of a higher degree (unlike canonical basis). The coefficients of a polynomial product requires transformation through the Lagrange basis:

Evaluate both Newton polynomials at the product grid’s unisolvent nodes to obtain Lagrange coefficients
Multiply the Lagrange coefficients
Transform back to Newton coefficients on the product grid

Special cases (monomials addition used instead):

Scalar polynomial with scalar grid: If one operand is a constant polynomial (multi-index contains only \((0, \ldots, 0)\)) and its grid’s multi-index is also scalar, direct coefficient multiplication is used.
Scalar polynomial with compatible non-scalar grid: If one operand is a constant polynomial but its grid’s multi-index is non-scalar, direct coefficient multiplication is used only if the grid is compatible with the product grid.

Preconditions:

This function assumes the caller has verified: both polynomials are in the Newton basis, both are initialized, their domains match, and they have the same number of polynomial instances.
The provided multi_index may differ from grid.multi_index when the polynomial multi-index set is a subset of the grid multi-index set (i.e., separated indices). The coefficients are computed with respect to the provided multi_index.

static _div(*args, **kwargs)#

A placeholder function to indicate a feature that is not supported.

Warning

This feature is not implemented yet!

Raises:: NotImplementedError – Any time this function or method is called.
Return type:: None

static _pow(*args, **kwargs)#

A placeholder function to indicate a feature that is not supported.

Warning

This feature is not implemented yet!

Raises:: NotImplementedError – Any time this function or method is called.
Return type:: None

static _scalar_add(poly, scalar)#

Add an instance of polynomial with a real scalar based on the monomial.

Monomial-based scalar addition add the scalar to the polynomial coefficient that corresponds to the multi-index set element of \((0, \ldots, 0)\) (if exists). If the element does not exist, meaning that the polynomial does not have a constant term, then the multi-index set is extended.

Parameters:

poly (MultivariatePolynomialSingleABC) – A polynomial instance to be added with a scalar.
scalar (SCALAR) – The real scalar number to be added to the polynomial instance.

Returns:

The summed polynomial; the polynomial is a new instance.

Return type:

Notes

Currently NewtonPolynomial, CanonicalPolynomial, and ChebyshevPolynomial follow monomial-based scalar addition, while LagrangePolynomial does not. For the latter, because the coefficients are function values, adding scalar will add to all coefficients.

static _diff(poly, order, diff_factor, *, backend='numba')#

Differentiate polynomial(s) in the Newton basis of specified orders of derivatives along each dimension.

The orders must be specified for each dimension. This is a wrapper for the differentiation function in the Newton basis.

Parameters:

poly (NewtonPolynomial) – The instance of polynomial in Newton form to differentiate.
order (numpy.ndarray) – A one-dimensional integer array specifying the orders of derivative along each dimension. The length of the array must be m where m is the spatial dimension of the polynomial.
backend (str) –
Computational backend to carry out the differentiation. Supported values are:
- "numpy": implementation based on NumPy; not performant, only applicable for a very small problem size (small degree, low dimension).
- "numba" (default): implementation based on compiled code with the help of Numba; for up to moderate problem size.
- "numba-par": parallelized (CPU) implementation based compiled code with the help of Numba for relatively large problem sizes.
diff_factor (float)

Returns:

A new instance of NewtonPolynomial that represents the partial derivative of the original polynomial of the given order of derivative with respect to the specified dimension.

Return type:

Notes

The abstract class is responsible to validate order; no additional validation regarding that parameter is required here.
The transformation of computed Lagrange coefficients of the differentiated polynomial to the Newton coefficients is carried out using multivariate divided-difference scheme (DDS).

See also

NewtonPolynomial.diff: The public method to differentiate the polynomial instance of the given orders of derivative along each dimension.
NewtonPolynomial.partial_diff: The public method to differentiate the polynomial instance of a specified order of derivative with respect to a given dimension.

static _integrate_over(poly, bounds)#

Compute the definite integral of polynomial(s) in the Newton basis.

Parameters:

poly (NewtonPolynomial) – The polynomial of which the integration is carried out.
bounds (numpy.ndarray) – The bounds (lower and upper, respectively) of the definite integration, specified as an (M,2) array, where M is the spatial dimension of the polynomial.

Returns:

The integral value of the polynomial over the given domain.

Return type:

__add__(other)#

Add the polynomial(s) with another polynomial(s) or a real scalar.

This function is called when:

two polynomials are added: P1 + P2, where P1 (i.e., self) and P2 (other) are both instances of a concrete polynomial class.
a polynomial is added with a real scalar number: P1 + a, where a (other) is a real scalar number.

Polynomials are closed under scalar addition, meaning that the result of the addition is also a polynomial with the same underlying multi-index set; only the coefficients are altered.

Parameters:: other (Union[MultivariatePolynomialSingleABC, SCALAR]) – The right operand, either an instance of polynomial (of the same concrete class as the left operand) or a real scalar number.
Returns:: The result of the addition, an instance of summed polynomial.
Return type:: MultivariatePolynomialSingleABC

Notes

The concrete implementation of polynomial-polynomial and polynomial- scalar addition is delegated to the respective polynomial concrete class.

__call__(xx, *, truncate_cols=False, **kwargs)#

Evaluate the polynomial on a set of query points.

The function is called when an instance of a polynomial is called with a set of query points, i.e., \(p(\mathbf{X})\) where \(\mathbf{X}\) is a matrix of values with \(k\) rows and each row is of length \(m\) (i.e., a point in \(m\)-dimensional space).

Parameters:

xx (array_like) – Query points to evaluate. Can be a scalar, list, or numpy array. The points will be standardized to a two-dimensional array of shape (k, m) where k is the number of query points and m is the spatial dimension of the polynomial.
truncate_cols (bool, optional) – If True, then the last columns of xx are truncated to match the spatial dimension of the polynomial; otherwise all provided columns are attempted to be evaluated. The default is False.
**kwargs – Additional keyword-only arguments that change the behavior of the underlying evaluation (see the concrete implementation).

Returns:

The values of the polynomial evaluated at query points.

Return type:

__copy__()#

Creates of a shallow copy.

This function is called, if one uses the top-level function copy() on an instance of this class.

Returns:: The copy of the current instance.
Return type:: MultivariatePolynomialSingleABC

See also

copy.copy: copy operator form the python standard library.

__deepcopy__(mem)#

Creates of a deepcopy.

This function is called, if one uses the top-level function deepcopy() on an instance of this class.

Returns:: The deepcopy of the current instance.
Return type:: MultivariatePolynomialSingleABC

See also

copy.deepcopy: copy operator form the python standard library.

__eq__(other)#

Compare two concrete polynomial instances for exact equality.

Two polynomial instances are equal if and only if:

both are of the same concrete class, and
the underlying multi-index sets are equal, and
the underlying grid instances are equal (including the underlying domains and multi-index sets), and
the coefficients of the polynomials are equal.

Parameters:: other (MultivariatePolynomialSingleABC) – Another instance of concrete implementation of MultivariatePolynomialSingleABC to compare with
Returns:: True if the current instance is equal to the other instance, False otherwise.
Return type:: bool

__floordiv__(other)#

Divide an instance of polynomial with a real scalar number (//).

Parameters:: other (Union[MultivariatePolynomialSingleABC, SCALAR]) – The right operand of the (floor) division expression, a real scalar number.
Returns:: An instance of polynomial, the result of (floor) scalar division of a polynomial.
Return type:: MultivariatePolynomialSingleABC

__hash__ = None#

__init__(multi_index, coeffs=None, grid=None, domain=None)#

Parameters:

multi_index (MultiIndexSet | ndarray)
coeffs (ndarray | None)
grid (Grid | None)
domain (Domain | None)

__len__()#

Return the number of polynomials in the instance.

Returns:: The number of polynomials in the instance. A single instance of polynomial may contain multiple polynomials with different coefficient values but sharing the same underlying multi-index set and grid.
Return type:: int

__mul__(other)#

Multiply the polynomial(s) with another polynomial or a real scalar.

This function is called when:

two polynomials are multiplied: P1 * P2, where P1 and P2 are both instances of a concrete polynomial class.
a polynomial is multiplied with a real scalar number: P1 * a, where a is a real scalar number.

Polynomials are closed under scalar multiplication, meaning that the result of the multiplication is also a polynomial with the same underlying multi-index set; only the coefficients are altered.

Parameters:: other (Union[MultivariatePolynomialSingleABC, SCALAR]) – The right operand, either an instance of polynomial (of the same concrete class as the right operand) or a real scalar number.
Returns:: The result of the multiplication, an instance of multiplied polynomial.
Return type:: MultivariatePolynomialSingleABC

Notes

The concrete implementation of polynomial-polynomial multiplication is delegated to the respective polynomial concrete class.

__neg__()#

Negate the polynomial(s) instance.

This function is called when a polynomial is negated via the - operator, e.g., -P.

Returns:: New polynomial(s) instance with negated coefficients.
Return type:: MultivariatePolynomialSingleABC

Notes

The resulting polynomial is a deep copy of the original polynomial.
-P is not the same as -1 * P, the latter of which is a scalar multiplication. In this case, however, the result is the same; it returns a new instance with negated coefficients.

__pos__()#

Plus sign the polynomial(s) instance.

This function is called when a polynomial is plus signed via the + operator, e.g., +P.

Returns:: The same polynomial
Return type:: MultivariatePolynomialSingleABC

Notes

+P is not the same as 1 * P, the latter of which is a scalar multiplication. In this case, the result actually differs because the scalar multiplication 1 * P returns a new instance of polynomial even though the coefficients are not altered.

__pow__(power)#

Take the polynomial instance to the given power.

Parameters:: power (int) – The power in the exponentiation expression; the value must be a non-negative real scalar whole number. The value may not strictly be an integer as long as it is a whole number (e.g., \(2.0\) is acceptable).
Returns:: The result of exponentiation, an instance of a concrete polynomial class.
Return type:: MultivariatePolynomialSingleABC

Notes

Exponentiation by zero returns a constant polynomial whose coefficients are zero except for the constant term with respect to the multi-index set which is given a value of \(1.0\). In the case of polynomials in the Lagrange basis whose no constant term with respect to the multi-index set, all coefficients are set to \(1.0\).

__radd__(other)#

Right-sided addition of the polynomial(s) with a real scalar number.

This function is called for the expression a + P where a and P is a real scalar number and an instance of polynomial, respectively.

Parameters:: other (SCALAR) – A real scalar number (the left operand) to be added to the polynomial.
Returns:: The result of adding the scalar value to the polynomial.
Return type:: MultivariatePolynomialSingleABC

Notes

If the left operand is not a real scalar number, the right-sided addition is not explicitly supported, and it will rely on the __add__() method of the left operand.

__rmul__(other)#

Right sided multiplication of the polynomial(s) with a real scalar.

This function is called if a real scalar number is multiplied with a polynomial like a * P where a and P are a scalar and a polynomial instance, respectively.

Parameters:: other (SCALAR) – The left operand, a real scalar number.
Returns:: The result of the multiplication, an instance of multiplied polynomial.
Return type:: MultivariatePolynomialSingleABC

__rsub__(other)#

Right-sided subtraction of the polynomial(s) with a real scalar.

This function is called for the expression a - P where a and P is a real scalar number and an instance of polynomial, respectively.

Parameters:: other (SCALAR) – A real scalar number (the left operand) to be substracted by the polynomial.
Returns:: The result of subtracting a scalar value by the polynomial.
Return type:: MultivariatePolynomialSingleABC

Notes

If the left operand is not a real scalar number, the right-sided subtraction is not explicitly supported, and it will rely on the __add__() method of the left operand.
This operation relies on the negation of a polynomial and scalar addition

__sub__(other)#

Subtract the polynomial(s) with another poly. or a real scalar.

This function is called when:

two polynomials are subtracted: P1 - P2, where P1 and P2 are both instances of a concrete polynomial class.
a polynomial is added with a real scalar number: P1 - a, where a is a real scalar number.

Polynomials are closed under scalar subtraction, meaning that the result of the subtraction is also a polynomial with the same underlying multi-index set; only the coefficients are altered.

Parameters:: other (Union[MultivariatePolynomialSingleABC, SCALAR]) – The right operand, either an instance of polynomial (of the same concrete class as the right operand) or a real scalar number.
Returns:: The result of the subtraction, an instance of subtracted polynomial.
Return type:: MultivariatePolynomialSingleABC

Notes

Under the hood subtraction is an addition operation with a negated operand on the right; no separate concrete implementation is used.

__truediv__(other)#

Divide an instance of polynomial with a real scalar number (/).

Parameters:: other (Union[MultivariatePolynomialSingleABC, SCALAR]) – The right operand of the (true) division expression, a real scalar number.
Returns:: An instance of polynomial, the result of (true) scalar division of a polynomial.
Return type:: MultivariatePolynomialSingleABC

__weakref__#: list of weak references to the object (if defined)

_new_instance_if_necessary(new_grid, new_indices=None)#

Constructs a new instance only if the multi indices have changed.

Parameters:

new_grid (Grid) – Grid instance the polynomial is defined on.
new_indices (MultiIndexSet, optional) – MultiIndexSet instance for the polynomial(s), needs to be a subset of the current multi_index. Default is None.

Returns:

Same polynomial instance if grid and multi_index stay the same, otherwise new polynomial instance with the new grid and multi_index.

Return type:

_verify_operands(other)#

Verify the operands are valid before moving on.

Parameters:: other (MultivariatePolynomialSingleABC)
Return type:: Tuple[MultivariatePolynomialSingleABC, MultivariatePolynomialSingleABC]

add_points(exponents)#

Extend grid and multi_index

Adds points grid and exponents to multi_index related to a given set of additional exponents.

Parameters:: exponents (np.ndarray) – Array of exponents added.
Returns:: New polynomial with the added exponents.
Return type:: MultivariatePolynomialSingleABC

property coeffs: ndarray#

The coefficients of the polynomial(s).

Returns:: One- or two-dimensional array that contains the polynomial coefficients. Coefficients of multiple polynomials having common structure are stored in a two-dimensional array of shape (N, P) where N is the number of monomials and P is the number of polynomials.
Return type:: numpy.ndarray
Raises:: ValueError – If the coefficients of an uninitialized polynomial are accessed.

Notes

coeffs may be assigned with None to indicate an uninitialized
polynomial. Accessing such coefficients, however, raises an exception. Many operations involving polynomial instances, require the instance to be initialized and raising the exception here provides a common single point of failure.

diff(order, **kwargs)#

Return the partial derivative poly. of given orders along each dim.

Parameters:

order (numpy.ndarray) – A one-dimensional integer array specifying the orders of derivative along each dimension. The length of the array must be m where m is the spatial dimension of the polynomial.
**kwargs – Additional keyword-only arguments that change the behavior of the underlying differentiation (see the respective concrete implementations).

Returns:

A new polynomial instance that represents the partial derivative of the original polynomial of the specified orders of derivative along each dimension.

Return type:

Notes

This method calls the concrete implementation of the abstract method _diff() after input validation.
For zero-order derivative (identity operation), returns a copy of the polynomial.

See also

_diff: The underlying static method to differentiate the polynomial of specified orders of derivative along each dimension.

property domain: Domain#

The domain associated with the Grid of the polynomial(s).

The domain represents the rectangular bounds of the Grid.

Returns:: The domain of the interpolation grid.
Return type:: Domain

eval_on_internal(xx, *, truncate_cols=False, **kwargs)#

Evaluate polynomial at points in the internal domain.

This method evaluates the polynomial at points assumed to already be in the internal domain used by the polynomial’s algorithms. It skips coordinate transformation to avoid unnecessary floating-point error accumulation.

Parameters:

xx (numpy.ndarray) – Query points in the internal domain. It should be a two-dimensional array of shape (k, m) where k is the number of query points and m is the spatial dimension.
truncate_cols (bool, optional) – If True, then the last columns of xx are truncated to match the spatial dimension of the polynomial; otherwise all provided columns are attempted to be evaluated. The default is False.
**kwargs – Additional keyword-only arguments passed to the underlying evaluation method (see concrete implementation).

Returns:

The values of the polynomial evaluated at query points.

If there is only a single polynomial (i.e., a single set of coefficients), then a one-dimensional array of length k is returned.
If there are multiple polynomials (i.e., multiple sets of coefficients), then a two-dimensional array of shape (k, np) is returned where np is the number of coefficient sets.

Return type:

Notes

Use this method when: (1) Points are already in the internal domain (e.g., unisolvent nodes) (2) Avoiding unnecessary coordinate transformations that incur floating-point errors.
Coordinate transformations are not free numerically. While they are affine, round-trip transformations over many interation may accumulate floating-point errors.

Notes

The function calls the concrete implementation of the static method _eval().

See also

_eval: The underlying static method to evaluate the polynomial(s) instance on a set of query points.

expand_dim(target_dimension)#

Expand the spatial dimension of the polynomial instance.

Parameters:: target_dimension (int) – The new spatial dimension. It must be larger than or equal to the current spatial dimension of the polynomial.
Returns:: The new instance of polynomial with expanded dimension.
Return type:: MultivariatePolynomialSingleABC

classmethod from_degree(spatial_dimension, poly_degree, lp_degree, coeffs=None, grid=None, domain=None)#

Create a polynomial from polynomial degree specifications.

This factory method constructs a polynomial with a complete multi-index set \(\mathcal{M}_{m, n, p}\) defined by the spatial dimension \(m\), polynomial degree \(n\), and \(l_p\) degree \(p\).

Parameters:

spatial_dimension (int) – Spatial dimension of the multi-index set (\(m\)); the value of spatial_dimension must be a positive integer (\(m > 0\)).
poly_degree (int) – Polynomial degree of the multi-index set (\(n\)); the value of poly_degree must be a non-negative integer (\(n \geq 0\)).
lp_degree (float) – \(p\) of the \(l_p\)-norm (i.e., the \(l_p\)-degree) that is used to define the multi-index set. The value of lp_degree must be a positive float (\(p > 0\)).
coeffs (np.ndarray, optional) – Coefficients of the polynomial. If None, the polynomial is uninitialized. Either one-dimensional array of length equal to the number of monomials, or two-dimensional array of shape (num_monomials, num_polynomials) for multiple polynomials sharing the same multi-index set.
grid (Grid, optional) – The underlying grid on which the polynomial is defined. If not given, a default Grid instance will be constructed.
domain (Domain, optional) – The domain of the underlying grid. If not given, the domain will be derived from the Grid instance (either provided or constructed).

Returns:

A new polynomial instance with the specified parameters of the complete multi-index set.

Return type:

classmethod from_grid(grid, coeffs=None)#

Create an instance of polynomial with a Grid instance.

Parameters:

grid (Grid) – The grid on which the polynomial is defined.
coeffs (numpy.ndarray, optional) – The coefficients of the polynomial(s); a one-dimensional array with the same length as the length of the multi-index set or a two-dimensional array with each column corresponds to the coefficients of a single polynomial on the same grid. This parameter is optional, if not specified the polynomial is considered “uninitialized”.

Returns:

An instance of polynomial defined on the given grid.

Return type:

classmethod from_poly(polynomial, new_coeffs=None)#

Create a new polynomial instance based on an existing polynomial.

This factory method constructs a new polynomial by copying the structure (multi-index set, grid) from an existing polynomial, optionally with new coefficients. Useful for converting between polynomial types or creating polynomials with the same structure but different coefficients.

Parameters:

polynomial (MultivariatePolynomialSingleABC) – Input polynomial instance defining the properties to be reused (multi-index set and grid).
new_coeffs (np.ndarray, optional) – The coefficients the new polynomial should have. If None, uses a copy of polynomial.coeffs.

Returns:

A new polynomial instance with the same structure as the input polynomial.

Return type:

Notes

The coefficients can also be assigned later if the polynomial is created uninitialized.

property grid: Grid#

The underlying grid of the polynomial(s).

Returns:: The underlying grid of the polynomial(s). Interpolating polynomials live on a Grid.
Return type:: Grid

integrate_over(bounds=None, **kwargs)#

Compute the definite integral of the polynomial over the bounds.

Parameters:

bounds (np.ndarray, optional) – The integral bounds or the limits of integration, an array of shape (m, 2) where m is the number of spatial dimensions. Each row corresponds to the limits [lower, upper] for a given dimension. If not given, the integral is computed over the entire domain (i.e., self.domain.bounds).
**kwargs – Additional keyword-only arguments that change the behavior of the underlying integration (see the respective concrete implementations).

Returns:

The integral value of the polynomial over the given bounds. If only one polynomial is available, a single value of float type is returned. For multiple polynomials, an array of values is returned.

Return type:

Union[float, numpy.ndarray]

Raises:

ValueError – If the bounds are of inconsistent shape.

Notes

Bounds are specified in the user domain. Internally, they are transformed to the internal domain.
The concrete implementation of the abstract method _integrate_over() assumes the domain is internal.
Integration outside the domain bounds is allowed but involves extrapolation.

See also

_integrate_over: The underlying static method to integrate the polynomial instance over the given bounds.

make_complete()#

returns a possibly new polynomial instance with a complete multi index set.

Returns:: completed polynomial, where additional coefficients setted to zero.
Return type:: MultivariatePolynomialSingleABC

Notes

the active monomials stay equal. only the grid (“basis”) changes
in the case of a Lagrange polynomial this could be done by evaluating the polynomial on the complete grid

property num_active_monomials: int#

The number of active monomials of the polynomial(s).

The multi-index set that directly defines a polynomial and the grid (where the polynomial lives) may differ. Active monomials are the monomials that are defined by the multi-index set not by the one in the grid.

Returns:: The number of active monomials.
Return type:: int

partial_diff(dim, order=1, **kwargs)#

Differentiate the polynomial with respect to a given dimension.

Parameters:

dim (int) – Spatial dimension with respect to which the differentiation is taken. The dimension starts at 0 (i.e., the first dimension).
order (int) – Order of partial derivative; the default is 1.
**kwargs – Additional keyword-only arguments that change the behavior of the underlying differentiation (see the respective concrete implementations).

Returns:

A new polynomial instance that represents the partial derivative of the original polynomial of the specified order of derivative and with respect to the specified dimension.

Return type:

Notes

This method is a syntactic sugar to diff() to differentiate with respect to a particular dimension.

property spatial_dimension: int#

The spatial dimension of the polynomial(s).

Returns:: The spatial dimension of the polynomial(s). This dimension may be less than the spatial dimension of the underlying grid.
Return type:: int

Notes

The value is propagated from the underlying multi_index.

property unisolvent_nodes: ndarray#

Unisolvent nodes on which the interpolating polynomial lives.

Returns:: A two-dimensional array of shape (N, m) where N is the number of the multi-index set exponents and m is the spatial dimension.
Return type:: np.ndarray

Notes

The value is propagated from the underlying grid.

minterpy.polynomials.newton_polynomial.eval_newton(poly, xx)[source]#

Evaluate polynomial(s) in the Newton basis on a set of query points.

This is a wrapper for the evaluation function in the Newton basis.

Parameters:

poly (NewtonPolynomial) – The instance of polynomial in the Newton basis to evaluate.
xx (numpy.ndarray) – Array of query points in the at which the polynomial(s) is evaluated. The array is of shape (N, m) where N is the number of points and m is the spatial dimension of the polynomial.

Return type:

ndarray

See also

minterpy.utils.polynomials.newton.eval_newton_polynomials: The actual implementation of the evaluation of polynomials in the Newton basis.

minterpy.polynomials.newton_polynomial.add_newton(poly_1, poly_2, multi_index, grid)[source]#

Add two instances of polynomials in the Newton basis.

This is the concrete implementation of _add() method in the MultivariatePolynomialSingleABC abstract class specifically for handling polynomials in the Newton basis.

Parameters:

poly_1 (NewtonPolynomial) – Left operand of the addition.
poly_2 (NewtonPolynomial) – Right operand of the addition.
multi_index (MultiIndexSet) – The multi-index set of the resulting polynomial, i.e., the union of the multi-index sets of the operands.
grid (Grid) – The grid of the resulting polynomial, i.e., the union of the grids of the two operands.

Returns:

The sum of two polynomials in the Newton basis as a new instance of polynomial.

Return type:

Notes

Algorithm:

The Newton basis is in general not closed under addition because Newton monomials depend on the underlying grid’s generating points. When grids differ, the monomials differ, requiring transformation through the Lagrange basis:

Evaluate both Newton polynomials at the union grid’s unisolvent nodes to obtain Lagrange coefficients
Sum the Lagrange coefficients
Transform back to Newton coefficients on the union grid

Special cases (monomials addition used instead):

Compatible grids: If both operand grids are compatible with the result grid, their Newton monomials are identical, allowing direct coefficient addition.
Scalar operand: If one operand is a constant (multi-index set contains only \((0, \ldots, 0)\)), it can be added directly regardless of grid compatibility.

Preconditions:

This function assumes the caller has verified: both polynomials are in the Newton basis, both are initialized, their domains match, and they have the same number of polynomial instances.
The provided multi_index may differ from grid.multi_index when the polynomial multi-index set is a subset of the grid multi-index set (i.e., separated indices). The coefficients are computed with respect to the provided multi_index.

minterpy.polynomials.newton_polynomial.mul_newton(poly_1, poly_2, multi_index, grid)[source]#

Multiply instances of polynomials in the Newton basis.

This is the concrete implementation of _mul() method in the MultivariatePolynomialSingleABC abstract class specifically for polynomials in the Newton basis.

Parameters:

poly_1 (NewtonPolynomial) – Left operand of the multiplication.
poly_2 (NewtonPolynomial) – Right operand of the multiplication.
multi_index (MultiIndexSet) – The multi-index set of the resulting polynomial, i.e., the product of the multi-index sets of the operands.
grid (Grid) – The grid of the resulting polynomial, i.e., the product of the grids of the two operands.

Returns:

The product of two polynomials in the Newton basis as a new instance of polynomial.

Return type:

Notes

Algorithm:

The Newton basis is in general not closed under multiplication because the product of Newton monomials does not result in a Newton monomial of a higher degree (unlike canonical basis). The coefficients of a polynomial product requires transformation through the Lagrange basis:

Evaluate both Newton polynomials at the product grid’s unisolvent nodes to obtain Lagrange coefficients
Multiply the Lagrange coefficients
Transform back to Newton coefficients on the product grid

Special cases (monomials addition used instead):

Scalar polynomial with scalar grid: If one operand is a constant polynomial (multi-index contains only \((0, \ldots, 0)\)) and its grid’s multi-index is also scalar, direct coefficient multiplication is used.
Scalar polynomial with compatible non-scalar grid: If one operand is a constant polynomial but its grid’s multi-index is non-scalar, direct coefficient multiplication is used only if the grid is compatible with the product grid.

Preconditions:

This function assumes the caller has verified: both polynomials are in the Newton basis, both are initialized, their domains match, and they have the same number of polynomial instances.
The provided multi_index may differ from grid.multi_index when the polynomial multi-index set is a subset of the grid multi-index set (i.e., separated indices). The coefficients are computed with respect to the provided multi_index.

minterpy.polynomials.newton_polynomial.diff_newton(poly, order, diff_factor, *, backend='numba')[source]#

Differentiate polynomial(s) in the Newton basis of specified orders of derivatives along each dimension.

The orders must be specified for each dimension. This is a wrapper for the differentiation function in the Newton basis.

Parameters:

poly (NewtonPolynomial) – The instance of polynomial in Newton form to differentiate.
order (numpy.ndarray) – A one-dimensional integer array specifying the orders of derivative along each dimension. The length of the array must be m where m is the spatial dimension of the polynomial.
backend (str) –
Computational backend to carry out the differentiation. Supported values are:
- "numpy": implementation based on NumPy; not performant, only applicable for a very small problem size (small degree, low dimension).
- "numba" (default): implementation based on compiled code with the help of Numba; for up to moderate problem size.
- "numba-par": parallelized (CPU) implementation based compiled code with the help of Numba for relatively large problem sizes.
diff_factor (float)

Returns:

A new instance of NewtonPolynomial that represents the partial derivative of the original polynomial of the given order of derivative with respect to the specified dimension.

Return type:

Notes

The abstract class is responsible to validate order; no additional validation regarding that parameter is required here.
The transformation of computed Lagrange coefficients of the differentiated polynomial to the Newton coefficients is carried out using multivariate divided-difference scheme (DDS).

See also

NewtonPolynomial.diff: The public method to differentiate the polynomial instance of the given orders of derivative along each dimension.
NewtonPolynomial.partial_diff: The public method to differentiate the polynomial instance of a specified order of derivative with respect to a given dimension.

minterpy.polynomials.newton_polynomial.integrate_over_newton(poly, bounds)[source]#

Compute the definite integral of polynomial(s) in the Newton basis.

Parameters:

poly (NewtonPolynomial) – The polynomial of which the integration is carried out.
bounds (numpy.ndarray) – The bounds (lower and upper, respectively) of the definite integration, specified as an (M,2) array, where M is the spatial dimension of the polynomial.

Returns:

The integral value of the polynomial over the given domain.

Return type: