| Current File : //proc/self/root/proc/self/root/lib64/python2.7/site-packages/numpy/lib/polynomial.pyo |
�
E�`Qc @ s� d Z d d d d d d d d d d
d d g Z d
d l Z d
d l Z d
d l j j Z d
d l m Z m
Z
m Z m Z m
Z
m Z d
d l m Z m Z d
d l m Z m Z d
d l m Z m Z m Z d
d l m Z m Z m Z d e f d � � YZ d � Z d � Z d e! d � Z" d d � Z# e! e$ e! e$ d � Z% d � Z& d � Z' d � Z( d � Z) d � Z* e j+ d � Z, d! d" � Z- d
e. f d# � � YZ/ e j0 d$ e � d S(% s&
Functions to operate on polynomials.
t polyt rootst polyintt polydert polyaddt polysubt polymult polydivt polyvalt poly1dt polyfitt RankWarningi����N( t isscalart abst finfot
atleast_1dt hstackt dot( t diagt vander( t
trim_zerost sort_complex( t iscomplext realt imag( t eigvalst lstsqt invc B s e Z d Z RS( s�
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`.
( t __name__t
__module__t __doc__( ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyR s c C s� t | � } | j } t | � d k rZ | d | d k rZ | d d k rZ t | � } n! t | � d k ro n t d � � t | � d k r� d Sd g } x= t t | � � D]) } t j | d | | g d d �} q� Wt | j j
t j � r�t j | t
� } t t j | j d k | � � } t j t t j | j d k | � � � } t | � t | � k r�t j | | k � r�| j j � } q�n | S( s�
Find the coefficients of a polynomial with the given sequence of roots.
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 : Evaluate a polynomial at a point.
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])
Or a square matrix object:
>>> np.poly(np.matrix(P))
array([ 1. , 0. , 0.16666667])
Note how in all cases the leading coefficient is always 1.
i i i s$ input must be 1d or square 2d array.g �?t modet full( R t shapet lenR t
ValueErrort ranget NXt convolvet
issubclasst dtypet typet complexfloatingt asarrayt complexR t compressR t conjugatet alltrueR t copy( t seq_of_zerost sht at kR t pos_rootst neg_roots( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyR s* \ 6 '! !c C s~ t | � } t | j � d k r0 t d � � n t j t j | � � d } t | � d k rk t j g � St | � | d d } | t | d � t | d � d !} t | j
j t j t j
f � s� | j t � } n t | � } | d k rJt t j | d f | j
� d � } | d | d | d d d � f <t | � } n t j g � } t | t j | | j
� f � } | S( s�
Return the roots of a polynomial with coefficients given in p.
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 complex 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 : Evaluate a polynomial at a point.
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])
i s Input must be a rank-1 array.i i����i N( R R" R! R# R% t nonzerot ravelt arrayt intR' R( R) t floatingR* t astypet floatR t onesR R t zeros( t pt non_zerot trailing_zerost Nt AR ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyR � s$ 2
%! %#!i c C s] t | � } | d k r' t d � � n | d k rH t j | t � } n t | � } t | � d k r� | d k r� | d t j | t � } n t | � | k r� t d � � n t | t
� } t j | � } | d k r� | r� t
| � S| St j | j
t j t | � d d � � | d g f � } t | | d d | d �} | rUt
| � S| Sd S( s|
Return an antiderivative (indefinite integral) of a polynomial.
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, poly1d}
Polynomial to differentiate.
A sequence is interpreted as polynomial coefficients, see `poly1d`.
m : int, optional
Order of the antiderivative. (Default: 1)
k : {None, list of `m` scalars, 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. ])
>>> 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. ])
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
i s0 Order of integral must be positive (see polyder)i s7 k must be a scalar or a rank-1 array of length 1 or >m.i����R4 N( R: R# t NoneR% R? R= R R" R> t
isinstanceR R+ t concatenatet __truediv__t arangeR ( R@ t mR4 t truepolyt yt val( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyR � s, C
:
c C s� t | � } | d k r' t d � � n t | t � } t j | � } t | � d } | d t j | d d � } | d k r� | } n t | | d � } | r� t | � } n | S( sb
Return the derivative of the specified order of a polynomial.
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.])
i s2 Order of derivative must be positive (see polyint)i i����( R: R# RF R R% R+ R" RI R ( R@ RJ RK t nRL RM ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyR F s 4 c C s t | � d } t j | � d } t j | � d } | d k rQ t d � � n | j d k ro t d � � n | j d k r� t d � � n | j d k s� | j d k r� t d � � n | j d | j d k r� t d � � n | d k rt | � t
| j � j } n t
| | � } | } | d k r�t j | � d } | j d k r]t d
� n | j d | j d k r�t d � n | | d d � t j f 9} | j d k r�| | d d � t j f 9} q�| | 9} n t j | | j d
d � � }
| |
:} t | | | � \ } } }
} | j |
j } |
| k r_| r_d } t j | t � n | rx| | |
| | f S| rt t | j | � � } | t j |
|
� :} | t | � | d } | j d k r�| | | f S| | d d � d d � t j f | f Sn | Sd S( s�
Least squares polynomial fit.
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.
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 to apply to the y-coordinates of the sample points.
cov : bool, optional
Return the estimate and the covariance matrix of the estimate
If full is True, then cov is not returned.
Returns
-------
p : ndarray, shape (M,) or (M, 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 : present only if `full` = True
Residuals of the least-squares fit, the effective rank of the scaled
Vandermonde coefficient matrix, its singular values, and the specified
value of `rcond`. For more details, see `linalg.lstsq`.
V : ndaray, 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 : Computes 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[n] + ... + x[0] * p[1] + p[0] = y[0]
x[1]**n * p[n] + ... + x[1] * p[1] + p[0] = y[1]
...
x[k]**n * p[n] + ... + x[k] * p[1] + p[0] = 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",
http://en.wikipedia.org/wiki/Curve_fitting
.. [2] Wikipedia, "Polynomial interpolation",
http://en.wikipedia.org/wiki/Polynomial_interpolation
Examples
--------
>>> 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])
It is convenient to use `poly1d` objects for dealing with polynomials:
>>> p = np.poly1d(z)
>>> p(0.5)
0.6143849206349179
>>> p(3.5)
-0.34732142857143039
>>> p(10)
22.579365079365115
High-order polynomials may oscillate wildly:
>>> p30 = np.poly1d(np.polyfit(x, y, 30))
/... RankWarning: Polyfit may be poorly conditioned...
>>> p30(4)
-0.80000000000000204
>>> p30(5)
-0.99999999999999445
>>> p30(4.5)
-0.10547061179440398
Illustration:
>>> import matplotlib.pyplot as plt
>>> xp = np.linspace(-2, 6, 100)
>>> plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--')
[<matplotlib.lines.Line2D object at 0x...>, <matplotlib.lines.Line2D object at 0x...>, <matplotlib.lines.Line2D object at 0x...>]
>>> plt.ylim(-2,2)
(-2, 2)
>>> plt.show()
i g i s expected deg >= 0s expected 1D vector for xs expected non-empty vector for xi s expected 1D or 2D array for ys$ expected x and y to have same lengths expected a 1-d array for weightss( expected w and y to have the same lengthNt axiss! Polyfit may be poorly conditionedg @( R: R% R+ R# t ndimt TypeErrort sizeR! RE R" R R( t epsR t newaxist sqrtt sumR t Tt warningst warnR R R t outer( t xRL t degt rcondR t wt covt ordert lhst rhst scalet ct residst rankt st msgt Vbaset fac( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyR
� sX �
-c C sx t j | � } t | t � r' d } n t j | � } t j | � } x, t t | � � D] } | | | | } qX W| S( sL
Evaluate a polynomial at specific values.
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, a 1D 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.
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.])
i ( R% R+ RF R t
zeros_likeR$ R" ( R@ R[ RL t i( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyR ] s ; c C s� t | t � p t | t � } t | � } t | � } t | � t | � } | d k re | | } nq | d k r� t j | | j � } t j | | f � | } n4 t j t | � | j � } | t j | | f � } | r� t | � } n | S( s3
Find the sum of two 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
i ( RF R R R" R% R? R( RG R
( t a1t a2RK t diffRM t zr( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyR � s ,
c C s� t | t � p t | t � } t | � } t | � } t | � t | � } | d k re | | } nq | d k r� t j | | j � } t j | | f � | } n4 t j t | � | j � } | t j | | f � } | r� t | � } n | S( s�
Difference (subtraction) of two 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])
i ( RF R R R" R% R? R( RG R
( Rm Rn RK Ro RM Rp ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyR � s
c C sb t | t � p t | t � } t | � t | � } } t j | | � } | r^ t | � } n | S( s�
Find the product of two 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
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
( RF R R% R& ( Rm Rn RK RM ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyR
s / c C sr t | t � p t | t � } t | � d } t | � d } | d | d } t | � d } t | � d } d | d } t j t | | d d � f | j � } | j � } xV t d | | d � D]= } | | | }
|
| | <| | | | d c !|
| 8+q� Wx= t j
| d d d d �rK| j d d k rK| d } qW| rht | � t | � f S| | f S( s�
Returns the quotient and remainder of polynomial division.
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]))
g i i g �?t rtolg�+����=i����( RF R R R" R% R? t maxR( R0 R$ t allcloseR! ( t ut vRK R^ RJ RN Rc t qt rR4 t d( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyR C s$ - )
#2s [*][*]([0-9]*)iF c C sZ d } d } d } d } x!t j | | � } | d k r= Pn | j � } | j � d } | | | d !} | d } | d t | � d }
d t | � d | } t | � t |
� | k s� t | � t | � | k r| | d | d 7} | } |
} q | | d t | � d 7} | d t | � d | 7} q | | d | 7} | | | S( Ni t t i s
s
( t _poly_matt searchRE t spant groupsR" ( t astrt wrapRN t line1t line2t outputt matR} t powert partstrt toadd2t toadd1( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt _raise_power� s.
c B s( e Z d Z d Z d Z d Z d d d � Z d d � Z d � Z d � Z
d � Z d � Z d � Z
d � Z d
� Z d � Z d � Z d
� Z d � Z d � Z d � Z d � Z e Z d � Z e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d d d � Z! d d � Z" RS( s6
A one-dimensional polynomial class.
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])
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])
i c C s% t | t � r] x+ | j j � D] } | j | | j | <q W| d k rY | | j d <n d S| rr t | � } n t | � } t | j � d k r� t d � � n t
| d d �} t | � d k r� t j d g � } n | | j d <t | � d | j d <| d k rd
} n | | j d <d S( Nt variablei s Polynomial must be 1d only.t trimt fi g t coeffsR` R[ (
RF R t __dict__t keysRE R R R" R! R# R R% R9 ( t selft c_or_rRw R� t key( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __init__ s&
c C s- | r t j | j | � St j | j � Sd S( N( R% R+ R� ( R� t t( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __array__ s c C s$ t | j � } | d d !} d | S( Ni i����s
poly1d(%s)( t reprR� ( R� t vals( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __repr__" s
c C s | j S( N( R` ( R� ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __len__' s c
C s7 d } | j } | j t j j | j d k � } t | � d } d � } x�t t | � � D]�} t | | � s� | t | | � � } nc t | | � d k r� d | t | | � � } n0 d | t | | � � | t | | � � f } | | } | d k r?| d k r!d | f } q�| d k r6d } q�d } n� | d k r�| d k r`d } q�| d k ru| } q�d
| | f } nG | d k r�d } n2 | d k r�d | | f } n d | | | f } | d k r#| d k r)| j
d
� r
d | | d f } q d | | f } q)q] | } q] Wt | � S( Nt 0i i c S s* d | } | j d � r& | d } n | S( Ns %.4gs .0000i����( t endswith( Rv Rg ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt fmt_float2 s
s %sjs
(%s + %sj)s %sRy t bs %s %ss %s**%ds %s %s**%dt -s %s - %ss %s + %s( R� R� R% t
logical_ort
accumulateR" R$ R R R t
startswithR� (
R� t thestrt varR� RC R� R4 t coefstrR� t newstr( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __str__* sJ "
c C s t | j | � S( N( R R� ( R� RM ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __call__d s c C s t | j � S( N( R R� ( R� ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __neg__g s c C s | S( N( ( R� ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __pos__j s c C sF t | � r t | j | � St | � } t t | j | j � � Sd S( N( R R R� R ( R� t other( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __mul__m s c C sF t | � r t | | j � St | � } t t | j | j � � Sd S( N( R R R� R ( R� R� ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __rmul__t s c C s% t | � } t t | j | j � � S( N( R R R� ( R� R� ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __add__{ s c C s% t | � } t t | j | j � � S( N( R R R� ( R� R� ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __radd__ s c C sv t | � s+ t | � | k s+ | d k r: t d � � n d g } x& t | � D] } t | j | � } qP Wt | � S( Ni s$ Power to non-negative integers only.i ( R R: R# R$ R R� R ( R� RM t rest _( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __pow__� s + c C s% t | � } t t | j | j � � S( N( R R R� ( R� R� ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __sub__� s c C s% t | � } t t | j | j � � S( N( R R R� ( R� R� ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __rsub__� s c C s: t | � r t | j | � St | � } t | | � Sd S( N( R R R� R ( R� R� ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __div__� s c C s: t | � r t | | j � St | � } t | | � Sd S( N( R R R� R ( R� R� ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __rdiv__� s c C s t j | j | j k � S( N( R% R/ R� ( R� R� ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __eq__� s c C s t j | j | j k � S( N( R% t anyR� ( R� R� ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __ne__� s c C s t d � � d S( Ns& Attributes cannot be changed this way.( R# ( R� R� RM ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __setattr__� s c C s | d k r t | j � S| d k r, | j S| d
k r? | j Sy | j | SWn* t k
rz t d | j | f � � n Xd S( NRw R Rd t coeft coefficientst os '%s' has no attribute '%s'( Rw s roots( Rd R� R� ( R� ( R R� R` R� t KeyErrort AttributeErrort __class__( R� R� ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __getattr__� s
c C s; | j | } | | j k r d S| d k r0 d S| j | S( Ni ( R` R� ( R� RM t ind( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __getitem__� s
c C s� | j | } | d k r( t d � � n | | j k r� t j | | j | j j � } t j | | j f � | j d <| | j d <d } n | | j d | <d S( Ni s! Does not support negative powers.R� R` ( R` R# R% R? R� R( RG R� ( R� R� RM R� Rp ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __setitem__� s
c C s
t | j � S( N( t iterR� ( R� ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt __iter__� s i c C s t t | j d | d | �� S( s�
Return an antiderivative (indefinite integral) of this polynomial.
Refer to `polyint` for full documentation.
See Also
--------
polyint : equivalent function
RJ R4 ( R R R� ( R� RJ R4 ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt integ� s c C s t t | j d | �� S( s�
Return a derivative of this polynomial.
Refer to `polyder` for full documentation.
See Also
--------
polyder : equivalent function
RJ ( R R R� ( R� RJ ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt deriv� s N(# R R R RE R� R` R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� RH R� t __rtruediv__R� R� R� R� R� R� R� R� R� ( ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyR � s@ c :
t always(1 R t __all__t reRX t numpy.core.numerict coret numericR% t
numpy.coreR R
R R R R t numpy.lib.twodim_baseR R t numpy.lib.function_baseR R t numpy.lib.type_checkR R R t numpy.linalgR R R t UserWarningR R R RE R R t FalseR
R R R R R t compileR{ R� t objectR t simplefilter( ( ( s: /usr/lib64/python2.7/site-packages/numpy/lib/polynomial.pyt <module> s6 .
x T] D� E < / 6 A � O