Ë
|
Kñúhx[ ã óÆ d Z ddlZddlZddlZddlZddlmZmZ ddl m
|
Z
|
g d¢Z d Z ddZ ddZd Zd
|
Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd ZddZd Z d Z d dZ y) an
|
Utility classes and functions for the polynomial modules.
|
|
This module provides: error and warning objects; a polynomial base class;
|
and some routines used in both the `polynomial` and `chebyshev` modules.
|
|
Functions
|
---------
|
|
.. autosummary::
|
:toctree: generated/
|
|
as_series convert list of array_likes into 1-D arrays of common type.
|
trimseq remove trailing zeros.
|
trimcoef remove small trailing coefficients.
|
getdomain return the domain appropriate for a given set of abscissae.
|
mapdomain maps points between domains.
|
mapparms parameters of the linear map between domains.
|
|
é N)Údragon4_positionalÚdragon4_scientific)Ú RankWarning)Ú as_seriesÚtrimseqÚtrimcoefÚ getdomainÚ mapdomainÚmapparmsÚ format_floatc ó t | « dk( s| d dk7 r| S t t | « dz
|
dd« D ] }| | dk7 s n | ddz S )aÍ Remove small Poly series coefficients.
|
|
Parameters
|
----------
|
seq : sequence
|
Sequence of Poly series coefficients.
|
|
Returns
|
-------
|
series : sequence
|
Subsequence with trailing zeros removed. If the resulting sequence
|
would be empty, return the first element. The returned sequence may
|
or may not be a view.
|
|
Notes
|
-----
|
Do not lose the type info if the sequence contains unknown objects.
|
|
r éÿÿÿÿé N)ÚlenÚrange)ÚseqÚis úMH:\Change_password\venv_build\Lib\site-packages\numpy/polynomial/polyutils.pyr r $ s^ ô( 3x1}B 1 Ø
|
äs3x !| R¨Ó,ò AØ1v{Ùð ð 6AE{Ðó c óø | D cg c] }t j |dd¬« }}|D ]6 }|j dk( r t d« |j dk7 s-t d« |r|D cg c] }t |« }} t j | }|D cg c] }t j |d|¬« }}|S c c}w c c}w c c}w # t $ r¬}t j j « }d }g }|D ]l }|j |k7 r:t j t |« |¬
|
« } |dd | dd |j | « Ld}|j |j « « n |s t d « |Y d}~|S d}~ww xY w) a-
|
Return argument as a list of 1-d arrays.
|
|
The returned list contains array(s) of dtype double, complex double, or
|
object. A 1-d argument of shape ``(N,)`` is parsed into ``N`` arrays of
|
size one; a 2-d argument of shape ``(M,N)`` is parsed into ``M`` arrays
|
of size ``N`` (i.e., is "parsed by row"); and a higher dimensional array
|
raises a Value Error if it is not first reshaped into either a 1-d or 2-d
|
array.
|
|
Parameters
|
----------
|
alist : array_like
|
A 1- or 2-d array_like
|
trim : boolean, optional
|
When True, trailing zeros are removed from the inputs.
|
When False, the inputs are passed through intact.
|
|
Returns
|
-------
|
[a1, a2,...] : list of 1-D arrays
|
A copy of the input data as a list of 1-d arrays.
|
|
Raises
|
------
|
ValueError
|
Raised when `as_series` cannot convert its input to 1-d arrays, or at
|
least one of the resulting arrays is empty.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> from numpy.polynomial import polyutils as pu
|
>>> a = np.arange(4)
|
>>> pu.as_series(a)
|
[array([0.]), array([1.]), array([2.]), array([3.])]
|
>>> b = np.arange(6).reshape((2,3))
|
>>> pu.as_series(b)
|
[array([0., 1., 2.]), array([3., 4., 5.])]
|
|
>>> pu.as_series((1, np.arange(3), np.arange(2, dtype=np.float16)))
|
[array([1.]), array([0., 1., 2.]), array([0., 1.])]
|
|
>>> pu.as_series([2, [1.1, 0.]])
|
[array([2.]), array([1.1])]
|
|
>>> pu.as_series([2, [1.1, 0.]], trim=False)
|
[array([2.]), array([1.1, 0. ])]
|
|
r N)ÚndminÚcopyr zCoefficient array is emptyz Coefficient array is not 1-dT)r ÚdtypeF©r z&Coefficient arrays have no common type)ÚnpÚarrayÚsizeÚ
|
ValueErrorÚndimr Ú common_typeÚ ExceptionÚdtypesÚ ObjectDTyper Úemptyr Úappendr )
|
ÚalistÚtrimÚaÚarraysr ÚretÚeÚ object_dtypeÚhas_one_object_typeÚtmps
|
r r r A sy ðf 8=Ö =°!bhhq ¨Ö-Ð =FÐ =Ø ò =Ø 66Q;Ü Ð 9Ó:Ð :Ø 66Q;Ü Ð ;Ó<Ð <ð =ñ
|
Ø&,Ö- '!*Ð-Ð-ðDÜ Ð'ð =CÖC°qrxx ¨EÖ2ÐCÐCØ Jùò7 >ùò .ùò& Døô ò NÜyy×,Ñ,Ó. Ø #ÐØØò %AØww,Ò&Ühhs 1v¨\Ô:Ø1AØ
|
|
3à&*Ð#Ø
|
|
1668Õ$ð %ñ #Ü Ð EÓFÈAÐ Mó #ð Jûð! Nús*
B5Á'B:Á<C Â B?Ã E9Ã B!E4Å4E9c óö |dk r t d« t | g« \ } t j t j | « |kD « \ }t |« dk( r| dd dz S | d|d dz j « S )a
|
Remove "small" "trailing" coefficients from a polynomial.
|
|
"Small" means "small in absolute value" and is controlled by the
|
parameter `tol`; "trailing" means highest order coefficient(s), e.g., in
|
``[0, 1, 1, 0, 0]`` (which represents ``0 + x + x**2 + 0*x**3 + 0*x**4``)
|
both the 3-rd and 4-th order coefficients would be "trimmed."
|
|
Parameters
|
----------
|
c : array_like
|
1-d array of coefficients, ordered from lowest order to highest.
|
tol : number, optional
|
Trailing (i.e., highest order) elements with absolute value less
|
than or equal to `tol` (default value is zero) are removed.
|
|
Returns
|
-------
|
trimmed : ndarray
|
1-d array with trailing zeros removed. If the resulting series
|
would be empty, a series containing a single zero is returned.
|
|
Raises
|
------
|
ValueError
|
If `tol` < 0
|
|
Examples
|
--------
|
>>> from numpy.polynomial import polyutils as pu
|
>>> pu.trimcoef((0,0,3,0,5,0,0))
|
array([0., 0., 3., 0., 5.])
|
>>> pu.trimcoef((0,0,1e-3,0,1e-5,0,0),1e-3) # item == tol is trimmed
|
array([0.])
|
>>> i = complex(0,1) # works for complex
|
>>> pu.trimcoef((3e-4,1e-3*(1-i),5e-4,2e-5*(1+i)), 1e-3)
|
array([0.0003+0.j , 0.001 -0.001j])
|
|
r ztol must be non-negativeNr r )r r r ÚnonzeroÚabsr r )ÚcÚtolÚinds r r r sy ðP QwÜÐ3Ó4Ð4ä
|
QC.CQÜ JJrvvay 3Ó 'ESÜ
|
3x1}Ø!uqyÐà #b'A+×#Ñ#Ó%Ð%r c ó t | gd¬« \ } | j j t j d v r| j
|
j « | j
|
j « }}| j j « | j j « }}t j t ||« t ||« f« S t j | j « | j « f« S )aV
|
Return a domain suitable for given abscissae.
|
|
Find a domain suitable for a polynomial or Chebyshev series
|
defined at the values supplied.
|
|
Parameters
|
----------
|
x : array_like
|
1-d array of abscissae whose domain will be determined.
|
|
Returns
|
-------
|
domain : ndarray
|
1-d array containing two values. If the inputs are complex, then
|
the two returned points are the lower left and upper right corners
|
of the smallest rectangle (aligned with the axes) in the complex
|
plane containing the points `x`. If the inputs are real, then the
|
two points are the ends of the smallest interval containing the
|
points `x`.
|
|
See Also
|
--------
|
mapparms, mapdomain
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> from numpy.polynomial import polyutils as pu
|
>>> points = np.arange(4)**2 - 5; points
|
array([-5, -4, -1, 4])
|
>>> pu.getdomain(points)
|
array([-5., 4.])
|
>>> c = np.exp(complex(0,1)*np.pi*np.arange(12)/6) # unit circle
|
>>> pu.getdomain(c)
|
array([-1.-1.j, 1.+1.j])
|
|
F©r' ÚComplex) r r Úcharr Ú typecodesÚrealÚminÚmaxÚimagr Úcomplex)ÚxÚrminÚrmaxÚiminÚimaxs r r r Ä sª ôN QCeÔ
|
$CQØww||r|| IÑ.Ñ.ØVVZZ\ 1§6¡6§:¡:£<dØVVZZ\ 1§6¡6§:¡:£<dÜxx tÓ,¬g°d¸DÓ.AÐBÓCÐCäxx !§%¡%£'Ð*Ó+Ð+r c ót | d | d z
|
}|d |d z
|
}| d |d z | d |d z z
|
|z }||z }||fS )aì
|
Linear map parameters between domains.
|
|
Return the parameters of the linear map ``offset + scale*x`` that maps
|
`old` to `new` such that ``old[i] -> new[i]``, ``i = 0, 1``.
|
|
Parameters
|
----------
|
old, new : array_like
|
Domains. Each domain must (successfully) convert to a 1-d array
|
containing precisely two values.
|
|
Returns
|
-------
|
offset, scale : scalars
|
The map ``L(x) = offset + scale*x`` maps the first domain to the
|
second.
|
|
See Also
|
--------
|
getdomain, mapdomain
|
|
Notes
|
-----
|
Also works for complex numbers, and thus can be used to calculate the
|
parameters required to map any line in the complex plane to any other
|
line therein.
|
|
Examples
|
--------
|
>>> from numpy.polynomial import polyutils as pu
|
>>> pu.mapparms((-1,1),(-1,1))
|
(0.0, 1.0)
|
>>> pu.mapparms((1,-1),(-1,1))
|
(-0.0, -1.0)
|
>>> i = complex(0,1)
|
>>> pu.mapparms((-i,-1),(1,i))
|
((1+1j), (1-0j))
|
|
r r © )ÚoldÚnewÚoldlenÚnewlenÚoffÚscls r r r ó s` ðR Vc!f_FØ Vc!f_FØ q6CF?S V c¨!¡f_Ñ ,°Ñ
|
6CØ
|
6/CØ 8Or c óÆ t | « t t t fvr/t | t
|
j « st j | « } t ||« \ }}||| z z S )aN
|
Apply linear map to input points.
|
|
The linear map ``offset + scale*x`` that maps the domain `old` to
|
the domain `new` is applied to the points `x`.
|
|
Parameters
|
----------
|
x : array_like
|
Points to be mapped. If `x` is a subtype of ndarray the subtype
|
will be preserved.
|
old, new : array_like
|
The two domains that determine the map. Each must (successfully)
|
convert to 1-d arrays containing precisely two values.
|
|
Returns
|
-------
|
x_out : ndarray
|
Array of points of the same shape as `x`, after application of the
|
linear map between the two domains.
|
|
See Also
|
--------
|
getdomain, mapparms
|
|
Notes
|
-----
|
Effectively, this implements:
|
|
.. math::
|
x\_out = new[0] + m(x - old[0])
|
|
where
|
|
.. math::
|
m = \frac{new[1]-new[0]}{old[1]-old[0]}
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> from numpy.polynomial import polyutils as pu
|
>>> old_domain = (-1,1)
|
>>> new_domain = (0,2*np.pi)
|
>>> x = np.linspace(-1,1,6); x
|
array([-1. , -0.6, -0.2, 0.2, 0.6, 1. ])
|
>>> x_out = pu.mapdomain(x, old_domain, new_domain); x_out
|
array([ 0. , 1.25663706, 2.51327412, 3.76991118, 5.02654825, # may vary
|
6.28318531])
|
>>> x - pu.mapdomain(x_out, new_domain, old_domain)
|
array([0., 0., 0., 0., 0., 0.])
|
|
Also works for complex numbers (and thus can be used to map any line in
|
the complex plane to any other line therein).
|
|
>>> i = complex(0,1)
|
>>> old = (-1 - i, 1 + i)
|
>>> new = (-1 + i, 1 - i)
|
>>> z = np.linspace(old[0], old[1], 6); z
|
array([-1. -1.j , -0.6-0.6j, -0.2-0.2j, 0.2+0.2j, 0.6+0.6j, 1. +1.j ])
|
>>> new_z = pu.mapdomain(z, old, new); new_z
|
array([-1.0+1.j , -0.6+0.6j, -0.2+0.2j, 0.2-0.2j, 0.6-0.6j, 1.0-1.j ]) # may vary
|
|
) ÚtypeÚintÚfloatr> Ú
|
isinstancer ÚgenericÚ
|
asanyarrayr )r? rF rG rJ rK s r r
|
r
|
" sQ ô@ AwsE¤7Ð+Ñ+´J¸qÄ"Ç*Á*Ô4MÜ MM!Ó ÜSÓ!HCØ q=Ðr c ó\ t j g|z }t d « || < t |« S ©N)r ÚnewaxisÚsliceÚtuple)r r Úsls r Ú
|
_nth_slicerY h s) Ü
|
** Ñ BÜ $KBqEÜ 9Ðr c óª t « t « k7 rt d dt « « t « k7 rt d dt « « dk( r t d« t t j t « « dz « fdt « D « }t j t j |« S )am
|
A generalization of the Vandermonde matrix for N dimensions
|
|
The result is built by combining the results of 1d Vandermonde matrices,
|
|
.. math::
|
W[i_0, \ldots, i_M, j_0, \ldots, j_N] = \prod_{k=0}^N{V_k(x_k)[i_0, \ldots, i_M, j_k]}
|
|
where
|
|
.. math::
|
N &= \texttt{len(points)} = \texttt{len(degrees)} = \texttt{len(vander\_fs)} \\
|
M &= \texttt{points[k].ndim} \\
|
V_k &= \texttt{vander\_fs[k]} \\
|
x_k &= \texttt{points[k]} \\
|
0 \le j_k &\le \texttt{degrees[k]}
|
|
Expanding the one-dimensional :math:`V_k` functions gives:
|
|
.. math::
|
W[i_0, \ldots, i_M, j_0, \ldots, j_N] = \prod_{k=0}^N{B_{k, j_k}(x_k[i_0, \ldots, i_M])}
|
|
where :math:`B_{k,m}` is the m'th basis of the polynomial construction used along
|
dimension :math:`k`. For a regular polynomial, :math:`B_{k, m}(x) = P_m(x) = x^m`.
|
|
Parameters
|
----------
|
vander_fs : Sequence[function(array_like, int) -> ndarray]
|
The 1d vander function to use for each axis, such as ``polyvander``
|
points : Sequence[array_like]
|
Arrays of point coordinates, all of the same shape. The dtypes
|
will be converted to either float64 or complex128 depending on
|
whether any of the elements are complex. Scalars are converted to
|
1-D arrays.
|
This must be the same length as `vander_fs`.
|
degrees : Sequence[int]
|
The maximum degree (inclusive) to use for each axis.
|
This must be the same length as `vander_fs`.
|
|
Returns
|
-------
|
vander_nd : ndarray
|
An array of shape ``points[0].shape + tuple(d + 1 for d in degrees)``.
|
z Expected z" dimensions of sample points, got z dimensions of degrees, got r z9Unable to guess a dtype or shape when no points are givenç c 3 ób K | ]& } | | | « d t |« z ( yw)).N)rY )Ú.0r ÚdegreesÚn_dimsÚpointsÚ vander_fss r ú <genexpr>z _vander_nd.<locals>.<genexpr>ª s? øè ø ò à ð ! VAY ¨¡
|
Ó+¨F´ZÀÀ6Ó5JÑ,JÕKñùs ,/)
|
r r rW r Úasarrayr Ú functoolsÚreduceÚoperatorÚmul)ra r` r^ Ú vander_arraysr_ s ``` @r Ú
|
_vander_ndri n sÌ û ôZ ^FØ VÒ ÜØxÐ AÄ#ÀfÃ+À Ð OóQð Qà W Ò ÜØxÐ ;¼CÀ»L¸>Ð JóLð Là {ÜÐTÓUÐUô 2::e FmÓ,¨sÑ2Ó 3Föäv ôMô × Ñ HLL¨-Ó 8Ð8r c ór t | ||« }|j |j dt |« dz « S )z
|
Like `_vander_nd`, but flattens the last ``len(degrees)`` axes into a single axis
|
|
Used to implement the public ``<type>vander<n>d`` functions.
|
N)r )ri ÚreshapeÚshaper )ra r` r^ Úvs r Ú_vander_nd_flatrn ³ s7 ô 9f gÓ.AØ 99QWW^s 7|mÐ,¨uÑ4Ó 5Ð5r c ó t |« dk( rt j d« S t |gd¬« \ }|j « |D cg c] } | | d« }}t |« }|dkD rUt |d« \ }}t |« D cg c] } ||| |||z « }}|r ||d |d « |d< |}|}|dkD rU|d S c c}w c c}w )a
|
Helper function used to implement the ``<type>fromroots`` functions.
|
|
Parameters
|
----------
|
line_f : function(float, float) -> ndarray
|
The ``<type>line`` function, such as ``polyline``
|
mul_f : function(array_like, array_like) -> ndarray
|
The ``<type>mul`` function, such as ``polymul``
|
roots
|
See the ``<type>fromroots`` functions for more detail
|
r r Fr6 é r )r r Úonesr ÚsortÚdivmodr ) Úline_fÚmul_fÚrootsÚrÚpÚnÚmr r. s r Ú
|
_fromrootsr{ ½ sÝ ô 5zQÜwwqzÐäUG¨%Ô0Ø
|
|
Ø$)Ö *qVQB]Ð *Ð *Ü FØ!eÜ!Q<DAqÜ27¸³(Ö;¨Q51q Q¡xÕ(Ð;CÐ;ÙÙ s 1v q¨¡uÓ-AØAØAð !eð t ùò +ùò <s ÁCÂC
|
c ó~ |D cg c] }t j |« }}|d j t fd|dd D « « s=t |« dk( r t d« t |« dk( r t d« t d « t |« }t |« } | ||« }|D ] } | ||d
|
¬ « } |S c c}w ) a4
|
Helper function used to implement the ``<type>val<n>d`` functions.
|
|
Parameters
|
----------
|
val_f : function(array_like, array_like, tensor: bool) -> array_like
|
The ``<type>val`` function, such as ``polyval``
|
c, args
|
See the ``<type>val<n>d`` functions for more detail
|
r c 3 ó< K | ] }|j k( y wrT )rl )r] r( Úshape0s r rb z_valnd.<locals>.<genexpr>è s øè ø Ò3 Qqww&Õ Ñ3ùs r Né zx, y, z are incompatiblerp zx, y are incompatiblezordinates are incompatibleF)Útensor)r rR rl Úallr r ÚiterÚnext)Úval_fr2 Úargsr( ÚitÚx0Úxir~ s @r Ú_valndr Û s ø ð '+Ö + BMM!Õ Ð +DÐ +Ø !W]]FÜ Ó3¨$¨q¨r¨(Ô3Ô 3Ü t9>Ü Ð 7Ó8Ð 8Ü Y!^Ü Ð 4Ó5Ð 5ä Ð 9Ó:Ð :Ü dBÜ bBñ b! AØò 'Ù "a Ô &ð'à Hùò! ,s B:c ó& |D ] } | ||« } |S )a6
|
Helper function used to implement the ``<type>grid<n>d`` functions.
|
|
Parameters
|
----------
|
val_f : function(array_like, array_like, tensor: bool) -> array_like
|
The ``<type>val`` function, such as ``polyval``
|
c, args
|
See the ``<type>grid<n>d`` functions for more detail
|
rE )r r2 r
r s r Ú_gridndr ù s# ð ò Ù "aLðà Hr c ó¦ t ||g« \ }}|d dk( rt t |« }t |« }||k r
|
|dd dz |fS |dk( r||d z |dd dz fS t j ||z
|
dz |j
|
¬« }|}t ||z
|
dd« D ]1 } | dg|z dgz |« }|d |d z } |dd | |dd z z
|
}| ||< 3 |t |« fS )a¸
|
Helper function used to implement the ``<type>div`` functions.
|
|
Implementation uses repeated subtraction of c2 multiplied by the nth basis.
|
For some polynomial types, a more efficient approach may be possible.
|
|
Parameters
|
----------
|
mul_f : function(array_like, array_like) -> array_like
|
The ``<type>mul`` function, such as ``polymul``
|
c1, c2
|
See the ``<type>div`` functions for more detail
|
r r Nr r )r ÚZeroDivisionErrorr r r$ r r r )
|
ru Úc1Úc2Úlc1Úlc2ÚquoÚremr rx Úqs
|
r Ú_divr s ô "bÓ"HRØ "v{Ü Ð ä
|
b'CÜ
|
b'CØ
|
SyØ"1vz2~Ð Ø ØBrF{Br F QJÐ&Ð&ähhsSy 1}¨B¯H©HÔ5ØÜsSy # rÓ*ò AÙqcAg m RÓ(AØB!B%AØcr(Q 3 B ZÑ'CØCFð ð
|
GCLÐ Ð r c óä t | |g« \ } }t | « t |« kD r%| d|j xxx |z ccc | }t |« S |d| j xxx | z ccc |}t |« S )z@ Helper function used to implement the ``<type>add`` functions. N©r r r r ©r r r* s r Ú_addr - sp ô "bÓ"HRÜ
|
2wRÒØ
|
8BGG Ñ Øô 3<Ðð 8BGG Ñ ØÜ 3<Ðr c óê t | |g« \ } }t | « t |« kD r%| d|j xxx |z ccc | }t |« S | }|d| j xxx | z ccc |}t |« S )z@ Helper function used to implement the ``<type>sub`` functions. Nr r s r Ú_subr : sw ô "bÓ"HRÜ
|
2wRÒØ
|
8BGG Ñ Øô
|
3<Ðð SØ
|
8BGG Ñ ØÜ 3<Ðr c óö t j |« dz }t j |« dz }t j |« }|j dkD s'|j j dvs|j
|
dk( r t d« |j « dk r t d« |j dk7 r t d« |j
|
dk( r t d« |j dk s|j d kD r t d
|
« t |« t |« k7 r t d « |j dk( r|}|dz } | ||« } n5t j |« }|d }t |« } | ||« d d
|f } | j }
|
|j } |^t j |« dz }|j dk7 r t d« t |« t |« k7 r t d« |
|
|z }
|
| |z } |5t |« t j |j « j z }t |
|
j j t j « rbt j" t j$ |
|
j& « t j$ |
|
j( « z j+ d« « } n7t j" t j$ |
|
« j+ d« « } d| | dk( < t j, j/ |
|
j | z | j |« \ } }}}| j | z j } |j dkD rn| j d k( r4t j0 |dz | j2 d f| j ¬« }n$t j0 |dz | j ¬« }| ||< |} ||k7 r |s d}t5 j6 |t8 d ¬« |r| ||||gfS | S )a
|
Helper function used to implement the ``<type>fit`` functions.
|
|
Parameters
|
----------
|
vander_f : function(array_like, int) -> ndarray
|
The 1d vander function, such as ``polyvander``
|
c1, c2
|
See the ``<type>fit`` functions for more detail
|
r[ r Úiur z0deg must be an int or non-empty 1-D array of intzexpected deg >= 0zexpected 1D vector for xz expected non-empty vector for xrp z expected 1D or 2D array for yz$expected x and y to have same lengthr Nzexpected 1D vector for wz$expected x and w to have same lengthr z!The fit may be poorly conditioned)Ú
|
stacklevel) r rc r r Úkindr Ú TypeErrorr; r r rr ÚTÚfinfoÚepsÚ
|
issubclassrM ÚcomplexfloatingÚsqrtÚsquarer: r= ÚsumÚlinalgÚlstsqÚzerosrl ÚwarningsÚwarnr )Úvander_fr? ÚyÚdegÚrcondÚfullÚwÚlmaxÚorderÚvanÚlhsÚrhsrK r2 ÚresidsÚrankÚsÚccÚmsgs r Ú_fitr¾ H s; ô
|
|
1 ÑAÜ
|
|
|
1 ÑAÜ
|
**S/Cð xx!|syy~~¨TÑ1°S·X±XÀ²]ÜÐJÓKÐKØ
|
wwy1}ÜÐ,Ó-Ð-Øvv{ÜÐ2Ó3Ð3Øvv{ÜÐ9Ó:Ð:ØvvzQVVaZÜÐ7Ó8Ð8Ü
|
1vQÒÜÐ>Ó?Ð?à
|
xx1}ØØqÙq$Ó äggclØ2wÜCÙq$Ó ¢ 3 Ñ'ð %%CØ
|
##CØ}Ü JJqMCÑ Ø 66Q;ÜÐ 6Ó7Ð 7Ü q6SVÒ ÜÐ BÓCÐ Cð AgØAgð }ÜA !§'¡'Ó*×.Ñ.Ñ.ô #))..¤"×"4Ñ"4Ô5Üggryy §¡Ó*¬R¯Y©Y°s·x±xÓ-@Ñ@×EÑEÀaÓHÓIäggbii n×(Ñ(¨Ó+Ó,ØCqMô ¨¯©°©°c·e±e¸UÓCÑAvtQØ
|
s Að xx!|Ø 66Q;Ü4 !8 Q§W¡W¨Q¡ZÐ0¸¿¹Ô@Bä$ (¨!¯'©'Ô2BØ3Ø ð u}TØ1Ü c;°1Õ5á Ø64 EÐ*Ð*Ð*àr c ó t |g« \ }t |« }||k7 s|dk r t d« |||kD r t d« |dk( r"t j dg|j
|
¬« S |dk( r|S |}t d|dz « D ] } | ||« } |S )af
|
Helper function used to implement the ``<type>pow`` functions.
|
|
Parameters
|
----------
|
mul_f : function(array_like, array_like) -> ndarray
|
The ``<type>mul`` function, such as ``polymul``
|
c : array_like
|
1-D array of array of series coefficients
|
pow, maxpower
|
See the ``<type>pow`` functions for more detail
|
r z%Power must be a non-negative integer.zPower is too larger r rp )r rN r r r r r )ru r2 ÚpowÚmaxpowerÚpowerÚprdr s r Ú_powrÄ s§ ô QC.CQÜ HEØ |uqyÜÐ@ÓAÐAØ Ð %¨(Ò"2ÜÐ-Ó.Ð.Ø !Üxx 1§7¡7Ô+Ð+Ø !Øð Üq% !)Ó$ò AÙQ-Cð à
|
r c ór t j | « S # t $ r}t | d| « |d}~ww xY w)aA
|
Like `operator.index`, but emits a custom exception when passed an
|
incorrect type
|
|
Parameters
|
----------
|
x : int-like
|
Value to interpret as an integer
|
desc : str
|
description to include in any error message
|
|
Raises
|
------
|
TypeError : if x is a float or non-numeric
|
z must be an integer, received N)rf Úindexr )r? Údescr+ s r Ú_as_intrÈ Á sB ð KÜ~~aÓ Ð øÜ ò KÜ4&Ð >¸q¸cÐBÓCÈÐJûðKús 6 1±6c ó* t j t | « t j « s t | « S t j
|
« }t j | « r|d S t j | « r|d S d}| dk7 r8t j | « }|dk\ s |dt d|d dz
|
d z « z k rd
|
}d \ }}|d d k( rd\ }}|r%t | |d |||d dk( ¬« }|rd|z dz }|S t | |d d
|
|||d dk( ¬« }|S )NÚnanstrÚinfstrFr g ×Aé
|
Ú precisionr rp T)Ú0TÚ floatmodeÚfixed)ÚkFÚsignú+)rÍ Úuniquer' rÒ ú(ú))rÍ Ú
|
fractionalrÔ r' rÒ ) r Ú
|
issubdtyperM ÚfloatingÚstrÚget_printoptionsÚisnanÚisinfr1 r; r r )r? ÚparensÚoptsÚ
|
exp_formatr( r' rÔ r» s r r r × s2 Ü ==a¤"§+¡+Ô .Ü1v ä × Ñ Ó Dä xx{ØH~Ð Ü !ØH~Ð àJØAvÜ FF1IØ 9B¤ A¨¨kÑ):¸QÑ)>Ð'?À1Ñ'DÓ EÑ EÒEØ Jà LD&Ø KÑGÒ#Ø! fáÜ q¨D°Ñ,=Ø&,°4Ø$(¨¡L°CÑ$7ô 9ñ Øa# Að Hô q¨D°Ñ,=Ø*.Ø&,°4Ø$(¨¡L°CÑ$7ô 9ð Hr )T)r )NFN)F) Ú__doc__rd rf r¬ Únumpyr Únumpy._core.multiarrayr r Únumpy.exceptionsr Ú__all__r r r r r r
|
rY ri rn r{ r r r r r r¾ rÄ rÈ r rE r r ú<module>ræ s ðñó( Û Û ã ß IÝ (ò òó:Nób0&òd-,ò^-ò^CòLò B9òJ6òò< ò< ò !!òH
|
ò ó Uòp òBKô, r
|
