U
    hâËd„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"   úK/home/sam/Atlas/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ÚtupZ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"   r9   r#   Ú_create_tuple_result_shape-   s
    
rC   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   r7   Z	value_argrE   Z
slice_datar(   ©Z
axis_valuer:   r<   r"   r#   r=   }   s    


þz!_gen_index_tuple.<locals>.codegen)	Ú
isinstancer   ÚLiteralr   Úliteral_valuer>   rF   r.   ÚTuple)	r@   rA   ÚvalueÚaxisÚbeforeÚafterZ
types_listrB   r=   r"   rG   r#   Ú_gen_index_tupleV   s     	
rP   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©rV   ©Úlocals©Úreturn_typer/   Údictr   ©Úcontextr2   Úsigr4   rZ   Úresr"   rX   r#   Ú	array_sum¢   s    

ÿre   c                 C   s   | S r&   r"   )rU   rW   r"   r"   r#   Ú_array_sum_axis_nop²   s    rf   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ÚpoprC   rR   ÚfullÚtyper,   rP   )rU   rM   ri   Z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ÚoprY   r"   r#   Úinner¸   s<    

ÿ
z gen_sum_axis_impl.<locals>.innerr"   )rs   rr   rt   rY   ru   r"   rq   r#   Úgen_sum_axis_impl·   s    =rv   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   ri   Fz'axis' entry is out of boundsrh   ©r4   Tc                    s
   ˆ | |ƒS r&   r"   )rU   rM   rw   ©Úcompiledr"   r#   Úarray_sum_impl_axis  s    z1array_sum_axis_dtype.<locals>.array_sum_impl_axis)r_   ÚgetattrrR   Útakerf   r4   rH   r   rI   rJ   ri   rj   Útyping_contextÚresolve_value_typer-   Úreplacerv   r   r/   r   )rb   r2   rc   r4   ÚrettyrY   rt   Úty_arrayÚty_axisZty_dtypers   rr   Úaxis_valÚgen_implr{   rd   r"   ry   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&   rQ   )rU   rw   rV   rW   rX   r"   r#   rZ   (  s    z'array_sum_dtype.<locals>.array_sum_implr[   r\   r^   ra   r"   rX   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 )Nrw   r   ri   Fz'axis' entry (z) is out of boundsrx   Tc                    s
   ˆ | |ƒS r&   r"   ©rU   rM   ry   r"   r#   r{   X  s    z+array_sum_axis.<locals>.array_sum_impl_axis)r_   r|   rR   r}   rf   r4   rH   r   rI   rJ   ri   r   r~   r   r-   r€   rv   r   r/   r   )rb   r2   rc   r4   r�   rY   rt   r‚   rƒ   rs   rr   Úmsgr„   r…   r{   rd   r"   ry   r#   Úarray_sum_axis3  s2    

rŠ   c                 C   s,   | j tjkrt |¡ | ¡}n
|   |¡}|S r&   )ro   rR   Ztimedelta64Úint64Úview)rw   rL   Ú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&   rQ   ©r'   rV   rW   ©r�   r"   r#   Úarray_prod_implo  s    z#array_prod.<locals>.array_prod_impl)rH   r   ÚArrayr	   rw   rŽ   )r'   rw   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&   ©rR   ÚemptyÚsizeÚ	enumerateÚflat©r'   ÚoutrV   ÚidxrW   ©r�   rw   r"   r#   Úarray_cumsum_impl†  s    
z'array_cumsum.<locals>.array_cumsum_impl©
rH   r   r“   rw   Z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&   )rR   rS   rT   r˜   r�   r‘   r"   r#   Úarray_mean_impl¶  s    z#array_mean.<locals>.array_mean_impl)
rH   r   r“   rw   Zinteger_domainÚ	frozensetr¡   r	   Úfloat64rŽ   )r'   Z	is_numberrw   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©   rR   rS   rT   ÚrealÚconjr˜   )r'   ÚmÚssdrW   Úvalr"   r"   r#   Úarray_var_implÅ  s    z!array_var.<locals>.array_var_impl©rH   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'   Z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˜   rj   rR   rS   Únextr}   rT   )r'   ÚitÚ	min_valuerŒ   rW   ©Z
comparatorZpre_return_funcr"   r#   Úimpl_min  s    


znpy_min.<locals>.impl_min)rH   r   r“   rw   Ú
NPDatetimeÚNPTimedeltarR   Ú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'   Z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Œ   rW   rÌ   r"   r#   Úimpl_max9  s    


znpy_max.<locals>.impl_max)rH   r   r“   rw   rÎ   rÏ   rR   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˜   rj   rR   rS   rÉ   r}   rÐ   rT   )ÚarryrÊ   rË   Úmin_idxr�   rŒ   rW   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˜   rj   rš   rR   rÓ   ©rÜ   rW   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Ú   Zunreachabler%   )r˜   rj   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)rH   rw   r   rÎ   rÏ   rÞ   rÒ   rá   rã   r   Ú%build_argmax_or_argmin_with_axis_impl)rU   rM   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Œ   rW   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Ü   rW   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˜   rj   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.
    rM   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%   éÿÿÿÿ)ri   rj   r,   r   Ú	transposerl   Úravelr˜   ÚAssertionErrorrR   r—   Úreshape)	rU   rM   Ú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,   ri   )rU   rM   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)rH   rw   r   rÎ   rÏ   rì   rÒ   rî   rï   r   rè   )rU   rM   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    rQ   ©r'   rW   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©rR   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©rR   ÚasarrayrS   r	  rT   )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  )rR   r  Zbroadcast_arraysrS   r	  rT   )	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
   Ú	TypeErrorrH   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Ä   rQ   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&   )rR   r  r©   ©rU   rM   Ú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.)rR   r  rl   r  ri   ÚsumÚZeroDivisionErrorÚmultiply)rU   rM   r  Z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)rH   r   ZNoneType)rU   rM   r  r   r"   r"   r#   Ú
np_average–  s    
r&  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)rH   r   rÒ   rÑ   rR   rÓ   r   )rw   r)  r"   r"   r#   Ú	get_isnan»  s
    
r*  c                 C   s   t | ƒrdd„ S d S )Nc                 S   s   t  | ¡jdkS r¯   ©rR   r  rÆ   r'  r"   r"   r#   Ú<lambda>Ì  ó    znp_iscomplex.<locals>.<lambda>©r
   r'  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¯   r+  r'  r"   r"   r#   r,  Ô  r-  znp_isreal.<locals>.<lambda>r.  r'  r"   r"   r#   Ú	np_isrealÐ  s    r0  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"   r'  ©Ziscmplxr"   r#   r÷   â  s    ziscomplexobj.<locals>.implc                    s   ˆ S r&   r"   r'  r1  r"   r#   r÷   ç  s    )Údetermine_dtyperH   r   ÚOptionalro   rR   Ú
issubdtypeÚcomplexfloating)r(  Údtr÷   r"   r1  r#   ÚiscomplexobjØ  s    
r7  c                 C   s   dd„ }|S )Nc                 S   s   t  | ¡ S r&   )rR   r7  r'  r"   r"   r#   r÷   ñ  s    zisrealobj.<locals>.implr"   ©r(  r÷   r"   r"   r#   Ú	isrealobjì  s    r9  c                    s   t | ƒ‰ ‡ fdd„}|S )Nc                    s   ˆ S r&   r"   )Únum©rd   r"   r#   r÷   ú  s    znp_isscalar.<locals>.impl)r   )r:  r÷   r"   r;  r#   Únp_isscalarö  s    r<  c                    s*   t |ƒrd‡ fdd„	}nd‡ fdd„	}|S )Nc                    s   t  t  | ¡ˆ t  | ¡ƒ¡S r&   ©rR   Úlogical_andr  Zsignbit©r(  rœ   ©Úfnr"   r#   r÷     s    zis_np_inf_impl.<locals>.implc                    s   t  t  | ¡ˆ t  | ¡ƒ|¡S r&   r=  r?  r@  r"   r#   r÷     s    )N)N©r   )r(  rœ   rA  r÷   r"   r@  r#   Úis_np_inf_implÿ  s    rC  c                 C   s   t dd„ ƒ}t| ||ƒS )Nc                 S   s   | S r&   r"   r'  r"   r"   r#   r,    r-  zisneginf.<locals>.<lambda>©r   rC  ©r(  rœ   rA  r"   r"   r#   Úisneginf  s    rF  c                 C   s   t dd„ ƒ}t| ||ƒS )Nc                 S   s   |  S r&   r"   r'  r"   r"   r#   r,    r-  zisposinf.<locals>.<lambda>rD  rE  r"   r"   r#   Úisposinf  s    rG  c                 C   s   | |k S r&   r"   ©r'   r  r"   r"   r#   Ú	less_than  s    rI  c                 C   s   | |kS r&   r"   rH  r"   r"   r#   Úgreater_than  s    rJ  c                 C   s   | j dkrtdƒ‚d S )Nr   z3zero-size array to reduction operation not possible)r˜   rj   r»   r"   r"   r#   Úcheck_array"  s    
rK  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¯   )
rR   r  rK  rS   rÉ   r}   rT   rÓ   r°   rÆ   ©r'   rU   rÊ   Ú
return_valrŒ   rW   ©Ú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¯   )rR   r  rK  rS   rÉ   r}   rT   rÓ   rL  rN  r"   r#   r÷   ;  s    



r"   )rO  Úis_complex_dtyper÷   r"   rN  r#   Únan_min_max_factory(  s    rQ  )rP  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  )r(  Úyr  r  r  r"   r"   r#   Ú_isclose_itemX  s    rS  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ô   rR   Úzerosr>   r¡   r,   rS  rl   ©	r'   r  r  r  r  r(  rR  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 rT  rU  rW  r"   r"   r#   rX  s  s    
c                 S   s„   t  | j|j¡}t  | |¡}t  ||¡}t jt|ƒt jd�}tt  ||f¡ƒD ](\}	\}
}t	|
 
¡ | 
¡ |||ƒ||	< qNt  ||¡S ©N©rw   )rR   Úbroadcast_shapesrl   Úbroadcast_torV  r>   r¡   r™   rS   rS  rT   )r'   r  r  r  r  rl   Úa_Úb_rœ   r(   r  r  r"   r"   r#   rX  |  s    ÿ
c                 S   s   t | ||||ƒS r&   )rS  r  r"   r"   r#   rX  ˆ  s    )r   r  F)r   r  F)r   r  F)r   r  F)r
   r   rH   r   r“   r  )r'   r  r  r  r  rX  r"   r"   r#   Úisclosed  s    
r_  c                 C   s"   t | ƒ}t |tj¡rtS tS d S r&   )r2  rR   r4  r5  Úcomplex_nanminÚreal_nanmin©r'   r6  r"   r"   r#   Ú	np_nanminŽ  s    rc  c                 C   s"   t | ƒ}t |tj¡rtS tS d S r&   )r2  rR   r4  r5  Úcomplex_nanmaxÚreal_nanmaxrb  r"   r"   r#   Ú	np_nanmax—  s    rf  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%   )rR   rS   rT   Údivide)r'   rV   ÚcountrŒ   rW   ©rÓ   r"   r#   Únanmean_impl¦  s    
z np_nanmean.<locals>.nanmean_impl©rH   r   r“   r*  rw   )r'   rk  r"   rj  r#   Ú
np_nanmean   s
    
rm  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 rg  )rR   ÚnanmeanrS   rT   r°   r±   rh  )r'   r²   r³   ri  rŒ   rW   r´   rj  r"   r#   Únanvar_implº  s    

znp_nanvar.<locals>.nanvar_implrl  )r'   ro  r"   rj  r#   Ú	np_nanvar´  s
    
rp  c                 C   s   t | tjƒsd S dd„ }|S )Nc                 S   s   t  | ¡d S r¹   )rR   Únanvarr»   r"   r"   r#   Únanstd_implÒ  s    znp_nanstd.<locals>.nanstd_implr¶   )r'   rr  r"   r"   r#   Ú	np_nanstdÍ  s    rs  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&   rQ   ©r'   rV   rŒ   rW   ©rÓ   rY   r"   r#   Únansum_implã  s    
znp_nansum.<locals>.nansum_impl©rH   r   r“   rw   ÚIntegerr.   r*  )r'   r�   rv  r"   ru  r#   Ú	np_nansumØ  s    
ry  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&   rQ   rt  ©rÓ   Úoner"   r#   Únanprod_implù  s    
z np_nanprod.<locals>.nanprod_implrw  )r'   r�   r|  r"   rz  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&   )rR   r¦   r»   r"   r"   r#   r,    r-  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©rH   r   r“   rw   r  rx  r*  )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&   )rR   r•   r»   r"   r"   r#   r,  $  r-  znp_nancumsum.<locals>.<lambda>r   c                    sD   t  | jˆ¡}ˆ}t| jƒD ]"\}}ˆ |ƒ r6||7 }|||< q|S r&   r–   r›   ©r  r�   rY   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>   rj   ©r'   rU   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´   ©rt   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    )rH   r   rÑ   )rt   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)rR   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Ä   )rR   rÓ   r—  r”  r˜  r"   r#   r÷   v  s    

c                    s   dˆ fS rÁ   r"   r”  r˜  r"   r#   r÷   |  s    )rH   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 )Nrw   ú+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'   rU   Za_flatZa_minÚa_maxr(   r´   Ztake_branchÚretvalr"   r"   r#   Únp_ptp_implŠ  s    
znp_ptp.<locals>.np_ptp_impl)ÚhasattrrH   rw   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    )rR   rÓ   rH  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ÚmidZ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%   rh   N)r³  r±  )Ú	temp_arryÚnr¤  r¥  Z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¯   )Úflattenrl   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   rZ  éd   rh   ç      Y@)r®  r¤  r¥  )r>   rR   rn   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_finiteZ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>   rR   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)ri   r˜   r,   rR   rÓ   r  )rÂ  Úq_upper_boundZ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Í  rj   ©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 rY  )
rR   r  r¬   r·  rÓ   rÊ  rÇ  rn   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)r2  rR   r4  r5  r   rH   r   r  r  r“   ri   )r'   rÂ  rÉ  rÔ  rÓ  r6  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%   )rR   r—   r˜   rw   rS   rT   r—  r¶  )r'   r´  rµ  rŒ   rW   rj  r"   r#   Únanmedian_implä  s    
z$np_nanmedian.<locals>.nanmedian_implrl  )r'   rä  r"   rj  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%   )rR   Ú
empty_likeÚndindexrl   Ú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 )NrZ  rð   r   r%   )	rR   ræ  r.   rç  rl   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†  ÚastyperR   r‹   ri   rj   r  r  rl   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)rw   ú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©
rH   r   r“   ÚSequencerK   r  ri   r|   r  rx  )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÷  rw   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   rZ  r%   )rÕ   rR   r—   r¬   r,   rÃ   )ÚNÚMr®  rl   rœ   r(   Z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%   rZ  )ri   ró   r>   rR   r—   rw   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®  rZ  ©rR   Útrirl   rñ  ÚuintÚwhereÚ
zeros_likerw   ©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  ©
rR   r  rl   rñ  r  rç  ræ  r  rw   r  ©r²   r®  r  r�   ÚzZzero_optÚselr"   r"   r#   Únp_tril_impl_multi¶  s    $
z#my_tril.<locals>.np_tril_impl_multir%   rh   )r   )r   )r   ri   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®  ©rR   Ú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²   r  r"   r"   r#   Únp_tril_indicesÇ  s    



r   c                 C   s*   t |dƒ | jdkrtdƒ‚ddd„}|S )Nr®  rh   úinput array must be 2-dr   c                 S   s   t j| jd || jd d�S ©Nr   r%   )r®  r²   )rR   Útril_indicesrl   ©rU   r®  r"   r"   r#   Únp_tril_indices_from_implÞ  s    z7np_tril_indices_from.<locals>.np_tril_indices_from_impl)r   ©r   ri   r   )rU   r®  r%  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	  rZ  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%   rh   )r   )r   )r   ri   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  r  r"   r"   r#   Únp_triu_indices_impl  s    z-np_triu_indices.<locals>.np_triu_indices_impl)r   Nr  )rµ  r®  r²   r-  r"   r"   r#   Únp_triu_indices  s    



r.  c                 C   s*   t |dƒ | jdkrtdƒ‚ddd„}|S )Nr®  rh   r!  r   c                 S   s   t j| jd || jd d�S r"  )rR   Útriu_indicesrl   r$  r"   r"   r#   Únp_triu_indices_from_impl  s    z7np_triu_indices_from.<locals>.np_triu_indices_from_impl)r   r&  )rU   r®  r0  r"   r"   r#   Únp_triu_indices_from  s
    


r1  c                 C   s   d S r&   r"   ©rU   r"   r"   r#   Ú_prepare_array  s    r3  c                 C   s"   | d t jfkrdd„ S dd„ S d S )Nc                 S   s
   t  d¡S )Nr"   ©rR   Úarrayr2  r"   r"   r#   r,  &  r-  z%_prepare_array_impl.<locals>.<lambda>c                 S   s   t | ƒ ¡ S r&   )r†  rò   r2  r"   r"   r#   r,  (  r-  ©r   Únoner2  r"   r"   r#   Ú_prepare_array_impl#  s    r8  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   rw   ztype has no dtype attr)rH   r   r  r  r	   r|   rR   r¬   r  rü  rw   )ZinobjÚobjÚlr6  r"   r"   r#   Ú_dtype_of_compound+  s    r<  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%   rZ  )r3  rw   r>   rR   r—   Údiff)
ÚaryÚto_endÚto_beginÚstartr§  ÚendÚ	out_dtyperœ   Z	start_idxZmid_idxr"   r"   r#   Únp_ediff1d_implV  s$    ÿz#np_ediff1d.<locals>.np_ediff1d_impl)NN)
rH   r   r“   rw   r  r   r<  r   rR   Zcan_cast)r>  r?  r@  Zary_dtZto_begin_dtZ	to_end_dtr‰   rD  r"   r"   r#   Ú
np_ediff1d<  s$    
rE  c                 C   s   d S r&   r"   r2  r"   r"   r#   Ú_select_elementt  s    rF  c                 C   s0   t | dd ƒdk}|r dd„ }|S dd„ }|S d S )Nri   r   c                 S   s$   t jd| jd�}| |d d …< |d S )N)r%   rZ  r   )rR   r5  rw   )rU   r(  r"   r"   r#   r÷   |  s    z"_select_element_impl.<locals>.implc                 S   s   | S r&   r"   r2  r"   r"   r#   r÷   ‚  s    ©r|   )rU   Zzerodr÷   r"   r"   r#   Ú_select_element_implx  s    rH  c                 C   s   d S r&   r"   )Údxr(  r"   r"   r#   Ú_get_d‡  s    rJ  c                 C   s   t | ƒrdd„ }ndd„ }|S )Nc                 S   s
   t  |¡S r&   ©rR   r  ©r(  rI  r"   r"   r#   r÷   Ž  s    zget_d_impl.<locals>.implc                 S   s   t  t  | ¡¡S r&   )rR   r=  r  rL  r"   r"   r#   r÷   ‘  s    rB  )r(  rI  r÷   r"   r"   r#   Ú
get_d_impl‹  s    
rM  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ð   ç       @)rR   r  rJ  rD   r"  rF  )rR  r(  rI  ZyarrÚdZy_aveÚretÚ	processedr"   r"   r#   r÷   ¡  s    

(znp_trapz.<locals>.impl)Nr  )rH   r   r  r  r   r“   ri   )rR  r(  rI  r÷   r"   r"   r#   Únp_trapz–  s    

rR  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ð   )rl   r>   ró   r,   rR   r$  )r(  r  Ú
increasingrœ   r²   rµ  r(   r"   r"   r#   Ú
_np_vander¬  s    

,rT  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)ri   rj   )r(  r  r"   r"   r#   Ú_check_vander_paramsÈ  s    
rU  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 rY  )r>   rU  rR   r—   rÁ  rT  )r(  r  rS  rœ   rZ  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 rY  )r>   rR   r5  rU  r—   rÁ  rw   rT  )r(  r  rS  Úx_arrrœ   r"   r"   r#   Únp_vander_seq_implâ  s    

z%np_vander.<locals>.np_vander_seq_impl)NF)NF)r   r7  rH   rx  r   r“   r	   rw   rR   Úpromote_typesrÁ  rK   rü  )r(  r  rS  rV  rX  Úx_dtr"   rZ  r#   Ú	np_vanderÐ  s    

r[  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 rY  )rR   r  r—   rl   rw   rš   r,   r˜   )r'   ÚshiftrU   rœ   Zarr_flatr(   r�   r"   r"   r#   Únp_roll_implý  s    
znp_roll.<locals>.np_roll_implc                 S   s
   t  | ¡S r&   rK  )r'   r\  r"   r"   r#   r,  
	  r-  znp_roll.<locals>.<lambda>)rH   r   rx  r  r   r  )r'   r\  r]  r"   r"   r#   Únp_rollø  s    r^  é   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ð   é   rg   rh   )ÚLIKELY_IN_CACHE_SIZE)ÚkeyrU   ÚlengthÚguessZiminZimaxr(   Zimidr"   r"   r#   Úbinary_search_with_guess	  sL    
ÿ

ÿ

re  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%   ©Z
fill_valuerw   rZ  r–  r!  rð   )rR   r  r>   rj   r˜   rn   rl   r—   r,   rš   r°   rÆ   rÓ   re  )r(  ÚxpÚfprw   ÚdzrI  Ú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ˆ    










	$&
$&
rw  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 )NrZ  r   rf  rg  r%   rh  rð   )rR   r  r¬   r>   rj   r˜   rn   rl   r—   r,   rš   rÓ   re  )r(  ri  rj  rw   rk  rI  rl  rm  rn  ro  rp  rq  rr  rs  r(   rt  r¨  ru  rv  r"   r"   r#   Únp_interp_impl_innerÈ	  sf    




2




(&(rx  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 )
Nri   r%   zxp must be 1Dzfp must be 1Dz:Cannot cast array data from complex dtype to float64 dtypec                    s   ˆ| ||ˆ ƒS r&   r"   ©r(  ri  rj  ©rw   ru   r"   r#   Únp_interp_impl<
  s    z!np_interp.<locals>.np_interp_implc                    s   ˆ| ||ˆ ƒj d S r¯   ©rš   ry  rz  r"   r#   Únp_interp_scalar_impl?
  s    z(np_interp.<locals>.np_interp_scalar_impl)rŸ  ri   r   r2  rR   r4  r5  Úresult_typer¬   rw  rx  rH   r   r  rÑ   )r(  ri  rj  Zcomplex_dtype_msgZxp_dtZfp_dtr{  r}  r"   rz  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 )Nrh   r%   rZ  r   )ri   ró   rl   rR   r—   rw   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!  )rl   rÕ   r€  rR   Údotr±   ÚTr¾  )ÚXÚbiasÚddofZfactrV   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&   )rR   Ú
atleast_2dr†  r‚  )r²   rR  Úrowvarrw   Ú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 dimensionsrZ  )rR   rˆ  r†  rl   r‚  rj   r—   )r²   rR  r‰  rw   rŠ  Úy_arrZm_rowsZm_colsZy_rowsZy_colsrœ   r"   r"   r#   r‡  ‚
  s    

r6  )r²   rR  r‰  rw   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 )Nrh   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].)ri   rl   râ   )r²   r‰   r"   r"   r#   Ú_handle_m_dim_changeŸ
  s    r�  c                 C   s   | S r&   r"   r'  r"   r"   r#   r,  ¨
  r-  r,  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 )Nri  c                    s   g | ]}ˆ   |¡‘qS r"   )Úadd)Ú.0rW   ©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     )rR   r¬   rH   r   r“   r	   rw   r  r  r?   rK   ÚsetrŸ  rŽ  r>   rY  rm   )Ú
array_likeZarray_like_dtr´   r"   r�  r#   r2  «
  s     

r2  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 )Nrh   z{0} has more than 2 dimensionsr   )rH   r   r“   ri   r  Úformatrü  rb  )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)rR   r¼  rj   rÁ  )r…  r"   r"   r#   Ú_handle_ddofÊ
  s    
r˜  c                 C   s   | S r&   r"   r'  r"   r"   r#   r,  Ò
  r-  c                 C   s   || ƒ ||ƒ t | |||ƒS r&   )r‡  )r²   rR  r‰  rw   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&   )rH   r   r  r  ©r�  r(  r"   r"   r#   Ú	<genexpr>ä
  s   ÿz)scalar_result_expected.<locals>.<genexpr>r   TF)r   r7  rH   r“   ri   Z	BaseTuplerü   r>   r  r  rü  rb  )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¢  )rR   r  ÚfabsÚsignr'  r"   r"   r#   Ú
_clip_corr÷
  s    r¡  c                 C   s    t | jƒ}t | jƒ}|d|  S )Nr–  )r¡  r°   rÆ   )r(  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²   rR  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   rh  )	r›  rñ  rR   r  r5  rl   rn   r—  r†  )r²   rR  r‰  r„  r…  rƒ  ©r™  rš  rw   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ñ  rR   r  r5  rl   r—  r†  rš   )r²   rR  r‰  r„  r…  rƒ  Zvariancer£  r"   r#   Únp_cov_impl_single_variable,  s    ÿÿz+np_cov.<locals>.np_cov_impl_single_variable)NTFN)NTFN)r—  r   r7  Ú_handle_ddof_noprH   rx  r  rÒ   r˜  r   Ú_handle_m_dim_nopr“   r�  r2  rR   r~  r¬   rž  )	r²   rR  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¯   )rR   ÚcovZdiagÚsqrtr°   r,   rl   )r(  rR  r‰  rV   rO  Ústddevr(   ©Zclip_fnr"   r#   Únp_corrcoef_implJ  s    
z%np_corrcoef.<locals>.np_corrcoef_implc                 S   s   t  | ||¡}|| S r&   )rR   rª  )r(  rR  r‰  rV   r"   r"   r#   Ú np_corrcoef_impl_single_variableU  s    z5np_corrcoef.<locals>.np_corrcoef_impl_single_variable)NT)NT)r2  rR   r~  r¬   Zcomplex_r¢  r¡  rž  )r(  rR  r‰  rZ  r¨  rw   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%   rZ  )	rR   r  rl   rV  r   r.   rñ   Z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 rY  )ÚboolrR   rV  r   r.   r»   ©ZfalseishZtrueishr"   r#   r÷   s  s    )rH   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¯   )rR   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>rZ  )r±  r,   rR   r5  r   r.   )r'   r8   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 )Nrh   r   r%   z/All dimensions of input must be of equal lengthrð   )ri   rl   rÃ   rR   r5  rü   r=  rj   r¦   r"  r�   )r'   Úwrapr²   rµ  ÚsteprB  rl   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µ  rB  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µ  rB  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)rR   Úiinforw   rÃ   rÕ   r  r¼  rj   )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º  )rR   Úfinforw   rÃ   rÕ   r¼  r  rj   )r'   r´   r¿  r¼  r½  Zfinite_valsr"   r"   r#   Ú_check_val_floatÃ  s    rÀ  c                 C   s   | S r&   r"   ©r(  rR  r"   r"   r#   r,  Ð  r-  c                 C   s   d S r&   r"   r'  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"   r'  r"   r"   r#   r,  Ú  r-  z_asarray_impl.<locals>.<lambda>c                 S   s
   t  | ¡S r&   r4  r'  r"   r"   r#   r,  Ü  r-  c                    s   t j| gˆ d�S rY  r4  r'  ©r’  r"   r#   r,  ß  r-  )rH   r   r“   rü  rK   r  r  r	   r'  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µ  Ú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)ri   rH   rw   r   rx  r¾  rÒ   rÀ  Ú
_check_nopr  rK   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ÚllvmliteZirÚFunctionTyper   Zget_or_insert_functionrÍ  Úcallr   r_   )rb   r2   rc   r4   r´   rÌ  ZlltyrÎ  ZfntyrA  rd   r"   r"   r#   r=     s    

ÿz _np_round_float.<locals>.codegenr"   )Z	typingctxr´   rc   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Ò  )r(  ÚndigitsZpow1Zpow2rR  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¯   )rR   ÚroundrÖ  r"   r"   r#   r÷   Z  s    c                 S   s   t  | ¡}t  | ||¡S r&   )rR   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)rl   rj   rR   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   rH   r   r“   r   rÒ   rx  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’¡œÇ;)rR   ÚpiÚsinr'  r"   r"   r#   r÷   q  s    
zimpl_np_sinc.<locals>.implc                 S   s0   t  | ¡}t  | ¡D ]\}}t  |¡||< q|S r&   )rR   r  rò  Úsinc)r(  rœ   rô  r´   r"   r"   r#   r÷   x  s    
z,Argument "x" must be a Number or array-like.)rH   r   r  r“   r   r8  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&   )rR   Zarctan2rÆ   r°   )r  Údeg)Údeg_multr"   r#   r÷   ˆ  s    zov_np_angle.<locals>.implc                    s6   t j| ˆ d�}t  | ¡D ]\}}t  ||¡||< q|S rY  )rR   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)ÚfloatrR   rÛ  rH   r   r  r“   rw   rÑ   Zunderlying_floatrÒ   r   )r  rà  r÷   rw   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   Z	_getvalue)r�  r(   ©r2   rb   Ú	out_shapeÚoutarytyr"   r#   r‘  À  s   ÿz!array_nonzero.<locals>.<listcomp>c                    s   g | ]}t ˆƒˆˆ |ƒ‘qS r"   )r   ©r�  rœ   )r2   rb   rè  r"   r#   r‘  Â  s     c                 S   s   g | ]
}|j ‘qS r"   )r8   ré  r"   r"   r#   r‘  Ã  s     r"   ÚC)r4   r_   rw   ri  r   r   Zunpack_tuplerl   Ústridesr8   Úlayoutr-   r   r.   Zalloca_once_valueZ	loop_nestro   Zget_item_pointer2r   Zis_trueZif_thenÚstorerŽ  Úloadr,   r   Z
make_tupler   )rb   r2   rc   r4   Zarytyr�   Znoutsr>  rl   rë  r8   rì  rY   r{  ri  ÚindicesZptrr´   ZnzZ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&   )rR   r  rñ  )Ú	conditionr(  rR  Úx_Úy_rZ  r"   r#   r÷   Þ  s    z)_where_zero_size_array_impl.<locals>.implr"   )rw   r÷   r"   rZ  r#   Ú_where_zero_size_array_implÝ  s    rõ  c                 C   s0   t  | ¡D ] \}}|r|| n|| ||< q
|S r&   )rR   rò  )Úcondr(  rR  rd   r�   rV   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ö  r(  rR  rd   ÚcfZ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 )Nrû  rð   rZ  )	rR   r  r[  rl   r\  r—   r‚  rú  r÷  )rò  r(  rR  Zcond1Úx1Úy1rl   Zcond_ró  rô  rd   ©rw   rì  Zuse_faster_implr"   r#   r÷   ú  s    "z!_where_generic_impl.<locals>.implr"   )rw   rì  r÷   r"   rþ  r#   Ú_where_generic_impl÷  s    rÿ  c                 C   s    t | ƒsd}t|ƒ‚dd„ }|S )Nú+The argument "condition" must be array-likec                 S   s   t  | ¡ ¡ S r&   )rR   r  r  )rò  r"   r"   r#   Úwhere_cond_none_none  s    z)ov_np_where.<locals>.where_cond_none_none)r
   r   )rò  r‰   r  r"   r"   r#   Úov_np_where  s
    r  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 )Nr   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¯   )rH   r   r  r“   ri   ©Ú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&   )rR   r  r  )rò  r(  rR  r"   r"   r#   r÷   J  s    zov_np_where_x_y.<locals>.impl)r
   r   r   Úzipr•  rH   r   r“   r2  rR   rY  rü   rõ  rì  rÿ  )rò  r(  rR  r‰   r  r–  Zcond_arrrW  r‹  rZ  r¨  rw   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'   r  r"   r"   r#   Únp_imagW  s    r  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Ä   )rR   rS   )rU   rb  r(  r"   r"   r#   Únp_contains_implg  s    z%np_contains.<locals>.np_contains_implr¶   )rU   rb  r  r"   r"   r#   Únp_containsb  s    r  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¯   )rR   rò   r"  ©rU   rM   Úarr2r"   r"   r#   r÷   v  s    
znp_count_nonzero.<locals>.implc                 S   s   |   tj¡}tj||d�S )N)rM   )rñ  rR   r¡   r"  r  r"   r"   r#   r÷   {  s    )N)N)r
   r   r   )rU   rM   r÷   r"   r"   r#   Únp_count_nonzerop  s    

r  c                 C   s   | S r&   r"   r'  r"   r"   r#   r,  �  r-  c                 C   s
   t  | ¡S r&   rK  r'  r"   r"   r#   r,  ‚  r-  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 )NrZ  F)rR   rò   r  r˜   Úonesr¡   )rU   r:  r  Z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%   )rR   rò   r  r˜   Ú
IndexErrorÚconcatenate)rU   r:  r  Úposr"   r"   r#   Únp_delete_scalar_impl£  s    z(np_delete.<locals>.np_delete_scalar_impl)
rH   r   r“   rü  r   Z	SliceTypeÚnp_delete_handler_isslicerw   rx  Únp_delete_handler_isarray)rU   r:  r  r  r"   r  r#   Ú	np_delete…  s    r  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è  rj   rl   rÕ   rR   r—   rw   r˜   rô   r,   )r'   rµ  r˜   rç  rœ   Úa2Zout2ZworkÚmajorr(   Zniterr"   r"   r#   Ú	diff_impl¹  s(    

"znp_diff_impl.<locals>.diff_impl)r%   )rH   r   r“   ri   )r'   rµ  r  r"   r"   r#   Únp_diff_impl´  s    
r   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"   rH  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Á   )rR   r  rl   rü   rH  r"   r"   r#   r÷   ç  s
    

)r
   r   r   r  r  rH   )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ð   )rR   r  ró  r  Úsort)Úar1Úar2Zauxr  Zint1dr"   r"   r#   Únp_intersects1d_implù  s    



z0jit_np_intersect1d.<locals>.np_intersects1d_impl©r
   r   )r$  r%  r&  r"   r"   r#   Újit_np_intersect1dñ  s    r(  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)rH   r   r“   ri   r  r•  rü  )Ú	func_nameÚseqr"   r"   r#   Úvalidate_1d_array_like  s    
ÿÿr+  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>   rj   ©r'   r  r-  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"   r.  r"   r"   r#   r/  .  s    c                 S   s   | |  d7  < d S r¢  r"   r0  r"   r"   r#   r1  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)rj   r>   r,   rÕ   rR   rV  )r'   r  r-  rµ  rœ  r(   Z
out_lengthrœ   ©r1  rC  r/  r"   r#   Úbincount_impl6  s    z"np_bincount.<locals>.bincount_impl)Nr   )r+  rH   rw   r   rx  r   r7  rR   r¬   r   r.   )r'   r  r-  r3  r"   r2  r#   Únp_bincount  s$    





r4  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%   )rR   rÓ   r,   )r'   rW   Úv_lastÚloÚhirµ  r(   r§  ©Úfuncr"   r#   Úsearchsorted_innerM  s    


z)_searchsorted.<locals>.searchsorted_innerr"   )r9  r:  r"   r8  r#   Ú_searchsortedL  s    .r;  c                 C   s   | |kS r&   r"   rÁ  r"   r"   r#   r,    r-  Ú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 )NrJ   r<  Úrightz Invalid value given for 'side': c           
         sn   t | ƒ}d}|}t |jtj¡}|jd }t ||f¡D ]0\}}	ˆ | | ¡ ||||ƒ}| ¡ }|	 |¡ q8|S r¯   )	r>   rR   r—   rl   r.   rš   rS   rT   Úitemset)
r'   rW   Úsiderµ  r6  r7  rœ   r5  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>   rR   r—   r.   r,   )	r'   rW   r?  rµ  r6  r7  rœ   r5  r(   rA  r"   r#   rB  ž  s    
c                    s   t | ƒ}ˆ | ||d||ƒS r¯   )r>   )r'   rW   r?  rµ  rA  r"   r#   rB  ¬  s    )r<  )r<  )r<  )r|   Ú_searchsorted_leftÚ_searchsorted_rightr   rH   r   r“   rü  )r'   rW   r?  Zside_valrB  r"   rA  r#   Úsearchsorted„  s    rE  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,   rj   )Ú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>   rR   rÓ   r,   ©r(  rF  r=  rµ  r6  r7  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ã  rJ  rK  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&   )rR   r—   rl   r.   rS   rT   r>  )r(  rF  r=  rG  rœ   rŒ   r@  rô  ©rI  rL  rM  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&   )rR   r—   r>   r.   r,   )r(  rF  r=  rG  rœ   r(   rN  r"   r#   rO  '  s    )F)F)r   rH   r   r“   rü  )r(  rF  r=  rO  r"   rN  r#   Únp_digitize³  s    

%
$
rP  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&   )rR   rS   rT   Ú	histogram)r'   rF  r,   Úbin_minÚbin_maxrŒ   rW   ©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%   )
rj   rR   rV  r.   rS   rT   r¿  rÀ  rÁ  Zlinspace)r'   rF  r,   rR  rS  ÚhistZ	bin_ratiorŒ   rW   r  Z
bins_arrayr"   r"   r#   rU  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>   Ú_rangerj   rR   rV  r.   rS   rT   )r'   rF  r,   Znbinsr(   rR  rS  rV  rŒ   rW   r6  r7  r§  r"   r"   r#   rU  f  s*    

)rË  N)rË  N)rË  N)rH   rÁ  r   rx  r7  rä  )r'   rF  r,   rU  r"   rT  r#   Únp_histogram7  s    
!rX  )ZibetarÊ   ÚmachepÚepsÚnegepÚepsnegÚiexpÚminexpZxminÚmaxexpZxmaxZirndZngrdÚepsilonÚtinyZhugeÚ	precisionÚ
resolutionÚMachAr)rZ  r\  r]  rY  rÕ   r_  rÃ   r^  r[  ZnexpZnmantrb  rc  ra  Úbitsr¿  )rÃ   rÕ   re  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"   rG  rœ  ©rÄ  r"   r#   r‘  ´  s     z7_gen_np_machar.<locals>.MachAr_impl.<locals>.<listcomp>r   c                      s   t ˆ Ž S r&   )rd  r"   )Ú_mach_ar_datar"   r#   r÷   ½  s    z1_gen_np_machar.<locals>.MachAr_impl.<locals>.impl)	rø   Ú_mach_ar_supportedÚwarningsÚwarn_explicitri  r4   r   ÚfilenameÚlineno)Zwmsgr÷   ©Z	np122plusZ	np_MachArÚw)rl  rÄ  r#   ÚMachAr_impl±  s    ýz#_gen_np_machar.<locals>.MachAr_impl)r   rn  Úcatch_warningsÚfilterwarningsÚDeprecationWarningrR   rd  r   )r‰   rt  r"   rr  r#   Ú_gen_np_machar£  s    þrx  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 )Nrw   c                    s   g | ]}t ˆ |ƒ‘qS r"   rG  rœ  rk  r"   r#   r‘  Ï  s     z6generate_xinfo.<locals>.xinfo_impl.<locals>.<listcomp>c                    s   ˆ ˆŽ S r&   r"   r  )Ú	containerr8   r"   r#   r÷   Ñ  s    z0generate_xinfo.<locals>.xinfo_impl.<locals>.impl)r|   r	   rj   rø   )r  ZnbtyZnp_dtyper÷   ©Úattrry  Únp_func)r8   rÄ  r#   Ú
xinfo_implÆ  s    z"generate_xinfo.<locals>.xinfo_impl)r   )r|  ry  r{  r}  r"   rz  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&   )rR   r�  rñ  rH  ©r6  r"   r#   Ú	_dot_wrapò  s    z"_get_inner_prod.<locals>._dot_wrap)r   Ú
_HAVE_BLASr   Zreal_domainÚcomplex_domainr	   rR   rY  )ZdtaZdtbr�  Z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 )rH   r   r“   ri   r   )r'   r)  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%   rh   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•  rj   r>   rR   rV  r,   )rŠ  r‹  rŒ  r�  Zn1Zn2rc  rµ  Zn_leftZn_rightrP  r�   Úincr(   ©ÚModer6  Z	innerprodr"   r#   r÷     sD    	

(
 z%_np_correlate_core_impl.<locals>.impl)r	   rw   rR   rY  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&   )rR   r±   r'  r"   r"   r#   Úop_conjQ  s    z_np_correlate.<locals>.op_conjc                 S   s   | S r&   r"   r'  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>   rj   rŽ  r”  ©r'   rW   ZlaÚlv©r˜  Za_opZb_opr"   r#   r÷   j  s    z_np_correlate.<locals>.impl)r‰  r   r�  rw   r   r…  )r'   rW   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>   rj   rŽ  r•  r�  ©r˜  r"   r#   r÷   €  s    znp_convolve.<locals>.impl)r‰  r�  )r'   rW   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'   rw   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&   r4  r£  r"   r"   r#   r÷   ¦  s    c                 S   s   t  | |¡S r&   r4  r£  r"   r"   r#   r÷   ©  s    c                    s   t  | ˆ ¡S r&   r4  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 rY  )r>   rR   r—   r™   )r'   rw   r;  rP  r(   rW   )Útarget_dtyper"   r#   r÷   ¹  s
    
c                    s   ˆ   ¡ S r&   )rè  r£  r2  r"   r#   r÷   Â  s    )N)N)N)N)N)N)N)r
   rH   r   r“   r   rw   rü  rK   r  r  r	   Ú
containersZListTyper   ZStringLiteralrR   r  rJ   )r'   rw   r÷   Zdt_convr"   )rU   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&   rK  r£  ©rI  r"   r#   r÷   Ò  s    znp_asfarray.<locals>.impl)rH   r   ÚTyper	   rR   r4  Zinexactr¬   )r'   rw   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>)	rR   r  r·  r˜   rj   r  rÃ   r,   r5  )rò  rU   r‰   Úmax_lenrœ   r"   rª  r#   Únp_extract_implÚ  s    

 z#np_extract.<locals>.np_extract_implr"   )rò  rU   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>   rj   rR   r  rl   rw   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   )rH   r   ÚListr?   r   rÁ  r  r  r“   rw   ri   )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&   )rR   rò   r  ró  r  )Úarr1r  r'   r  r"   r"   r#   Ú
union_impl,  s    znp_union1d.<locals>.union_impl)r
   r   rw   r–  )r¶  r  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 )NrZ  z#array must not contain infs or NaNs)rR   r  rS   r¼  rj   )r'   rw   r(   r‚  r"   r#   r÷   C  s
    

z"np_asarray_chkfinite.<locals>.impl)N)
rH   r   r“   rü  rK   r   r   rw   r	   r   )r'   rw   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  rh   r   r%   )rR   rî  r  Z
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  rh   gáz®GáÚ?rº   r%   g{®Gáz´?rN  ©rR   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%   rh   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%   rh   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"   rZ  )rR   r5  Úfloat_r  )r  r8  r"   r#   Úwindow_impls  s
    z>window_generator.<locals>.window_overload.<locals>.window_impl)rH   r   rx  r   )r  rÃ  r8  r"   r#   Úwindow_overloado  s    z)window_generator.<locals>.window_overloadr"   )r9  rÄ  r"   r8  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  )r(  Ú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º   rN  g      @@)rR   Ú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 )NrZ  r%   rN  )rR   ræ  rÂ  rÎ  r,   r>   r«  )rµ  ÚalphaÚbetarR  Ú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"   rZ  r   rN  )rR   r5  rÂ  r  rî  rÒ  )r  rÐ  rµ  rÏ  r"   r"   r#   Únp_kaiser_implí  s    z!np_kaiser.<locals>.np_kaiser_impl)rH   r   rx  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ð   rg   ©.rh   r   )rl   rR   r$  rw   ro   )r(  Úx0rü  Zx2r"   r"   r#   Ú_cross_preprocessingþ  s    
z._cross_operation.<locals>._cross_preprocessingrÕ  rÖ  r×  )rR   r$  )r'   r  rœ   rÙ  Úa0Úa1r  rÇ  rÈ  rÉ  Zcp0Zcp1Zcp2r"   r"   r#   Ú_cross_operationû  s    	rÜ  c                 C   s   d S r&   r"   rH  r"   r"   r#   Ú_cross  s    rÝ  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©rg   )rR   r—   rÜ  )r'   r  ÚcprZ  r"   r#   r÷     s    z_cross_impl.<locals>.implc                    s6   t  | d |d ¡j}t  |d ˆ ¡}t| ||ƒ |S )NrÕ  rÞ  )rR   rŽ  rl   r—   rÜ  )r'   r  rl   rß  rZ  r"   r#   r÷      s    )rR   rY  r	   rw   ri   ©r'   r  r÷   r"   rZ  r#   Ú_cross_impl  s
    rá  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ð   )rh   rg   zDIncompatible dimensions for cross product
(dimension must be 2 or 3)rg   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`.)rR   r  rl   rj   rÝ  ©r'   r  r]  r^  r"   r"   r#   r÷   -  s    

ÿ
ÿznp_cross.<locals>.implr'  rà  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"   )r(  rØ  rü  r"   r"   r#   rÙ  D  s    z0_cross2d_operation.<locals>._cross_preprocessing)rR   r$  r  )r'   r  rÙ  rÚ  rÛ  rÇ  rÈ  rß  r"   r"   r#   Ú_cross2d_operationA  s
    rå  c                 C   s   d S r&   r"   rH  r"   r"   r#   Úcross2dU  s    ræ  c                 C   s$   t | ƒrt |ƒstdƒ‚dd„ }|S )Nrâ  c                 S   sB   t  | ¡}t  |¡}|jd dks0|jd dkr8tdƒ‚t||ƒS )Nrð   rh   zRIncompatible dimensions for 2D cross product
(dimension must be 2 for both inputs))rR   r  rl   rj   rå  rã  r"   r"   r#   r÷   ^  s    

ÿzcross2d_impl.<locals>.implr'  rà  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   )r<  )F)rË  N)N)r   )N(r  r“  r¿  Úcollectionsr   Úenumr   r�  rn  Zllvmlite.irrÏ  ÚnumpyrR   Z
numba.corer   r   Znumba.core.extendingr   r   r   Znumba.np.numpy_supportr	   r
   r   r   r   r   Znumba.core.imputilsr   r   r   r   Znumba.np.arrayobjr   r   r   r   Znumba.np.linalgr   r   Znumba.core.errorsr   r   r   r   r   r   Znumba.cpython.unsafe.tupler   r$   r„  rC   rP   r"  r“   re   rf   rv   r.   Z	DTypeSpecZ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  Zaverager&  r*  Z	iscomplexr/  Zisrealr0  r7  r9  Zisscalarr<  rC  rF  rG  rI  rJ  rK  rQ  ra  re  r`  rd  rS  r_  Znanminrc  Znanmaxrf  rn  rm  rq  rp  Znanstdrs  Znansumry  Znanprodr}  Z
nancumprodr‚  Z	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¶  Zmedianr¹  rÇ  rÊ  rÍ  rÑ  rÒ  rÕ  rÛ  rÃ  rÞ  Znanpercentilerß  Zquantilerá  Znanquantilerâ  Z	nanmedianrå  rí  rð  rõ  Ú	partitionrþ  rª  r   r  r  r  r  r  Ztrilr  r#  r   Ztril_indices_fromr'  r)  Ztriur,  r/  r.  Ztriu_indices_fromr1  r3  r8  r<  Zediff1drE  rF  rH  rJ  rM  ZtrapzrR  rT  rU  Zvanderr[  Zrollr^  ra  re  rw  rx  Zinterpr  r€  r†  r‡  rŒ  r�  r§  r2  r—  r˜  r¦  r›  rž  r¡  r¢  rª  r©  Zcorrcoefr°  Zargwherer³  Zflatnonzeror´  r·  r¸  r¹  r¾  rÀ  rÊ  r†  rÃ  Zfill_diagonalrË  rÍ  rÒ  rÕ  ZaroundrÙ  rÚ  rÝ  rÞ  râ  rå  r  rñ  rõ  r÷  rú  rÿ  r  r  r  r°   r
  rÆ   r  Úcontainsr  Zcount_nonzeror  r  r  Údeleter  r=  r   Zarray_equalr"  Zintersect1dr(  r+  r,  r4  r;  Z_ltZ_lerC  rD  rE  ZdigitizerP  r,   rW  rQ  rX  rm  rd  Z_finfo_supportedr¿  Z_iinfo_supportedr»  rx  r~  rˆ  r‰  rŽ  r�  r™  Z	correlater   Zconvolver¢  r  r¦  Zasfarrayr¬   r©  Úextractr­  Úselectr´  Zunion1dr¸  Zasarray_chkfiniter¹  r»  r¾  r¿  rÀ  rÅ  ZbartlettZblackmanZhammingZhanningr5  rÌ  rÍ  rÊ  rÎ  rÒ  ZkaiserrÔ  rÜ  rÝ  rá  Ú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

 â!ç
	

