To remove in the future –– numpy.polynomial
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 :None:None:`~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 routines.polynomials.classes
for more details.
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.
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
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
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
p.deriv()
-- Take the derivative of p
p.integ()
-- Integrate p
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
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 :None:None:`p`
.
p.trim()
-- Remove trailing coefficients.
p.cutdeg(degree)
-- Truncate p to given degree
p.truncate(size)
-- Truncate p to given size
The following pages refer to to this document either explicitly or contain code examples using this.
numpy.polynomial.chebyshev
numpy.polynomial.legendre
numpy.polynomial.hermite
numpy.polynomial.laguerre
numpy.polynomial.polynomial
scipy.interpolate._interpolate.lagrange
numpy.polynomial.polyutils
numpy.polynomial
numpy.polynomial.hermite_e
Hover to see nodes names; edges to Self not shown, Caped at 50 nodes.
Using a canvas is more power efficient and can get hundred of nodes ; but does not allow hyperlinks; , arrows or text (beyond on hover)
SVG is more flexible but power hungry; and does not scale well to 50 + nodes.
All aboves nodes referred to, (or are referred from) current nodes; Edges from Self to other have been omitted (or all nodes would be connected to the central node "self" which is not useful). Nodes are colored by the library they belong to, and scaled with the number of references pointing them