U
|
P ±d² ã @ s d Z ddddddddd d
|
d d g Zd dlZd dlZd dlZd dlm mZ d dl m
|
Z
|
m Z m Z m Z mZmZmZmZ d dl mZ d dlmZ d dlmZmZ d dlmZ d dlmZm Z m Z m Z d dl m Z m!Z!m"Z" ej#ej$ddZ$edG dd d e%Z&dd Z'e$e'dd Z(d d Z)e$e)d d Z*d;d d Z+e$e+d<d"dZ,d=d#d$Z-e$e-d>d%dZ.d?d&d'Z/e$e/d@d)d Z0d*d+ Z1e$e1d,d Z2d-d. Z3e$e3d/d Z4e$e3d0d Z5e$e3d1d Z6d2d3 Z7e$e7d4d Z8e 9d5¡Z:dAd7d8Z;edG d9d
|
d
|
Z<e =d:e&¡ dS )Bz'
|
Functions to operate on polynomials.
|
|
ÚpolyÚrootsÚpolyintÚpolyderÚpolyaddÚpolysubÚpolymulÚpolydivÚpolyvalÚpoly1dÚpolyfitÚ RankWarningé N)ÚisscalarÚabsÚfinfoÚ
|
atleast_1dÚhstackÚdotÚarrayÚones)Ú overrides)Ú
|
set_module)ÚdiagÚvander)Ú
|
trim_zeros)Ú iscomplexÚrealÚimagÚ mintypecode)ÚeigvalsÚlstsqÚinvÚnumpy)Úmodulec @ s e Zd ZdZdS )r zÈ
|
Issued by `polyfit` when the Vandermonde matrix is rank deficient.
|
|
For more information, a way to suppress the warning, and an example of
|
`RankWarning` being issued, see `polyfit`.
|
|
N)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__© r( r( úKd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/lib/polynomial.pyr s c C s | S ©Nr( )Ú seq_of_zerosr( r( r) Ú_poly_dispatcher( s r, c C s
|
t | } | j}t|dkr@|d |d kr@|d dkr@t| } n4t|dkrl| j}|tkrt| t|j¡} nt dt| dkrdS | j}t
|
d|d}| D ]"}t j |t d| g|ddd }qt|jjt jrt | t¡}t t |¡t | ¡ ¡k¡r|j ¡ }|S )
|
a#
|
Find the coefficients of a polynomial with the given sequence of roots.
|
|
.. note::
|
This forms part of the old polynomial API. Since version 1.4, the
|
new polynomial API defined in `numpy.polynomial` is preferred.
|
A summary of the differences can be found in the
|
:doc:`transition guide </reference/routines.polynomials>`.
|
|
Returns the coefficients of the polynomial whose leading coefficient
|
is one for the given sequence of zeros (multiple roots must be included
|
in the sequence as many times as their multiplicity; see Examples).
|
A square matrix (or array, which will be treated as a matrix) can also
|
be given, in which case the coefficients of the characteristic polynomial
|
of the matrix are returned.
|
|
Parameters
|
----------
|
seq_of_zeros : array_like, shape (N,) or (N, N)
|
A sequence of polynomial roots, or a square array or matrix object.
|
|
Returns
|
-------
|
c : ndarray
|
1D array of polynomial coefficients from highest to lowest degree:
|
|
``c[0] * x**(N) + c[1] * x**(N-1) + ... + c[N-1] * x + c[N]``
|
where c[0] always equals 1.
|
|
Raises
|
------
|
ValueError
|
If input is the wrong shape (the input must be a 1-D or square
|
2-D array).
|
|
See Also
|
--------
|
polyval : Compute polynomial values.
|
roots : Return the roots of a polynomial.
|
polyfit : Least squares polynomial fit.
|
poly1d : A one-dimensional polynomial class.
|
|
Notes
|
-----
|
Specifying the roots of a polynomial still leaves one degree of
|
freedom, typically represented by an undetermined leading
|
coefficient. [1]_ In the case of this function, that coefficient -
|
the first one in the returned array - is always taken as one. (If
|
for some reason you have one other point, the only automatic way
|
presently to leverage that information is to use ``polyfit``.)
|
|
The characteristic polynomial, :math:`p_a(t)`, of an `n`-by-`n`
|
matrix **A** is given by
|
|
:math:`p_a(t) = \mathrm{det}(t\, \mathbf{I} - \mathbf{A})`,
|
|
where **I** is the `n`-by-`n` identity matrix. [2]_
|
|
References
|
----------
|
.. [1] M. Sullivan and M. Sullivan, III, "Algebra and Trignometry,
|
Enhanced With Graphing Utilities," Prentice-Hall, pg. 318, 1996.
|
|
.. [2] G. Strang, "Linear Algebra and Its Applications, 2nd Edition,"
|
Academic Press, pg. 182, 1980.
|
|
Examples
|
--------
|
Given a sequence of a polynomial's zeros:
|
|
>>> np.poly((0, 0, 0)) # Multiple root example
|
array([1., 0., 0., 0.])
|
|
The line above represents z**3 + 0*z**2 + 0*z + 0.
|
|
>>> np.poly((-1./2, 0, 1./2))
|
array([ 1. , 0. , -0.25, 0. ])
|
|
The line above represents z**3 - z/4
|
|
>>> np.poly((np.random.random(1)[0], 0, np.random.random(1)[0]))
|
array([ 1. , -0.77086955, 0.08618131, 0. ]) # random
|
|
Given a square array object:
|
|
>>> P = np.array([[0, 1./3], [-1./2, 0]])
|
>>> np.poly(P)
|
array([1. , 0. , 0.16666667])
|
|
Note how in all cases the leading coefficient is always 1.
|
|
é r é z.input must be 1d or non-empty square 2d array.ç ð?)r. ©ÚdtypeÚfull)Úmode)r ÚshapeÚlenr r1 ÚobjectÚastyper ÚcharÚ
|
ValueErrorr ÚNXÚconvolver Ú
|
issubclassÚtypeÚcomplexfloatingÚasarrayÚcomplexÚallÚsortÚ conjugater Úcopy)r+ ÚshÚdtÚaZzeror r( r( r) r , s( ^(
|
|
c C s | S r* r( )Úpr( r( r) Ú_roots_dispatcher§ s rI c C s t | } | jdkrtdt t | ¡¡d }t|dkrDt g ¡S t| |d d }| t|d t|d d
} t | j
|
j tj tj fs| t¡} t| }|dkrîtt |d f| j
|
¡d}| dd
| d |ddd
f< t|}n
|
t g ¡}t|t ||j
|
¡f}|S )aà
|
Return the roots of a polynomial with coefficients given in p.
|
|
.. note::
|
This forms part of the old polynomial API. Since version 1.4, the
|
new polynomial API defined in `numpy.polynomial` is preferred.
|
A summary of the differences can be found in the
|
:doc:`transition guide </reference/routines.polynomials>`.
|
|
The values in the rank-1 array `p` are coefficients of a polynomial.
|
If the length of `p` is n+1 then the polynomial is described by::
|
|
p[0] * x**n + p[1] * x**(n-1) + ... + p[n-1]*x + p[n]
|
|
Parameters
|
----------
|
p : array_like
|
Rank-1 array of polynomial coefficients.
|
|
Returns
|
-------
|
out : ndarray
|
An array containing the roots of the polynomial.
|
|
Raises
|
------
|
ValueError
|
When `p` cannot be converted to a rank-1 array.
|
|
See also
|
--------
|
poly : Find the coefficients of a polynomial with a given sequence
|
of roots.
|
polyval : Compute polynomial values.
|
polyfit : Least squares polynomial fit.
|
poly1d : A one-dimensional polynomial class.
|
|
Notes
|
-----
|
The algorithm relies on computing the eigenvalues of the
|
companion matrix [1]_.
|
|
References
|
----------
|
.. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*. Cambridge, UK:
|
Cambridge University Press, 1999, pp. 146-7.
|
|
Examples
|
--------
|
>>> coeff = [3.2, 2, 1]
|
>>> np.roots(coeff)
|
array([-0.3125+0.46351241j, -0.3125-0.46351241j])
|
|
r. z Input must be a rank-1 array.r éÿÿÿÿr- N)r Úndimr9 r: ZnonzeroZravelr5 r Úintr< r1 r= Zfloatingr> r7 Úfloatr r r r Úzeros)rH Znon_zeroZtrailing_zerosÚNÚAr r( r( r) r « s$ 9
|
|
|
"
|
|
c C s | fS r* r( )rH ÚmÚkr( r( r) Ú_polyint_dispatcher s rS r. c C sò t |}|dk rtd|dkr,t |t¡}t|}t|dkr\|dkr\|d t |t¡ }t||k rptdt| t }t
|
| ¡} |dkr|rt | S | S t | t t| dd¡¡|d gf¡}t||d |dd
d}|rêt |S |S dS )a¡
|
Return an antiderivative (indefinite integral) of a polynomial.
|
|
.. note::
|
This forms part of the old polynomial API. Since version 1.4, the
|
new polynomial API defined in `numpy.polynomial` is preferred.
|
A summary of the differences can be found in the
|
:doc:`transition guide </reference/routines.polynomials>`.
|
|
The returned order `m` antiderivative `P` of polynomial `p` satisfies
|
:math:`\frac{d^m}{dx^m}P(x) = p(x)` and is defined up to `m - 1`
|
integration constants `k`. The constants determine the low-order
|
polynomial part
|
|
.. math:: \frac{k_{m-1}}{0!} x^0 + \ldots + \frac{k_0}{(m-1)!}x^{m-1}
|
|
of `P` so that :math:`P^{(j)}(0) = k_{m-j-1}`.
|
|
Parameters
|
----------
|
p : array_like or poly1d
|
Polynomial to integrate.
|
A sequence is interpreted as polynomial coefficients, see `poly1d`.
|
m : int, optional
|
Order of the antiderivative. (Default: 1)
|
k : list of `m` scalars or scalar, optional
|
Integration constants. They are given in the order of integration:
|
those corresponding to highest-order terms come first.
|
|
If ``None`` (default), all constants are assumed to be zero.
|
If `m = 1`, a single scalar can be given instead of a list.
|
|
See Also
|
--------
|
polyder : derivative of a polynomial
|
poly1d.integ : equivalent method
|
|
Examples
|
--------
|
The defining property of the antiderivative:
|
|
>>> p = np.poly1d([1,1,1])
|
>>> P = np.polyint(p)
|
>>> P
|
poly1d([ 0.33333333, 0.5 , 1. , 0. ]) # may vary
|
>>> np.polyder(P) == p
|
True
|
|
The integration constants default to zero, but can be specified:
|
|
>>> P = np.polyint(p, 3)
|
>>> P(0)
|
0.0
|
>>> np.polyder(P)(0)
|
0.0
|
>>> np.polyder(P, 2)(0)
|
0.0
|
>>> P = np.polyint(p, 3, k=[6,5,3])
|
>>> P
|
poly1d([ 0.01666667, 0.04166667, 0.16666667, 3. , 5. , 3. ]) # may vary
|
|
Note that 3 = 6 / 2!, and that the constants are given in the order of
|
integrations. Constant of the highest-order polynomial term comes first:
|
|
>>> np.polyder(P, 2)(0)
|
6.0
|
>>> np.polyder(P, 1)(0)
|
5.0
|
>>> P(0)
|
3.0
|
|
r z0Order of integral must be positive (see polyder)Nr. z7k must be a scalar or a rank-1 array of length 1 or >m.rJ )rR )rL r9 r: rN rM r r5 r Ú
|
isinstancer
|
r? Ú concatenateÚ __truediv__Úaranger )rH rQ rR ÚtruepolyÚyÚvalr( r( r) r s. J ÿ
|
|
(c C s | fS r* r( )rH rQ r( r( r) Ú_polyder_dispatcherp s r[ c C s~ t |}|dk rtdt| t}t | ¡} t| d }| dd
t |dd¡ }|dkr`| }nt||d }|rzt|}|S )ax
|
Return the derivative of the specified order of a polynomial.
|
|
.. note::
|
This forms part of the old polynomial API. Since version 1.4, the
|
new polynomial API defined in `numpy.polynomial` is preferred.
|
A summary of the differences can be found in the
|
:doc:`transition guide </reference/routines.polynomials>`.
|
|
Parameters
|
----------
|
p : poly1d or sequence
|
Polynomial to differentiate.
|
A sequence is interpreted as polynomial coefficients, see `poly1d`.
|
m : int, optional
|
Order of differentiation (default: 1)
|
|
Returns
|
-------
|
der : poly1d
|
A new polynomial representing the derivative.
|
|
See Also
|
--------
|
polyint : Anti-derivative of a polynomial.
|
poly1d : Class for one-dimensional polynomials.
|
|
Examples
|
--------
|
The derivative of the polynomial :math:`x^3 + x^2 + x^1 + 1` is:
|
|
>>> p = np.poly1d([1,1,1,1])
|
>>> p2 = np.polyder(p)
|
>>> p2
|
poly1d([3, 2, 1])
|
|
which evaluates to:
|
|
>>> p2(2.)
|
17.0
|
|
We can verify this, approximating the derivative with
|
``(f(x + h) - f(x))/h``:
|
|
>>> (p(2. + 0.001) - p(2.)) / 0.001
|
17.007000999997857
|
|
The fourth-order derivative of a 3rd-order polynomial is zero:
|
|
>>> np.polyder(p, 2)
|
poly1d([6, 2])
|
>>> np.polyder(p, 3)
|
poly1d([6])
|
>>> np.polyder(p, 4)
|
poly1d([0])
|
|
r z2Order of derivative must be positive (see polyint)r. NrJ ) rL r9 rT r
|
r: r? r5 rW r )rH rQ rX ÚnrY rZ r( r( r) r t s ;
|
|
c C s
|
| ||fS r* r( )ÚxrY ÚdegÚrcondr2 ÚwÚcovr( r( r) Ú_polyfit_dispatcherÀ s rb Fc C s\ t |d }t | ¡d } t |¡d }|dk r8td| jdkrJtd| jdkr\td|jdk sp|jdkrxtd| jd |jd krtd |d
|
kr°t| t | j
|
j }t | |}|} |d
|
k rHt |¡d }|jdkrètd |jd |jd krtd ||d
|
d
|
tj f 9 }| jdkr@| |d
|
d
|
tj f 9 } n| |9 } t || jdd ¡}
|
||
|
}t|| |\} } } }| j|
|
j} | |krª|sªd}tj|tdd |r¾| | | ||fS |rTtt|j|}|t |
|
|
|
¡ }|dkrôd}n&t| |kr
|
td| t| | }|jdkr2| || fS | |d
|
d
|
d
|
d
|
tj f | fS n| S d
|
S )a¦
|
Least squares polynomial fit.
|
|
.. note::
|
This forms part of the old polynomial API. Since version 1.4, the
|
new polynomial API defined in `numpy.polynomial` is preferred.
|
A summary of the differences can be found in the
|
:doc:`transition guide </reference/routines.polynomials>`.
|
|
Fit a polynomial ``p(x) = p[0] * x**deg + ... + p[deg]`` of degree `deg`
|
to points `(x, y)`. Returns a vector of coefficients `p` that minimises
|
the squared error in the order `deg`, `deg-1`, ... `0`.
|
|
The `Polynomial.fit <numpy.polynomial.polynomial.Polynomial.fit>` class
|
method is recommended for new code as it is more stable numerically. See
|
the documentation of the method for more information.
|
|
Parameters
|
----------
|
x : array_like, shape (M,)
|
x-coordinates of the M sample points ``(x[i], y[i])``.
|
y : array_like, shape (M,) or (M, K)
|
y-coordinates of the sample points. Several data sets of sample
|
points sharing the same x-coordinates can be fitted at once by
|
passing in a 2D-array that contains one dataset per column.
|
deg : int
|
Degree of the fitting polynomial
|
rcond : float, optional
|
Relative condition number of the fit. Singular values smaller than
|
this relative to the largest singular value will be ignored. The
|
default value is len(x)*eps, where eps is the relative precision of
|
the float type, about 2e-16 in most cases.
|
full : bool, optional
|
Switch determining nature of return value. When it is False (the
|
default) just the coefficients are returned, when True diagnostic
|
information from the singular value decomposition is also returned.
|
w : array_like, shape (M,), optional
|
Weights. If not None, the weight ``w[i]`` applies to the unsquared
|
residual ``y[i] - y_hat[i]`` at ``x[i]``. Ideally the weights are
|
chosen so that the errors of the products ``w[i]*y[i]`` all have the
|
same variance. When using inverse-variance weighting, use
|
``w[i] = 1/sigma(y[i])``. The default value is None.
|
cov : bool or str, optional
|
If given and not `False`, return not just the estimate but also its
|
covariance matrix. By default, the covariance are scaled by
|
chi2/dof, where dof = M - (deg + 1), i.e., the weights are presumed
|
to be unreliable except in a relative sense and everything is scaled
|
such that the reduced chi2 is unity. This scaling is omitted if
|
``cov='unscaled'``, as is relevant for the case that the weights are
|
w = 1/sigma, with sigma known to be a reliable estimate of the
|
uncertainty.
|
|
Returns
|
-------
|
p : ndarray, shape (deg + 1,) or (deg + 1, K)
|
Polynomial coefficients, highest power first. If `y` was 2-D, the
|
coefficients for `k`-th data set are in ``p[:,k]``.
|
|
residuals, rank, singular_values, rcond
|
These values are only returned if ``full == True``
|
|
- residuals -- sum of squared residuals of the least squares fit
|
- rank -- the effective rank of the scaled Vandermonde
|
coefficient matrix
|
- singular_values -- singular values of the scaled Vandermonde
|
coefficient matrix
|
- rcond -- value of `rcond`.
|
|
For more details, see `numpy.linalg.lstsq`.
|
|
V : ndarray, shape (M,M) or (M,M,K)
|
Present only if ``full == False`` and ``cov == True``. The covariance
|
matrix of the polynomial coefficient estimates. The diagonal of
|
this matrix are the variance estimates for each coefficient. If y
|
is a 2-D array, then the covariance matrix for the `k`-th data set
|
are in ``V[:,:,k]``
|
|
|
Warns
|
-----
|
RankWarning
|
The rank of the coefficient matrix in the least-squares fit is
|
deficient. The warning is only raised if ``full == False``.
|
|
The warnings can be turned off by
|
|
>>> import warnings
|
>>> warnings.simplefilter('ignore', np.RankWarning)
|
|
See Also
|
--------
|
polyval : Compute polynomial values.
|
linalg.lstsq : Computes a least-squares fit.
|
scipy.interpolate.UnivariateSpline : Computes spline fits.
|
|
Notes
|
-----
|
The solution minimizes the squared error
|
|
.. math::
|
E = \sum_{j=0}^k |p(x_j) - y_j|^2
|
|
in the equations::
|
|
x[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0]
|
x[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1]
|
...
|
x[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k]
|
|
The coefficient matrix of the coefficients `p` is a Vandermonde matrix.
|
|
`polyfit` issues a `RankWarning` when the least-squares fit is badly
|
conditioned. This implies that the best fit is not well-defined due
|
to numerical error. The results may be improved by lowering the polynomial
|
degree or by replacing `x` by `x` - `x`.mean(). The `rcond` parameter
|
can also be set to a value smaller than its default, but the resulting
|
fit may be spurious: including contributions from the small singular
|
values can add numerical noise to the result.
|
|
Note that fitting polynomial coefficients is inherently badly conditioned
|
when the degree of the polynomial is large or the interval of sample points
|
is badly centered. The quality of the fit should always be checked in these
|
cases. When polynomial fits are not satisfactory, splines may be a good
|
alternative.
|
|
References
|
----------
|
.. [1] Wikipedia, "Curve fitting",
|
https://en.wikipedia.org/wiki/Curve_fitting
|
.. [2] Wikipedia, "Polynomial interpolation",
|
https://en.wikipedia.org/wiki/Polynomial_interpolation
|
|
Examples
|
--------
|
>>> import warnings
|
>>> x = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
|
>>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0])
|
>>> z = np.polyfit(x, y, 3)
|
>>> z
|
array([ 0.08703704, -0.81349206, 1.69312169, -0.03968254]) # may vary
|
|
It is convenient to use `poly1d` objects for dealing with polynomials:
|
|
>>> p = np.poly1d(z)
|
>>> p(0.5)
|
0.6143849206349179 # may vary
|
>>> p(3.5)
|
-0.34732142857143039 # may vary
|
>>> p(10)
|
22.579365079365115 # may vary
|
|
High-order polynomials may oscillate wildly:
|
|
>>> with warnings.catch_warnings():
|
... warnings.simplefilter('ignore', np.RankWarning)
|
... p30 = np.poly1d(np.polyfit(x, y, 30))
|
...
|
>>> p30(4)
|
-0.80000000000000204 # may vary
|
>>> p30(5)
|
-0.99999999999999445 # may vary
|
>>> p30(4.5)
|
-0.10547061179440398 # may vary
|
|
Illustration:
|
|
>>> import matplotlib.pyplot as plt
|
>>> xp = np.linspace(-2, 6, 100)
|
>>> _ = plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--')
|
>>> plt.ylim(-2,2)
|
(-2, 2)
|
>>> plt.show()
|
|
r. ç r zexpected deg >= 0zexpected 1D vector for xz expected non-empty vector for xr- z expected 1D or 2D array for yz$expected x and y to have same lengthNz expected a 1-d array for weightsz(expected w and y to have the same length)Zaxisz!Polyfit may be poorly conditionedé ©Ú
|
stacklevelZunscaledzJthe number of data points must exceed order to scale the covariance matrix)rL r: r? r9 rK Ú TypeErrorÚsizer4 r5 r r1 Zepsr ZnewaxisÚsqrtÚsumr ÚTÚwarningsÚwarnr r! r Úouter)r] rY r^ r_ r2 r` ra ÚorderÚlhsÚrhsÚscaleÚcZresidsZrankÚsÚmsgZVbaseZfacr( r( r) r Ä sb 1
|
|
|
|
|
|
"c C s | |fS r* r( )rH r] r( r( r) Ú_polyval_dispatcher¼ s rv c C sH t | ¡} t|trd}nt |¡}t |¡}| D ]}|| | }q2|S )a³
|
Evaluate a polynomial at specific values.
|
|
.. note::
|
This forms part of the old polynomial API. Since version 1.4, the
|
new polynomial API defined in `numpy.polynomial` is preferred.
|
A summary of the differences can be found in the
|
:doc:`transition guide </reference/routines.polynomials>`.
|
|
If `p` is of length N, this function returns the value:
|
|
``p[0]*x**(N-1) + p[1]*x**(N-2) + ... + p[N-2]*x + p[N-1]``
|
|
If `x` is a sequence, then ``p(x)`` is returned for each element of ``x``.
|
If `x` is another polynomial then the composite polynomial ``p(x(t))``
|
is returned.
|
|
Parameters
|
----------
|
p : array_like or poly1d object
|
1D array of polynomial coefficients (including coefficients equal
|
to zero) from highest degree to the constant term, or an
|
instance of poly1d.
|
x : array_like or poly1d object
|
A number, an array of numbers, or an instance of poly1d, at
|
which to evaluate `p`.
|
|
Returns
|
-------
|
values : ndarray or poly1d
|
If `x` is a poly1d instance, the result is the composition of the two
|
polynomials, i.e., `x` is "substituted" in `p` and the simplified
|
result is returned. In addition, the type of `x` - array_like or
|
poly1d - governs the type of the output: `x` array_like => `values`
|
array_like, `x` a poly1d object => `values` is also.
|
|
See Also
|
--------
|
poly1d: A polynomial class.
|
|
Notes
|
-----
|
Horner's scheme [1]_ is used to evaluate the polynomial. Even so,
|
for polynomials of high degree the values may be inaccurate due to
|
rounding errors. Use carefully.
|
|
If `x` is a subtype of `ndarray` the return value will be of the same type.
|
|
References
|
----------
|
.. [1] I. N. Bronshtein, K. A. Semendyayev, and K. A. Hirsch (Eng.
|
trans. Ed.), *Handbook of Mathematics*, New York, Van Nostrand
|
Reinhold Co., 1985, pg. 720.
|
|
Examples
|
--------
|
>>> np.polyval([3,0,1], 5) # 3 * 5**2 + 0 * 5**1 + 1
|
76
|
>>> np.polyval([3,0,1], np.poly1d(5))
|
poly1d([76])
|
>>> np.polyval(np.poly1d([3,0,1]), 5)
|
76
|
>>> np.polyval(np.poly1d([3,0,1]), np.poly1d(5))
|
poly1d([76])
|
|
r )r: r? rT r
|
Z
|
asanyarrayZ
|
zeros_like)rH r] rY Úpvr( r( r) r À s D
|
|
|
|
c C s | |fS r* r( )Úa1Úa2r( r( r) Ú_binary_op_dispatcher s rz c C s¤ t | tpt |t}t| } t|}t|t| }|dkrF| | }nN|dkrpt || j¡}t || f¡| }n$t t||j¡}| t ||f¡ }|r t|}|S )aN
|
Find the sum of two polynomials.
|
|
.. note::
|
This forms part of the old polynomial API. Since version 1.4, the
|
new polynomial API defined in `numpy.polynomial` is preferred.
|
A summary of the differences can be found in the
|
:doc:`transition guide </reference/routines.polynomials>`.
|
|
Returns the polynomial resulting from the sum of two input polynomials.
|
Each input must be either a poly1d object or a 1D sequence of polynomial
|
coefficients, from highest to lowest degree.
|
|
Parameters
|
----------
|
a1, a2 : array_like or poly1d object
|
Input polynomials.
|
|
Returns
|
-------
|
out : ndarray or poly1d object
|
The sum of the inputs. If either input is a poly1d object, then the
|
output is also a poly1d object. Otherwise, it is a 1D array of
|
polynomial coefficients from highest to lowest degree.
|
|
See Also
|
--------
|
poly1d : A one-dimensional polynomial class.
|
poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval
|
|
Examples
|
--------
|
>>> np.polyadd([1, 2], [9, 5, 4])
|
array([9, 6, 6])
|
|
Using poly1d objects:
|
|
>>> p1 = np.poly1d([1, 2])
|
>>> p2 = np.poly1d([9, 5, 4])
|
>>> print(p1)
|
1 x + 2
|
>>> print(p2)
|
2
|
9 x + 5 x + 4
|
>>> print(np.polyadd(p1, p2))
|
2
|
9 x + 6 x + 6
|
|
r © rT r
|
r r5 r: rN r1 rU r ©rx ry rX ZdiffrZ Úzrr( r( r) r s 3
|
c C s¤ t | tpt |t}t| } t|}t|t| }|dkrF| | }nN|dkrpt || j¡}t || f¡| }n$t t||j¡}| t ||f¡ }|r t|}|S )a
|
Difference (subtraction) of two polynomials.
|
|
.. note::
|
This forms part of the old polynomial API. Since version 1.4, the
|
new polynomial API defined in `numpy.polynomial` is preferred.
|
A summary of the differences can be found in the
|
:doc:`transition guide </reference/routines.polynomials>`.
|
|
Given two polynomials `a1` and `a2`, returns ``a1 - a2``.
|
`a1` and `a2` can be either array_like sequences of the polynomials'
|
coefficients (including coefficients equal to zero), or `poly1d` objects.
|
|
Parameters
|
----------
|
a1, a2 : array_like or poly1d
|
Minuend and subtrahend polynomials, respectively.
|
|
Returns
|
-------
|
out : ndarray or poly1d
|
Array or `poly1d` object of the difference polynomial's coefficients.
|
|
See Also
|
--------
|
polyval, polydiv, polymul, polyadd
|
|
Examples
|
--------
|
.. math:: (2 x^2 + 10 x - 2) - (3 x^2 + 10 x -4) = (-x^2 + 2)
|
|
>>> np.polysub([2, 10, -2], [3, 10, -4])
|
array([-1, 0, 2])
|
|
r r{ r| r( r( r) r W s %
|
c C sB t | tpt |t}t| t| } }t | |¡}|r>t|}|S )a;
|
Find the product of two polynomials.
|
|
.. note::
|
This forms part of the old polynomial API. Since version 1.4, the
|
new polynomial API defined in `numpy.polynomial` is preferred.
|
A summary of the differences can be found in the
|
:doc:`transition guide </reference/routines.polynomials>`.
|
|
Finds the polynomial resulting from the multiplication of the two input
|
polynomials. Each input must be either a poly1d object or a 1D sequence
|
of polynomial coefficients, from highest to lowest degree.
|
|
Parameters
|
----------
|
a1, a2 : array_like or poly1d object
|
Input polynomials.
|
|
Returns
|
-------
|
out : ndarray or poly1d object
|
The polynomial resulting from the multiplication of the inputs. If
|
either inputs is a poly1d object, then the output is also a poly1d
|
object. Otherwise, it is a 1D array of polynomial coefficients from
|
highest to lowest degree.
|
|
See Also
|
--------
|
poly1d : A one-dimensional polynomial class.
|
poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval
|
convolve : Array convolution. Same output as polymul, but has parameter
|
for overlap mode.
|
|
Examples
|
--------
|
>>> np.polymul([1, 2, 3], [9, 5, 1])
|
array([ 9, 23, 38, 17, 3])
|
|
Using poly1d objects:
|
|
>>> p1 = np.poly1d([1, 2, 3])
|
>>> p2 = np.poly1d([9, 5, 1])
|
>>> print(p1)
|
2
|
1 x + 2 x + 3
|
>>> print(p2)
|
2
|
9 x + 5 x + 1
|
>>> print(np.polymul(p1, p2))
|
4 3 2
|
9 x + 23 x + 38 x + 17 x + 3
|
|
)rT r
|
r: r; )rx ry rX rZ r( r( r) r s 7 c C s | |fS r* r( )ÚuÚvr( r( r) Ú_polydiv_dispatcherÌ s r c C s( t | tpt |t}t| d } t|d }| d |d }t| d }t|d }d|d }t t|| d df|j¡}| |j¡}t d|| d D ]8} ||| }
|
|
|
|| < || | | d
|
|
| 8 < qtj
|
|d dddr
|
|j d dkr
|
|dd
}qÖ|r t|t|fS ||fS ) a
|
|
Returns the quotient and remainder of polynomial division.
|
|
.. note::
|
This forms part of the old polynomial API. Since version 1.4, the
|
new polynomial API defined in `numpy.polynomial` is preferred.
|
A summary of the differences can be found in the
|
:doc:`transition guide </reference/routines.polynomials>`.
|
|
The input arrays are the coefficients (including any coefficients
|
equal to zero) of the "numerator" (dividend) and "denominator"
|
(divisor) polynomials, respectively.
|
|
Parameters
|
----------
|
u : array_like or poly1d
|
Dividend polynomial's coefficients.
|
|
v : array_like or poly1d
|
Divisor polynomial's coefficients.
|
|
Returns
|
-------
|
q : ndarray
|
Coefficients, including those equal to zero, of the quotient.
|
r : ndarray
|
Coefficients, including those equal to zero, of the remainder.
|
|
See Also
|
--------
|
poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub
|
polyval
|
|
Notes
|
-----
|
Both `u` and `v` must be 0-d or 1-d (ndim = 0 or 1), but `u.ndim` need
|
not equal `v.ndim`. In other words, all four possible combinations -
|
``u.ndim = v.ndim = 0``, ``u.ndim = v.ndim = 1``,
|
``u.ndim = 1, v.ndim = 0``, and ``u.ndim = 0, v.ndim = 1`` - work.
|
|
Examples
|
--------
|
.. math:: \frac{3x^2 + 5x + 2}{2x + 1} = 1.5x + 1.75, remainder 0.25
|
|
>>> x = np.array([3.0, 5.0, 2.0])
|
>>> y = np.array([2.0, 1.0])
|
>>> np.polydiv(x, y)
|
(array([1.5 , 1.75]), array([0.25]))
|
|
rc r r. r/ g+¡=)ZrtolrJ N) rT r
|
r r5 r: rN Úmaxr1 r7 ÚrangeZallcloser4 ) r~ r rX r` rQ r\ rr ÚqÚrrR Údr( r( r) r Ð s$ 4 "&z \*\*([0-9]*)éF c C s d}d}d}d}t | |¡}|d kr&qò| ¡ }| ¡ d }| ||d
} |d }| dt|d }
|
dt| d | } t|t|
|
|ks¢t|t| |krÀ||d | d 7 }| }|
|
}q|| dt|d 7 }|dt| d | 7 }q||d | 7 }|| |d
S )Nr Ú ú r. Ú
|
z
|
)Ú _poly_matÚsearchÚspanÚgroupsr5 ) ZastrÚwrapr\ Zline1Zline2ÚoutputÚmatr ÚpowerZpartstrZtoadd2Ztoadd1r( r( r) Ú _raise_power s. ÿr c @ sP e Zd ZdZdZedd Zejdd Zedd Zedd Z ed
|
d Z
|
ed d Z e jdd Z e
|
Z e Z ZZe ZdBddZdCddZdd Zdd Zdd Zdd Zd d Zd d Zd d! Zd"d# Zd$d% Zd&d' Z d(d) Z d*d+ Z d,d- Z d.d/ Z e Z!d0d1 Z"e"Z#d2d3 Z$d4d5 Z%d6d7 Z&d8d9 Z'd:d; Z(dDd>d?Z)dEd@dAZ*dS )Fr
|
aX
|
A one-dimensional polynomial class.
|
|
.. note::
|
This forms part of the old polynomial API. Since version 1.4, the
|
new polynomial API defined in `numpy.polynomial` is preferred.
|
A summary of the differences can be found in the
|
:doc:`transition guide </reference/routines.polynomials>`.
|
|
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
|
:math:`x^2 + 2x + 3`, whereas ``poly1d([1, 2, 3], True)`` returns
|
one that represents :math:`(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6`.
|
r : bool, optional
|
If True, `c_or_r` specifies the polynomial's roots; the default
|
is False.
|
variable : str, optional
|
Changes the variable used when printing `p` from `x` to `variable`
|
(see Examples).
|
|
Examples
|
--------
|
Construct the polynomial :math:`x^2 + 2x + 3`:
|
|
>>> p = np.poly1d([1, 2, 3])
|
>>> print(np.poly1d(p))
|
2
|
1 x + 2 x + 3
|
|
Evaluate the polynomial at :math:`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 `p` can be modified,
|
using the `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])
|
|
Nc C s | j S )z The polynomial coefficients )Ú_coeffs©Úselfr( r( r) Úcoeffs¡ s z poly1d.coeffsc C s || j k rtdd S )NzCannot set attribute)r ÚAttributeError)r Úvaluer( r( r) r ¦ s
|
c C s | j S )z% The name of the polynomial variable )Ú _variabler r( r( r) Úvariable¬ s zpoly1d.variablec C s t | jd S )z' The order or degree of the polynomial r. )r5 r r r( r( r) ro ² s z poly1d.orderc C s
|
t | jS )z1 The roots of the polynomial, where self(x) == 0 )r r r r( r( r) r · s z poly1d.rootsc C s
|
| j d S ©Nr ©Ú__dict__r r( r( r) r ¾ s zpoly1d._coeffsc C s || j d< d S r r )r r r( r( r) r Á s Fc C sÎ t |trb|j| _|j| _t|jt| j rPd}tj|tdd | j |j¡ |d k r^|| _d S |rnt
|
|}t |}|j dkrt dt|dd}t|dkr²tjdg|jd }|| _|d krÄd
|
}|| _d S ) NzbIn the future extra properties will not be copied across when constructing one poly1d from anotherr- re r. zPolynomial must be 1d only.Úf)Ztrimr r0 r] )rT r
|
r r Úsetr rl rm Ú FutureWarningÚupdater r rK r9 r r5 r: r r1 )r Zc_or_rr r ru r( r( r) Ú__init__Ê s,
|
|
zpoly1d.__init__c C s" |rt | j|¡S t | j¡S d S r* )r: r? r )r Útr( r( r) Ú __array__å s zpoly1d.__array__c C s t | j}|dd
}d| S )Né rJ z
|
poly1d(%s))Úreprr )r Úvalsr( r( r) Ú__repr__ë s
|
zpoly1d.__repr__c C s | j S r* )ro r r( r( r) Ú__len__ð s zpoly1d.__len__c C s d}| j }| jtj | jdk¡ }t|d }dd }t|D ]B\}}t|s^|t|}n:t|dkr|d|t | }n d|t||t |f }|| } | dkrÐ|dkr¼d|f }
|
n|dkrÊd}
|
nd }
|
nj| dkr|dkrèd }
|
n|d
|
krö|}
|
n d ||f }
|
n6|dkrd }
|
n&|d
|
kr,d || f }
|
nd ||| f }
|
|dkr~|
|
d kr|
|
|
d¡rpd||
|
dd
f }n d||
|
f }q>|
|
}q>t |S )NÚ0r r. c S s" d| }| d¡r |d d
}|S )Nz%.4gz.0000éûÿÿÿ)Úendswith)r rt r( r( r) Ú fmt_floatû s
|
z!poly1d.__str__.<locals>.fmt_floatz%sjz
|
(%s + %sj)z%sr Úbz%s %sz%s**%dz %s %s**%dú-z%s - %sz%s + %s) r r r: Ú
|
logical_orÚ
|
accumulater5 Ú enumerater r r Ú
|
startswithr ) r ZthestrÚvarr rO r rR ZcoeffZcoefstrr Znewstrr( r( r) Ú__str__ó sL
|
ÿ
|
|
|
|
|
zpoly1d.__str__c C s t | j|S r* )r r )r rZ r( r( r) Ú__call__, s zpoly1d.__call__c C s t | j S r* )r
|
r r r( r( r) Ú__neg__/ s zpoly1d.__neg__c C s | S r* r( r r( r( r) Ú__pos__2 s zpoly1d.__pos__c C s4 t |rt| j| S t|}tt| j|jS d S r* ©r r
|
r r ©r Úotherr( r( r) Ú__mul__5 s zpoly1d.__mul__c C s4 t |rt|| j S t|}tt| j|jS d S r* r¹ rº r( r( r) Ú__rmul__< s zpoly1d.__rmul__c C s t |}t t| j|jS r* ©r
|
r r rº r( r( r) Ú__add__C s zpoly1d.__add__c C s t |}t t| j|jS r* r¾ rº r( r( r) Ú__radd__G s zpoly1d.__radd__c C sL t |r t||ks |dk r$tddg}t|D ]}t| j|}q2t|S )Nr z$Power to non-negative integers only.r. )r rL r9 r r r r
|
)r rZ ÚresÚ_r( r( r) Ú__pow__K s zpoly1d.__pow__c C s t |}t t| j|jS r* ©r
|
r r rº r( r( r) Ú__sub__S s zpoly1d.__sub__c C s t |}t t|j| jS r* rÄ rº r( r( r) Ú__rsub__W s zpoly1d.__rsub__c C s, t |rt| j| S t|}t| |S d S r* ©r r
|
r r rº r( r( r) Ú__div__[ s zpoly1d.__div__c C s, t |rt|| j S t|}t|| S d S r* rÇ rº r( r( r) Ú__rdiv__d s zpoly1d.__rdiv__c C s2 t |tstS | jj|jjkr"dS | j|jk ¡ S )NF)rT r
|
ÚNotImplementedr r4 rA rº r( r( r) Ú__eq__m s
|
|
z poly1d.__eq__c C s t |tstS | |¡ S r* )rT r
|
rÊ rË rº r( r( r) Ú__ne__t s
|
z poly1d.__ne__c C sB | j | }|| j kr"| jj d¡S |dk r8| jj d¡S | j| S )Nr )ro r r1 r= )r rZ Úindr( r( r) Ú __getitem__z s
|
|
zpoly1d.__getitem__c C s^ | j | }|dk rtd|| j krPt || j | jj¡}t || jf¡| _d}|| j|< d S )Nr z!Does not support negative powers.)ro r9 r: rN r r1 rU r )r ÚkeyrZ rÍ r} r( r( r) Ú __setitem__ s
|
|
|
zpoly1d.__setitem__c C s
|
t | jS r* )Úiterr r r( r( r) Ú__iter__ s zpoly1d.__iter__r. r c C s t t| j||dS )zÒ
|
Return an antiderivative (indefinite integral) of this polynomial.
|
|
Refer to `polyint` for full documentation.
|
|
See Also
|
--------
|
polyint : equivalent function
|
|
)rQ rR )r
|
r r )r rQ rR r( r( r) Úinteg s z poly1d.integc C s t t| j|dS )z·
|
Return a derivative of this polynomial.
|
|
Refer to `polyder` for full documentation.
|
|
See Also
|
--------
|
polyder : equivalent function
|
|
)rQ )r
|
r r )r rQ r( r( r) Úderiv s z poly1d.deriv)FN)N)r. r )r. )+r$ r% r& r' Ú__hash__Úpropertyr Úsetterr ro r r r rs ZcoefZ coefficientsÚor¢ r¤ r¨ r© rµ r¶ r· r¸ r¼ r½ r¿ rÀ rà rÅ rÆ rÈ rV rÉ Ú __rtruediv__rË rÌ rÎ rÐ rÒ rÓ rÔ r( r( r( r) r
|
4 sZ i
|
|
|
|
|
|
|
|
|
9
|
Úalways)NN)r. N)N)r. )NNNN)NFNF)r )>r' Ú__all__Ú functoolsÚrerl Znumpy.core.numericÚcoreÚnumericr: Z
|
numpy.corer r r r r r r r r Znumpy.core.overridesr Znumpy.lib.twodim_baser r Znumpy.lib.function_baser Znumpy.lib.type_checkr r r r Z numpy.linalgr r r! ÚpartialZarray_function_dispatchÚ UserWarningr r, r rI r rS r r[ r rb r rv r rz r r r r r Úcompiler r r
|
Ú simplefilterr( r( r( r) Ú<module> s|
|
þ( ÿ
|
z
|
[
|
d
|
K
|
x
|
N
|
C
|
5
|
>
|
G
|
|
y
|
