codekingpro/portable-devtools

1�

2z�jb[���SrS
SK
r
S
SKrS
SKrS
SKr/SQ
rSrSSj
rSSj
r	Sr3SrS	rS4r
SrSrS
rSrSrSrSrSrSSj
rSrSrSSj
rg)an5Utility classes and functions for the polynomial modules.6 7This module provides: error and warning objects; a polynomial base class;8and some routines used in both the `polynomial` and `chebyshev` modules.9 10Functions11---------12 13.. autosummary::14   :toctree: generated/15 16   as_series    convert list of array_likes into 1-D arrays of common type.17   trimseq      remove trailing zeros.18   trimcoef     remove small trailing coefficients.19   getdomain    return the domain appropriate for a given set of abscissae.20   mapdomain    maps points between domains.21   mapparms     parameters of the linear map between domains.22 23�N)�	as_series�trimseq�trimcoef�	getdomain�	mapdomain�mapparms�format_floatc
��[
U5
S
:Xd	USS
:waU$[[
U5
S-24SS5H
n
X
S
:wdM
 O USW
S-$)a�
Remove small Poly series coefficients.25 26Parameters27----------28seq : sequence29    Sequence of Poly series coefficients.30 31Returns32-------33series : sequence34    Subsequence with trailing zeros removed. If the resulting sequence35    would be empty, return the first element. The returned sequence may36    or may not be a view.37 38Notes39-----40Do not lose the type info if the sequence contains unknown objects.41 42r������
N)�len�range)�seq�
is  �`D:\code\apps\devtools\python\user_packages\Python313\site-packages\numpy/polynomial/polyutils.pyrr"sW��(�3�x�1�}��B��1���43��s�3�x�!�|�R��,�A��v��{��-��6�A�
�E�{��c	�&�UVs/sHn[R"US
SS9PM nnUH9nURS:Xa[S5
e
URS
:wdM0[S5
e
 U
(aUVs/sHn[U5
PM nn[R"U6nUVs/sHn[R"USUS9PM nnU$s snfs snfs snf![a�n[RR5nS	n/nUHmnURU:wa9[R"[U5
US449n	USSU	SS&URU	5
 MLSnURUR55
 Mo U(d[S5
UeSnAU$SnAf
f=f
)a�45Return argument as a list of 1-d arrays.46 47The returned list contains array(s) of dtype double, complex double, or48object.  A 1-d argument of shape ``(N,)`` is parsed into ``N`` arrays of49size one; a 2-d argument of shape ``(M,N)`` is parsed into ``M`` arrays50of size ``N`` (i.e., is "parsed by row"); and a higher dimensional array51raises a Value Error if it is not first reshaped into either a 1-d or 2-d52array.53 54Parameters55----------56alist : array_like57    A 1- or 2-d array_like58trim : boolean, optional59    When True, trailing zeros are removed from the inputs.60    When False, the inputs are passed through intact.61 62Returns63-------64[a1, a2,...] : list of 1-D arrays65    A copy of the input data as a list of 1-d arrays.66 67Raises68------69ValueError70    Raised when `as_series` cannot convert its input to 1-d arrays, or at71    least one of the resulting arrays is empty.72 73Examples74--------75>>> import numpy as np76>>> from numpy.polynomial import polyutils as pu77>>> a = np.arange(4)78>>> pu.as_series(a)79[array([0.]), array([1.]), array([2.]), array([3.])]80>>> b = np.arange(6).reshape((2,3))81>>> pu.as_series(b)82[array([0., 1., 2.]), array([3., 4., 5.])]83 84>>> pu.as_series((1, np.arange(3), np.arange(2, dtype=np.float16)))85[array([1.]), array([0., 1., 2.]), array([0., 1.])]86 87>>> pu.as_series([2, [1.1, 0.]])88[array([2.]), array([1.1])]89 90>>> pu.as_series([2, [1.1, 0.]], trim=False)91[array([2.]), array([1.1, 0. ])]92 93rN)�ndmin�copyrzCoefficient array is emptyzCoefficient array is not 1-dT)r�dtypeF�
rz&Coefficient arrays have no common type)�np�array�size�94ValueError�ndimr�common_type�	Exception�dtypes�ObjectDTyper�emptyr
�appendr)95�alist�trim�
a�arraysr�ret�
e�object_dtype�has_one_object_type�tmps96          rrr?sr
��f
8=�
=�u�!�b�h�h�q�
��-�u�F�
=�
�
��6�6�Q�;��9�:�:��6�6�Q�;��;�<�<�	�97�&,�-�f��'�!�*�f��-�D
�����'�� =C
�C�F�q�r�x�x�
��E�2�F��C��J��7>��.��&D
���
N
��y�y�,�,�.��#�����A��w�w�,�&��h�h�s�1�v�\�:���1���A���98�99�3��&*�#��100�101�1�6�6�8�$��#��E�F�A�M�#��J��!
N
�s*� C�1C	�	C�  C�102F�B(F�Fc���U
S
:a[
S5
e
[U/
5
u
n[R"[R"U5
U
:�5
u
n[U5
S
:XaUSSS
-$USUSS-R
5$)a�103Remove "small" "trailing" coefficients from a polynomial.104 105"Small" means "small in absolute value" and is controlled by the106parameter `tol`; "trailing" means highest order coefficient(s), e.g., in107``[0, 1, 1, 0, 0]`` (which represents ``0 + x + x**2 + 0*x**3 + 0*x**4``)108both the 3-rd and 4-th order coefficients would be "trimmed."109 110Parameters111----------112c : array_like113    1-d array of coefficients, ordered from lowest order to highest.114tol : number, optional115    Trailing (i.e., highest order) elements with absolute value less116    than or equal to `tol` (default value is zero) are removed.117 118Returns119-------120trimmed : ndarray121    1-d array with trailing zeros removed.  If the resulting series122    would be empty, a series containing a single zero is returned.123 124Raises125------126ValueError127    If `tol` < 0128 129Examples130--------131>>> from numpy.polynomial import polyutils as pu132>>> pu.trimcoef((0,0,3,0,5,0,0))133array([0.,  0.,  3.,  0.,  5.])134>>> pu.trimcoef((0,0,1e-3,0,1e-5,0,0),1e-3) # item == tol is trimmed135array([0.])136>>> i = complex(0,1) # works for complex137>>> pu.trimcoef((3e-4,1e-3*(1-i),5e-4,2e-5*(1+i)), 1e-3)138array([0.0003+0.j   , 0.001 -0.001j])139 140rztol must be non-negativeNrr)rrr�nonzero�absr
r)�
c�tol�inds   rrr�sy��P
�Q�w��3�4�4�141�Q�C�.�C�Q��J�J�r�v�v�a�y�3��'�E�S�142�3�x�1�}���!�u�q�y����#�b�'�A�+��#�#�%�%rc
��
�[
U/
S
S9u
nURR[RS;a�UR143R
5UR144R5p!URR
5URR5pC[R"[X5[X$545
$[R"UR
5UR545
$)a�145Return a domain suitable for given abscissae.146 147Find a domain suitable for a polynomial or Chebyshev series148defined at the values supplied.149 150Parameters151----------152x : array_like153    1-d array of abscissae whose domain will be determined.154 155Returns156-------157domain : ndarray158    1-d array containing two values.  If the inputs are complex, then159    the two returned points are the lower left and upper right corners160    of the smallest rectangle (aligned with the axes) in the complex161    plane containing the points `x`. If the inputs are real, then the162    two points are the ends of the smallest interval containing the163    points `x`.164 165See Also166--------167mapparms, mapdomain168 169Examples170--------171>>> import numpy as np172>>> from numpy.polynomial import polyutils as pu173>>> points = np.arange(4)**2 - 5; points174array([-5, -4, -1,  4])175>>> pu.getdomain(points)176array([-5.,  4.])177>>> c = np.exp(complex(0,1)*np.pi*np.arange(12)/6) # unit circle178>>> pu.getdomain(c)179array([-1.-1.j,  1.+1.j])180 181F�
r$�Complex)rr�charr�	typecodes�real�min�max�imagr�complex)�
x�rmin�rmax�imin�imaxs     rrr�s���N
�Q�C�e�182$�C�Q��w�w�|�|�r�|�|�I�.�.��V�V�Z�Z�\�1�6�6�:�:�<�d��V�V�Z�Z�\�1�6�6�:�:�<�d��x�x���,�g�d�.A�B�C�C��x�x�����!�%�%�'�*�+�+rc�p�US
US-183nU
S
U
S-184nUS
U
S-USU
S
--185U-nX2-nXE4$)al186Linear map parameters between domains.187 188Return the parameters of the linear map ``offset + scale*x`` that maps189`old` to `new` such that ``old[i] -> new[i]``, ``i = 0, 1``.190 191Parameters192----------193old, new : array_like194    Domains. Each domain must (successfully) convert to a 1-d array195    containing precisely two values.196 197Returns198-------199offset, scale : scalars200    The map ``L(x) = offset + scale*x`` maps the first domain to the201    second.202 203See Also204--------205getdomain, mapdomain206 207Notes208-----209Also works for complex numbers, and thus can be used to calculate the210parameters required to map any line in the complex plane to any other211line therein.212 213Examples214--------215>>> from numpy.polynomial import polyutils as pu216>>> pu.mapparms((-1,1),(-1,1))217(0.0, 1.0)218>>> pu.mapparms((1,-1),(-1,1))219(-0.0, -1.0)220>>> i = complex(0,1)221>>> pu.mapparms((-i,-1),(1,i))222((1+1j), (1-0j))223 224rr�)�old�new�oldlen�newlen�off�scls      rrr�s\��R
��V�c�!�f�_�F�
��V�c�!�f�_�F��q�6�C�
�F�?�S��V�c�!�f�_�,��2256�C�226�/�C��8�Orc���[
U5
[[[4;
a5[	U[227R5(d[228R"U5
n[X5up4X4U--$)
a�229Apply linear map to input points.230 231The linear map ``offset + scale*x`` that maps the domain `old` to232the domain `new` is applied to the points `x`.233 234Parameters235----------236x : array_like237    Points to be mapped. If `x` is a subtype of ndarray the subtype238    will be preserved.239old, new : array_like240    The two domains that determine the map.  Each must (successfully)241    convert to 1-d arrays containing precisely two values.242 243Returns244-------245x_out : ndarray246    Array of points of the same shape as `x`, after application of the247    linear map between the two domains.248 249See Also250--------251getdomain, mapparms252 253Notes254-----255Effectively, this implements:256 257.. math::258    x\_out = new[0] + m(x - old[0])259 260where261 262.. math::263    m = \frac{new[1]-new[0]}{old[1]-old[0]}264 265Examples266--------267>>> import numpy as np268>>> from numpy.polynomial import polyutils as pu269>>> old_domain = (-1,1)270>>> new_domain = (0,2*np.pi)271>>> x = np.linspace(-1,1,6); x272array([-1. , -0.6, -0.2,  0.2,  0.6,  1. ])273>>> x_out = pu.mapdomain(x, old_domain, new_domain); x_out274array([ 0.        ,  1.25663706,  2.51327412,  3.76991118,  5.02654825, # may vary275        6.28318531])276>>> x - pu.mapdomain(x_out, new_domain, old_domain)277array([0., 0., 0., 0., 0., 0.])278 279Also works for complex numbers (and thus can be used to map any line in280the complex plane to any other line therein).281 282>>> i = complex(0,1)283>>> old = (-1 - i, 1 + i)284>>> new = (-1 + i, 1 - i)285>>> z = np.linspace(old[0], old[1], 6); z286array([-1. -1.j , -0.6-0.6j, -0.2-0.2j,  0.2+0.2j,  0.6+0.6j,  1. +1.j ])287>>> new_z = pu.mapdomain(z, old, new); new_z288array([-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 vary289 290)	�type�int�floatr;�291isinstancer�generic�292asanyarrayr)r<rCrDrGrHs     rrr 
sN��@�A�w�s�E�7�+�+�J�q�"�*�*�4M�4M��M�M�!��
���!�H�C��q��=�rc�Z�[R/
U
-n[S5
X '[U5
$�
N)r�newaxis�slice�tuple)rr�sls   r�293_nth_slicerVf
s'��294�*�*���	�B��$�K�B�E���9�rc�
^^
^^�[
T5
mT[
T
5
:wa[S
TS[
T
5
35
e
T[
T5
:wa[S
TS[
T5
35
e
TS:Xa[S5
e
[[R"[T
5
5
S-5
m
UUU
U4Sj[T5
5n[R"[RU5$)a�295A generalization of the Vandermonde matrix for N dimensions296 297The result is built by combining the results of 1d Vandermonde matrices,298 299.. math::300    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]}301 302where303 304.. math::305    N &= \texttt{len(points)} = \texttt{len(degrees)} = \texttt{len(vander\_fs)} \\306    M &= \texttt{points[k].ndim} \\307    V_k &= \texttt{vander\_fs[k]} \\308    x_k &= \texttt{points[k]} \\309    0 \le j_k &\le \texttt{degrees[k]}310 311Expanding the one-dimensional :math:`V_k` functions gives:312 313.. math::314    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])}315 316where :math:`B_{k,m}` is the m'th basis of the polynomial construction used along317dimension :math:`k`. For a regular polynomial, :math:`B_{k, m}(x) = P_m(x) = x^m`.318 319Parameters320----------321vander_fs : Sequence[function(array_like, int) -> ndarray]322    The 1d vander function to use for each axis, such as ``polyvander``323points : Sequence[array_like]324    Arrays of point coordinates, all of the same shape. The dtypes325    will be converted to either float64 or complex128 depending on326    whether any of the elements are complex. Scalars are converted to327    1-D arrays.328    This must be the same length as `vander_fs`.329degrees : Sequence[int]330    The maximum degree (inclusive) to use for each axis.331    This must be the same length as `vander_fs`.332 333Returns334-------335vander_nd : ndarray336    An array of shape ``points[0].shape + tuple(d + 1 for d in degrees)``.337z	Expected z" dimensions of sample points, got z dimensions of degrees, got rz9Unable to guess a dtype or shape when no points are given�c
3�h># �UH'n
TU
"TU
TU
5S[
U
T5-v� M) g
7f
))
.N)
rV)�.0r�degrees�n_dims�points�	vander_fss  ����r�	<genexpr>�_vander_nd.<locals>.<genexpr>�
s<������A�	�!��V�A�Y��
�338�+�F�Z�
�6�5J�,J�K��s�/2
)339r
rrTr�asarrayr�	functools�reduce�operator�mul)r^r]r[�
vander_arraysr\s``` @r�340_vander_ndrgl
s����Z
��^�F�
��V������x�A�#�f�+��O�
Q
�
	Q
�
��W������x�;�C��L�>�J�
L
�
	L
�
��{��T�U�U��2�:�:�e�F�m�,�s�2�
3�F���v���M����H�L�L�-�8�8rc�p�[
X
U5nURURS
[U5
*S-5
$)z�341Like `_vander_nd`, but flattens the last ``len(degrees)`` axes into a single axis342 343Used to implement the public ``<type>vander<n>d`` functions.344N)
r)rg�reshape�shaper
)r^r]r[�
vs    r�_vander_nd_flatrl�
s5��	�9�g�.�A��9�9�Q�W�W�^�s�7�|�m�,�u�4�5�5rc	�
�[
U5
S
:Xa[R"S5
$[U/
SS9u
nUR	5 UVs/sHo0"U*S5PM nn[
U5
nUS:�a[[US5upc[
U5
Vs/sHoq"XGXGU-5PM nnU(aU
"US
US5US
'UnUnUS:�aM[US
$s snfs snf)af
345Helper function used to implement the ``<type>fromroots`` functions.346 347Parameters348----------349line_f : function(float, float) -> ndarray350    The ``<type>line`` function, such as ``polyline``351mul_f : function(array_like, array_like) -> ndarray352    The ``<type>mul`` function, such as ``polymul``353roots354    See the ``<type>fromroots`` functions for more detail355rrFr3�r)r
r�onesr�sort�divmodr)	�line_f�mul_f�roots�
r�
p�
n�
mrr+s	         r�356_fromrootsry�
s����5�z�Q���w�w�q�z���U�G�%�0���
�357�358��$)�*�E�q�V�Q�B�
�]�E�
�*��
�F�
��!�e��!�Q�<�D�A�27�
�(�;�(�Q�5���q�Q��x�(�(�C�;���s�1�v�q��u�-��A���A��A�
�!�e���t���
+��<s�C
�Cc�
^�UVs/sHn[R"U5
PM nnUS
Rm[U4
SjUSS55
(d?[	U5
S:Xa[S5
e
[	U5
S:Xa[S5
e
[S	5
e
[
U5
n[U5
nU"XQ5n
UH359nU"XaS360S9n
M U
$s snf)a
361Helper function used to implement the ``<type>val<n>d`` functions.362 363Parameters364----------365val_f : function(array_like, array_like, tensor: bool) -> array_like366    The ``<type>val`` function, such as ``polyval``367c, args368    See the ``<type>val<n>d`` functions for more detail369rc
3�@>
# �UHoRT:Hv� M g7f
rQ)
rj)rZr%�shape0s  �rr_�_valnd.<locals>.<genexpr>�
s����3�(�Q�w�w�&� �(�s�
rN�zx, y, z are incompatiblernzx, y are incompatiblezordinates are incompatibleF)
�tensor)rrOrj�allr
r�iter�next)�val_fr/�argsr%�it�x0�xir|s       @r�_valndr��
s����'+�+�d��B�M�M�!��d�D�+�
�!�W�]�]�F��3�$�q�r�(�3�3�3��t�9�
�>��7�8�8�
��Y�!�^��4�5�5��9�:�:�	
�d��B�	
�b��B�	�b��A����"��&�
���H��!,s� Cc�(�UHnU"X15n
M
 U
$)
a
370Helper function used to implement the ``<type>grid<n>d`` functions.371 372Parameters373----------374val_f : function(array_like, array_like, tensor: bool) -> array_like375    The ``<type>val`` function, such as ``polyval``376c, args377    See the ``<type>grid<n>d`` functions for more detail378rB)r�r/r�r�s    r�_gridndr��
s�����"�L�
���Hrc�
�[
X/5
upUS
S:Xa[e
[U
5
n[U5
nX4:a379U
SSS-U
4$US:XaXS
-U
SSS-4$[R"X4-380S-U
R381S9nU
n[
X4-382S
S
5H0nU"S/
U-S/
-U5nUS
US
-n	USS
X�SS
--383nX�U'M2 U[U5
4$)a�
384Helper function used to implement the ``<type>div`` functions.385 386Implementation uses repeated subtraction of c2 multiplied by the nth basis.387For some polynomial types, a more efficient approach may be possible.388 389Parameters390----------391mul_f : function(array_like, array_like) -> array_like392    The ``<type>mul`` function, such as ``polymul``393c1, c2394    See the ``<type>div`` functions for more detail395rrNrr)r�ZeroDivisionErrorr
rr!rrr)396rs�c1�c2�lc1�lc2�quo�remrrv�
qs397          r�_divr�s����"��"�H�R�	�"�v��{���398
�b�'�C�399
�b�'�C�400�y��"�1�v�
�z�2�~��	�
���r�F�{�B�r�
�F�Q�J�&�&��h�h�s�y�1�}�B�H�H�5�����s�y�#�r�*�A��q�c�A�g���m�R�(�A��B��!�B�%��A��c�r�(�Q�3�B��Z�'�C��
�F�	+�401�G�C�L� � rc���[
X
/5
up
[U5
[U
5
:�aUS
U
R===U
-
sss&UnOU
S
UR===U-
sss&U
n[U5
$)z?Helper function used to implement the ``<type>add`` functions. N�rr
rr�r�r�r's   r�_addr�+s^���"��"�H�R�402�2�w��R���403�8�B�G�G�������404�8�B�G�G��������3�<�rc���[
X
/5
up
[U5
[U
5
:�aUS
U
R===U
-sss&UnOU
*n
U
S
UR===U-
sss&U
n[U5
$)z?Helper function used to implement the ``<type>sub`` functions. Nr�r�s   r�_subr�8se���"��"�H�R�405�2�w��R���406�8�B�G�G��������S��407�8�B�G�G��������3�<�rc�Z�[R"U
5
S
-n
[R"U5
S
-n[R"U5
nURS:�d*URRS;
dUR408S:Xa[
S5
e
UR5S:a[S5
e
U
RS:wa[
S5
e
U
R409S:Xa[
S5
e
URS:dURS	:�a[
S4105
e
[U
5
[U5
:wa[
S5
e
URS:XaUnUS-nU"X5n	O5[R"U5
nUSn[U5
nU"X5S
S
2U4n	U	Rn411URnUb_[R"U5
S
-nURS:wa[
S5
e
[U
5
[U5
:wa[
S5
e
X�-n412X�-nUc6[U
5
[R"U
R5
R-n[U413RR[R 5(ae[R""[R$"U414R&5
[R$"U415R(5
-R+S5
5
nO9[R""[R$"U4165
R+S5
5
nSX�S:H'[R,R/U417RU-URU5up�nnU
RU-Rn
URS:�akU
RS	:Xa2[R0"US-U
R2S4U
RS9nO"[R0"US-U
RS9nU
UU'Un
X�:wa7U(d0Sn[4R6"U[R8R:S	S9 U(aX�UUU/4$U
$)z�418Helper function used to implement the ``<type>fit`` functions.419 420Parameters421----------422vander_f : function(array_like, int) -> ndarray423    The 1d vander function, such as ``polyvander``424c1, c2425    See the ``<type>fit`` functions for more detail426rXr�iurz0deg must be an int or non-empty 1-D array of intzexpected deg >= 0zexpected 1D vector for xzexpected non-empty vector for xrnzexpected 1D or 2D array for yz$expected x and y to have same lengthrNzexpected 1D vector for wz$expected x and w to have same lengthrz!The fit may be poorly conditioned)
�427stacklevel)rrarr�kindr�	TypeErrorr8rr
rp�
T�finfo�eps�428issubclassrJ�complexfloating�sqrt�squarer7r:�sum�linalg�lstsq�zerosrj�warnings�warn�429exceptions�RankWarning)�vander_fr<�
y�deg�rcond�full�
w�lmax�order�van�lhs�rhsrHr/�resids�rank�
s�cc�msgs                   r�_fitr�Fs8��	�430�431�1�
���A�432�433�434�1�
���A�435�*�*�S�/�C��x�x�!�|�s�y�y�~�~�T�1�S�X�X��]��J�K�K�436�w�w�y�1�}��,�-�-��v�v��{��2�3�3��v�v��{��9�:�:��v�v�
�z�Q�V�V�a�Z��7�8�8�437�1�v��Q����>�?�?�438�x�x�1�}����q����q����g�g�c�l���2�w���C����q��
�3��'���%�%�C�439�#�#�C��}��J�J�q�M�C��
��6�6�Q�;��6�7�7��q�6�S��V���B�C�C��g���g��
�}��A�����!�'�'�*�.�.�.���#�)�)�.�.�"�"4�"4�5�5��g�g�r�y�y����*�R�Y�Y�s�x�x�-@�@�E�E�a�H�I���g�g�b�i�i��n�(�(��+�,���C�q��M�����������c�e�e�U�C��A�t�Q�	440���s��
�
�A��x�x�!�|��6�6�Q�;����4�!�8�Q�W�W�Q�Z�0�
���@�B����$��(�!�'�'�2�B���3���
��}�T�1���
�
�c�2�=�=�4�4��C���4��E�*�*�*��rc�&
�[
U
/
5
u
n
[U5
nXB:wdUS
:a[S5
e
UbXC:�a[S5
e
US
:Xa [R"S/
U
R441S9$US:XaU
$U
n[
SUS-5HnU"XQ5nM
 U$)a>
442Helper function used to implement the ``<type>pow`` functions.443 444Parameters445----------446mul_f : function(array_like, array_like) -> ndarray447    The ``<type>mul`` function, such as ``polymul``448c : array_like449    1-D array of array of series coefficients450pow, maxpower451    See the ``<type>pow`` functions for more detail452rz%Power must be a non-negative integer.zPower is too largerrrn)rrKrrrrr)rsr/�pow�maxpower�power�prdrs       r�_powr��s����Q�C�.�C�Q���H�E��|�u�q�y��@�A�A�	�	�%�"2��-�.�.�	�!���x�x���1�7�7�+�+�	�!�������q�%�!�)�$�A���-�C�%��453rc�v�[R"U5
$![an[U
S
U35
UeSnAf
f=f
)a
454Like `operator.index`, but emits a custom exception when passed an455incorrect type456 457Parameters458----------459x : int-like460    Value to interpret as an integer461desc : str462    description to include in any error message463 464Raises465------466TypeError : if x is a float or non-numeric467z must be an integer, received N)rd�indexr�)r<�descr(s   r�_as_intr��sB�� K
��~�~�a� � ���
K
��4�&� >�q�c�B�C��J��
K
�s��4688�3�8c	�Z�S
SKJ
nJn [R"[U5
[R5(d[U5
$[R"5n[R"U5
(aUS$[R"U5
(aUS$SnUS
:wa;[R"U5
nUS:�dUS[S
USS	-469*S470-5-:aSnSupxUS
S:XaSupxU(a"U"XSX�USS:HS9n	U
(aSU	-S-n	U	$U"XSSX�USS:HS9n	U	$)Nr)�dragon4_positional�dragon4_scientific�nanstr�infstrFg�חA�471�	precisionrrnT)�
0T�	floatmode�fixed)�
kF�sign�
+)r��uniquer$r��
(�
))r��472fractionalr�r$r�)
�numpy._core.multiarrayr�r�r�473issubdtyperJ�floating�str�get_printoptions�isnan�isinfr.r8)474r<�parensr�r��opts�475exp_formatr%r$r�r�s476          rr	r	�s0
��M�
�=�=��a��"�+�+�.�.��1�v�
�
��� �D�	�x�x�
�{�{��H�~��	���!����H�~���J��A�v��F�F�1�I�
���9�
�B��A��k�):�Q�)>�'?�1�'D� E�E�E��J��L�D��K��G�#�!�����q��,=�&,�$(��L�C�$7�
9�
���a��#�
�A�
�H�	
�q��,=�*.�&,�$(��L�C�$7�
9�
�
�Hr)
T)
r)NFN)
F)�__doc__rbrdr��numpyr�__all__rrrrrrrVrgrlryr�r�r�r�r�r�r�r�r	rBrr�<module>r�
s��


�
�(
������
�:N

�b0
&�d
-
,�^
-
�^
C

�L
�B

9�J
6�
�<

�<


� !
!�H
477
�
�U

�p
�B

K
�,"

r