A convenience class, used to encapsulate "natural" operations on polynomials so that said operations may take on their customary form in code (see Examples).

Parameters

c_or_r : array_like

The polynomial's coefficients, in decreasing powers, or if the value of the second parameter is True, the polynomial's roots (values where the polynomial evaluates to 0). For example, poly1d([1, 2, 3]) returns an object that represents $x^2 + 2x + 3$ , whereas poly1d([1, 2, 3], True) returns one that represents $(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6$ .

r : bool, optional

If True, :None:None:`c_or_r` specifies the polynomial's roots; the default is False.

variable : str, optional

Changes the variable used when printing :None:None:`p` from :None:None:`x` to :None:None:`variable` (see Examples).

A one-dimensional polynomial class.

Examples

Construct the polynomial $x^2 + 2x + 3$ :

>>> p = np.poly1d([1, 2, 3])
... print(np.poly1d(p))
   2
1 x + 2 x + 3

Evaluate the polynomial at $x = 0.5$ :

>>> p(0.5)
4.25

Find the roots:

>>> p.r
array([-1.+1.41421356j, -1.-1.41421356j])

>>> p(p.r)
array([ -4.44089210e-16+0.j,  -4.44089210e-16+0.j]) # may vary

These numbers in the previous line represent (0, 0) to machine precision

Show the coefficients:

>>> p.c
array([1, 2, 3])

Display the order (the leading zero-coefficients are removed):

>>> p.order
2

Show the coefficient of the k-th power in the polynomial (which is equivalent to p.c[-(i+1)] ):

>>> p[1]
2

Polynomials can be added, subtracted, multiplied, and divided (returns quotient and remainder):

>>> p * p
poly1d([ 1,  4, 10, 12,  9])

>>> (p**3 + 4) / p
(poly1d([ 1.,  4., 10., 12.,  9.]), poly1d([4.]))

asarray(p) gives the coefficient array, so polynomials can be used in all functions that accept arrays:

>>> p**2 # square of polynomial
poly1d([ 1,  4, 10, 12,  9])

>>> np.square(p) # square of individual coefficients
array([1, 4, 9])

The variable used in the string representation of :None:None:`p` can be modified, using the :None:None:`variable` parameter:

>>> p = np.poly1d([1,2,3], variable='z')
... print(p)
   2
1 z + 2 z + 3

Construct a polynomial from its roots:

>>> np.poly1d([1, 2], True)
poly1d([ 1., -3.,  2.])

This is the same polynomial as obtained by:

>>> np.poly1d([1, -1]) * np.poly1d([1, -2])
poly1d([ 1, -3,  2])

See :

Back References

The following pages refer to to this document either explicitly or contain code examples using this.

numpy.roots numpy.polyint scipy.interpolate._polyint.approximate_taylor_polynomial numpy.ma.extras.polyfit numpy.poly numpy.polyfit numpy.polyval numpy.polymul scipy.interpolate._pade.pade scipy.interpolate._interpolate.lagrange numpy.polyder scipy.special scipy.signal._waveforms.sweep_poly numpy.polyadd numpy.polysub

Local connectivity graph

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

---

GitHub : /numpy/__init__.py#None
type: <class 'type'>
Commit: