multivariate_polynomial_abstract#

This module contains the abstract base classes for all polynomial base classes.

All concrete implementations of polynomial bases must inherit from the abstract base class. This ensures a consistent interface across all polynomials. As a result, additional features can be developed without needing to reference specific polynomial classes, while allowing each concrete class to manage its own implementation details.

See e.g. PEP 3119 for further explanations on the topic.

class minterpy.core.ABC.multivariate_polynomial_abstract.MultivariatePolynomialABC[source]#

the most general abstract base class for multivariate polynomials.

Every data type which needs to behave like abstract polynomial(s) should subclass this class and implement all the abstract methods.

Properties

`coeffs`	Abstract container which stores the coefficients of the polynomial.
`num_active_monomials`	Abstract container for the number of monomials of the polynomial(s).
`spatial_dimension`	Abstract container for the dimension of space where the polynomial(s) live on.
`unisolvent_nodes`	Abstract container for unisolvent nodes the polynomial(s) is(are) defined on.

abstract property coeffs: ndarray#

Abstract container which stores the coefficients of the polynomial.

This is a placeholder of the ABC, which is overwritten by the concrete implementation.

abstract property num_active_monomials#

Abstract container for the number of monomials of the polynomial(s).

Notes

This is a placeholder of the ABC, which is overwritten by the concrete implementation.

abstract property spatial_dimension#

Abstract container for the dimension of space where the polynomial(s) live on.

Notes

This is a placeholder of the ABC, which is overwritten by the concrete implementation.

abstract property unisolvent_nodes#

Abstract container for unisolvent nodes the polynomial(s) is(are) defined on.

Notes

This is a placeholder of the ABC, which is overwritten by the concrete implementation.

abstract static _eval(poly, xx, **kwargs)[source]#

Abstract method to the polynomial evaluation function.

Parameters:

poly (MultivariatePolynomialABC) – A concrete instance of a polynomial class that can be evaluated on a set of query points.
xx (numpy.ndarray) – The set of query points to evaluate as 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.
**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.

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

This is a placeholder of the ABC, which is overwritten by the concrete implementation.

See also

__call__: The dunder method as a syntactic sugar to evaluate the polynomial(s) instance on a set of query points.

__call__(xx, **kwargs)[source]#

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 (numpy.ndarray) – The set of query points to evaluate as 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.
**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.

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

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.

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

class minterpy.core.ABC.multivariate_polynomial_abstract.MultivariatePolynomialSingleABC(multi_index, coeffs=None, internal_domain=None, user_domain=None, grid=None)[source]#

Bases: MultivariatePolynomialABC

abstract base class for “single instance” multivariate polynomials

Parameters:

multi_index (MultiIndexSet | ndarray)
coeffs (ndarray | None)
internal_domain (ndarray | None)
user_domain (ndarray | None)
grid (Grid | None)

multi_index#

The multi-indices of the multivariate polynomial.

Type:: MultiIndexSet

internal_domain#

The domain the polynomial is defined on (basically the domain of the unisolvent nodes). Either one-dimensional domain (min,max), a stack of domains for each domain with shape (spatial_dimension,2).

Type:: array_like

user_domain#

The domain where the polynomial can be evaluated. This will be mapped onto the internal_domain. Either one-dimensional domain min,max) a stack of domains for each domain with shape (spatial_dimension,2).

Type:: array_like

Notes

the grid with the corresponding indices defines the “basis” or polynomial space a polynomial is part of. e.g. also the constraints for a Lagrange polynomial, i.e. on which points they must vanish. ATTENTION: the grid might be defined on other indices than multi_index! e.g. useful for defining Lagrange coefficients with “extra constraints” but all indices from multi_index must be contained in the grid! this corresponds to polynomials with just some of the Lagrange polynomials of the basis being “active”

Properties

`coeffs`	The coefficients of the polynomial(s).
`num_active_monomials`	The number of active monomials of the polynomial(s).
`spatial_dimension`	Spatial dimension.
`unisolvent_nodes`	Unisolvent nodes the polynomial(s) is(are) defined on.

Methods

`add_points`(exponents)	Extend `grid` and `multi_index`
`diff`(order, **kwargs)	Return the partial derivative poly.
`expand_dim`(target_dimension[, ...])	Expand the spatial dimension of the polynomial instance.
`from_degree`(spatial_dimension, poly_degree, ...)	Initialise Polynomial from given coefficients and the default construction for given polynomial degree, spatial dimension and \(l_p\) degree.
`from_grid`(grid[, coeffs, internal_domain, ...])	Create an instance of polynomial with a `Grid` instance.
`from_poly`(polynomial[, new_coeffs])	constructs a new polynomial instance based on the properties of an input polynomial
`generate_internal_domain`(internal_domain, ...)
`generate_user_domain`(user_domain, ...)
`has_matching_dimension`(other)	Return `True` if the polynomials have matching dimensions.
`has_matching_domain`(other[, tol])	Return `True` if the polynomials have matching domains.
`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])	Return the partial derivative poly.

static _gen_grid_default(multi_index)[source]#

Return the default Grid for a given MultiIndexSet instance.

For the default values of the Grid class, see minterpy.Grid.

Parameters:: multi_index (MultiIndexSet) – An instance of MultiIndexSet for which the default Grid shall be build
Returns:: An instance of Grid with the default optional parameters.
Return type:: Grid

abstract static _partial_diff(poly, dim, order, **kwargs)[source]#

Abstract method for differentiating poly. on a given dim. and order.

Parameters:

poly (MultivariatePolynomialABC) – The instance of polynomial to differentiate.
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.
**kwargs – Additional keyword-only arguments that change the behavior of the underlying differentiation (see the concrete implementation).

Returns:

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

Return type:

MultivariatePolynomialSingleABC

Notes

The concrete implementation of this static method is called when the public method partial_diff() is called on an instance.

See also

partial_diff: The public method to differentiate the polynomial of a specified order of derivative with respect to a given dimension.

abstract static _diff(poly, order, **kwargs)[source]#

Abstract method for diff. poly. on given orders w.r.t each dim.

Parameters:

poly (MultivariatePolynomialABC) – The instance of polynomial 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.
**kwargs – Additional keyword-only arguments that change the behavior of the underlying differentiation (see the concrete implementation).

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

The concrete implementation of this static method is called when the public method diff() is called on an instance.

See also

diff: The public method to differentiate the polynomial instance on the given orders of derivative along each dimension.

abstract static _integrate_over(poly, bounds, **kwargs)[source]#

Abstract method for definite integration.

Parameters:

poly (MultivariatePolynomialABC) – The instance of polynomial to integrate.
bounds (Union[List[List[float]], np.ndarray], optional) – The bounds of the integral, an (m, 2) array where m is the number of spatial dimensions. Each row corresponds to the bounds in a given dimension. If not given, then the canonical bounds \([-1, 1]^m\) will be used instead.
**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, the return value is of a float type.

Return type:

Union[float, numpy.ndarray]

Notes

The concrete implementation of this static method is called when the public method integrate_over() is called on an instance.

See also

integrate_over: The public method to integrate the polynomial instance over the given bounds.

__init__(multi_index, coeffs=None, internal_domain=None, user_domain=None, grid=None)[source]#

Parameters:

multi_index (MultiIndexSet | ndarray)
coeffs (ndarray | None)
internal_domain (ndarray | None)
user_domain (ndarray | None)
grid (Grid | None)

classmethod from_degree(spatial_dimension, poly_degree, lp_degree, coeffs=None, internal_domain=None, user_domain=None)[source]#

Initialise Polynomial from given coefficients and the default construction for given polynomial degree, spatial dimension and \(l_p\) degree.

Parameters:

spatial_dimension (int) – Dimension of the domain space of the polynomial.
poly_degree (int) – The degree of the polynomial, i.e. the (integer) supremum of the \(l_p\) norms of the monomials.
lp_degree (int) – The \(l_p\) degree used to determine the polynomial degree.
coeffs (np.ndarray) – coefficients of the polynomial. These shall be 1D for a single polynomial, where the length of the array is the number of monomials given by the multi_index. For a set of similar polynomials (with the same number of monomials) the array can also be 2D, where the first axis refers to the monomials and the second axis refers to the polynomials.
internal_domain (np.ndarray or callable) – the internal domain (factory) where the polynomials are defined on, e.g. \([-1,1]^d\) where \(d\) is the dimension of the domain space. If a callable is passed, it shall get the dimension of the domain space and returns the internal_domain as an np.ndarray.
user_domain (np.ndarray or callable) – the domain window (factory), from which the arguments of a polynomial are transformed to the internal domain. If a callable is passed, it shall get the dimension of the domain space and returns the user_domain as an np.ndarray.

classmethod from_poly(polynomial, new_coeffs=None)[source]#

constructs a new polynomial instance based on the properties of an input polynomial

useful for copying polynomials of other types

Parameters:

polynomial (MultivariatePolynomialSingleABC) – input polynomial instance defining the properties to be reused
new_coeffs (ndarray | None) – the coefficients the new polynomials should have. using polynomial.coeffs if None

Returns:

new polynomial instance with equal properties

Return type:

MultivariatePolynomialSingleABC

Notes

The coefficients can also be assigned later.

classmethod from_grid(grid, coeffs=None, internal_domain=None, user_domain=None)[source]#

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”.
internal_domain (numpy.ndarray, optional) – The internal domain of the polynomial(s).
user_domain (numpy.ndarray, optional) – The user domain of the polynomial(s).

Returns:

An instance of polynomial defined on the given grid.

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.

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

__eq__(other)[source]#

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, 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

__neg__()[source]#

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__()[source]#

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.

__add__(other)[source]#

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 right 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.

__sub__(other)[source]#

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.

__mul__(other)[source]#

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.

__truediv__(other)[source]#

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

__floordiv__(other)[source]#

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

__pow__(power)[source]#

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)[source]#

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.

__rsub__(other)[source]#

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

__rmul__(other)[source]#

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

__copy__()[source]#

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)[source]#

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.

__len__()[source]#

Return the number of polynomials in the instance.

Returns:: The number of polynomial 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

property spatial_dimension#

Spatial dimension.

The dimension of space where the polynomial(s) live on.

Returns:: Dimension of domain space.
Return type:: int

Notes

This is propagated from the multi_index.spatial_dimension.

property unisolvent_nodes#

Unisolvent nodes the polynomial(s) is(are) defined on.

For definitions of unisolvent nodes see the mathematical introduction.

Returns:: Array of unisolvent nodes.
Return type:: np.ndarray

Notes

This is propagated from from self.grid.unisolvent_nodes.

_new_instance_if_necessary(new_grid, new_indices=None)[source]#

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

make_complete()[source]#

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

add_points(exponents)[source]#

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

expand_dim(target_dimension, extra_internal_domain=None, extra_user_domain=None)[source]#

Expand the spatial dimension of the polynomial instance.

Parameters:

target_dimension (Union[int, MultivariatePolynomialSingleABC]) – The new spatial dimension. It must be larger than or equal to the current dimension of the polynomial. Alternatively, another instance of polynomial that has a higher dimension, a consistent underlying Grid instance is consistent, and a matching domain can also be specified as a target dimension.
extra_internal_domain (numpy.ndarray, optional) – The additional internal domains for the expanded polynomial. This parameter is optional; if not specified, the values are either taken from the domain of the higher-dimensional polynomial or from the domain of the other dimensions.
extra_user_domain (numpy.ndarray, optional) – The additional user domains for the expanded polynomial. This parameter is optional; if not specified, the values are either taken from the domain of the higher-dimensional polynomial or from the domain of the other dimensions.

Returns:

A new instance of polynomial whose spatial dimension has been expanded to the target.

Return type:

MultivariatePolynomialSingleABC

Raises:

ValueError – If the target dimension is an int, the exception is raised when the user or internal domains cannot be extrapolated to a higher dimension. If the target dimension is an instance of MultivariatePolynomialSingleABC, the exception is raised when the user or internal domains do no match. In both cases, an exception may also be raised by attempting to expand the dimension of the underlying Grid or MultiIndexSet instances.

partial_diff(dim, order=1, **kwargs)[source]#

Return the partial derivative poly. at the given dim. and order.

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.
**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 calls the concrete implementation of the abstract method _partial_diff() after input validation.

See also

_partial_diff: The underlying static method to differentiate the polynomial instance of a specified order of derivative and with respect to a specified dimension.

diff(order, **kwargs)[source]#

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.

See also

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

integrate_over(bounds=None, **kwargs)[source]#

Compute the definite integral of the polynomial over the bounds.

Parameters:

bounds (Union[List[List[float]], np.ndarray], optional) – The bounds of the integral, an (m, 2) array where m is the number of spatial dimensions. Each row corresponds to the bounds in a given dimension. If not given, then the canonical bounds \([-1, 1]^m\) will be used instead.
**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, the return value is of a float type.

Return type:

Union[float, numpy.ndarray]

Raises:

ValueError – If the bounds either of inconsistent shape or not in the \([-1, 1]^m\) domain.

Notes

This method calls the concrete implementation of the abstract method _integrate_over() after input validation.

See also

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

has_matching_dimension(other)[source]#

Return True if the polynomials have matching dimensions.

Parameters:: other (MultivariatePolynomialSingleABC) – The second instance of polynomial to compare.
Returns:: True if the two spatial dimensions match, False otherwise.
Return type:: bool

has_matching_domain(other, tol=1e-16)[source]#

Return True if the polynomials have matching domains.

Parameters:

other (MultivariatePolynomialSingleABC) – The second instance of polynomial to compare.
tol (float, optional) – The tolerance used to check for matching domains. Default is 1e-16.

Returns:

True if the two domains match, False otherwise.

Return type:

bool

Notes

The method checks both the internal and user domains.
If the dimensions of the polynomials do not match, the comparison is carried out up to the smallest matching dimension.

_match_dims(other)[source]#

Match the dimension of two polynomials.

Parameters:: other (MultivariatePolynomialSingleABC) – An instance polynomial whose dimension is to match with the current polynomial instance.
Returns:: The two instances of polynomials whose dimensions have been matched.
Return type:: Tuple[MultivariatePolynomialSingleABC, MultivariatePolynomialSingleABC]
Raises:: ValueError – If the dimension of one of the polynomial instance can’t be matched due to, for instance, incompatible domain.

Notes

If both polynomials have matching dimension and domains, then the function return the two polynomials as they are.

_verify_operands(other, operation)[source]#

Verify the operands are valid before moving on.

Parameters:

other (MultivariatePolynomialSingleABC)
operation (str)

Return type:

Tuple[MultivariatePolynomialSingleABC, MultivariatePolynomialSingleABC]

__call__(xx, **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 (numpy.ndarray) – The set of query points to evaluate as 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.
**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.

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

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.

__hash__ = None#

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

abstract static _eval(poly, xx, **kwargs)#

Abstract method to the polynomial evaluation function.

Parameters:

poly (MultivariatePolynomialABC) – A concrete instance of a polynomial class that can be evaluated on a set of query points.
xx (numpy.ndarray) – The set of query points to evaluate as 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.
**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.

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

This is a placeholder of the ABC, which is overwritten by the concrete implementation.

See also

__call__: The dunder method as a syntactic sugar to evaluate the polynomial(s) instance on a set of query points.