A sub-package for efficiently dealing with polynomials.

Within the documentation for this sub-package, a “finite power series,” i.e., a polynomial (also referred to simply as a “series”) is represented by a 1-D numpy array of the polynomial’s coefficients, ordered from lowest order term to highest. For example, array([1,2,3]) represents `P_0 + 2*P_1 + 3*P_2`, where P_n is the n-th order basis polynomial applicable to the specific module in question, e.g., `polynomial` (which “wraps” the “standard” basis) or `chebyshev`. For optimal performance, all operations on polynomials, including evaluation at an argument, are implemented as operations on the coefficients. Additional (module-specific) information can be found in the docstring for the module of interest.

This package provides convenience classes for each of six different kinds of polynomials:

> Name | Provides
> --- | ---
> `Polynomial` | Power series
> `Chebyshev` | Chebyshev series
> `Legendre` | Legendre series
> `Laguerre` | Laguerre series
> `Hermite` | Hermite series
> `HermiteE` | HermiteE series

These convenience classes provide a consistent interface for creating, manipulating, and fitting data with polynomials of different bases. The convenience classes are the preferred interface for the `polynomial` package, and are available from the `numpy.polynomial` namespace. This eliminates the need to navigate to the corresponding submodules, e.g. `np.polynomial.Polynomial` or `np.polynomial.Chebyshev` instead of `np.polynomial.polynomial.Polynomial` or `np.polynomial.chebyshev.Chebyshev`, respectively. The classes provide a more consistent and concise interface than the type-specific functions defined in the submodules for each type of polynomial. For example, to fit a Chebyshev polynomial with degree `1` to data given by arrays `xdata` and `ydata`, the `fit` class method:

    >>> from numpy.polynomial import Chebyshev
    >>> c = Chebyshev.fit(xdata, ydata, deg=1)

is preferred over the `chebyshev.chebfit` function from the `np.polynomial.chebyshev` module:

    >>> from numpy.polynomial.chebyshev import chebfit
    >>> c = chebfit(xdata, ydata, deg=1)

See Using the Convenience Classes for more details.

# Convenience Classes

The following lists the various constants and methods common to all of the classes representing the various kinds of polynomials. In the following, the term `Poly` represents any one of the convenience classes (e.g. `Polynomial`, `Chebyshev`, `Hermite`, etc.) while the lowercase `p` represents an instance of a polynomial class.

## Constants

- `Poly.domain` – Default domain

- `Poly.window` – Default window

- `Poly.basis_name` – String used to represent the basis

- `Poly.maxpower` – Maximum value `n` such that `p**n` is allowed

- `Poly.nickname` – String used in printing

## Creation

Methods for creating polynomial instances.

- `Poly.basis(degree)` – Basis polynomial of given degree

- `Poly.identity()` – `p` where `p(x) = x` for all `x`

- `Poly.fit(x, y, deg)` – `p` of degree `deg` with coefficients determined by the least-squares fit to the data `x`, `y`

- `Poly.fromroots(roots)` – `p` with specified roots

- `p.copy()` – Create a copy of `p`

## Conversion

Methods for converting a polynomial instance of one kind to another.

- `p.cast(Poly)` – Convert `p` to instance of kind `Poly`

- `p.convert(Poly)` – Convert `p` to instance of kind `Poly` or map between `domain` and `window`

## Calculus

- `p.deriv()` – Take the derivative of `p`

- `p.integ()` – Integrate `p`

## Validation

- `Poly.has_samecoef(p1, p2)` – Check if coefficients match

- `Poly.has_samedomain(p1, p2)` – Check if domains match

- `Poly.has_sametype(p1, p2)` – Check if types match

- `Poly.has_samewindow(p1, p2)` – Check if windows match

## Misc

- `p.linspace()` – Return `x, p(x)` at equally-spaced points in `domain`

- `p.mapparms()` – Return the parameters for the linear mapping between `domain` and `window`.

- `p.roots()` – Return the roots of p.

- `p.trim()` – Remove trailing coefficients.

- `p.cutdeg(degree)` – Truncate p to given degree

- `p.truncate(size)` – Truncate p to given size

# Configuration

`numpy.polynomial.set_default_printstyle`(style) | Set the default format for the string representation of polynomials.