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.Polynomial
Power series ~chebyshev.Chebyshev
Chebyshev series ~legendre.Legendre
Legendre series ~laguerre.Laguerre
Laguerre series ~hermite.Hermite
Hermite series ~hermite_e.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 ~numpy.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
~chebyshev.Chebyshev.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 :doc:`routines.polynomials.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.Polynomial
, ~chebyshev.Chebyshev
, ~hermite.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
Module | chebyshev |
This module provides a number of objects (mostly functions) useful for dealing with Chebyshev series, including a Chebyshev class that encapsulates the usual arithmetic operations. (General information on how this module represents and works with such polynomials is in the docstring for its "parent" sub-package, ... |
Module | hermite |
This module provides a number of objects (mostly functions) useful for dealing with Hermite series, including a Hermite class that encapsulates the usual arithmetic operations. (General information on how this module represents and works with such polynomials is in the docstring for its "parent" sub-package, ... |
Module | hermite |
This module provides a number of objects (mostly functions) useful for dealing with Hermite_e series, including a HermiteE class that encapsulates the usual arithmetic operations. (General information on how this module represents and works with such polynomials is in the docstring for its "parent" sub-package, ... |
Module | laguerre |
This module provides a number of objects (mostly functions) useful for dealing with Laguerre series, including a Laguerre class that encapsulates the usual arithmetic operations. (General information on how this module represents and works with such polynomials is in the docstring for its "parent" sub-package, ... |
Module | legendre |
This module provides a number of objects (mostly functions) useful for dealing with Legendre series, including a Legendre class that encapsulates the usual arithmetic operations. (General information on how this module represents and works with such polynomials is in the docstring for its "parent" sub-package, ... |
Module | polynomial |
This module provides a number of objects (mostly functions) useful for dealing with polynomials, including a Polynomial class that encapsulates the usual arithmetic operations. (General information on how this module represents and works with polynomial objects is in the docstring for its "parent" sub-package, ... |
Module | polyutils |
Utility classes and functions for the polynomial modules. |
Module | setup |
Undocumented |
Package | tests |
No package docstring; 9/10 modules documented |
Module | _polybase |
Abstract base class for the various polynomial Classes. |
From __init__.py
:
Function | set |
Set the default format for the string representation of polynomials. |
Variable | test |
Undocumented |
Set the default format for the string representation of polynomials.
Values for style must be valid inputs to __format__, i.e. 'ascii' or 'unicode'.
Notes
The default format depends on the platform: 'unicode' is used on Unix-based systems and 'ascii' on Windows. This determination is based on default font support for the unicode superscript and subscript ranges.
Examples
>>> p = np.polynomial.Polynomial([1, 2, 3]) >>> c = np.polynomial.Chebyshev([1, 2, 3]) >>> np.polynomial.set_default_printstyle('unicode') >>> print(p) 1.0 + 2.0·x + 3.0·x² >>> print(c) 1.0 + 2.0·T₁(x) + 3.0·T₂(x) >>> np.polynomial.set_default_printstyle('ascii') >>> print(p) 1.0 + 2.0 x + 3.0 x**2 >>> print(c) 1.0 + 2.0 T_1(x) + 3.0 T_2(x) >>> # Formatting supersedes all class/package-level defaults >>> print(f"{p:unicode}") 1.0 + 2.0·x + 3.0·x²
Parameters | |
style:str | Format string for default printing style. Must be either 'ascii' or 'unicode'. |