U
    ¿|e„0 ã                    @   s\  d Z ddlZddlmZ ddlmZ ddlZddlZddlZ	ddl
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mZmZmZ ddlmZmZmZmZ dd	lm Z m!Z!m"Z"m#Z# dd
l$m%Z% ddlm&Z& ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z- ddl.m/Z/ dd„ Z0e0ƒ Z1e&dd„ ƒZ2e&dd„ ƒZ3eej4ej5ƒedej5ƒdd„ ƒƒZ6edd„ ƒZ7dd„ Z8eej4ej5ej9ej:ƒeej4ej5ej;ej:ƒedej5ej9ej:ƒedej5ej;ej:ƒdd„ ƒƒƒƒZ<eej4ej5ej:ƒedej5ej:ƒdd„ ƒƒZ=eej4ej5ej9ƒeej4ej5ej;ƒedej5ej9ƒedej5ej;ƒdd „ ƒƒƒƒZ>d!d"„ Z?eej@ƒeej5d#ƒd$d%„ ƒƒZAeejBƒeej5d&ƒd'd(„ ƒƒZCeejDƒeej5d)ƒd*d+„ ƒƒZEeejFƒeej5d,ƒd-d.„ ƒƒZGeejHƒeej5d/ƒd0d1„ ƒƒZIeejJƒeej5d2ƒd3d4„ ƒƒZKed5d6„ ƒZLed7d8„ ƒZMed9d:„ ƒZNeejOƒeej5d;ƒd<d=„ ƒƒZPeejQƒeej5d>ƒd?d@„ ƒƒZRedAdB„ ƒZSedCdD„ ƒZTedEdF„ ƒZUeejVƒeej5dGƒ�dÿdHdI„ƒƒZWedJdK„ ƒZXedLdM„ ƒZYedNdO„ ƒZZdPdQ„ Z[eej\ƒeej5dRƒ�d dSdT„ƒƒZ]eej^ƒeej5dUƒdVdW„ ƒƒZ_e�dd[d\„ƒZ`eejaƒeej5d]ƒ�dd^d_„ƒƒZbeejcƒeej5d`ƒdadb„ ƒƒZdeejeƒ�ddcdd„ƒZfdedf„ Zgeejhƒdgdh„ ƒZieejjƒdidj„ ƒZkeejlƒdkdl„ ƒZleejmƒdmdn„ ƒZmeejnƒdodp„ ƒZodqdr„ Zpeejqƒ�ddsdt„ƒZqeejrƒ�ddudv„ƒZredwdx„ ƒZsedydz„ ƒZted{d|„ ƒZud}d~„ ZveevesdZd�ƒZweevetdZd�ƒZxeevesd€d�ƒZyeevetd€d�ƒZzed�d‚„ ƒZ{eej|ƒ�ddƒd„„ƒZ|eej}ƒd…d†„ ƒZ~eejƒd‡dˆ„ ƒZ€eej�ƒd‰dŠ„ ƒZ‚eejƒƒd‹dŒ„ ƒZ„eej…ƒd�dŽ„ ƒZ†eej‡ƒd�d�„ ƒZˆeej‰ƒd‘d’„ ƒZŠeej‹ƒd“d”„ ƒZŒeej�ƒd•d–„ ƒZŽed—d˜„ ƒZ�d™dš„ Z�d›dœ„ Z‘d�dž„ Z’ee‘ƒdŸd „ ƒZ“ee’ƒd¡d¢„ ƒZ”d£d¤„ Z•ee•ƒd¥d¦„ ƒZ–eej5d§ƒeej—ƒd¨d©„ ƒƒZ˜edªd«„ ƒZ™�dd¬d­„ZšeešesƒƒZ›eeše™ƒƒZœeeše™d€d®�ƒZ�d¯d°„ Zžeeže›ƒƒZŸeežeœƒƒZ eeže�ƒƒZ¡ed±d²„ ƒZ¢ed³d´„ ƒZ£eej¤ƒdµd¶„ ƒZ¥ed·d¸„ ƒZ¦ed¹dº„ ƒZ§ed»d¼„ ƒZ¨ed½d¾„ ƒZ©ed¿dÀ„ ƒZªedÁdÂ„ ƒZ«dÃdÄ„ Z¬eej­ƒdÅdÆ„ ƒZ®eej¯ƒdÇdÈ„ ƒZ°eej±ƒdÉdÊ„ ƒZ²eej³ƒdËdÌ„ ƒZ´eejµƒdÍdÎ„ ƒZ¶edÏdÐ„ ƒZ·edÑdÒ„ ƒZ¸edÓdÔ„ ƒZ¹eejºƒdÕdÖ„ ƒZ»eej¼ƒd×dØ„ ƒZ½edÙdÚ„ ƒZ¾eej¿ƒ�ddÛdÜ„ƒZÀedÝdÞ„ ƒZÁe�d	dßdà„ƒZÂeejÃƒ�d
dádâ„ƒZÄeejÅƒ�ddãdä„ƒZÆeejÇƒ�ddådæ„ƒZÈe�ddçdè„ƒZÉeejÊƒ�ddédê„ƒZËeejÌƒ�ddëdì„ƒZÍeejÎƒ�ddídî„ƒZÏdïdð„ ZÐeeÐƒdñdò„ ƒZÑdódô„ ZÒeejÓƒ�ddõdö„ƒZÔd÷dø„ ZÕeeÕƒdùdú„ ƒZÖdûdü„ Z×ee×ƒdýdþ„ ƒZØeejÙƒ�d�d �d„ƒZÚe�d�d„ ƒZÛe�d�d„ ƒZÜeejÝƒ�d�d�d„ƒZÞeejßƒ�d�d	„ ƒZà�d
Záe�d�d„ ƒZâe�d�d„ ƒZãe�d�d„ ƒZäeejåƒ�d�d„ ƒZæe�d�d„ ƒZçe�d�d„ ƒZè�d�d„ Zéeeéƒ�d�d„ ƒZêe�d�d„ ƒZëe�d�d„ ƒZì�d�d „ Zí�d!�d"„ Zîe�d#�d$„ ƒZïe�d%�d„ ƒZðe�d&�d'„ ƒZñ�d(�d)„ Zòe�d*�d+„ ƒZóe�d,�d-„ ƒZôeejõƒ�d�d.�d/„ƒZöeej÷ƒ�d�d0�d1„ƒZøeejùƒ�d2�d3„ ƒZúeejûƒ�d4�d5„ ƒZüe�d6�d7„ ƒZýe�d8�d9„ ƒZþe�d:�d;„ ƒZÿe�d<�d=„ ƒ�Z e�d>�d?„ ƒ�Ze�d@�d„ ƒ�Z�dA�dB„ �Ze�eƒ�dC�dD„ ƒ�Zee�jƒ�d�dE�dF„ƒ�Z�dG�dH„ �Ze&�dI�dJ„ ƒ�Ze�dK�dL„ ƒ�Z	ee�j
ƒee�jƒ�d�dM�dN„ƒƒ�Zee�jƒ�dO�dP„ ƒ�Zee�jƒ�d�dQ�dR„ƒ�Zee�jej5ƒe�dSej5ƒ�dT�dU„ ƒƒ�Z�dV�dW„ �Ze�dX�dY„ ƒ�Ze�dZ�d[„ ƒ�Z�d\�d]„ �Zee�jƒ�d^�d_„ ƒ�Zee�jƒ�d`�da„ ƒ�Zee�jƒ�db�dc„ ƒ�Zee�jƒ�dd�de„ ƒ�Zee�jƒ�df�dg„ ƒ�Zee�j ƒ�d�dh�di„ƒ�Z!e�dj�d„ ƒ�Z"e�dk�d„ ƒ�Z#ee�j$ƒ�dl�dm„ ƒ�Z%ee�j&ƒ�d�do�dp„ƒ�Z'ee�j(ƒ�dq�dr„ ƒ�Z)ee�j*ƒ�ds�dt„ ƒ�Z+�du�dv„ �Z,ee�j-ƒ�d�dw�dx„ƒ�Z.�dy�dz„ �Z/es�Z0e�d{�d„ ƒ�Z1e�e/�e0ƒƒ�Z2e�e/�e1ƒƒ�Z3ee�j4ƒ�d�d}�d~„ƒ�Z4ee�j5ƒ�d�d�d€„ƒ�Z6�e7�Z8ee�j9ƒ�d�d‚�dƒ„ƒ�Z:�d„�Z;e�d…�e;ƒ�Z<�d†�Z=e�d‡�e=ƒ�Z>�dˆ�Z?e�d‰�e?ƒ�Z@�dŠ�d‹„ �ZA�eAƒ  �dŒ�d�„ �ZB�eBe�j>�e>�e=ƒ �eBe�j@�e@�e?ƒ �dŽ�d�„ �ZC�d��d‘„ �ZD�d’�d“„ �ZEG �d”�d•„ �d•eƒ�ZFe�eEƒ�d–�d—„ ƒ�ZGee�jHƒ�d˜�d™„ ƒ�ZIee�jJƒ�dš�d›„ ƒ�ZKee�jLƒ�d�dœ�d�„ƒ�ZMee�jNƒe�jOf�dž�dŸ„ƒ�ZPee�jQƒ�d �d¡„ ƒ�ZRee�jSƒ�d �d¢�d£„ƒ�ZTee�jUƒ�d¤�d¥„ ƒ�ZVee�jWƒ�d!�d¦�d§„ƒ�ZXe�d¨�d©„ ƒ�ZYe�dª�d«„ ƒ�ZZe�d¬�d­„ ƒ�Z[e�d®�d¯„ ƒ�Z\�d°�d±„ �Z]ee�j^ƒ�e]�eYƒƒ ee�j_ƒ�e]�eZƒƒ ee�j`ƒ�e]�e[ƒƒ ee�jaƒ�e]�e\ƒƒ e� b�d²�d³�d´�dµ�d¶�d·�d¸�d¹�dº�d»�d¼�d½�d¾�d¿�dÀ�dÁ�dÂ�dÃ�dÄ�dÅ�dÆ�dÇ�dÈ�dÉ�dÊ�dË�dÌ�dÍ�dÎ�dÏg¡�Zce� b�dÐ�dÑ�dÒ�dÓ�dÔ�dÕ�dÖ�d×�dØ�dÙ�dÚ�dÛ�dÜ�dÝ�dÞ�dß�dà�dá�dâ�dã�dä�då�dæ�dç�dèg¡�Zde�dé�dê„ ƒ�Zee�dë�dì„ ƒ�Zfe�dí�dî„ ƒ�Zgee�jhƒ�dï�dð„ ƒ�Zie�dñ�dò„ ƒ�Zj�dó�dô„ �Zke�ekƒ�dõ�dö„ ƒ�Zlee�jmƒ�d÷�dø„ ƒ�Zne�dù�dú„ ƒ�Zo�dû�dü„ �Zpe�epƒ�dý�dþ„ ƒ�ZqdS ("  z5
Implementation of math operations on Array objects.
é    N)Ú
namedtuple)ÚIntEnum)ÚtypesÚcgutils)ÚoverloadÚoverload_methodÚregister_jitable)Úas_dtypeÚtype_can_asarrayÚtype_is_scalarÚnumpy_versionÚis_nonelikeÚcheck_is_integer)Úlower_builtinÚimpl_ret_borrowedÚimpl_ret_new_refÚimpl_ret_untracked)Ú
make_arrayÚ	load_itemÚ
store_itemÚ_empty_nd_impl)Úensure_blas)Ú	intrinsic)ÚRequireLiteralValueÚTypingErrorÚNumbaValueErrorÚNumbaNotImplementedErrorÚNumbaTypeErrorÚNumbaDeprecationWarning)Útuple_setitemc                   C   s&   z
t ƒ  W n tk
r    Y dS X dS ©NFT)r   ÚImportError© r"   r"   úO/var/www/website-v5/atlas_env/lib/python3.8/site-packages/numba/np/arraymath.pyÚ_check_blas!   s
    
r$   c                    s<   t |ƒd ‰ t tjˆ ¡‰ˆˆ|ƒ}‡ ‡‡fdd„}||fS )a  
    This routine converts shape list where the axis dimension has already
    been popped to a tuple for indexing of the same size.  The original shape
    tuple is also required because it contains a length field at compile time
    whereas the shape list does not.
    é   c              	      sp   |   ˆ¡}t |¡}|\}}dd„ }tˆ ƒD ]>}	|  tj|	¡}
|  ||t ˆtj¡||
g¡}| |||	¡}q,|S )Nc                 S   s   | | S ©Nr"   )ÚaÚir"   r"   r#   Úarray_indexerF   s    zB_create_tuple_result_shape.<locals>.codegen.<locals>.array_indexer)	Úget_value_typer   Úget_null_valueÚrangeÚget_constantr   ÚintpÚcompile_internalÚinsert_value)ÚcgctxÚbuilderÚ	signatureÚargsÚlltuptyÚtupÚin_shapeÚ_r)   r(   ZdataidxÚdata©ÚndÚ
shape_listÚtuptyr"   r#   Úcodegen>   s    

þz+_create_tuple_result_shape.<locals>.codegen)Úlenr   ÚUniTupler.   )Útyctxr<   Úshape_tupleÚfunction_sigr>   r"   r:   r#   Ú_create_tuple_result_shape-   s
    
rD   c           	         sœ   t |tjƒstdƒ‚|j‰ t|ƒ‰ˆ ˆkr.d‰ ˆ }ˆ| d }g }|tjg| 7 }|tjg7 }|tjg| 7 }t |¡‰ˆ|||ƒ}‡ ‡‡fdd„}||fS )aH  
    Generates a tuple that can be used to index a specific slice from an
    array for sum with axis.  shape_tuple is the size of the dimensions of
    the input array.  'value' is the value to put in the indexing tuple
    in the axis dimension and 'axis' is that dimension.  For this to work,
    axis has to be a const.
    z axis argument must be a constantr   r%   c                    sŒ   |   ˆ¡}t |¡}|\}}}dd„ }|  ||t ¡ g ¡}	tdˆ ƒD ]}
| ||	|
¡}qD| ||ˆ ¡}tˆ d ˆƒD ]}
| ||	|
¡}qt|S )Nc                   S   s
   t d d ƒS r&   )Úslicer"   r"   r"   r#   Úcreate_full_slice†   s    z<_gen_index_tuple.<locals>.codegen.<locals>.create_full_slicer   r%   )r*   r   r+   r/   r   Úslice2_typer,   r0   )r1   r2   r3   r4   r5   r6   r8   Z	value_argrF   Z
slice_datar(   ©Z
axis_valuer;   r=   r"   r#   r>   }   s    


þz!_gen_index_tuple.<locals>.codegen)	Ú
isinstancer   ÚLiteralr   Úliteral_valuer?   rG   r.   ÚTuple)	rA   rB   ÚvalueÚaxisÚbeforeÚafterZ
types_listrC   r>   r"   rH   r#   Ú_gen_index_tupleV   s     	
rQ   z	array.sumc                    sB   |  d¡‰ ‡ fdd„}| j||||t|j d�d�}t| ||j |ƒS )Nr   c                    s$   ˆ }t  | ¡D ]}|| ¡ 7 }q|S r&   ©ÚnpÚnditerÚitem)ÚarrÚcÚv©Úzeror"   r#   Úarray_sum_impl§   s    z!array_sum.<locals>.array_sum_impl©rW   ©Úlocals©Úreturn_typer/   Údictr   ©Úcontextr2   Úsigr4   r[   Úresr"   rY   r#   Ú	array_sum¢   s    

ÿrf   c                 C   s   | S r&   r"   )rV   rX   r"   r"   r#   Ú_array_sum_axis_nop²   s    rg   c                    s   ‡ ‡‡‡fdd„}|S )Nc                    s4  | j }ˆs"|dk s|dkr"tdƒ‚||kr2tdƒ‚t| jƒ}|| }| |¡ t|| jƒ}t |ˆtˆƒ¡}t	|ƒD ]´}ˆr˜t
| j|ˆ ƒ}|| | 7 }qt|dkr¼t
| j|dƒ}	|| |	 7 }qt|dkràt
| j|dƒ}
|| |
 7 }qt|dk�rt
| j|dƒ}|| | 7 }qt|dkrtt
| j|dƒ}|| | 7 }qtˆ|dƒS )a(  
        function that performs sums over one specific axis

        The third parameter to gen_index_tuple that generates the indexing
        tuples has to be a const so we can't just pass "axis" through since
        that isn't const.  We can check for specific values and have
        different instances that do take consts.  Supporting axis summation
        only up to the fourth dimension for now.

        typing/arraydecl.py:sum_expand defines the return type for sum with
        axis. It is one dimension less than the input array.
        r   é   zHNumba does not support sum with axis parameter outside the range 0 to 3.zaxis is out of bounds for arrayr%   é   )ÚndimÚ
ValueErrorÚlistÚshapeÚpoprD   rS   ÚfullÚtyper,   rQ   )rV   rN   rj   ÚashapeZaxis_lenZashape_without_axisÚresultZ
axis_indexZindex_tuple_genericZindex_tuple1Zindex_tuple2Zindex_tuple3Zindex_tuple4©Úconst_axis_valÚis_axis_constÚoprZ   r"   r#   Úinner¸   s<    

ÿ
z gen_sum_axis_impl.<locals>.innerr"   )ru   rt   rv   rZ   rw   r"   rs   r#   Úgen_sum_axis_impl·   s    =rx   c                    s  |j }t|d|ƒdƒ}t|dd ƒd kr.tj}nt}|j\}}}	d}
d}t|tjƒrÄ|j	}|dk rj|j
| }|dk s|||j
kr„tdƒ‚| j |¡}|  ||¡}|d ||d f}|j|||	gd�}d}
t|
|||ƒ}t|ƒ‰ ‡ fd	d
„}|  ||||¡}t| ||j |ƒS )NÚdtyper   rj   Fz'axis' entry is out of boundsri   ©r4   Tc                    s
   ˆ | |ƒS r&   r"   )rV   rN   ry   ©Úcompiledr"   r#   Úarray_sum_impl_axis  s    z1array_sum_axis_dtype.<locals>.array_sum_impl_axis)r`   ÚgetattrrS   Útakerg   r4   rI   r   rJ   rK   rj   rk   Útyping_contextÚresolve_value_typer-   Úreplacerx   r   r/   r   )rc   r2   rd   r4   ÚrettyrZ   rv   Úty_arrayÚty_axisÚty_dtyperu   rt   Úaxis_valÚgen_implr}   re   r"   r{   r#   Úarray_sum_axis_dtypeø   s0    
r‰   c                    sB   |  d¡‰ ‡ fdd„}| j||||t|j d�d�}t| ||j |ƒS )Nr   c                    s$   ˆ }t  | ¡D ]}|| ¡ 7 }q|S r&   rR   )rV   ry   rW   rX   rY   r"   r#   r[   (  s    z'array_sum_dtype.<locals>.array_sum_implr\   r]   r_   rb   r"   rY   r#   Úarray_sum_dtype#  s    

ÿrŠ   c                    s  |j }t|d|ƒdƒ}t|dd ƒd kr.tj}nt}|j\}}d}	d}
t|tjƒrÆ|j	}
|
dk rh|j
|
 }
|
dk sz|
|j
krŽd|
› d�}t|ƒ‚| j |
¡}|  ||
¡}|d |f}|j||gd�}d}	t|	|
||ƒ}t|ƒ‰ ‡ fd	d
„}|  ||||¡}t| ||j |ƒS )Nry   r   rj   Fz'axis' entry (z) is out of boundsrz   Tc                    s
   ˆ | |ƒS r&   r"   ©rV   rN   r{   r"   r#   r}   X  s    z+array_sum_axis.<locals>.array_sum_impl_axis)r`   r~   rS   r   rg   r4   rI   r   rJ   rK   rj   r   r€   r�   r-   r‚   rx   r   r/   r   )rc   r2   rd   r4   rƒ   rZ   rv   r„   r…   ru   rt   Úmsgr‡   rˆ   r}   re   r"   r{   r#   Úarray_sum_axis3  s2    

r�   c                 C   s,   | j tjkrt |¡ | ¡}n
|   |¡}|S r&   )rp   rS   Útimedelta64Úint64Úview)ry   rM   Úacc_initr"   r"   r#   Úget_accumulator_  s    
r’   Úprodc                    s4   t | tjƒr0t| jƒ}t|dƒ‰ ‡ fdd„}|S d S )Nr%   c                    s$   ˆ }t  | ¡D ]}|| ¡ 9 }q|S r&   rR   ©r'   rW   rX   ©r‘   r"   r#   Úarray_prod_implo  s    z#array_prod.<locals>.array_prod_impl)rI   r   ÚArrayr	   ry   r’   )r'   ry   r–   r"   r•   r#   Ú
array_prodg  s
    

r˜   Úcumsumc                    sr   t | tjƒrn| jtjk}| jtjk}|r8| jjtjjk s<|rHttjƒ‰n
t| jƒ‰t	ˆdƒ‰ ‡ ‡fdd„}|S d S )Nr   c                    s:   t  | jˆ¡}ˆ }t| jƒD ]\}}||7 }|||< q|S r&   ©rS   ÚemptyÚsizeÚ	enumerateÚflat©r'   ÚoutrW   ÚidxrX   ©r‘   ry   r"   r#   Úarray_cumsum_impl†  s    
z'array_cumsum.<locals>.array_cumsum_impl©
rI   r   r—   ry   Úsigned_domainÚbool_Úbitwidthr.   r	   r’   )r'   Ú
is_integerÚis_boolr£   r"   r¢   r#   Úarray_cumsumx  s    ÿ

rª   Úcumprodc                    sr   t | tjƒrn| jtjk}| jtjk}|r8| jjtjjk s<|rHttjƒ‰n
t| jƒ‰t	ˆdƒ‰ ‡ ‡fdd„}|S d S )Nr%   c                    s:   t  | jˆ¡}ˆ }t| jƒD ]\}}||9 }|||< q|S r&   rš   rŸ   r¢   r"   r#   Úarray_cumprod_implŸ  s    
z)array_cumprod.<locals>.array_cumprod_implr¤   )r'   r¨   r©   r¬   r"   r¢   r#   Úarray_cumprod‘  s    ÿ

r­   Úmeanc                    s\   t | tjƒrX| jtjttjgƒB k}|r4ttjƒ}n
t| jƒ}t	|dƒ‰ ‡ fdd„}|S d S )Nr   c                    s*   ˆ }t  | ¡D ]}|| ¡ 7 }q|| j S r&   )rS   rT   rU   rœ   r”   r•   r"   r#   Úarray_mean_impl¶  s    z#array_mean.<locals>.array_mean_impl)
rI   r   r—   ry   Úinteger_domainÚ	frozensetr¦   r	   Úfloat64r’   )r'   Z	is_numberry   r¯   r"   r•   r#   Ú
array_meanª  s    

r³   Úvarc                 C   s   t | tjƒrdd„ }|S d S )Nc                 S   sJ   |   ¡ }d}t | ¡D ](}| ¡ | }|t |t |¡ ¡7 }q|| j S ©Nr   )r®   rS   rT   rU   ÚrealÚconjrœ   )r'   ÚmÚssdrX   Úvalr"   r"   r#   Úarray_var_implÅ  s    z!array_var.<locals>.array_var_impl©rI   r   r—   )r'   r»   r"   r"   r#   Ú	array_varÁ  s    r½   Ústdc                 C   s   t | tjƒrdd„ }|S d S )Nc                 S   s   |   ¡ d S ©Nç      à?)r´   ©r'   r"   r"   r#   Úarray_std_impl×  s    z!array_std.<locals>.array_std_implr¼   )r'   rÂ   r"   r"   r#   Ú	array_stdÓ  s    rÃ   c                 C   s   | |k S r&   r"   ©r'   Úmin_valr"   r"   r#   Úmin_comparatorÝ  s    rÆ   c                 C   s   | |kS r&   r"   rÄ   r"   r"   r#   Úmax_comparatorâ  s    rÇ   c                 C   s   dS ©NFr"   rÁ   r"   r"   r#   Úreturn_falseç  s    rÉ   Úminc                    sˆ   t | tjƒsd S t | jtjtjfƒr0tj‰t‰ nFt | jtj	ƒrTt
‰dd„ }t|ƒ‰ n"t | jtjƒrntj‰t‰ nt
‰t‰ ‡ ‡fdd„}|S )Nc                 S   s0   | j |j k rdS | j |j kr,| j|jk r,dS dS ©NTF©r¶   ÚimagrÄ   r"   r"   r#   Ú	comp_funcø  s    znpy_min.<locals>.comp_funcc                    sj   | j dkrtdƒ‚t | ¡}t|ƒ d¡}ˆ|ƒr6|S |D ]*}| ¡ }ˆ|ƒrV|  S ˆ ||ƒr:|}q:|S )Nr   zDzero-size array to reduction operation minimum which has no identity©rœ   rk   rS   rT   Únextr   rU   )r'   ÚitÚ	min_valuer�   rX   ©Z
comparatorZpre_return_funcr"   r#   Úimpl_min  s    


znpy_min.<locals>.impl_min)rI   r   r—   ry   Ú
NPDatetimeÚNPTimedeltarS   ÚisnatrÆ   ÚComplexrÉ   r   ÚFloatÚisnan)r'   rÎ   rÔ   r"   rÓ   r#   Únpy_minì  s     
rÛ   Úmaxc                    sˆ   t | tjƒsd S t | jtjtjfƒr0tj‰t‰ nFt | jtj	ƒrTt
‰dd„ }t|ƒ‰ n"t | jtjƒrntj‰t‰ nt
‰t‰ ‡ ‡fdd„}|S )Nc                 S   s0   | j |j krdS | j |j kr,| j|jkr,dS dS rË   rÌ   )r'   Úmax_valr"   r"   r#   rÎ   )  s    znpy_max.<locals>.comp_funcc                    sj   | j dkrtdƒ‚t | ¡}t|ƒ d¡}ˆ|ƒr6|S |D ]*}| ¡ }ˆ|ƒrV|  S ˆ ||ƒr:|}q:|S )Nr   zDzero-size array to reduction operation maximum which has no identityrÏ   )r'   rÑ   Ú	max_valuer�   rX   rÓ   r"   r#   Úimpl_max9  s    


znpy_max.<locals>.impl_max)rI   r   r—   ry   rÕ   rÖ   rS   r×   rÇ   rØ   rÉ   r   rÙ   rÚ   )r'   rÎ   rß   r"   rÓ   r#   Únpy_max  s     
rà   c                 C   s€   | j dkrtdƒ‚t | ¡}t|ƒ d¡}d}t |¡r<|S d}|D ]6}| ¡ }t |¡rb|  S ||k rr|}|}|d7 }qD|S ©Nr   ú*attempt to get argmin of an empty sequencer%   ©rœ   rk   rS   rT   rÐ   r   r×   rU   )ÚarryrÑ   rÒ   Úmin_idxr¡   r�   rX   r"   r"   r#   Úarray_argmin_impl_datetimeN  s"    




ræ   c                 C   sv   | j dkrtdƒ‚| jD ]}|}d} q*qt |¡r8|S d}| jD ].}t |¡rX|  S ||k rh|}|}|d7 }qB|S rá   ©rœ   rk   rž   rS   rÚ   ©rä   rX   rÒ   rå   r¡   r"   r"   r#   Úarray_argmin_impl_floatd  s"    





ré   c                 C   s^   | j dkrtdƒ‚| jD ]}|}d} q2qtdƒ‚d}| jD ]}||k rP|}|}|d7 }q<|S )Nr   râ   Úunreachabler%   )rœ   rk   rž   ÚRuntimeErrorrè   r"   r"   r#   Úarray_argmin_impl_genericz  s    



rì   Úargminc                    sZ   t | jtjtjfƒrt‰ nt | jtjƒr.t‰ nt‰ t	|ƒrJd‡ fdd„	}nt
| |ˆ ƒ}|S )Nc                    s   ˆ | ƒS r&   r"   r‹   ©Úflatten_implr"   r#   Úarray_argmin_impl™  s    z'array_argmin.<locals>.array_argmin_impl)N)rI   ry   r   rÕ   rÖ   ræ   rÙ   ré   rì   r   Ú%build_argmax_or_argmin_with_axis_impl)rV   rN   rð   r"   rî   r#   Úarray_argminŽ  s      ÿrò   c                 C   s€   | j dkrtdƒ‚t | ¡}t|ƒ d¡}d}t |¡r<|S d}|D ]6}| ¡ }t |¡rb|  S ||krr|}|}|d7 }qD|S ©Nr   z*attempt to get argmax of an empty sequencer%   rã   )rä   rÑ   rÞ   Úmax_idxr¡   r�   rX   r"   r"   r#   Úarray_argmax_impl_datetime¢  s"    




rõ   c                 C   sv   | j dkrtdƒ‚| jD ]}|}d} q*qt |¡r8|S d}| jD ].}t |¡rX|  S ||krh|}|}|d7 }qB|S ró   rç   ©rä   rX   rÞ   rô   r¡   r"   r"   r#   Úarray_argmax_impl_float¸  s"    





r÷   c                 C   sV   | j dkrtdƒ‚| jD ]}|}d} q*qd}| jD ]}||krH|}|}|d7 }q4|S ró   )rœ   rk   rž   rö   r"   r"   r#   Úarray_argmax_impl_genericÎ  s    



rø   c                    s4   t |dƒ tj‰tt| jƒƒ‰d‡ ‡‡fdd„	}|S )z|
    Given a function that implements the logic for handling a flattened
    array, return the implementation function.
    rN   Nc           	         s  |dk r| j | }|dk s$|| j kr,tdƒ‚| j dkr>ˆ | ƒS ˆ}t|| j d ƒD ]}t|||d ƒ}qRt|| j d |ƒ}|  |¡}|jd }| ¡ }|j| jks¦t‚|j| dks¸t‚t	 
|j| ˆ¡}t|jƒD ]$}ˆ ||| |d | … ƒ||< qÔ| |jd d… ¡S )Nr   zaxis is out of boundsr%   éÿÿÿÿ)rj   rk   r,   r   Ú	transposerm   Úravelrœ   ÚAssertionErrorrS   r›   Úreshape)	rV   rN   Útmpr(   Ztranspose_indexZtransposed_arrr¸   Zraveledr    ©rï   rƒ   Ztuple_bufferr"   r#   Úimplê  s&    



"z3build_argmax_or_argmin_with_axis_impl.<locals>.impl)N)r   r   r.   Útupler,   rj   )rV   rN   rï   r   r"   rÿ   r#   rñ   à  s
    
rñ   Úargmaxc                    sZ   t | jtjtjfƒrt‰ nt | jtjƒr.t‰ nt‰ t	|ƒrJd‡ fdd„	}nt
| |ˆ ƒ}|S )Nc                    s   ˆ | ƒS r&   r"   r‹   rî   r"   r#   Úarray_argmax_impl  s    z'array_argmax.<locals>.array_argmax_impl)N)rI   ry   r   rÕ   rÖ   rõ   rÙ   r÷   rø   r   rñ   )rV   rN   r  r"   rî   r#   Úarray_argmax  s      ÿr  Úallc                 C   s   dd„ }|S )Nc                 S   s"   t  | ¡D ]}| ¡ s
 dS q
dS r    rR   ©r'   rX   r"   r"   r#   Úflat_all#  s    znp_all.<locals>.flat_allr"   )r'   r  r"   r"   r#   Únp_all   s    r  çñhãˆµøä>ç:Œ0âŽyE>Fc                 C   s‚   t  | ¡}t  |¡}|s|s$|r(|s(dS |r:|r:|s~dS nDt  | ¡sNt  |¡rV| |kS t  | | ¡||t  |d ¡  kr~dS dS )NFç      ð?T©rS   rÚ   ÚisinfÚabs)Za_vZb_vÚrtolÚatolÚ	equal_nanZ	a_v_isnanZ	b_v_isnanr"   r"   r#   Ú_allclose_scalars,  s     

ÿÿ$r  Úallclosec                 C   sÐ   t | ƒstdƒ‚t |ƒs tdƒ‚t|tjƒs4tdƒ‚t|tjƒsHtdƒ‚t|tjƒs\tdƒ‚t| tjƒ}t|tjƒ}|rŠ|rŠdd	d
„}|S |r |s ddd„}|S |s¶|r¶ddd„}	|	S |sÌ|sÌddd„}
|
S d S )Nz)The first argument "a" must be array-likez*The second argument "b" must be array-likez2The third argument "rtol" must be a floating pointz3The fourth argument "atol" must be a floating pointz0The fifth argument "equal_nan" must be a booleanr	  r
  Fc                 S   s   t | ||||d�S )N©r  r  r  )r  ©r'   Úbr  r  r  r"   r"   r#   Únp_allclose_impl_scalar_scalar`  s    
ÿz3np_allclose.<locals>.np_allclose_impl_scalar_scalarc                 S   s:   t  |¡}t  |¡D ] }t| | ¡ |||d�s dS qdS ©Nr  FT©rS   ÚasarrayrT   r  rU   )r'   r  r  r  r  Úbvr"   r"   r#   Únp_allclose_impl_scalar_arrayf  s    
ÿz2np_allclose.<locals>.np_allclose_impl_scalar_arrayc                 S   s:   t  | ¡} t  | ¡D ] }t| ¡ ||||d�s dS qdS r  r  )r'   r  r  r  r  Úavr"   r"   r#   Únp_allclose_impl_array_scalarp  s    
ÿz2np_allclose.<locals>.np_allclose_impl_array_scalarc           	      S   s`   t  | ¡} t  |¡}t  | |¡\}}t  ||f¡D ](\}}t| ¡ | ¡ |||d�s2 dS q2dS r  )rS   r  Úbroadcast_arraysrT   r  rU   )	r'   r  r  r  r  Za_aZb_br  r  r"   r"   r#   Únp_allclose_impl_array_arrayz  s    

 ÿz1np_allclose.<locals>.np_allclose_impl_array_array)r	  r
  F)r	  r
  F)r	  r
  F)r	  r
  F)r
   Ú	TypeErrorrI   r   rÙ   r   ÚBooleanÚNumber)r'   r  r  r  r  Zis_a_scalarZis_b_scalarr  r  r  r   r"   r"   r#   Únp_allcloseF  s@      ÿ
  ÿ
  ÿ
  ÿ
r$  Úanyc                 C   s   dd„ }|S )Nc                 S   s"   t  | ¡D ]}| ¡ r
 dS q
dS rË   rR   r  r"   r"   r#   Úflat_any�  s    znp_any.<locals>.flat_anyr"   )r'   r&  r"   r"   r#   Únp_anyŠ  s    r'  c                 C   sN   |d kst |tjƒr ddd„}n*|d ks4t |tjƒr@ddd„}n
ddd„}|S )Nc                 S   s   t  | ¡} t  | ¡S r&   )rS   r  r®   ©rV   rN   Úweightsr"   r"   r#   Únp_average_implš  s    
z#np_average.<locals>.np_average_implc                 S   sv   t  | ¡} t  |¡}| j|jkrB|d kr0tdƒ‚|jdkrBtdƒ‚t  |¡}|dkr\tdƒ‚t  t  | |¡¡| }|S )NzCNumba does not support average when shapes of a and weights differ.r%   z81D weights expected when shapes of a and weights differ.ç        z)Weights sum to zero, can't be normalized.)rS   r  rm   r!  rj   ÚsumÚZeroDivisionErrorÚmultiply)rV   rN   r)  ÚsclÚavgr"   r"   r#   r*  Ÿ  s$    

ÿ
ÿ
ÿc                 S   s   t dƒ‚d S )Nz)Numba does not support average with axis.)r!  r(  r"   r"   r#   r*  µ  s    )NN)NN)NN)rI   r   ÚNoneType)rV   rN   r)  r*  r"   r"   r#   Ú
np_average–  s    
r2  c                 C   s,   t | tjtjfƒrtjS tdd„ ƒ}|S dS )z$
    A generic isnan() function
    c                 S   s   dS rÈ   r"   ©Úxr"   r"   r#   Ú_trivial_isnanÂ  s    z!get_isnan.<locals>._trivial_isnanN)rI   r   rÙ   rØ   rS   rÚ   r   )ry   r5  r"   r"   r#   Ú	get_isnan»  s
    
r6  c                 C   s   t | ƒrdd„ S d S )Nc                 S   s   t  | ¡jdkS rµ   ©rS   r  rÍ   r3  r"   r"   r#   Ú<lambda>Ì  ó    znp_iscomplex.<locals>.<lambda>©r
   r3  r"   r"   r#   Únp_iscomplexÈ  s    r;  c                 C   s   t | ƒrdd„ S d S )Nc                 S   s   t  | ¡jdkS rµ   r7  r3  r"   r"   r#   r8  Ô  r9  znp_isreal.<locals>.<lambda>r:  r3  r"   r"   r#   Ú	np_isrealÐ  s    r<  c                    sV   t | ƒ}t| tjƒrt | jƒ}t |tj¡‰ t| tjƒrF‡ fdd„}n‡ fdd„}|S )Nc                    s   | d krdS ˆ S rÈ   r"   r3  ©Ziscmplxr"   r#   r   â  s    ziscomplexobj.<locals>.implc                    s   ˆ S r&   r"   r3  r=  r"   r#   r   ç  s    )Údetermine_dtyperI   r   ÚOptionalrp   rS   Ú
issubdtypeÚcomplexfloating)r4  Údtr   r"   r=  r#   ÚiscomplexobjØ  s    
rC  c                 C   s   dd„ }|S )Nc                 S   s   t  | ¡ S r&   )rS   rC  r3  r"   r"   r#   r   ñ  s    zisrealobj.<locals>.implr"   ©r4  r   r"   r"   r#   Ú	isrealobjì  s    rE  c                    s   t | ƒ‰ ‡ fdd„}|S )Nc                    s   ˆ S r&   r"   )Únum©re   r"   r#   r   ú  s    znp_isscalar.<locals>.impl)r   )rF  r   r"   rG  r#   Únp_isscalarö  s    rH  c                    s*   t |ƒrd‡ fdd„	}nd‡ fdd„	}|S )Nc                    s   t  t  | ¡ˆ t  | ¡ƒ¡S r&   ©rS   Úlogical_andr  Úsignbit©r4  r    ©Úfnr"   r#   r     s    zis_np_inf_impl.<locals>.implc                    s   t  t  | ¡ˆ t  | ¡ƒ|¡S r&   rI  rL  rM  r"   r#   r     s    )N)N©r   )r4  r    rN  r   r"   rM  r#   Úis_np_inf_implÿ  s    rP  c                 C   s   t dd„ ƒ}t| ||ƒS )Nc                 S   s   | S r&   r"   r3  r"   r"   r#   r8    r9  zisneginf.<locals>.<lambda>©r   rP  ©r4  r    rN  r"   r"   r#   Úisneginf  s    rS  c                 C   s   t dd„ ƒ}t| ||ƒS )Nc                 S   s   |  S r&   r"   r3  r"   r"   r#   r8    r9  zisposinf.<locals>.<lambda>rQ  rR  r"   r"   r#   Úisposinf  s    rT  c                 C   s   | |k S r&   r"   ©r'   r  r"   r"   r#   Ú	less_than  s    rV  c                 C   s   | |kS r&   r"   rU  r"   r"   r#   Úgreater_than  s    rW  c                 C   s   | j dkrtdƒ‚d S )Nr   z3zero-size array to reduction operation not possible)rœ   rk   rÁ   r"   r"   r#   Úcheck_array"  s    
rX  c                    s"   |r‡ fdd„}n‡ fdd„}|S )Nc                    s�   t  | ¡}t|ƒ t  |¡}t|ƒ d¡}|D ]\}| ¡ }t  |j¡rXt  |j¡sX|}q.ˆ |j|jƒrl|}q.|j|jkr.ˆ |j	|j	ƒr.|}q.|S rµ   )
rS   r  rX  rT   rÐ   r   rU   rÚ   r¶   rÍ   ©r'   rV   rÑ   Ú
return_valr�   rX   ©Úcomparison_opr"   r#   r   *  s    

z!nan_min_max_factory.<locals>.implc                    sX   t  | ¡}t|ƒ t  |¡}t|ƒ d¡}|D ]$}| ¡ }t  |¡s.ˆ ||ƒs.|}q.|S rµ   )rS   r  rX  rT   rÐ   r   rU   rÚ   rY  r[  r"   r#   r   ;  s    



r"   )r\  Úis_complex_dtyper   r"   r[  r#   Únan_min_max_factory(  s    r^  )r]  Tc                 C   st   t  | ¡rt  |¡r|S t  | ¡r<t  |¡r<| dk|dkkS t  | ¡sPt  |¡rTdS t| | ƒ||t|ƒ  kS d S )Nr   Fr  )r4  Úyr  r  r  r"   r"   r#   Ú_isclose_itemX  s    r`  c                 C   s’   t | ƒrt |ƒstdƒ‚t| tjƒr<t|tjƒr<d
dd„}nRt| tjƒr`t|tjƒr`ddd„}n.t| tjƒr„t|tjƒr„ddd„}n
dd	d„}|S )Nz+Inputs for `np.isclose` must be array-like.r	  r
  Fc           	      S   sV   |   d¡}|}t t|ƒtj¡}tt|ƒƒD ]}t|| ||||ƒ||< q,|  | j¡S ©Nrù   ©rý   rS   Úzerosr?   r¦   r,   r`  rm   ©	r'   r  r  r  r  r4  r_  r    r(   r"   r"   r#   Úisclose_implj  s    
zisclose.<locals>.isclose_implc           	      S   sV   | }|  d¡}t t|ƒtj¡}tt|ƒƒD ]}t||| |||ƒ||< q,|  |j¡S ra  rb  rd  r"   r"   r#   re  s  s    
c                 S   s„   t  | j|j¡}t  | |¡}t  ||¡}t jt|ƒt jd�}tt  ||f¡ƒD ](\}	\}
}t	|
 
¡ | 
¡ |||ƒ||	< qNt  ||¡S ©N©ry   )rS   Úbroadcast_shapesrm   Úbroadcast_torc  r?   r¦   r�   rT   r`  rU   )r'   r  r  r  r  rm   Úa_Úb_r    r(   r  r  r"   r"   r#   re  |  s    ÿ
c                 S   s   t | ||||ƒS r&   )r`  r  r"   r"   r#   re  ˆ  s    )r	  r
  F)r	  r
  F)r	  r
  F)r	  r
  F)r
   r   rI   r   r—   r#  )r'   r  r  r  r  re  r"   r"   r#   Úisclosed  s    
rl  c                 C   s"   t | ƒ}t |tj¡rtS tS d S r&   )r>  rS   r@  rA  Úcomplex_nanminÚreal_nanmin©r'   rB  r"   r"   r#   Ú	np_nanminŽ  s    rp  c                 C   s"   t | ƒ}t |tj¡rtS tS d S r&   )r>  rS   r@  rA  Úcomplex_nanmaxÚreal_nanmaxro  r"   r"   r#   Ú	np_nanmax—  s    rs  c                    s*   t | tjƒsd S t| jƒ‰ ‡ fdd„}|S )Nc                    sH   d}d}t  | ¡D ](}| ¡ }ˆ |ƒs|| ¡ 7 }|d7 }qt  ||¡S ©Nr+  r   r%   )rS   rT   rU   Údivide)r'   rW   Úcountr�   rX   ©rÚ   r"   r#   Únanmean_impl¦  s    
z np_nanmean.<locals>.nanmean_impl©rI   r   r—   r6  ry   )r'   rx  r"   rw  r#   Ú
np_nanmean   s
    
rz  c                    s*   t | tjƒsd S t| jƒ‰ ‡ fdd„}|S )Nc                    sj   t  | ¡}d}d}t  | ¡D ]@}| ¡ }ˆ |ƒs| ¡ | }|t  |t  |¡ ¡7 }|d7 }qt  ||¡S rt  )rS   ÚnanmeanrT   rU   r¶   r·   ru  )r'   r¸   r¹   rv  r�   rX   rº   rw  r"   r#   Únanvar_implº  s    

znp_nanvar.<locals>.nanvar_implry  )r'   r|  r"   rw  r#   Ú	np_nanvar´  s
    
r}  c                 C   s   t | tjƒsd S dd„ }|S )Nc                 S   s   t  | ¡d S r¿   )rS   ÚnanvarrÁ   r"   r"   r#   Únanstd_implÒ  s    znp_nanstd.<locals>.nanstd_implr¼   )r'   r  r"   r"   r#   Ú	np_nanstdÍ  s    r€  c                    sP   t | tjƒsd S t | jtjƒr&tj}n| j}|dƒ‰t| jƒ‰ ‡ ‡fdd„}|S )Nr   c                    s0   ˆ}t  | ¡D ]}| ¡ }ˆ |ƒs||7 }q|S r&   rR   ©r'   rW   r�   rX   ©rÚ   rZ   r"   r#   Únansum_implã  s    
znp_nansum.<locals>.nansum_impl©rI   r   r—   ry   ÚIntegerr.   r6  )r'   rƒ   rƒ  r"   r‚  r#   Ú	np_nansumØ  s    
r†  c                    sP   t | tjƒsd S t | jtjƒr&tj}n| j}|dƒ‰t| jƒ‰ ‡ ‡fdd„}|S )Nr%   c                    s0   ˆ}t  | ¡D ]}| ¡ }ˆ |ƒs||9 }q|S r&   rR   r�  ©rÚ   Úoner"   r#   Únanprod_implù  s    
z np_nanprod.<locals>.nanprod_implr„  )r'   rƒ   r‰  r"   r‡  r#   Ú
np_nanprodî  s    
rŠ  c                    sZ   t | tjƒsd S t | jtjtjfƒr,dd„ S | j‰tˆƒ‰ ˆdƒ‰‡ ‡‡fdd„}|S d S )Nc                 S   s
   t  | ¡S r&   )rS   r«   rÁ   r"   r"   r#   r8    r9  znp_nancumprod.<locals>.<lambda>r%   c                    sD   t  | jˆ¡}ˆ}t| jƒD ]"\}}ˆ |ƒ r6||9 }|||< q|S r&   rš   rŸ   ©Úis_nanrˆ  rƒ   r"   r#   Únancumprod_impl  s    

z&np_nancumprod.<locals>.nancumprod_impl©rI   r   r—   ry   r"  r…  r6  )r'   r�  r"   r‹  r#   Únp_nancumprod  s    	r�  c                    sZ   t | tjƒsd S t | jtjtjfƒr,dd„ S | j‰tˆƒ‰ ˆdƒ‰‡ ‡‡fdd„}|S d S )Nc                 S   s
   t  | ¡S r&   )rS   r™   rÁ   r"   r"   r#   r8  $  r9  znp_nancumsum.<locals>.<lambda>r   c                    sD   t  | jˆ¡}ˆ}t| jƒD ]"\}}ˆ |ƒ r6||7 }|||< q|S r&   rš   rŸ   ©rŒ  rƒ   rZ   r"   r#   Únancumsum_impl*  s    

z$np_nancumsum.<locals>.nancumsum_implrŽ  )r'   r‘  r"   r�  r#   Únp_nancumsum  s    	r’  c                 C   s&   t | ƒ}t|ƒdkrtdƒ‚n|S d S )Nr   z&zero-size array reduction not possible)Ú_asarrayr?   rk   ©r'   rV   r"   r"   r#   Úprepare_ptp_input6  s    
r•  c                    s*   t |tjƒr‡ fdd„}n‡ fdd„}|S )Nc                    s4   ˆ |j | j ƒr|S |j | j kr0ˆ |j| jƒr0|S | S r&   rÌ   ©Úcurrent_valrº   ©rv   r"   r#   r   F  s    ÿz+_compute_current_val_impl_gen.<locals>.implc                    s   ˆ || ƒr|S | S r&   r"   r–  r˜  r"   r#   r   N  s    )rI   r   rØ   )rv   r—  rº   r   r"   r˜  r#   Ú_compute_current_val_impl_gen?  s    r™  c                 C   s   d S r&   r"   r–  r"   r"   r#   Ú_compute_a_maxS  s    rš  c                 C   s   d S r&   r"   r–  r"   r"   r#   Ú_compute_a_minW  s    r›  c                 C   s   t tj| |ƒS r&   )r™  ÚoperatorÚgtr–  r"   r"   r#   Ú_compute_a_max_impl[  s    rž  c                 C   s   t tj| |ƒS r&   )r™  rœ  Últr–  r"   r"   r#   Ú_compute_a_min_impl`  s    r   c                 C   s   d S r&   r"   ©rº   r"   r"   r#   Ú_early_returne  s    r¢  c                    sH   d‰ t | tjƒr‡ fdd„}n&t | tjƒr8‡ fdd„}n‡ fdd„}|S )Nr   c                    sH   t  | j¡r<t  | j¡r,dt jt jd  fS dt jd fS ndˆ fS d S )NTù              ð?y                F)rS   rÚ   r¶   rÍ   Únanr¡  ©ZUNUSEDr"   r#   r   m  s
    z _early_return_impl.<locals>.implc                    s    t  | ¡rdt jfS dˆ fS d S rË   )rS   rÚ   r¤  r¡  r¥  r"   r#   r   v  s    

c                    s   dˆ fS rÈ   r"   r¡  r¥  r"   r#   r   |  s    )rI   r   rØ   rÙ   )rº   r   r"   r¥  r#   Ú_early_return_impli  s    r¦  Úptpc                 C   s,   t | dƒr t| jtjƒr tdƒ‚dd„ }|S )Nry   ú+Boolean dtype is unsupported (as per NumPy)c           	      S   sj   t | ƒ}|j}|d }|d }t|jƒD ]8}|| }t|ƒ\}}|rL|  S t||ƒ}t||ƒ}q(|| S rµ   )r•  rž   r,   rœ   r¢  rš  r›  )	r'   rV   Za_flatÚa_minÚa_maxr(   rº   Ztake_branchÚretvalr"   r"   r#   Únp_ptp_implŠ  s    
znp_ptp.<locals>.np_ptp_impl)ÚhasattrrI   ry   r   r"  r   )r'   r¬  r"   r"   r#   Únp_ptp�  s
    
r®  c                 C   s(   t  | ¡rdS t  |¡rdS | |k S d S r    )rS   rÚ   rU  r"   r"   r#   Únan_aware_less_than¡  s
    

r¯  c                    s   d‡ ‡fdd„	}|S )Nc                    s  || d? }ˆ| | | | ƒrV| | | |  | |< | |< ˆ rV|| ||  ||< ||< ˆ| | | | ƒr | | | |  | |< | |< ˆ r || ||  ||< ||< ˆ| | | | ƒrê| | | |  | |< | |< ˆ rê|| ||  ||< ||< | | }| | | |  | |< | |< ˆ �r,|| ||  ||< ||< |}|d }||k �r^ˆ| | |ƒ�r^|d7 }�q8||k�r„ˆ|| | ƒ�r„|d8 }�q^||k�r’�qà| | | |  | |< | |< ˆ �rÌ|| ||  ||< ||< |d7 }|d8 }�q8| | | |  | |< | |< ˆ �r|| ||  ||< ||< |S ©Nr%   r"   )ÚAÚlowÚhighÚIÚmidÚpivotr(   Új©ÚargpartitionÚ	pivotimplr"   r#   Ú
_partition­  sD    
z&_partition_factory.<locals>._partition)Nr"   )rº  r¹  r»  r"   r¸  r#   Ú_partition_factory¬  s    -r¼  )r¹  c                    s   d‡ fdd„	}|S )Nc                    sV   ˆ | |||ƒ}||krN||k r6|d }ˆ | |||ƒ}q|d }ˆ | |||ƒ}q| | S )zJ
        Select the k'th smallest element in array[low:high + 1].
        r%   r"   )rä   Úkr²  r³  r¡   r(   ©Úpartitionimplr"   r#   Ú_selectæ  s    z _select_factory.<locals>._select)Nr"   )r¿  rÀ  r"   r¾  r#   Ú_select_factoryå  s    rÁ  c                 C   sŒ   ||kst ‚t| ||ƒ}||k r*|d }q ||d kr@|d }q ||krbt| |d |d |ƒ qxq t| |||d ƒ qxq | | | |d  fS )z©
    Select the k'th and k+1'th smallest elements in array[low:high + 1].

    This is significantly faster than doing two independent selections
    for k and k+1.
    r%   )rü   r»  rÀ  )rä   r½  r²  r³  r(   r"   r"   r#   Ú_select_twoû  s    	

rÂ  c                 C   sT   d}|d }|d? }|d@ dkrBt | |d ||ƒ\}}|| d S t| |||ƒS dS )zt
    The main logic of the median() call.  *temp_arry* must be disposable,
    as this function will mutate it.
    r   r%   ri   N)rÂ  rÀ  )Ú	temp_arryÚnr²  r³  Úhalfr'   r  r"   r"   r#   Ú_median_inner  s    rÆ  c                 C   s   t | tjƒsd S dd„ }|S )Nc                 S   s   |   ¡ }|jd }t||ƒS rµ   )Úflattenrm   rÆ  )r'   rÃ  rÄ  r"   r"   r#   Úmedian_impl)  s    
znp_median.<locals>.median_implr¼   )r'   rÈ  r"   r"   r#   Ú	np_median$  s    rÉ  c                 C   s¶  t | ƒ}|dkr.tjt |ƒ| d tjd�}�n„tjt |ƒtjd�}tt |ƒƒD �]`}|| }|dkr–t | ¡}t t | ¡¡ r’t |¡ r’tj	}�n|dk�rJt 
| ¡}t t | ¡¡ �r¨t | tjk¡}t | tj k¡}|||  }	|	dkrútj	}|dk�r|dk�rtj	}|dk�r$tj	}|	dk�r¨|dk�r¨|dk�r¨tj	}n^d|d t |d¡  }
t |
¡}|
| }t| t|d ƒd|d d�\}}|d|  ||  }|||< qN|S )Nr%   r   rg  éd   ri   ç      Y@)r½  r²  r³  )r?   rS   ro   r²   r›   r,   rÜ   r  Úisfiniter¤  rÊ   r,  ÚinfÚtrue_divideÚmathÚfloorrÂ  Úint)r'   ÚqrÄ  r    r(   Ú
percentilerº   Znum_pos_infZnum_neg_infZ
num_finiteÚrankÚfr¸   ÚlowerÚupperr"   r"   r#   Ú_collect_percentiles_inner3  sD    








 
rØ  c                 C   sT   |r | |  } t | ƒdkr.dS nt |¡r.dS t | ƒdkrL| d }t |¡S dS d S )Nr   Fr%   T)r?   rS   r%  rÌ  )r'   Únan_maskÚskip_nanrº   r"   r"   r#   Ú_can_collect_percentilesh  s    


rÛ  c                 C   sŒ   d}| j dkrX| jdk rXt| jƒD ]2}| | dk sL| | |ksLt | | ¡r"d} qˆq"n0t t | ¡¡s„t | dk ¡s„t | |k¡rˆd}|S )NTr%   é
   r+  F)rj   rœ   r,   rS   rÚ   r%  )rÒ  Úq_upper_boundÚvalidr(   r"   r"   r#   Úcheck_validy  s    &,rß  c                 C   s   t | dd�stdƒ‚d S )NrË  ©rÝ  z)Percentiles must be in the range [0, 100]©rß  rk   ©rÒ  r"   r"   r#   Úpercentile_is_validŠ  s    rã  c                 C   s   t | dd�stdƒ‚d S )Nr  rà  z%Quantiles must be in the range [0, 1]rá  râ  r"   r"   r#   Úquantile_is_valid�  s    rä  c                 C   sz   t j|t jd� ¡ }||ƒ || }t j| t jd� ¡ }t  |¡}t|||ƒrd||  }t||ƒ}nt  t|ƒt j	¡}|S rf  )
rS   r  r²   rÇ  rÚ   rÛ  rØ  ro   r?   r¤  )r'   rÒ  Úcheck_qÚfactorrÚ  rÃ  rÙ  r    r"   r"   r#   Ú_collect_percentiles–  s    

rç  c                    sv   t | ƒ}t |tj¡rtdƒ‚‡ ‡‡fdd„}‡ ‡‡fdd„}t|tjtjfƒrT|S t|tj	ƒrn|j
dkrn|S |S dS )zª
    The underlying algorithm to find percentiles and quantiles
    is the same, hence we converge onto the same code paths
    in this inner function implementation
    zNot supported for complex dtypec                    s   t | |ˆ ˆˆƒd S rµ   ©rç  ©r'   rÒ  ©rå  ræ  rÚ  r"   r#   Únp_percentile_q_scalar_impl´  s    z?_percentile_quantile_inner.<locals>.np_percentile_q_scalar_implc                    s   t | |ˆ ˆˆƒS r&   rè  ré  rê  r"   r#   Únp_percentile_impl·  s    z6_percentile_quantile_inner.<locals>.np_percentile_implr   N)r>  rS   r@  rA  r   rI   r   r#  r"  r—   rj   )r'   rÒ  rÚ  ræ  rå  rB  rë  rì  r"   rê  r#   Ú_percentile_quantile_inner¨  s    rí  c                 C   s   t | |ddtd�S )NFr  ©rÚ  ræ  rå  ©rí  rã  ré  r"   r"   r#   Únp_percentileÂ  s        ÿrð  c                 C   s   t | |ddtd�S )NTr  rî  rï  ré  r"   r"   r#   Únp_nanpercentileÉ  s        ÿrñ  c                 C   s   t | |ddtd�S )NFrË  rî  ©rí  rä  ré  r"   r"   r#   Únp_quantileÐ  s        ÿró  c                 C   s   t | |ddtd�S )NTrË  rî  rò  ré  r"   r"   r#   Únp_nanquantile×  s        ÿrô  c                    s*   t | tjƒsd S t| jƒ‰ ‡ fdd„}|S )Nc                    s\   t  | j| j¡}d}t  | ¡D ]$}| ¡ }ˆ |ƒs|||< |d7 }q|dkrRt jS t||ƒS ©Nr   r%   )rS   r›   rœ   ry   rT   rU   r¤  rÆ  )r'   rÃ  rÄ  r�   rX   rw  r"   r#   Únanmedian_implä  s    
z$np_nanmedian.<locals>.nanmedian_implry  )r'   rö  r"   rw  r#   Únp_nanmedianÞ  s
    
r÷  c           	      C   sl   t  | ¡}t  | jd d… ¡}|D ]D}| |  ¡ }d}t|ƒd }|D ]}t||||ƒ |}qF|||< q"|S )Nrù   r   r%   )rS   Ú
empty_likeÚndindexrm   Úcopyr?   Ú_select_w_nan)	r'   Ú	kth_arrayr    r¡   Úsrä   r²  r³  Úkthr"   r"   r#   Únp_partition_impl_inner÷  s    

rÿ  c           
      C   s‚   t j| t jd�}t  | jd d… ¡}|D ]T}| |  ¡ }t  t|ƒ¡}d}t|ƒd }|D ]}	t||	|||ƒ |	}qZ|||< q(|S )Nrg  rù   r   r%   )	rS   rø  r.   rù  rm   rú  Úaranger?   Ú_arg_select_w_nan)
r'   rü  r    r¡   rý  rä   Zidx_arryr²  r³  rþ  r"   r"   r#   Únp_argpartition_impl_inner  s    
r  c                 C   s�   t |ƒ tj¡}|jdkr"tdƒ‚t t |¡| jd k¡rDtdƒ‚t 	|¡}t 
|¡D ],\}}|dk r||| jd  ||< qX|||< qXt |¡S )a�  
    Returns a sorted, unique array of kth values which serve
    as indexers for partitioning the input array, a.

    If the absolute value of any of the provided values
    is greater than a.shape[-1] an exception is raised since
    we are partitioning along the last axis (per Numpy default
    behaviour).

    Values less than 0 are transformed to equivalent positive
    index values.
    r%   zkth must be scalar or 1-Drù   zkth out of boundsr   )r“  ÚastyperS   r�   rj   rk   r%  r  rm   rø  ÚndenumerateÚunique)r'   rþ  rü  r    Úindexrº   r"   r"   r#   Ú
valid_kths"  s    


r  c                 C   sn   t | tjtjtjfƒstdƒ‚t | tjƒr<| jdkr<tdƒ‚t|d|ƒ}t |tjtj	fƒsbtdƒ‚dd„ }|S )Nú(The first argument must be an array-liker   ú3The first argument must be at least 1-D (found 0-D)ry   úPartition index must be integerc                 S   s2   t | ƒ}|jdkr| ¡ S t||ƒ}t||ƒS d S rµ   )r“  rœ   rú  r  rÿ  ©r'   rþ  Za_tmprü  r"   r"   r#   Únp_partition_implS  s
    

z'np_partition.<locals>.np_partition_impl©
rI   r   r—   ÚSequencerL   r!  rj   r~   r"  r…  )r'   rþ  Úkthdtr  r"   r"   r#   Únp_partitionE  s    r  c                 C   sn   t | tjtjtjfƒstdƒ‚t | tjƒr<| jdkr<tdƒ‚t|d|ƒ}t |tjtj	fƒsbtdƒ‚dd„ }|S )Nr  r   r	  ry   r
  c                 S   s8   t | ƒ}|jdkr | ¡  d¡S t||ƒ}t||ƒS d S )Nr   r.   )r“  rœ   rú  r  r  r  r  r"   r"   r#   Únp_argpartition_impll  s
    

z-np_argpartition.<locals>.np_argpartition_implr  )r'   rþ  r  r  r"   r"   r#   Únp_argpartition^  s    r  c                 C   sv   t d| ƒt d|ƒf}tj|tjd�}t|d ƒD ]@}tt d|| d ƒ|d ƒ}d||d |…f< d|||d …f< q0|S )Nr   rg  r%   )rÜ   rS   r›   r²   r,   rÊ   )ÚNÚMr½  rm   r    r(   Úm_maxr"   r"   r#   Ú	_tri_implz  s    r  c                 C   s   t |dƒ ddd„}|S )Nr½  r   c                 S   s   |d kr| }t | ||ƒS r&   )r  )r  r  r½  r"   r"   r#   Útri_impl�  s    znp_tri.<locals>.tri_impl)Nr   )r   )r  r  r½  r  r"   r"   r#   Únp_tri‡  s    

r  c                 C   sD   | j dkst‚t| ƒ}tj||f| jd�}t|ƒD ]}| ||< q2|S )zq
    Takes a 1d array and tiles it to form a square matrix
    - i.e. a facsimile of np.tile(m, (len(m), 1))
    r%   rg  )rj   rü   r?   rS   r›   ry   r,   )r¸   Zlen_mr    r(   r"   r"   r#   Ú_make_square•  s    
r  c                 C   s>   t j| jd | jd |d� t j¡}t  || t j| | jd�¡S ©Néþÿÿÿrù   ©r  r½  rg  ©rS   Útrirm   r  ÚuintÚwhereÚ
zeros_likery   ©r¸   r½  Úmaskr"   r"   r#   Únp_tril_impl_2d¦  s    $r$  c                 C   sB   t |dƒ d	dd„}d
dd„}| jdkr,|S | jdkr:tS |S d S )Nr½  r   c                 S   s   t | ƒ}t||ƒS r&   )r  r$  ©r¸   r½  Zm_2dr"   r"   r#   Únp_tril_impl_1d²  s    z my_tril.<locals>.np_tril_impl_1dc                 S   sv   t j| jd | jd |d� t j¡}t  | jd d… ¡}t  | ¡}t j|| jd�}|D ]}t  	|| | |¡||< qV|S r  ©
rS   r  rm   r  r  rù  rø  r!  ry   r   ©r¸   r½  r#  r¡   ÚzZzero_optÚselr"   r"   r#   Únp_tril_impl_multi¶  s    $
z#my_tril.<locals>.np_tril_impl_multir%   ri   )r   )r   )r   rj   r$  )r¸   r½  r&  r+  r"   r"   r#   Úmy_tril¬  s    


	

r,  c                 C   s4   t | dƒ t |dƒ t|ƒs&t |dƒ ddd„}|S )NrÄ  r½  r¸   r   c                 S   s   t  t j| ||d�¡S )N©r½  ©rS   Únonzeror  ©rÄ  r½  r¸   r"   r"   r#   Únp_tril_indices_implÐ  s    z-np_tril_indices.<locals>.np_tril_indices_impl)r   N©r   r   )rÄ  r½  r¸   r1  r"   r"   r#   Únp_tril_indicesÇ  s    



r3  c                 C   s*   t |dƒ | jdkrtdƒ‚ddd„}|S )Nr½  ri   úinput array must be 2-dr   c                 S   s   t j| jd || jd d�S ©Nr   r%   )r½  r¸   )rS   Útril_indicesrm   ©rV   r½  r"   r"   r#   Únp_tril_indices_from_implÞ  s    z7np_tril_indices_from.<locals>.np_tril_indices_from_impl)r   ©r   rj   r   )rV   r½  r8  r"   r"   r#   Únp_tril_indices_fromÕ  s
    


r:  c                 C   sB   t j| jd | jd |d d� t j¡}t  |t j| | jd�| ¡S ©Nr  rù   r%   r  rg  r  r"  r"   r"   r#   Únp_triu_impl_2dã  s    (r<  c                 C   sB   t |dƒ d	dd„}d
dd„}| jdkr,|S | jdkr:tS |S d S )Nr½  r   c                 S   s   t | ƒ}t||ƒS r&   )r  r<  r%  r"   r"   r#   Únp_triu_impl_1dî  s    z my_triu.<locals>.np_triu_impl_1dc                 S   sz   t j| jd | jd |d d� t j¡}t  | jd d… ¡}t  | ¡}t j|| jd�}|D ]}t  	||| | ¡||< qZ|S r;  r'  r(  r"   r"   r#   Únp_triu_impl_multiò  s    (
z#my_triu.<locals>.np_triu_impl_multir%   ri   )r   )r   )r   rj   r<  )r¸   r½  r=  r>  r"   r"   r#   Úmy_triué  s    


	

r?  c                 C   s4   t | dƒ t |dƒ t|ƒs&t |dƒ ddd„}|S )NrÄ  r½  r¸   r   c                 S   s   t  dt j| ||d d� ¡S )Nr%   r-  r.  r0  r"   r"   r#   Únp_triu_indices_impl  s    z-np_triu_indices.<locals>.np_triu_indices_impl)r   Nr2  )rÄ  r½  r¸   r@  r"   r"   r#   Únp_triu_indices  s    



rA  c                 C   s*   t |dƒ | jdkrtdƒ‚ddd„}|S )Nr½  ri   r4  r   c                 S   s   t j| jd || jd d�S r5  )rS   Útriu_indicesrm   r7  r"   r"   r#   Únp_triu_indices_from_impl  s    z7np_triu_indices_from.<locals>.np_triu_indices_from_impl)r   r9  )rV   r½  rC  r"   r"   r#   Únp_triu_indices_from  s
    


rD  c                 C   s   d S r&   r"   ©rV   r"   r"   r#   Ú_prepare_array  s    rF  c                 C   s"   | d t jfkrdd„ S dd„ S d S )Nc                 S   s
   t  d¡S )Nr"   ©rS   ÚarrayrE  r"   r"   r#   r8  &  r9  z%_prepare_array_impl.<locals>.<lambda>c                 S   s   t | ƒ ¡ S r&   )r“  rû   rE  r"   r"   r#   r8  (  r9  ©r   ÚnonerE  r"   r"   r#   Ú_prepare_array_impl#  s    rK  c                 C   s€   | }t |tjtjfƒrt|ƒS t|dd ƒ}|d k	rB|ƒ dkrBtjS t|dd ƒ}|d kr^tdƒ‚t |tj	ƒrr|j
}qt|ƒS qd S )NÚ__len__r   ry   ztype has no dtype attr)rI   r   r#  r"  r	   r~   rS   r²   r!  r  ry   )ZinobjÚobjÚlrB  r"   r"   r#   Ú_dtype_of_compound+  s    rO  c                 C   s    t | tjƒr"t | jtjƒr"tdƒ‚t| ƒ}d }t|ƒs>t|ƒ}d }t|ƒsRt|ƒ}|d k	rrt 	||¡srd}t|ƒ‚|d k	r’t 	||¡s’d}t|ƒ‚ddd„}|S )Nr¨  z3dtype of to_begin must be compatible with input aryz1dtype of to_end must be compatible with input aryc           
      S   sÖ   t |ƒ}t | ƒ}t |ƒ}|j}t|ƒdkr˜tjt|ƒt|ƒ t|ƒ d |d�}t|ƒ}t|ƒt|ƒ d }	||d |…< t |¡|||	…< |||	d …< n:tjt|ƒt|ƒ |d�}t|ƒ}||d |…< |||d …< |S )Nr   r%   rg  )rF  ry   r?   rS   r›   Údiff)
ÚaryÚto_endÚto_beginÚstartrµ  ÚendÚ	out_dtyper    Ú	start_idxZmid_idxr"   r"   r#   Únp_ediff1d_implV  s$    ÿz#np_ediff1d.<locals>.np_ediff1d_impl)NN)
rI   r   r—   ry   r"  r   rO  r   rS   Úcan_cast)rQ  rR  rS  Zary_dtZto_begin_dtZ	to_end_dtrŒ   rX  r"   r"   r#   Ú
np_ediff1d<  s$    
rZ  c                 C   s   d S r&   r"   rE  r"   r"   r#   Ú_select_elementt  s    r[  c                 C   s0   t | dd ƒdk}|r dd„ }|S dd„ }|S d S )Nrj   r   c                 S   s$   t jd| jd�}| |d d …< |d S )N)r%   rg  r   )rS   rH  ry   )rV   r4  r"   r"   r#   r   |  s    z"_select_element_impl.<locals>.implc                 S   s   | S r&   r"   rE  r"   r"   r#   r   ‚  s    ©r~   )rV   Zzerodr   r"   r"   r#   Ú_select_element_implx  s    r]  c                 C   s   d S r&   r"   )Údxr4  r"   r"   r#   Ú_get_d‡  s    r_  c                 C   s   t | ƒrdd„ }ndd„ }|S )Nc                 S   s
   t  |¡S r&   ©rS   r  ©r4  r^  r"   r"   r#   r   Ž  s    zget_d_impl.<locals>.implc                 S   s   t  t  | ¡¡S r&   )rS   rP  r  ra  r"   r"   r#   r   ‘  s    rO  )r4  r^  r   r"   r"   r#   Ú
get_d_impl‹  s    
rb  r  c                 C   sH   t | tjtjfƒrtdƒ‚nt | tjƒr:| jdkr:tdƒ‚ddd„}|S )Nzy cannot be a scalarr   zy cannot be 0Dr  c                 S   sX   t  | ¡}t||ƒ}|dtdd ƒf |dtd dƒf  d }t  || d¡}t|ƒ}|S )N.r%   rù   ç       @)rS   r  r_  rE   r,  r[  )r_  r4  r^  ZyarrÚdZy_aveÚretÚ	processedr"   r"   r#   r   ¡  s    

(znp_trapz.<locals>.impl)Nr  )rI   r   r#  r"  r   r—   rj   )r_  r4  r^  r   r"   r"   r#   Únp_trapz–  s    

rg  c                 C   sÜ   |j \}}|t| ƒkst‚||ks&t‚|r|t|ƒD ]F}|dkrPd|dd…|f< q2t | |dd…|d f ¡|dd…|f< q2n\t|d ddƒD ]J}||d kr®d|dd…|f< qŒt | |dd…|d f ¡|dd…|f< qŒdS )a*  
    Generate an N-column Vandermonde matrix from a supplied 1-dimensional
    array, x. Store results in an output matrix, out, which is assumed to
    be of the required dtype.

    Values are accumulated using np.multiply to match the floating point
    precision behaviour of numpy.vander.
    r   r%   Nrù   )rm   r?   rü   r,   rS   r.  )r4  r  Ú
increasingr    r¸   rÄ  r(   r"   r"   r#   Ú
_np_vander¬  s    

,ri  c                 C   s&   | j dkrtdƒ‚|dk r"tdƒ‚d S )Nr%   z.x must be a one-dimensional array or sequence.r   z#Negative dimensions are not allowed)rj   rk   )r4  r  r"   r"   r#   Ú_check_vander_paramsÈ  s    
rj  c                    sz   |d t jfkr"t|t jƒs"tdƒ‚d‡ fdd„	}ddd„}t| t jƒr`t| jƒ}t 	|t
¡‰ |S t| t jt jfƒrv|S d S )	Nz,Second argument N must be None or an integerFc                    sF   |d krt | ƒ}t| |ƒ tjt | ƒt|ƒfˆ d�}t| |||ƒ |S rf  )r?   rj  rS   r›   rÑ  ri  )r4  r  rh  r    rg  r"   r#   Únp_vander_implÖ  s    
z!np_vander.<locals>.np_vander_implc                 S   sR   |d krt | ƒ}t | ¡}t||ƒ tjt | ƒt|ƒf|jd�}t||||ƒ |S rf  )r?   rS   rH  rj  r›   rÑ  ry   ri  )r4  r  rh  Úx_arrr    r"   r"   r#   Únp_vander_seq_implâ  s    

z%np_vander.<locals>.np_vander_seq_impl)NF)NF)r   rJ  rI   r…  r   r—   r	   ry   rS   Úpromote_typesrÑ  rL   r  )r4  r  rh  rk  rm  Úx_dtr"   rg  r#   Ú	np_vanderÐ  s    

rp  c                 C   sD   t |tjtjfƒstdƒ‚dd„ }t | tjtjfƒr<dd„ S |S d S )Nzshift must be an integerc                 S   sR   t  | ¡}t j|j|jd�}|j}t|jƒD ] }|| |j }|| |j|< q,|S rf  )rS   r  r›   rm   ry   rž   r,   rœ   )r'   ÚshiftrV   r    Úarr_flatr(   r¡   r"   r"   r#   Únp_roll_implý  s    
znp_roll.<locals>.np_roll_implc                 S   s
   t  | ¡S r&   r`  )r'   rq  r"   r"   r#   r8  
	  r9  znp_roll.<locals>.<lambda>)rI   r   r…  r"  r   r#  )r'   rq  rs  r"   r"   r#   Únp_rollø  s    rt  é   c                 C   sr  d}|}| ||d  kr|S | |d k r,dS |dkr^d}||k rV| || krV|d7 }q8|d S ||d krr|d }|dk r~d}| || k rÎ| ||d  k rÄ|d }|t krÌ| ||t   krÌ|t  }n|d S nb| ||d  k râ|S | ||d  k � rü|d S |d }||t  d k �r0| ||t   k �r0|t  }||k �rj||| d?  }| || k�rb|d }n|}�q0|d S )Nr   r%   rù   é   rh   ri   )ÚLIKELY_IN_CACHE_SIZE)ÚkeyrV   ÚlengthÚguessÚiminÚimaxr(   Zimidr"   r"   r#   Úbinary_search_with_guess	  sL    
ÿ

ÿ

r}  c                 C   sð  t  | ¡}t  |¡}t  |¡}t|ƒdkr2tdƒ‚t|ƒt|ƒkrJtdƒ‚|jdkrjt j|j|d |d�S t j|j|d�}|j}t|ƒ}	|d }
||	d  }|	dk�r|d }|d }t|ƒD ]@}|j	| }||k rà|
|j	|< q¾||krô||j	|< q¾||j	|< q¾�nèd}|	|k�r&t j|	d |d�}nt jd|d�}|j�r°t|	d ƒD ]f}d||d  ||   }||d  j
|| j
 | }||d  j|| j | }|d|  ||< �qHt|ƒD �]0}|j	| }t  |¡�rò|}d}|d|  |j	|< �q¸t|||	|ƒ}|d	k�r|
|j	|< �q¸||	k�r0||j	|< �q¸||	d k�rP|| |j	|< �q¸|| |k�rp|| |j	|< �q¸|j�r‚|| }n\d||d  ||   }||d  j
|| j
 | }||d  j|| j | }|d|  }|j
|||   || j
 }t  |¡�rZ|j
|||d    ||d  j
 }t  |¡�rZ|| j
||d  j
k�rZ|| j
}|j|||   || j }t  |¡�rÖ|j|||d    ||d  j }t  |¡�rÖ|| j||d  jk�rÖ|| j}|d|  |j	|< �q¸|S )
Nr   úarray of sample points is emptyú#fp and xp are not of the same size.r%   ©Ú
fill_valuery   rg  r£  r+  rù   )rS   r  r?   rk   rœ   ro   rm   r›   r,   rž   r¶   rÍ   rÚ   r}  )r4  ÚxpÚfpry   Údzr^  ÚdyÚdresÚlenxÚlenxpÚlvalÚrvalÚxp_valÚfp_valr(   Úx_valr·  ÚslopesZinv_dxr¶   rÍ   Úsloper"   r"   r#   Únp_interp_impl_complex_innerZ	  sˆ    










	$&
$&
r�  c                 C   sà  t j| t jd�}t j|t jd�}t j|t jd�}t|ƒdkrDtdƒ‚t|ƒt|ƒkr\tdƒ‚|jdkr|t j|j|d |d�S t j|j|d�}|j}t|ƒ}	|d }
||	d  }|	dk�r|d }|d }t	|ƒD ]B}|j
| }||k rò|
|j
|< qÐ||k�r||j
|< qÐ||j
|< qÐ�nÄd}|	|k�rX|dd … |d d…  |dd … |d d…   }nt jd|d�}t	|ƒD �]j}|j
| }t  |¡�r˜||j
|< �qnt|||	|ƒ}|dk�r¾|
|j
|< �qn||	k�rÖ||j
|< �qn||	d k�rô|| |j
|< nä|| |k�r|| |j
|< nÆ|j�r$|| }n(||d  ||  ||d  ||   }||||   ||  |j
|< t  |j
| ¡�rn||||d    ||d   |j
|< t  |j
| ¡�rn|| ||d  k�rn|| |j
|< �qn|S )Nrg  r   r~  r  r%   r€  rù   )rS   r  r²   r?   rk   rœ   ro   rm   r›   r,   rž   rÚ   r}  )r4  r‚  rƒ  ry   r„  r^  r…  r†  r‡  rˆ  r‰  rŠ  r‹  rŒ  r(   r�  r·  rŽ  r�  r"   r"   r#   Únp_interp_impl_innerÈ	  sf    




2




(&(r‘  c                    sÌ   t |dƒr|jdkrtdƒ‚t |dƒr8|jdkr8tdƒ‚d}t|ƒ}t |tj¡rZt|ƒ‚t|ƒ}t |tj¡‰ t ˆ tj¡r„t	‰nt
‰‡ ‡fdd„}‡ ‡fdd	„}t| tjƒrÈt| tjƒrÄt|ƒ‚|S |S )
Nrj   r%   zxp must be 1Dzfp must be 1Dz:Cannot cast array data from complex dtype to float64 dtypec                    s   ˆ| ||ˆ ƒS r&   r"   ©r4  r‚  rƒ  ©ry   rw   r"   r#   Únp_interp_impl<
  s    z!np_interp.<locals>.np_interp_implc                    s   ˆ| ||ˆ ƒj d S rµ   ©rž   r’  r“  r"   r#   Únp_interp_scalar_impl?
  s    z(np_interp.<locals>.np_interp_scalar_impl)r­  rj   r   r>  rS   r@  rA  Úresult_typer²   r�  r‘  rI   r   r#  rØ   )r4  r‚  rƒ  Zcomplex_dtype_msgZxp_dtZfp_dtr”  r–  r"   r“  r#   Ú	np_interp!
  s*    ÿr˜  c                 C   s`   | j dkst‚| j\}}tj|df| jd�}t|ƒD ]&}t | |d d …f ¡| ||df< q4|S )Nri   r%   rg  r   )rj   rü   rm   rS   r›   ry   r,   r,  )r'   r¸   rÄ  r    r(   r"   r"   r#   Úrow_wise_averageM
  s    
$r™  c                 C   sb   |d kr|rd}nd}| j d | }t|dƒ}| t| ƒ8 } t | t | j¡¡}|t d|¡9 }|S )Nr   r%   r+  )rm   rÜ   r™  rS   Údotr·   ÚTrÎ  )ÚXÚbiasÚddofÚfactrW   r"   r"   r#   Únp_cov_impl_innerZ
  s    
r   c                   C   s   d S r&   r"   r"   r"   r"   r#   Ú_prepare_cov_input_inners
  s    r¡  c                 C   s$   |d t jfkrdd„ }ndd„ }|S )Nc                 S   s   t  t| ƒ¡}|s|j}|S r&   )rS   Ú
atleast_2dr“  r›  )r¸   r_  Úrowvarry   Úm_arrr"   r"   r#   r¡  z
  s    z9_prepare_cov_input_impl.<locals>._prepare_cov_input_innerc                 S   s°   t  t| ƒ¡}t  t|ƒ¡}|sH|jd dkr4|j}|jd dkrH|j}|j\}}|j\}}	||	krltdƒ‚t j|| |f|d�}
||
d |…d d …f< ||
| d …d d …f< |
S )Nr   r%   z$m and y have incompatible dimensionsrg  )rS   r¢  r“  rm   r›  rk   r›   )r¸   r_  r£  ry   r¤  Úy_arrZm_rowsZm_colsZy_rowsZy_colsr    r"   r"   r#   r¡  ‚
  s    

rI  )r¸   r_  r£  ry   r¡  r"   r"   r#   Ú_prepare_cov_input_implw
  s    
r¦  c                 C   s(   | j dkr$| jd dkr$d}t|ƒ‚d S )Nri   r   r%   zŸ2D array containing a single row is unsupported due to ambiguity in type inference. To use numpy.cov in this case simply pass the row as a 1D array, i.e. m[0].)rj   rm   rë   )r¸   rŒ   r"   r"   r#   Ú_handle_m_dim_changeŸ
  s    r§  c                 C   s   | S r&   r"   r3  r"   r"   r#   r8  ¨
  r9  r8  c                    sÂ   t j}t| tjƒrt| jƒ}n t| tjtjfƒr:t| ƒ}n„t| tj	tj
fƒr¾tƒ ‰ | D ],}t|dƒrx‡ fdd„|D ƒ qVˆ  |¡ qVtˆ ƒdkr¦t jdd„ ˆ D ƒŽ }ntˆ ƒdkr¾tˆ  ¡ ƒ}|S )Nrv  c                    s   g | ]}ˆ   |¡‘qS r"   )Úadd)Ú.0rX   ©Zcoltypesr"   r#   Ú
<listcomp>µ
  s     z#determine_dtype.<locals>.<listcomp>r%   c                 S   s   g | ]}t |ƒ‘qS r"   )r	   )r©  Útyr"   r"   r#   r«  ¹
  s     )rS   r²   rI   r   r—   r	   ry   r#  r"  r@   rL   Úsetr­  r¨  r?   rn  rn   )Ú
array_likeZarray_like_dtrº   r"   rª  r#   r>  «
  s     

r>  c                 C   sn   t | tjƒr&| jdkrjtd |¡ƒ‚nDt | tjƒrjt | jd tjƒrjt | jd jd tjƒrjtd |¡ƒ‚d S )Nri   z{0} has more than 2 dimensionsr   )rI   r   r—   rj   r!  Úformatr  rx  )r®  Únamer"   r"   r#   Úcheck_dimensionsÀ
  s    
r±  c                 C   s.   t  | ¡stdƒ‚| t| ƒ dkr*tdƒ‚d S )Nz)Cannot convert non-finite ddof to integerr   zddof must be integral value)rS   rÌ  rk   rÑ  )rž  r"   r"   r#   Ú_handle_ddofÊ
  s    
r²  c                 C   s   | S r&   r"   r3  r"   r"   r#   r8  Ò
  r9  c                 C   s   || ƒ ||ƒ t | |||ƒS r&   )r¡  )r¸   r_  r£  ry   rž  Ú_DDOF_HANDLERÚ_M_DIM_HANDLERr"   r"   r#   Ú_prepare_cov_inputÕ
  s    rµ  c                 C   s°   |d t jfk}t| t jƒr(| jdkr(|S t| t jƒrptdd„ | j D ƒƒrL|S t| j ƒdkrpt| j d t jƒrp|S t| t jt j	fƒr†|S t| t j
ƒr¬t| jd t j
ƒs¬|r¬dS dS )Nr%   c                 s   s    | ]}t |tjtjfƒV  qd S r&   )rI   r   r#  r"  ©r©  r4  r"   r"   r#   Ú	<genexpr>ä
  s   ÿz)scalar_result_expected.<locals>.<genexpr>r   TF)r   rJ  rI   r—   rj   Ú	BaseTupler  r?   r#  r"  r  rx  )Zmandatory_inputZoptional_inputZopt_is_noner"   r"   r#   Úscalar_result_expectedÝ
  s(    ÿÿÿr¹  c                 C   s   t  t  | ¡dkt  | ¡| ¡S r°  )rS   r   ÚfabsÚsignr3  r"   r"   r#   Ú
_clip_corr÷
  s    r¼  c                 C   s    t | jƒ}t | jƒ}|d|  S )Nr£  )r¼  r¶   rÍ   )r4  r¶   rÍ   r"   r"   r#   Ú_clip_complexü
  s    

r½  c           	         sÈ   t | dƒ t |dƒ |d tjfkr(t‰ n2t|tjtjfƒr@t‰ nt|tjƒrRt‰ nt	dƒ‚t
‰t| tjƒrnt‰t| ƒ}t|ƒ}t ||tj¡‰d
‡ ‡‡fdd„	}d‡ ‡‡fdd	„	}t| |ƒrÀ|S |S d S )Nr¸   r_  z)ddof must be a real numerical scalar typeTFc                    sb   t | ||ˆ|ˆ ˆƒ ˆ¡}t t |j¡dk¡rRtj|jd |jd ftjˆd�S t|||ƒS d S )Nr   r€  )	rµ  r  rS   r%  rH  rm   ro   r¤  r   )r¸   r_  r£  r�  rž  rœ  ©r³  r´  ry   r"   r#   Únp_cov_impl"  s    ÿÿÿznp_cov.<locals>.np_cov_implc                    sT   t | |||ˆˆ ˆƒ ˆ¡}t t |j¡dk¡r8tj}nt|||ƒjd }t |¡S rµ   )	rµ  r  rS   r%  rH  rm   r¤  r   rž   )r¸   r_  r£  r�  rž  rœ  Úvariancer¾  r"   r#   Únp_cov_impl_single_variable,  s    ÿÿz+np_cov.<locals>.np_cov_impl_single_variable)NTFN)NTFN)r±  r   rJ  Ú_handle_ddof_noprI   r…  r"  rÙ   r²  r   Ú_handle_m_dim_nopr—   r§  r>  rS   r—  r²   r¹  )	r¸   r_  r£  r�  rž  Zm_dtÚy_dtr¿  rÁ  r"   r¾  r#   Únp_cov  s,    


  ÿ
rÅ  c                    sb   t | ƒ}t |ƒ}t ||tj¡}|tjkr0t‰ nt‰ d‡ fdd„	}ddd„}t| |ƒrZ|S |S d S )NTc                    sp   t  | ||¡}t  |¡}t  |j¡}t|jd ƒD ]4}||d d …f  |  < |d d …|f  |  < q2ˆ |ƒS rµ   )rS   ÚcovÚdiagÚsqrtr¶   r,   rm   )r4  r_  r£  rW   rd  Ústddevr(   ©Zclip_fnr"   r#   Únp_corrcoef_implJ  s    
z%np_corrcoef.<locals>.np_corrcoef_implc                 S   s   t  | ||¡}|| S r&   )rS   rÆ  )r4  r_  r£  rW   r"   r"   r#   Ú np_corrcoef_impl_single_variableU  s    z5np_corrcoef.<locals>.np_corrcoef_impl_single_variable)NT)NT)r>  rS   r—  r²   Úcomplex_r½  r¼  r¹  )r4  r_  r£  ro  rÄ  ry   rË  rÌ  r"   rÊ  r#   Únp_corrcoef>  s    


rÎ  c                    sB   t | tjtjfƒ}t| ƒr(|s(dd„ }nd‰ d‰‡ ‡fdd„}|S )Nc                 S   s:   t  | ¡}|jdkr$t jdtjd�S t  t  t  |¡¡¡S )Nr"   )r   r%   rg  )	rS   r  rm   rc  r   r.   rú   Úvstackr/  r”  r"   r"   r#   r   j  s    

znp_argwhere.<locals>.impl)r   r   )r%   r   c                    s4   | d k	r t | ƒr tjˆtjd�S tjˆ tjd�S d S rf  )ÚboolrS   rc  r   r.   rÁ   ©ZfalseishZtrueishr"   r#   r   s  s    )rI   r   r#  r"  r
   )r'   Z
use_scalarr   r"   rÑ  r#   Únp_argwherec  s    
rÒ  c                 C   s   t | ƒrdd„ }ndd„ }|S )Nc                 S   s   t  | ¡}t  t  |¡¡d S rµ   )rS   r  r/  rû   r”  r"   r"   r#   r   €  s    
znp_flatnonzero.<locals>.implc                 S   s:   | d k	rt | ƒrdg}ndd„ tdƒD ƒ}tj|tjd�S )Nr   c                 S   s   g | ]}|‘qS r"   r"   r¶  r"   r"   r#   r«  ˆ  s     z0np_flatnonzero.<locals>.impl.<locals>.<listcomp>rg  )rÐ  r,   rS   rH  r   r.   )r'   r9   r"   r"   r#   r   „  s    r:  )r'   r   r"   r"   r#   Únp_flatnonzero|  s    
rÓ  c                 C   s–   | j dkrD| jd }| jd }d| }|r4|| }qŽ|t||ƒ }nJt | j¡}t t |¡dk¡sltdƒ‚dt |d d… ¡ 	¡  }| 
¡ }||fS )Nri   r   r%   z/All dimensions of input must be of equal lengthrù   )rj   rm   rÊ   rS   rH  r  rP  rk   r«   r,  r“   )r'   Úwrapr¸   rÄ  ÚsteprU  rm   r"   r"   r#   Ú_fill_diagonal_paramsŽ  s    



rÖ  c                 C   s.   t | |ƒ\}}td||ƒD ]}|| j|< qd S rµ   )rÖ  r,   rž   )r'   rº   rÔ  rU  rÕ  r(   r"   r"   r#   Ú_fill_diagonal_scalar¤  s    r×  c                 C   sN   t | |ƒ\}}d}t|ƒ}td||ƒD ]"}|| | j|< |d7 }|| }q&d S rõ  )rÖ  r?   r,   rž   )r'   rº   rÔ  rU  rÕ  ZctrZv_lenr(   r"   r"   r#   Ú_fill_diagonal¬  s    rØ  c                 C   sR   t  | j¡}|j}|j}t  t  |¡ ¡sFt  ||k ¡sFt  ||k¡rNtdƒ‚d S ©Nz'Unable to safely conform val to a.dtype)rS   Úiinfory   rÊ   rÜ   r%  rÌ  rk   )r'   rº   rÚ  Úv_minÚv_maxr"   r"   r#   Ú_check_val_int¸  s
    .rÝ  c                 C   sN   t  | j¡}|j}|j}|t  |¡ }t  ||k ¡sBt  ||k¡rJtdƒ‚d S rÙ  )rS   Úfinfory   rÊ   rÜ   rÌ  r%  rk   )r'   rº   rÞ  rÛ  rÜ  Úfinite_valsr"   r"   r#   Ú_check_val_floatÃ  s    rà  c                 C   s   | S r&   r"   ©r4  r_  r"   r"   r#   r8  Ð  r9  c                 C   s   d S r&   r"   r3  r"   r"   r#   r“  Ó  s    r“  c                    sX   t | tjƒrdd„ S t | tjtjfƒr.dd„ S t | tjtjfƒrTt| ƒ‰ ‡ fdd„S d S )Nc                 S   s   | S r&   r"   r3  r"   r"   r#   r8  Ú  r9  z_asarray_impl.<locals>.<lambda>c                 S   s
   t  | ¡S r&   rG  r3  r"   r"   r#   r8  Ü  r9  c                    s   t j| gˆ d�S rf  rG  r3  ©r¬  r"   r#   r8  ß  r9  )rI   r   r—   r  rL   r#  r"  r	   r3  r"   râ  r#   Ú_asarray_impl×  s    rã  c                    sž   | j dkrˆt| jtjƒrt‰ nt| jtjƒr2t‰ nt‰ d‡ fdd„	}d	‡ fdd„	}t|tjtjtj	fƒrl|S t|tj
tjtjfƒrš|S nd| j  }t|ƒ‚d S )
Nr%   Fc                    s&   t |ƒ ¡ }ˆ | |ƒ t| ||ƒ d S r&   )r“  rÇ  r×  ©r'   rº   rÔ  Ztmpval©Úcheckerr"   r#   Úscalar_implð  s    
z%np_fill_diagonal.<locals>.scalar_implc                    s&   t |ƒ ¡ }ˆ | |ƒ t| ||ƒ d S r&   )r“  rÇ  rØ  rä  rå  r"   r#   Únon_scalar_implõ  s    
z)np_fill_diagonal.<locals>.non_scalar_implz4The first argument must be at least 2-D (found %s-D))F)F)rj   rI   ry   r   r…  rÝ  rÙ   rà  Ú
_check_nopr"  rL   r  r—   r   )r'   rº   rÔ  rç  rè  rŒ   r"   rå  r#   Únp_fill_diagonalâ  s    

rê  c                 C   s   d| j f S )Nzllvm.rint.f%d)r§   )Útpr"   r"   r#   Ú_np_round_intrinsic  s    rì  c                 C   s   ||ƒ}dd„ }||fS )Nc                 S   s`   |\}|j d }|  |¡}|j}tj ||g¡}t ||t|ƒ¡}	| 	|	|f¡}
t
| ||j|
ƒS rµ   )r4   r*   ÚmoduleÚllvmliteÚirÚFunctionTyper   Úget_or_insert_functionrì  Úcallr   r`   )rc   r2   rd   r4   rº   rë  Úlltyrí  ÚfntyrN  re   r"   r"   r#   r>     s    

ÿz _np_round_float.<locals>.codegenr"   )Ú	typingctxrº   rd   r>   r"   r"   r#   Ú_np_round_float  s    rö  c                 C   s’   t  | ¡st  | ¡r| S |dkrp|dkr:d|d  }d}nd| }d}| | | }t  |¡r`| S t|ƒ| | S d|  }| | }t|ƒ| S d S )Nr   é   g      $@g’ÕMÏð€Dr  )rÏ  r  rÚ   rö  )r4  ÚndigitsÚpow1Úpow2r_  r"   r"   r#   Úround_ndigits  s    

rû  c                 C   sâ   t | ƒstdƒ‚t|tjƒs0t|ƒs0d}t|ƒ‚t| tjtjtjfƒr®t|ƒržt| tjƒrhddd„}|S t| tjƒr‚ddd„}|S t| tjƒr¬ddd„}|S qÞddd„}|S n0t| tjƒrÞt|ƒrÐdd	d„}|S dd
d„}|S d S )Nz#The argument "a" must be array-likez5The argument "out" must be an array if it is providedr   c                 S   s   |dkrt | ƒS t| |ƒS d S rµ   )rö  rû  ©r'   Údecimalsr    r"   r"   r#   r   B  s    zimpl_np_round.<locals>.implc                 S   s   |dkr| S t t| |ƒƒS d S rµ   )rÑ  rû  rü  r"   r"   r#   r   I  s    c                 S   s@   |dkrt | jƒ}t | jƒ}nt| j|ƒ}t| j|ƒ}t||ƒS rµ   )rö  r¶   rÍ   rû  Úcomplex)r'   rý  r    r¶   rÍ   r"   r"   r#   r   P  s    
c                 S   s   t  | |¡|d< |S rµ   )rS   Úroundrü  r"   r"   r#   r   Z  s    c                 S   s   t  | ¡}t  | ||¡S r&   )rS   rø  rÿ  rü  r"   r"   r#   r   `  s    
c                 S   s<   | j |j krtdƒ‚t | ¡D ]\}}t ||¡||< q|S )Nzinvalid output shape)rm   rk   rS   r  rÿ  )r'   rý  r    r  rº   r"   r"   r#   r   e  s
    )r   N)r   N)r   N)r   N)r   N)r   N)	r
   r   rI   r   r—   r   rÙ   r…  rØ   )r'   rý  r    rŒ   r   r"   r"   r#   Úimpl_np_round5  s0    





r   c                 C   s<   t | tjƒrdd„ }|S t | tjƒr0dd„ }|S tdƒ‚d S )Nc                 S   s$   | dkrd} | t j9 } t  | ¡|  S )Nr+  g#B’¡œÇ;)rS   ÚpiÚsinr3  r"   r"   r#   r   q  s    
zimpl_np_sinc.<locals>.implc                 S   s0   t  | ¡}t  | ¡D ]\}}t  |¡||< q|S r&   )rS   r!  r  Úsinc)r4  r    r  rº   r"   r"   r#   r   x  s    
z,Argument "x" must be a Number or array-like.)rI   r   r#  r—   r   rD  r"   r"   r#   Úimpl_np_sincn  s    r  c                    sŒ   t dtj ƒ‰ t| tjƒr,d‡ fdd„	}|S t| tjƒrz| j}t|tjƒrR|j	‰nt|tj
ƒrd|‰nd S d‡fdd„	}|S td| › �ƒ‚d S )	Né´   Fc                    s,   |rt  | j| j¡ˆ  S t  | j| j¡S d S r&   )rS   Úarctan2rÍ   r¶   )r)  Údeg)Údeg_multr"   r#   r   ˆ  s    zov_np_angle.<locals>.implc                    s6   t j| ˆ d�}t  | ¡D ]\}}t  ||¡||< q|S rf  )rS   r!  r  Úangle)r)  r  r    r  rº   )Ú	ret_dtyper"   r#   r   ˜  s    z6Argument "z" must be a complex or Array[complex]. Got )F)F)ÚfloatrS   r  rI   r   r#  r—   ry   rØ   Úunderlying_floatrÙ   r   )r)  r  r   ry   r"   )r  r
  r#   Úov_np_angle‚  s    r  zarray.nonzeroc                    sH  |j d }|j}|j‰|j}t|ƒˆˆ |d ƒ}t ˆ |j¡}t ˆ |j¡}	|j	}
|j
}ˆ tjd¡}ˆ tjd¡}t ˆ |¡}t ˆ ||j¡�j}t ˆˆ |
||	||¡}tˆˆ ||ƒ}ˆ ˆ |j|¡}ˆ  |¡�  ˆ  ˆ  ˆ  |¡|¡|¡ W 5 Q R X W 5 Q R X ˆ  |¡f‰‡ ‡‡‡fdd„t|ƒD ƒ}‡ ‡‡fdd„|D ƒ}dd„ |D ƒ}t ˆ |¡}t ˆ ||j¡�º}t ˆˆ |
||	||¡}tˆˆ ||ƒ}ˆ ˆ |j|¡}ˆ  |¡�p |�s¶|f}ˆ  |¡}t|ƒD ]6}t ˆˆ || ˆdd|g¡}tˆˆ ˆ|| |ƒ �qÈˆ  ˆ  ||¡|¡ W 5 Q R X W 5 Q R X ˆ ˆ |j|¡}tˆˆ |j|ƒS )	Nr   r%   c                    s   g | ]}t ˆˆ ˆˆƒ ¡ ‘qS r"   )r   Ú	_getvalue)r©  r(   ©r2   rc   Ú	out_shapeÚoutarytyr"   r#   r«  À  s   ÿz!array_nonzero.<locals>.<listcomp>c                    s   g | ]}t ˆƒˆˆ |ƒ‘qS r"   )r   ©r©  r    )r2   rc   r  r"   r#   r«  Â  s     c                 S   s   g | ]
}|j ‘qS r"   )r9   r  r"   r"   r#   r«  Ã  s     r"   ÚC)r4   r`   ry   rv  r   r   Úunpack_tuplerm   Ústridesr9   Úlayoutr-   r   r.   Úalloca_once_valueÚ	loop_nestrp   Úget_item_pointer2r   Úis_trueÚif_thenÚstorer¨  Úloadr,   r   Ú
make_tupler   )rc   r2   rd   r4   Úarytyrƒ   ZnoutsrQ  rm   r  r9   r  rZ   rˆ  rv  ÚindicesÚptrrº   ÚnzÚoutsZoutarysZ	out_datasr  Úcurr(   r6   r"   r  r#   Úarray_nonzero£  sd    
 ÿ.ÿ ÿ
  þ(r%  c                    s   ‡ fdd„}|S )Nc                    s,   t  |¡ ˆ ¡}t  |¡ ˆ ¡}| r(|S |S r&   )rS   r  r  )Ú	conditionr4  r_  Úx_Úy_rg  r"   r#   r   Þ  s    z)_where_zero_size_array_impl.<locals>.implr"   )ry   r   r"   rg  r#   Ú_where_zero_size_array_implÝ  s    r)  c                 C   s0   t  | ¡D ] \}}|r|| n|| ||< q
|S r&   )rS   r  )Úcondr4  r_  re   r¡   rW   r"   r"   r#   Ú_where_generic_inner_implå  s    r+  c           	      C   sH   | j }|j }|j }|j }t| jƒD ] }|| r6|| n|| ||< q"|S r&   )rž   r,   rœ   )	r*  r4  r_  re   ÚcfÚxfZyfÚrfr(   r"   r"   r#   Ú_where_fast_inner_implì  s    r/  c                    s$   ˆdhdhfk‰‡ ‡‡fdd„}|S )Nr  ÚFc                    s°   t  | ¡t  |¡t  |¡  }}}t  |j|j|j¡}t  ||¡}t  ||¡}t  ||¡}	ˆdkr~t j|d d d… ˆ d�j}
nt j|ˆ d�}
ˆržt|||	|
ƒS t|||	|
ƒS d S )Nr0  rù   rg  )	rS   r  rh  rm   ri  r›   r›  r/  r+  )r&  r4  r_  Úcond1Úx1Úy1rm   Zcond_r'  r(  re   ©ry   r  Zuse_faster_implr"   r#   r   ú  s    "z!_where_generic_impl.<locals>.implr"   )ry   r  r   r"   r4  r#   Ú_where_generic_impl÷  s    r5  c                 C   s    t | ƒsd}t|ƒ‚dd„ }|S )Nú+The argument "condition" must be array-likec                 S   s   t  | ¡ ¡ S r&   )rS   r  r/  )r&  r"   r"   r#   Úwhere_cond_none_none  s    z)ov_np_where.<locals>.where_cond_none_none)r
   r   )r&  rŒ   r7  r"   r"   r#   Úov_np_where  s
    r8  c                    s.  t | ƒsd}t|ƒ‚t|ƒs$t|ƒr,tdƒ‚t||fdƒD ]"\}}t |ƒs:d}t| |¡ƒ‚q:t| tjƒ}t|tjƒ}t|tjƒ}|�rt|ƒ}	t|ƒ}
t	 
|	|
¡}dd„ ‰ t‡ fdd„| ||fD ƒƒ}|rÔt|ƒS | j}|�r|�r|j|j  k�r| jk�rn n|j}nd	}t||ƒS d
d„ }|S d S )Nr6  z"Argument "x" or "y" cannot be Nonerá  z0The argument "{}" must be array-like if providedc                 S   s"   t | tjƒp t | tjƒo | jdkS rµ   )rI   r   r#  r—   rj   ©Úargr"   r"   r#   Úcheck_0_dim;  s    ÿz$ov_np_where_x_y.<locals>.check_0_dimc                    s   g | ]}ˆ |ƒ‘qS r"   r"   )r©  r'   ©r;  r"   r#   r«  >  s     z#ov_np_where_x_y.<locals>.<listcomp>r±  c                 S   s    t  t  | ¡t  |¡t  |¡¡S r&   )rS   r   r  )r&  r4  r_  r"   r"   r#   r   J  s    zov_np_where_x_y.<locals>.impl)r
   r   r   Úzipr¯  rI   r   r—   r>  rS   rn  r  r)  r  r5  )r&  r4  r_  rŒ   r:  r°  Zcond_arrrl  r¥  ro  rÄ  ry   Zspecial_0_caser  r   r"   r<  r#   Úov_np_where_x_y  s8    "
r>  c                 C   s   dd„ }|S )Nc                 S   s   | j S r&   )r¶   rÁ   r"   r"   r#   Únp_real_implQ  s    znp_real.<locals>.np_real_implr"   )r'   r?  r"   r"   r#   Únp_realO  s    r@  c                 C   s   dd„ }|S )Nc                 S   s   | j S r&   )rÍ   rÁ   r"   r"   r#   Únp_imag_implY  s    znp_imag.<locals>.np_imag_implr"   )r'   rA  r"   r"   r#   Únp_imagW  s    rB  c                 C   s   t | tjƒsd S dd„ }|S )Nc                 S   s"   t  | ¡D ]}||kr
 dS q
dS rË   )rS   rT   )rV   rx  r4  r"   r"   r#   Únp_contains_implg  s    z%np_contains.<locals>.np_contains_implr¼   )rV   rx  rC  r"   r"   r#   Únp_containsb  s    rD  c                 C   s8   t | ƒstdƒ‚t|ƒr&ddd„}|S ddd„}|S d S )Nz3The argument to np.count_nonzero must be array-likec                 S   s   t  | ¡}t  |dk¡S rµ   )rS   rû   r,  ©rV   rN   Úarr2r"   r"   r#   r   v  s    
znp_count_nonzero.<locals>.implc                 S   s   |   tj¡}tj||d�S )N)rN   )r  rS   r¦   r,  rE  r"   r"   r#   r   {  s    )N)N)r
   r   r   )rV   rN   r   r"   r"   r#   Únp_count_nonzerop  s    

rG  c                 C   s   | S r&   r"   r3  r"   r"   r#   r8  �  r9  c                 C   s
   t  | ¡S r&   r`  r3  r"   r"   r#   r8  ‚  r9  c                    s�   t | tjtjfƒstdƒ‚t |tjtjtjfƒrlt |tjƒrBt‰ nt |jtjƒsXtdƒ‚t	‰ ‡ fdd„}|S t |tjƒs€tdƒ‚dd„ }|S d S )Nz)arr must be either an Array or a Sequencezobj should be of Integer dtypec                    s>   t  t  | ¡¡} | j}t j|t jd�}ˆ |ƒ}d||< | | S )Nrg  F)rS   rû   r  rœ   Úonesr¦   )rV   rM  r  Úkeep©Úhandlerr"   r#   Únp_delete_impl•  s    z!np_delete.<locals>.np_delete_implc                 S   sf   t  t  | ¡¡} | j}|}|| k s,||kr4tdƒ‚|dk rD||7 }t  | d |… | |d d … f¡S )Nz"obj must be less than the len(arr)r   r%   )rS   rû   r  rœ   Ú
IndexErrorÚconcatenate)rV   rM  r  Úposr"   r"   r#   Únp_delete_scalar_impl£  s    z(np_delete.<locals>.np_delete_scalar_impl)
rI   r   r—   r  r   Ú	SliceTypeÚnp_delete_handler_isslicery   r…  Únp_delete_handler_isarray)rV   rM  rL  rP  r"   rJ  r#   Ú	np_delete…  s    rT  r%   c                 C   s(   t | tjƒr| jdkrd S ddd„}|S )Nr   r%   c                 S   s0  |dkr|   ¡ S |dk r tdƒ‚| jd }| jd d… t|| dƒf }t || j¡}|jdkrd|S |  d|f¡}| d|jd f¡}t || j¡}t	|jd ƒD ]ˆ}t	|d ƒD ]$}	|||	d f |||	f  ||	< q²t	d|ƒD ]2}
t	||
 d ƒD ]}	||	d  ||	  ||	< qöqâ|d || … ||< q¢|S )Nr   z"diff(): order must be non-negativerù   r%   )
rú  rk   rm   rÜ   rS   r›   ry   rœ   rý   r,   )r'   rÄ  rœ   r  r    Úa2Zout2ÚworkÚmajorr(   Úniterr"   r"   r#   Ú	diff_impl¹  s(    

"znp_diff_impl.<locals>.diff_impl)r%   )rI   r   r—   rj   )r'   rÄ  rY  r"   r"   r#   Únp_diff_impl´  s    
rZ  c                 C   sN   t | ƒrt |ƒstdƒ‚tjtjf}t| |ƒrBt||ƒrBdd„ }ndd„ }|S )Nz3Both arguments to "array_equals" must be array-likec                 S   s   | |kS r&   r"   rU  r"   r"   r#   r   ä  s    znp_array_equal.<locals>.implc                 S   s2   t  | ¡} t  |¡}| j|jkr.t  | |k¡S dS rÈ   )rS   r  rm   r  rU  r"   r"   r#   r   ç  s
    

)r
   r   r   r"  r#  rI   )r'   r  Úacceptedr   r"   r"   r#   Únp_array_equalÛ  s    
r\  c                 C   s$   t | ƒst |ƒstdƒ‚dd„ }|S )Nz.intersect1d: first two args must be array-likec                 S   sj   t  | ¡} t  |¡}t  | ¡} t  |¡}t  | |f¡}| ¡  |dd … |d d… k}|d d… | }|S )Nr%   rù   )rS   r  r  rN  Úsort)Úar1Úar2Úauxr#  Úint1dr"   r"   r#   Únp_intersects1d_implù  s    



z0jit_np_intersect1d.<locals>.np_intersects1d_impl©r
   r   )r^  r_  rb  r"   r"   r#   Újit_np_intersect1dñ  s    rd  c                 C   sD   t |tjƒr&|jdkr@td | ¡ƒ‚nt |tjƒs@td | ¡ƒ‚d S )Nr%   z${0}(): input should have dimension 1z+{0}(): input should be an array or sequence)rI   r   r—   rj   r!  r¯  r  )Ú	func_nameÚseqr"   r"   r#   Úvalidate_1d_array_like  s    
ÿÿrg  c                    s’   t d| ƒ t| jtjƒsd S t|dƒ |d tjfkr^t d|ƒ tj‰t	dd„ ƒ‰t	dd„ ƒ‰ ntj
‰t	dd„ ƒ‰t	dd„ ƒ‰ d‡ ‡‡fd
d„	}|S )NÚbincountÚ	minlengthc                 S   s   t | ƒt |ƒkrtdƒ‚d S )Nz7bincount(): weights and list don't have the same length)r?   rk   ©r'   r)  ri  r"   r"   r#   Úvalidate_inputs!  s    z$np_bincount.<locals>.validate_inputsc                 S   s   | |  || 7  < d S r&   r"   ©r    r¡   rº   r)  r"   r"   r#   Ú
count_item'  s    znp_bincount.<locals>.count_itemc                 S   s   d S r&   r"   rj  r"   r"   r#   rk  .  s    c                 S   s   | |  d7  < d S r°  r"   rl  r"   r"   r#   rm  2  s    r   c                    s¨   ˆ| ||ƒ |dk rt dƒ‚t| ƒ}|dkr4| d nd}td|ƒD ]&}| | dk rZt dƒ‚t|| | ƒ}qBt|d |ƒ}t |ˆ¡}t|ƒD ]}ˆ ||| | |ƒ qŒ|S )Nr   z 'minlength' must not be negativerù   r%   z/bincount(): first argument must be non-negative)rk   r?   r,   rÜ   rS   rc  )r'   r)  ri  rÄ  rª  r(   Z
out_lengthr    ©rm  rV  rk  r"   r#   Úbincount_impl6  s    z"np_bincount.<locals>.bincount_impl)Nr   )rg  rI   ry   r   r…  r   rJ  rS   r²   r   r.   )r'   r)  ri  ro  r"   rn  r#   Únp_bincount  s$    





rp  c                    s   ‡ fdd„}|S )Nc                    s–   t  |¡r:t|ddƒD ]}t  | |d  ¡s|  S qdS ||k rH|}nd}||k r\|d n|}||kr’|| d? }ˆ | | |ƒrŒ|d }q`|}q`|S )a×  Perform inner loop of searchsorted (i.e. a binary search).

        This is loosely based on the NumPy implementation in [1]_.

        Parameters
        ----------
        a: 1-D array_like
            The input array.
        v: array_like
            The current value to insert into `a`.
        v_last: array_like
            The previous value inserted into `a`.
        lo: int
            The initial/previous "low" value of the binary search.
        hi: int
            The initial/previous "high" value of the binary search.
        n: int
            The length of `a`.


        .. [1] https://github.com/numpy/numpy/blob/809e8d26b03f549fd0b812a17b8a166bcd966889/numpy/core/src/npysort/binsearch.cpp#L173
        r   rù   r%   )rS   rÚ   r,   )r'   rX   Úv_lastÚloÚhirÄ  r(   rµ  ©Úfuncr"   r#   Úsearchsorted_innerM  s    


z)_searchsorted.<locals>.searchsorted_innerr"   )ru  rv  r"   rt  r#   Ú_searchsortedL  s    .rw  c                 C   s   | |kS r&   r"   rá  r"   r"   r#   r8    r9  Úleftc                    s€   t |d|ƒ}|dkrt‰ n|dkr(t‰ ntd|› �ƒ‚t|tjƒrRd	‡ fdd„	}n*t|tjƒrnd
‡ fdd„	}nd‡ fdd„	}|S )NrK   rx  Úrightz Invalid value given for 'side': c           
         sn   t | ƒ}d}|}t |jtj¡}|jd }t ||f¡D ]0\}}	ˆ | | ¡ ||||ƒ}| ¡ }|	 |¡ q8|S rµ   )	r?   rS   r›   rm   r.   rž   rT   rU   Úitemset)
r'   rX   ÚsiderÄ  rr  rs  r    rq  r�   Úoutview©Z	loop_implr"   r#   Úsearchsorted_impl�  s    
z'searchsorted.<locals>.searchsorted_implc           	         sf   t | ƒ}d}|}t t |ƒtj¡}|d }tt |ƒƒD ]*}ˆ | || ||||ƒ}|||< || }q6|S rµ   )r?   rS   r›   r.   r,   )	r'   rX   r{  rÄ  rr  rs  r    rq  r(   r}  r"   r#   r~  ž  s    
c                    s   t | ƒ}ˆ | ||d||ƒS rµ   )r?   )r'   rX   r{  rÄ  r}  r"   r#   r~  ¬  s    )rx  )rx  )rx  )r~   Ú_searchsorted_leftÚ_searchsorted_rightr   rI   r   r—   r  )r'   rX   r{  Zside_valr~  r"   r}  r#   Úsearchsorted„  s    r�  c                    sl   t dd„ ƒ‰ t dd„ ƒ‰t dd„ ƒ‰t| tjƒrFd‡ ‡‡fdd	„	}|S t| tjƒrhd‡ ‡‡fd
d	„	}|S d S )Nc                 S   sl   t | ƒ}d}d}|dkrh| d }td|ƒD ]<}| | }|oB||k }|oP||k  }|sb|sbtdƒ‚|}q*|S )NTr%   r   z3bins must be monotonically increasing or decreasing)r?   r,   rk   )ÚbinsrÄ  Úis_increasingZis_decreasingÚprevr(   r$  r"   r"   r#   Úare_bins_increasingµ  s    z(np_digitize.<locals>.are_bins_increasingc                 S   sÂ   t |ƒ}d}|}|r€t | ¡rNt|ddƒD ]}t ||d  ¡s*|  S q*dS ||kr¾|| d? }|| | k rx|d }qN|}qNn>t | ¡rŽ|S ||kr¾|| d? }|| | kr¸|d }qŽ|}qŽ|S )Nr   rù   r%   ©r?   rS   rÚ   r,   ©r4  r‚  ry  rÄ  rr  rs  r(   rµ  r"   r"   r#   Údigitize_scalarÉ  s,    




z$np_digitize.<locals>.digitize_scalarc                 S   s¼   t |ƒ}d}|}|rzt | ¡rHtd|ƒD ]}t || ¡s(|  S q(|S ||kr¸|| d? }|| | k rn|}qH|d }qHn>t | ¡rˆdS ||kr¸|| d? }|| | kr®|}qˆ|d }qˆ|S rõ  r†  r‡  r"   r"   r#   Údigitize_scalar_decreasingï  s,    



z/np_digitize.<locals>.digitize_scalar_decreasingFc                    sd   ˆ |ƒ}t  | jt j¡}t  | |f¡D ]8\}}|rDˆ| ¡ ||ƒ}nˆ| ¡ ||ƒ}| |¡ q&|S r&   )rS   r›   rm   r.   rT   rU   rz  )r4  r‚  ry  rƒ  r    r�   r|  r  ©r…  rˆ  r‰  r"   r#   Údigitize_impl  s    z"np_digitize.<locals>.digitize_implc                    s^   ˆ |ƒ}t  t| ƒt j¡}tt| ƒƒD ]2}|rDˆ| | ||ƒ||< q&ˆ| | ||ƒ||< q&|S r&   )rS   r›   r?   r.   r,   )r4  r‚  ry  rƒ  r    r(   rŠ  r"   r#   r‹  '  s    )F)F)r   rI   r   r—   r  )r4  r‚  ry  r‹  r"   rŠ  r#   Únp_digitize³  s    

%
$
rŒ  rÜ  c                    sP   t |ttjfƒrB|d tjfkr6tdƒ‰ d‡ fdd„	}qLddd„}n
d	dd„}|S )
NrÍ  rÜ  c                    sL   ˆ }ˆ  }t  | ¡D ]$}| ¡ }||kr,|}||k r|}qt  | |||f¡S r&   )rS   rT   rU   Ú	histogram)r'   r‚  r,   Úbin_minÚbin_maxr�   rX   ©rÍ  r"   r#   Úhistogram_impl@  s    z$np_histogram.<locals>.histogram_implc                 S   sØ   |dkrt dƒ‚|\}}||ks(t dƒ‚t |tj¡}||kr¾|||  }t | ¡D ]h}| ¡ }t || | ¡}	d|	  kr†|k r n n|t|	ƒ  d7  < qT||krT||d   d7  < qTt 	|||d ¡}
||
fS )Nr   z0histogram(): `bins` should be a positive integerz;histogram(): max must be larger than min in range parameterr%   )
rk   rS   rc  r.   rT   rU   rÏ  rÐ  rÑ  Úlinspace)r'   r‚  r,   rŽ  r�  ÚhistZ	bin_ratior�   rX   r  Z
bins_arrayr"   r"   r#   r‘  L  s"    c                 S   sä   t |ƒd }t|ƒD ] }|| ||d  kstdƒ‚q|d }|| }t |tj¡}|dkrÜt | ¡D ]t}| ¡ }	||	  kr†|ksŠqf qfd}
|d }|
|k rÊ|
| d d? }|	|| k rÄ|d }q–|}
q–||
  d7  < qf||fS )Nr%   z-histogram(): bins must increase monotonicallyr   )r?   Ú_rangerk   rS   rc  r.   rT   rU   )r'   r‚  r,   Únbinsr(   rŽ  r�  r“  r�   rX   rr  rs  rµ  r"   r"   r#   r‘  f  s*    

)rÜ  N)rÜ  N)rÜ  N)rI   rÑ  r   r…  rJ  r  )r'   r‚  r,   r‘  r"   r�  r#   Únp_histogram7  s    
!r–  )ÚibetarÑ   ÚmachepÚepsÚnegepÚepsnegÚiexpÚminexpÚxminÚmaxexpÚxmaxÚirndÚngrdÚepsilonÚtinyÚhugeÚ	precisionÚ
resolutionÚMachAr)r™  r›  rœ  r˜  rÜ   rŸ  rÊ   r�  rš  ÚnexpÚnmantr¦  r§  r¤  ÚbitsrÞ  )rÊ   rÜ   r«  rÚ  c               	      sh   t dkrd S t dk‰ d ‰tjdd��"‰d} tjd| tdd� tj‰W 5 Q R X tˆƒ‡ ‡‡fd	d
„ƒ}d S )N)r%   é   )r%   r÷  T)Úrecordz(`np.MachAr` is deprecated \(NumPy 1.22\)Úalwaysz.*numba.*arraymath)ÚmessageÚcategoryrí  c                     sX   ˆƒ ‰t ‡fdd„tD ƒƒ‰ ˆrHˆrHˆd } t | jjd t| j| j¡ ‡ fdd„}|S )Nc                    s   g | ]}t ˆ |ƒ‘qS r"   r\  r¶  ©rÕ  r"   r#   r«  ´  s     z7_gen_np_machar.<locals>.MachAr_impl.<locals>.<listcomp>r   c                      s   t ˆ Ž S r&   )r¨  r"   )Ú_mach_ar_datar"   r#   r   ½  s    z1_gen_np_machar.<locals>.MachAr_impl.<locals>.impl)	r  Ú_mach_ar_supportedÚwarningsÚwarn_explicitr¯  r4   r   ÚfilenameÚlineno)Úwmsgr   ©Z	np122plusZ	np_MachArÚw)r²  rÕ  r#   ÚMachAr_impl±  s    ýz#_gen_np_machar.<locals>.MachAr_impl)r   r´  Úcatch_warningsÚfilterwarningsÚDeprecationWarningrS   r¨  r   )rŒ   r»  r"   r¹  r#   Ú_gen_np_machar£  s    þr¿  c                    s   t ˆƒ‡ ‡‡fdd„ƒ}d S )Nc                    s`   t | d| ƒ}t|ƒ}zˆ|ƒ‰W n tk
r6   Y d S X t‡fdd„ˆD ƒƒ‰ ‡‡ fdd„}|S )Nry   c                    s   g | ]}t ˆ |ƒ‘qS r"   r\  r¶  r±  r"   r#   r«  Ï  s     z6generate_xinfo.<locals>.xinfo_impl.<locals>.<listcomp>c                    s   ˆ ˆŽ S r&   r"   r9  )Ú	containerr9   r"   r#   r   Ñ  s    z0generate_xinfo.<locals>.xinfo_impl.<locals>.impl)r~   r	   rk   r  )r:  ZnbtyÚnp_dtyper   ©ÚattrrÀ  Únp_func)r9   rÕ  r#   Ú
xinfo_implÆ  s    z"generate_xinfo.<locals>.xinfo_impl)r   )rÄ  rÀ  rÃ  rÅ  r"   rÂ  r#   Úgenerate_xinfoÅ  s    rÆ  c                    sl   t dd„ ƒ}ts|S tjtjB }| |ko.||k}|s8|S t| ƒ}t|ƒ}t ||¡‰ t ‡ fdd„ƒ}|S d S )Nc                 S   s.   d}t t| ƒƒD ]}|| | ||   }q|S rµ   ©r,   r?   )r'   r  Úaccr(   r"   r"   r#   Ú
_innerprodÞ  s    z#_get_inner_prod.<locals>._innerprodc                    s   t  |  ˆ ¡| ˆ ¡¡S r&   )rS   rš  r  rU  ©rB  r"   r#   Ú	_dot_wrapò  s    z"_get_inner_prod.<locals>._dot_wrap)r   Ú
_HAVE_BLASr   Úreal_domainÚcomplex_domainr	   rS   rn  )ÚdtaÚdtbrÉ  ÚfltyZfloatsÚa_dtÚb_dtrË  r"   rÊ  r#   Ú_get_inner_prodÚ  s    
rÔ  c                 C   s&   t | tjƒr"| jdks"td| ƒ‚d S )Nr%   z!%s() only supported on 1D arrays )rI   r   r—   rj   r   )r'   re  r"   r"   r#   Ú
_assert_1dø  s    
rÕ  c                 C   s   d S r&   r"   )Úap1Úap2ÚmodeÚ	directionr"   r"   r#   Ú_np_correlate_coreþ  s    rÚ  c                   @   s   e Zd ZdZdZdZdZdS )Ú_corr_conv_Modezº
    Enumerated modes for correlate/convolve as per:
    https://github.com/numpy/numpy/blob/ac6b1a902b99e340cf7eeeeb7392c91e38db9dd8/numpy/core/numeric.py#L862-L870    # noqa: E501
    r   r%   ri   N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__ÚVALIDZSAMEÚFULLr"   r"   r"   r#   rÛ    s   rÛ  c                    sF   t | jƒ}t |jƒ}t ||¡‰t| j|jƒ‰t‰ ‡ ‡‡fdd„}|S )Nc                    s€  |ˆ j ks|ˆ jkstdƒ‚t| ƒ}t|ƒ}|}|}|ˆ j krT|| d }d}d}	n0|ˆ jkr||d }	|d }|| d }ntdƒ‚t |ˆ¡}
|| }|dkrªd}d}n|dkrÀ|d }d}ntdƒ‚t|ƒD ]4}ˆ| d |d … ||d  d … ƒ|
|< || }qÐt|| d ƒD ](}ˆ| ||| … |ƒ|
|< || }�qt|	ddƒD ].}ˆ| | d … |d |… ƒ|
|< || }�qL|
S )NzInvalid moder%   r   rù   zInvalid direction)rà  rá  rk   r?   rS   rc  r,   )rÖ  r×  rØ  rÙ  Ún1Ún2ry  rÄ  Zn_leftZn_rightre  r¡   Úincr(   ©ÚModerB  Z	innerprodr"   r#   r     sD    	

(
 z%_np_correlate_core_impl.<locals>.impl)r	   ry   rS   rn  rÔ  rÛ  )rÖ  r×  rØ  rÙ  rÒ  rÓ  r   r"   rå  r#   Ú_np_correlate_core_impl  s    

4rç  c                    sŽ   t | dƒ t |dƒ tdd„ ƒ}tdd„ ƒ}t‰ | jtjkr\|jtjkrR|‰|‰qz|‰|‰n|jtjkrr|‰|‰n|‰|‰‡ ‡‡fdd„}|S )Nznp.correlatec                 S   s
   t  | ¡S r&   )rS   r·   r3  r"   r"   r#   Úop_conjQ  s    z_np_correlate.<locals>.op_conjc                 S   s   | S r&   r"   r3  r"   r"   r#   Úop_nopU  s    z_np_correlate.<locals>.op_nopc                    sl   t | ƒ}t |ƒ}|dkr tdƒ‚|dkr0tdƒ‚||k rPtˆ|ƒˆ| ƒˆ jdƒS tˆ| ƒˆ|ƒˆ jdƒS d S ©Nr   z'a' cannot be emptyz'v' cannot be emptyrù   r%   )r?   rk   rÚ  rà  ©r'   rX   ÚlaÚlv©ræ  Za_opZb_opr"   r#   r   j  s    z_np_correlate.<locals>.impl)rÕ  r   rÛ  ry   r   rÎ  )r'   rX   rè  ré  r   r"   rî  r#   Ú_np_correlateL  s(    



rï  c                    s(   t | dƒ t |dƒ t‰ ‡ fdd„}|S )Nznp.convolvec                    sp   t | ƒ}t |ƒ}|dkr tdƒ‚|dkr0tdƒ‚||k rRt|| d d d… ˆ jdƒS t| |d d d… ˆ jdƒS d S rê  )r?   rk   rÚ  rá  rë  ©ræ  r"   r#   r   €  s    znp_convolve.<locals>.impl)rÕ  rÛ  )r'   rX   r   r"   rð  r#   Únp_convolvey  s
    

rñ  c                    s.  t | ƒsd S d }t| tjƒrHt|ƒs0| j|jkr<d
dd„}n
ddd„}nât| tjtjfƒrzt|ƒrnddd„}n
ddd„}n°t| tjtj	fƒr´t|ƒr˜| n|}t
|ƒ‰d‡fdd„	}nvt| tjjƒ�rt| jtjtj	fƒsàtdƒ‚t|ƒrî| jn|‰d‡fdd„	}n(t| tjƒ�r*t | j¡‰ d‡ fd	d„	}|S )Nc                 S   s   | S r&   r"   ©r'   ry   r"   r"   r#   r   œ  s    znp_asarray.<locals>.implc                 S   s
   |   |¡S r&   )r  rò  r"   r"   r#   r   Ÿ  s    c                 S   s
   t  | ¡S r&   rG  rò  r"   r"   r#   r   ¦  s    c                 S   s   t  | |¡S r&   rG  rò  r"   r"   r#   r   ©  s    c                    s   t  | ˆ ¡S r&   rG  rò  râ  r"   r#   r   ¯  s    z?asarray support for List is limited to Boolean and Number typesc                    s4   t | ƒ}tj|ˆ d�}t| ƒD ]\}}|||< q|S rf  )r?   rS   r›   r�   )r'   ry   rN  re  r(   rX   )Útarget_dtyper"   r#   r   ¹  s
    
c                    s   ˆ   ¡ S r&   )rú  rò  rE  r"   r#   r   Â  s    )N)N)N)N)N)N)N)r
   rI   r   r—   r   ry   r  rL   r#  r"  r	   Ú
containersÚListTyper   ÚStringLiteralrS   r  rK   )r'   ry   r   Zdt_convr"   )rV   ró  r¬  r#   Ú
np_asarray‘  s4    ÿr÷  c                    sD   t |tjƒrt|ƒ}t |tj¡s*tj‰ n|‰ tjf‡ fdd„	}|S )Nc                    s   t  | ˆ ¡S r&   r`  rò  ©r^  r"   r#   r   Ò  s    znp_asfarray.<locals>.impl)rI   r   ÚTyper	   rS   r@  Úinexactr²   )r'   ry   r   r"   rø  r#   Únp_asfarrayÈ  s    rû  c                 C   s   dd„ }|S )Nc                    s†   t  | ¡ ¡ ‰t  |¡‰ ˆ jdkr*tdƒ‚t  ˆˆ jd … ¡rVˆjˆ jkrVd}t|ƒ‚tˆ jˆjƒ}‡ ‡fdd„t|ƒD ƒ}t  |¡S )Nr   z"Cannot extract from an empty arrayz+condition shape inconsistent with arr shapec                    s   g | ]}ˆ| rˆ j | ‘qS r"   r•  )r©  r¡   ©r'   r*  r"   r#   r«  ê  s      z7np_extract.<locals>.np_extract_impl.<locals>.<listcomp>)	rS   r  rÇ  rœ   rk   r%  rÊ   r,   rH  )r&  rV   rŒ   Úmax_lenr    r"   rü  r#   Únp_extract_implÚ  s    

 z#np_extract.<locals>.np_extract_implr"   )r&  rV   rþ  r"   r"   r#   Ú
np_extract×  s    rÿ  c                 C   sN  ddd„}t | tjtjfƒs$tdƒ‚t |tjtjfƒs>tdƒ‚t |ttjtjfƒsZtdƒ‚t | d tjƒsrtdƒ‚t |d tjƒsŠtdƒ‚t | d tjƒr´t | d j	tjƒs´td	ƒ‚t | d tjƒrðt | d tjƒrèt | d d tjƒsðtd
ƒ‚t | d tjƒ�r | d j
|d j
k�r tdƒ‚t | d tjƒ�rJ| d j
dk �rJtdƒ‚|S )Nr   c                 S   sp   t | ƒt |ƒkrtdƒ‚|t |d j|d j¡ }tt | ƒd ddƒD ]"}| | }|| }t |||¡}qH|S )Nz7list of cases must be same length as list of conditionsr   r%   rù   )r?   rk   rS   rH  rm   ry   r,   r   )ÚcondlistÚ
choicelistÚdefaultr    r(   r*  Úchoicer"   r"   r#   Únp_select_arr_implô  s    z%np_select.<locals>.np_select_arr_implz"condlist must be a List or a Tuplez$choicelist must be a List or a Tuplez,default must be a scalar (number or boolean)z items of condlist must be arraysz"items of choicelist must be arraysz%condlist arrays must contain booleansz*condlist tuples must only contain booleanszHcondlist and choicelist elements must have the same number of dimensionsr%   z/condlist arrays must be of at least dimension 1)r   )rI   r   ÚListr@   r   rÑ  r#  r"  r—   ry   rj   )r   r  r  r  r"   r"   r#   Ú	np_selectñ  s4    
ÿÿ"r  c                 C   sT   t | ƒrt |ƒstdƒ‚d| jjks0d|jjkrH| jj|jjkrHtdƒ‚dd„ }|S )Nz.The arguments to np.union1d must be array-likeÚunichrz/For Unicode arrays, arrays must have same dtypec                 S   s4   t  t  | ¡¡}t  t  |¡¡}t  t  ||f¡¡S r&   )rS   rû   r  r  rN  )Úarr1rF  r'   r  r"   r"   r#   Ú
union_impl,  s    znp_union1d.<locals>.union_impl)r
   r   ry   r°  )r  rF  r	  r"   r"   r#   Ú
np_union1d$  s    ÿr
  c                    sn   d}t | tjtjtjfƒs"t|ƒ‚t|ƒr2| j‰ n*zt|ƒ‰ W n t	k
rZ   tdƒ‚Y nX d‡ fdd„	}|S )Nz7The argument to np.asarray_chkfinite must be array-likez!dtype must be a valid Numpy dtypec                    s4   t j| ˆ d�} t  | ¡D ]}t  |¡stdƒ‚q| S )Nrg  z#array must not contain infs or NaNs)rS   r  rT   rÌ  rk   )r'   ry   r(   rÊ  r"   r#   r   C  s
    

z"np_asarray_chkfinite.<locals>.impl)N)
rI   r   r—   r  rL   r   r   ry   r	   r   )r'   ry   rŒ   r   r"   rÊ  r#   Únp_asarray_chkfinite4  s    r  c                 C   s@   t  d|  | d¡}t  t  |d¡d|| d   d|| d   ¡S )Nr  ri   r   r%   )rS   r   r   Ú
less_equal©r  rÄ  r"   r"   r#   Únp_bartlett_implU  s    r  c                 C   sR   t  d|  | d¡}ddt  t j| | d  ¡  dt  dt j | | d  ¡  S )Nr  ri   gáz®GáÚ?rÀ   r%   g{®Gáz´?rc  ©rS   r   Úcosr  r  r"   r"   r#   Únp_blackman_impl[  s    ÿr  c                 C   s2   t  d|  | d¡}ddt  t j| | d  ¡  S )Nr%   ri   gHáz®Gá?gq=
×£pÝ?r  r  r"   r"   r#   Únp_hamming_implb  s    r  c                 C   s2   t  d|  | d¡}ddt  t j| | d  ¡  S )Nr%   ri   rÀ   r  r  r"   r"   r#   Únp_hanning_implh  s    r  c                    s   ‡ fdd„}|S )Nc                    s$   t | tjƒstdƒ‚‡ fdd„}|S )NúM must be an integerc                    s8   | dk rt jdt jd�S | dkr0t jdt jd�S ˆ | ƒS )Nr%   r"   rg  )rS   rH  Úfloat_rH  )r  rt  r"   r#   Úwindow_impls  s
    z>window_generator.<locals>.window_overload.<locals>.window_impl)rI   r   r…  r   )r  r  rt  r"   r#   Úwindow_overloado  s    z)window_generator.<locals>.window_overloadr"   )ru  r  r"   rt  r#   Úwindow_generatorn  s    r  gïÐ4!·\T¼g‰¥}—b3ƒ<g´»rë„±¼gº^ö“ØæÞ<gëû—Â"P
½g'&&KF›5=gðîbLa½g$Ó›á/þ‰=g¼j”z•ü²½g<tÌ¾˜Ú=gV•®þÔ¾g4ËT¤Ù&>g«0ŒöêK¾g5dM�v;p>g�"�cì‘¾g¬ôŒ—$¿²>g'd¥Ëo†Ò¾gY(š¾X?ñ>gZÄY&+¿g«|tµ(?gRëýâB¿gŠuÜZ?gI¨ ^¶q¿gÝãÝóa™…?gð¶!ñžN˜¿g-£¨ÎŠ>©?gê-4pK¸¿gÀˆ¬w¬÷Å?g�ÍWÀëÓ¿g*¢5�N¨å?g‹ÊT·­`¼g0‘fÚFV¼g!„Ù¾‰<gÍA`Ýóƒ<gäÒ«`´¼g8ÞÙç®¸¼gûê£}îß<g×æ”�‘*ñ<gšbe~þƒ½g2»hÏ™]'½gEÅ_ÿV=gsÀƒkŒ[=gìŒ&úGCi=gf�C�½gò{~5×­½g%t9QÁ½gO è«þ$ª=guoôÀÌù >g‡["©d,->gmÕÖ€’VX>gnaÍÙ€‹>g†ÅÁ+AÈ>gRž™x£?gI�å¢Œ™k?gË	¨¬b¾é?c                 C   sH   |d }d}t dt|ƒƒD ] }|}|}| | | ||  }qd||  S )Nr   r+  r%   rÀ   rÇ  )r4  ÚvalsÚb0Úb1r(   Úb2r"   r"   r#   Ú_chbevlÃ  s    r  c                 C   s\   | dk r|  } | dkr6d|  d }t  | ¡t|tƒ S t  | ¡td|  d tƒ t  | ¡ S )Nr   g       @rÀ   rc  g      @@)rS   Úexpr  Ú_i0AÚ_i0BrÈ  rá  r"   r"   r#   Ú_i0Ð  s    r!  c                 C   sb   t j| t jd�}tt  |¡ƒ}tt|ƒƒD ]2}t|t  d| | | | d  ¡ ƒ| ||< q*|S )Nrg  r%   rc  )rS   rø  r  r!  r,   r?   rÈ  )rÄ  ÚalphaÚbetar_  Útr(   r"   r"   r#   Ú_i0nÛ  s
    0r%  c                 C   s:   t | tjƒstdƒ‚t |tjtjfƒs.tdƒ‚dd„ }|S )Nr  z beta must be an integer or floatc                 S   sT   | dk rt jdt jd�S | dkr0t jdt jd�S t  d| ¡}| d d }t|||ƒS )Nr%   r"   rg  r   rc  )rS   rH  r  rH  r   r%  )r  r#  rÄ  r"  r"   r"   r#   Únp_kaiser_implí  s    z!np_kaiser.<locals>.np_kaiser_impl)rI   r   r…  r   rÙ   )r  r#  r&  r"   r"   r#   Ú	np_kaiserå  s    r'  c                 C   sˆ   dd„ }|| ƒ\}}}||ƒ\}}}	t  ||	¡t  ||¡ }
t  ||¡t  ||	¡ }t  ||¡t  ||¡ }|
|d< ||d< ||d< d S )Nc                 S   sF   | d }| d }| j d dkr(| d }nt | j d¡|¡}|||fS )N©.r   ©.r%   rù   rh   ©.ri   r   )rm   rS   r.  ry   rp   )r4  Úx0r2  Úx2r"   r"   r#   Ú_cross_preprocessingþ  s    
z._cross_operation.<locals>._cross_preprocessingr(  r)  r*  )rS   r.  )r'   r  r    r-  Úa0Úa1rU  r  r  r  Úcp0Úcp1Úcp2r"   r"   r#   Ú_cross_operationû  s    	r3  c                 C   s   d S r&   r"   rU  r"   r"   r#   Ú_cross  s    r4  c                    sJ   t  t| jƒt|jƒ¡‰ | jdkr:|jdkr:‡ fdd„}n‡ fdd„}|S )Nr%   c                    s   t  dˆ ¡}t| ||ƒ |S )N©rh   )rS   r›   r3  )r'   r  Úcprg  r"   r#   r     s    z_cross_impl.<locals>.implc                    s6   t  | d |d ¡j}t  |d ˆ ¡}t| ||ƒ |S )Nr(  r5  )rS   r¨  rm   r›   r3  )r'   r  rm   r6  rg  r"   r#   r      s    )rS   rn  r	   ry   rj   ©r'   r  r   r"   rg  r#   Ú_cross_impl  s
    r8  c                 C   s$   t | ƒrt |ƒstdƒ‚dd„ }|S )NúInputs must be array-like.c                 S   sj   t  | ¡}t  |¡}|jd dks0|jd dkr8tdƒ‚|jd dksT|jd dkr^t||ƒS tdƒ‚d S )Nrù   )ri   rh   zDIncompatible dimensions for cross product
(dimension must be 2 or 3)rh   z†Dimensions for both inputs is 2.
Please replace your numpy.cross(a, b) call with a call to `cross2d(a, b)` from `numba.np.extensions`.)rS   r  rm   rk   r4  ©r'   r  rj  rk  r"   r"   r#   r   -  s    

ÿ
ÿznp_cross.<locals>.implrc  r7  r"   r"   r#   Únp_cross(  s    r;  c                 C   sB   dd„ }|| ƒ\}}||ƒ\}}t  ||¡t  ||¡ }t  |¡S )Nc                 S   s   | d }| d }||fS )Nr(  r)  r"   )r4  r+  r2  r"   r"   r#   r-  D  s    z0_cross2d_operation.<locals>._cross_preprocessing)rS   r.  r  )r'   r  r-  r.  r/  r  r  r6  r"   r"   r#   Ú_cross2d_operationA  s
    r<  c                 C   s   d S r&   r"   rU  r"   r"   r#   Úcross2dU  s    r=  c                 C   s$   t | ƒrt |ƒstdƒ‚dd„ }|S )Nr9  c                 S   sB   t  | ¡}t  |¡}|jd dks0|jd dkr8tdƒ‚t||ƒS )Nrù   ri   zRIncompatible dimensions for 2D cross product
(dimension must be 2 for both inputs))rS   r  rm   rk   r<  r:  r"   r"   r#   r   ^  s    

ÿzcross2d_impl.<locals>.implrc  r7  r"   r"   r#   Úcross2d_implY  s    
r>  )N)N)r	  r
  F)r	  r
  F)NN)N)N)r	  r
  F)F)Nr   )r   )r   )r   N)r   )r   )r   )r   N)r   )NN)Nr  )NF)NTFN)NT)F)r   N)F)N)r%   )Nr   )rx  )F)rÜ  N)N)r   )N(r  rß  rÏ  Úcollectionsr   Úenumr   rœ  r´  Úllvmlite.irrî  ÚnumpyrS   Ú
numba.corer   r   Únumba.core.extendingr   r   r   Únumba.np.numpy_supportr	   r
   r   r   r   r   Únumba.core.imputilsr   r   r   r   Znumba.np.arrayobjr   r   r   r   Únumba.np.linalgr   r   Únumba.core.errorsr   r   r   r   r   r   Únumba.cpython.unsafe.tupler   r$   rÌ  rD   rQ   r,  r—   rf   rg   rx   r.   Ú	DTypeSpecÚIntegerLiteralr‰   rŠ   r�   r’   r“   r˜   r™   rª   r«   r­   r®   r³   r´   r½   r¾   rÃ   rÆ   rÇ   rÉ   rÊ   rÛ   rÜ   rà   ræ   ré   rì   rí   rò   rõ   r÷   rø   rñ   r  r  r  r  r  r  r$  r%  r'  Úaverager2  r6  Ú	iscomplexr;  Úisrealr<  rC  rE  ÚisscalarrH  rP  rS  rT  rV  rW  rX  r^  rn  rr  rm  rq  r`  rl  Únanminrp  Únanmaxrs  r{  rz  r~  r}  Únanstdr€  Únansumr†  ÚnanprodrŠ  Ú
nancumprodr�  Ú	nancumsumr’  r•  r™  rš  r›  rž  r   r¢  r¦  r§  r®  r¯  r¼  r»  Z_partition_w_nanZ_argpartition_w_nanrÁ  rÀ  rû  r  rÂ  rÆ  ÚmedianrÉ  rØ  rÛ  rß  rã  rä  rç  rí  rÓ  rð  Únanpercentilerñ  Úquantileró  Únanquantilerô  Ú	nanmedianr÷  rÿ  r  r  Ú	partitionr  r¹  r  r  r  r  r  r$  Útrilr,  r6  r3  Útril_indices_fromr:  r<  Útriur?  rB  rA  Útriu_indices_fromrD  rF  rK  rO  Úediff1drZ  r[  r]  r_  rb  Útrapzrg  ri  rj  Úvanderrp  Úrollrt  rw  r}  r�  r‘  Úinterpr˜  r™  r   r¡  r¦  r§  rÃ  r>  r±  r²  rÂ  rµ  r¹  r¼  r½  rÆ  rÅ  ÚcorrcoefrÎ  ÚargwhererÒ  ÚflatnonzerorÓ  rÖ  r×  rØ  rÝ  rà  ré  r“  rã  Úfill_diagonalrê  rì  rö  rû  Úaroundrÿ  r   r  r  r	  r  r/  r%  r)  r+  r/  r5  r   r8  r>  r¶   r@  rÍ   rB  ÚcontainsrD  Úcount_nonzerorG  rR  rS  ÚdeleterT  rP  rZ  Úarray_equalr\  Úintersect1drd  rg  rh  rp  rw  Z_ltZ_ler  r€  r�  ÚdigitizerŒ  r,   r”  r�  r–  r³  r¨  Z_finfo_supportedrÞ  Z_iinfo_supportedrÚ  r¿  rÆ  rÔ  rÕ  rÚ  rÛ  rç  Ú	correlaterï  Úconvolverñ  r  r÷  Úasfarrayr²   rû  Úextractrÿ  Úselectr  Úunion1dr
  Úasarray_chkfiniter  r  r  r  r  r  ÚbartlettÚblackmanÚhammingÚhanningrH  r  r   r  r!  r%  Úkaiserr'  r3  r4  r8  Úcrossr;  r<  r=  r>  r"   r"   r"   r#   Ú<module>   sþ    	
(
K

A'(









/
/






,



B

$



	



"
ÿ
ÿ
ÿ
ÿ
)
















1þ



4












"




7


'DmX+'
:$


 

7

 8



5





.
&



92
.
 
T
?
,

6


2

 â!ç
	

