lagrange_polynomial#

This module contains the LagrangePolynomial class.

The LagrangePolynomial class is a concrete implementation of the abstract base class MultivariatePolynomialSingleABC for polynomials in the Lagrange basis.

Background information#

The relevant section of the documentation on Lagrange basis contains a more detailed explanation regarding the polynomials in the Lagrange form.

Implementation details#

LagrangePolynomial is currently designed to be a bare concrete implementation of the abstract base class MultivariatePolynomialSingleABC. In other words, most (if not all) concrete implementation of the abstract methods are left undefined and will raise an exception when called or invoked.

LagrangePolynomial serves as an entry point to Minterpy polynomials especially in the context of function approximations because the intuitiveness of the corresponding coefficients (i.e., they are the function values at the grid points). However, the polynomial itself is not fully featured (e.g., no addition, multiplication, etc.) as compared to polynomials in the other basis.

class minterpy.polynomials.lagrange_polynomial.LagrangePolynomial(multi_index, coeffs=None, grid=None, domain=None)[source]#

Bases: MultivariatePolynomialSingleABC

Concrete implementation of polynomials in the Lagrange basis.

A polynomial in the Lagrange basis is the sum of so-called Lagrange polynomials, each of which is multiplied with a coefficient.

The value a single Lagrange monomial is per definition \(1\) at one of the grid points and \(0\) on all the other points.

Notes

The Lagrange polynomials commonly appear in the Wikipedia article is in Minterpy considered the “monomial”. In other words, a polynomial in the Lagrange basis is the sum of Lagrange monomials each of which is multiplied with a coefficient.
A polynomial in the Lagrange basis may also be defined also for multi-indices of exponents which are not downward-closed. In such cases, the corresponding Lagrange monomials also form a basis. These mononomials still possess their special property of being \(1\) at a single grid point and \(0\) at all the other points, with respect to the given grid.

Properties

`coeffs`	The coefficients of the polynomial(s).
`domain`	The domain associated with the Grid of the polynomial(s).
`grid`	The underlying grid of the polynomial(s).
`num_active_monomials`	The number of active monomials of the polynomial(s).
`spatial_dimension`	The spatial dimension of the polynomial(s).
`unisolvent_nodes`	Unisolvent nodes on which the interpolating polynomial lives.

Methods

`add_points`(exponents)	Extend `grid` and `multi_index`
`diff`(order, **kwargs)	Return the partial derivative poly.
`eval_on_internal`(xx, *[, truncate_cols])	Evaluate polynomial at points in the internal domain.
`expand_dim`(target_dimension)	Expand the spatial dimension of the polynomial instance.
`from_degree`(spatial_dimension, poly_degree, ...)	Create a polynomial from polynomial degree specifications.
`from_grid`(grid[, coeffs])	Create an instance of polynomial with a Grid instance.
`from_poly`(polynomial[, new_coeffs])	Create a new polynomial instance based on an existing polynomial.
`integrate_over`([bounds])	Compute the definite integral of the polynomial over the bounds.
`make_complete`()	returns a possibly new polynomial instance with a complete multi index set.
`partial_diff`(dim[, order])	Differentiate the polynomial with respect to a given dimension.

Parameters:

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

static _eval(*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 _add(*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 _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(*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 _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 in the Lagrange basis with a real scalar.

This is the concrete implementation of _scalar_add method in the MultivariatePolynomialSingleABC for handling expressions like poly + x, where x is a real scalar number and poly is an instance of LagrangePolynomial.

Parameters:

poly (LagrangePolynomial) – A polynomial instance in the Lagrange basis to be added with a scalar.
scalar (SCALAR) – The real scalar number to be added to the polynomial instance.

Returns:

The summed polynomial in the Lagrange basis; the polynomial is a new instance.

Return type:

LagrangePolynomial

static _diff(*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 _integrate_over(poly, bounds)#

Compute the definite integral of a polynomial in the Lagrange basis.

Parameters:

poly (LagrangePolynomial) – The polynomial of which the integration is carried out.
bounds (numpy.ndarray) – The bounds (lower and upper) of the definite integration, an (M, 2) array, where M is the number of spatial dimensions.

Returns:

The integral value of the polynomial over the given domain.

Return type:

numpy.ndarray

__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:

numpy.ndarray

__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:

MultivariatePolynomialSingleABC

_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:

MultivariatePolynomialSingleABC

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:

numpy.ndarray

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:

MultivariatePolynomialSingleABC

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:

MultivariatePolynomialSingleABC

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:

MultivariatePolynomialSingleABC

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:

MultivariatePolynomialSingleABC

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.