U
    ¿|eµ  ã                	   @   s
  d Z ddlZddlZddlZddlmZ ddlmZ ddlZ	ddl
mZmZ ddlmZmZmZmZmZ ddlmZmZmZmZmZ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$m%Z%m&Z&m'Z'm(Z(m)Z) dd
l*m+Z+ ddl,m-Z- ddl.m/Z/m0Z0m1Z1m2Z2m3Z3 ddl4m5Z5m6Z6 ddl7m8Z8 ddl9m:Z:m;Z; ddl.m<Z< ddl=m>Z?m@ZAmBZBmCZCmDZD dd„ ZEdd„ ZFdd„ ZGdd„ ZHdd„ ZIdd„ ZJdd„ ZKd d!„ ZLd"d#„ ZM�d4d$d%„ZNd&d'„ ZOd(d)„ ZPe0ePƒd*d+„ ƒZQed,ejRƒd-d.„ ƒZSd/d0„ ZTed1ejUƒe%e)jVƒd2d3„ ƒƒZW�d5d4d5„ZXd6d7„ ZYd8d9„ ZZeej[ejRej\ƒeej[ejRej]ƒd:d;„ ƒƒZ^eej[ejRej_ƒd<d=„ ƒZ`eejaejRejbejbƒd>d?„ ƒZceedejRƒd@dA„ ƒZeedBejfƒdCdD„ ƒZgedEejfejbƒdFdG„ ƒZhG dHdI„ dIeiƒZjG dJdK„ dKejƒZkG dLdM„ dMejƒZlG dNdO„ dOejƒZmG dPdQ„ dQejƒZnG dRdS„ dSejƒZoG dTdU„ dUeiƒZpdVdW„ Zqeej[ejRejfƒdXdY„ ƒZrdZd[„ Zsd\d]„ Ztd^d_„ Zud`da„ Zvdbdc„ Zwddde„ Zxdfdg„ Zydhdi„ Zze2djdk„ ƒZ{e2dldm„ ƒZ|e/dndo„ ƒZ}dpdq„ Z~e0e	jƒdrds„ ƒZ€e/dtdu„ ƒZ�e0e	j‚ƒdvdw„ ƒZƒe0e	j„ƒdxdy„ ƒZ…dzd{„ Z†d|d}„ Z‡ed~ejfƒdd€„ ƒZˆd�d‚„ Z‰ed~ejfej_ƒdƒd„„ ƒZŠed~ejfe ‹ejb¡ƒd…d†„ ƒZŒe0e	j�ƒ�d6d‡dˆ„ƒZŽe ejfd‰ƒdŠd‹„ ƒZ�e0e	j�ƒ�d7d�dŽ„ƒZ‘e0e	j’ƒ�d8d�d‘„ƒZ“d’d“„ Z”d”d•„ Z•ed–ejfej_ƒd—d˜„ ƒZ–ed–ejfe ‹ejb¡ƒd™dš„ ƒZ—e0e	j˜ƒd›dœ„ ƒZ™e0e	jšƒ�d9d�dž„ƒZ›edŸejfƒd d¡„ ƒZœee	j�ejfƒd¢d£„ ƒZžed¤ejfƒd¥d¦„ ƒZŸe/d§d¨„ ƒZ e/d©dª„ ƒZ¡e0e	j¢ƒ�d:d«d¬„ƒZ£e1ejfd­ƒ�d;d®d¯„ƒZ¤d°d±„ Z¥e0e	j¦ƒd²d³„ ƒZ§e0e	j¨ƒd´dµ„ ƒZ©e0e	jªƒd¶d·„ ƒZ«e/d¸d¹„ ƒZ¬e 1ejfdº¡d»d¼„ ƒZ­e2d½d¾„ ƒZ®d¿dÀ„ Z¯e0e¯dÁdÂ�dÃdÄ„ ƒZ°edÅejfej±ƒdÆdÇ„ ƒZ²e ejfdÈƒdÉdÊ„ ƒZ³e ejfdËƒe ej´dËƒdÌdÍ„ ƒƒZµe ejfdÎƒe ej´dÎƒdÏdÐ„ ƒƒZ¶e ejfdÑƒe ej´dÑƒdÒdÓ„ ƒƒZ·e ejfdÔƒdÕdÖ„ ƒZ¸e ejfd×ƒe ej´d×ƒdØdÙ„ ƒƒZ¹e ejfdÚƒe ej´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 ej´dæƒdçdè„ ƒZ¾e ejfdéƒdêdë„ ƒZ¿e ejÀdìƒdídî„ ƒZÁe#ejÀejÂƒe#ejÀejÃƒdïdð„ ƒƒZÄdñdò„ ZÅe ejfdóƒdôdõ„ ƒZÆe ejÇdÝƒe ejÇdàƒdöd÷„ ƒƒZÈe ejÇdãƒdødù„ ƒZÉe ejfdúƒdûdü„ ƒZÊe ejfdýƒdþdÿ„ ƒZË�d �d„ ZÌe1ejf�dƒe1ejf�dƒ�d�d„ ƒƒZÍ�d�d„ ZÎe ejÏ�dƒeÎƒ e ejÏ�d	ƒeÎƒ e�d
ejÐejbƒ�d�d„ ƒZÑe!ejfƒ�d�d„ ƒZÒe�d
ejfej-ƒ�d�d„ ƒZÓe!ejÔƒ�d�d„ ƒZÕe"ejÔƒ�d�d„ ƒZÖe�d
ejÔej-ƒ�d�d„ ƒZ×e�d
ejÔejØƒ�d�d„ ƒZÙe�dejÔej-ejbƒ�d�d„ ƒZÚe�dejÔejØejbƒ�d�d„ ƒZÛe$ejfƒ�d�d„ ƒZÜe$ejÔƒ�d �d!„ ƒZÝe$ejÞƒ�d"�d#„ ƒZßeejàejfejfƒ�d$�d%„ ƒZáe3ejf�d&ƒ�d'�d(„ ƒZâ�d)�d*„ Zã�d+�d,„ Zä�d<�d-�d.„Zå�d=�d/�d0„Zæ�d1�d2„ Zç�d3�d4„ Zè�d5�d6„ Zée ejf�d7ƒ�d8�d9„ ƒZêed1ejëƒe%e)jVƒ�d:�d;„ ƒƒZìeej[ejëej\ƒ�d<�d=„ ƒZíeejaejëej\ejbƒ�d>�d?„ ƒZîeedejëƒ�d@�dA„ ƒZïee	jðejfƒ�dB�dC„ ƒZñed1ejòƒe%e)jVƒ�dD�dE„ ƒƒZóeee ‹ej\¡ƒee	jôe ‹ej\¡ƒ�dF�dG„ ƒƒZõeeej_ƒee	jôej_ƒ�dH�dI„ ƒƒZöed1ej÷ƒe%e)jVƒ�dJ�dK„ ƒƒZøee	jùejbƒ�dL�dM„ ƒZúed1ejûƒe%e)jVƒ�dN�dO„ ƒƒZü�dP�dQ„ Zýe<ejf�dRƒ�dS�dT„ ƒZþ�dU�dV„ Zÿe2�dW�dX„ ƒ�Z �dY�dZ„ �Z�d[�d\„ �Z�d]�d^„ �Z�d_�d`„ �Ze2�da�db„ ƒ�Ze0e	�jƒ�ef�dc�dd„ƒ�Ze2�de�df„ ƒ�Z	e0e	�j
ƒ�d>�dg�dh„ƒ�Ze2�di�dj„ ƒ�Ze1ejf�dkƒ�dl�dm„ ƒ�Ze0e	�jƒ�ef�dn�do„ƒ�Ze0e	�jƒ�d?�dp�dq„ƒ�Ze0e	�jƒ�d@�dr�ds„ƒ�Ze0e	�jƒ�dA�dt�du„ƒ�Ze0e	�jƒ�dB�dv�dw„ƒ�Ze0e	�jƒ�dC�dx�dy„ƒ�Ze0e	�jƒ�dD�dz�d{„ƒ�Z�d|�d}„ �Ze 0�e¡�d~�d„ ƒ�Ze 0e	�j¡dd�ef�d€�d�„ƒ�Ze0e	�j ƒ�dE�d‚�dƒ„ƒ�Z!e0e	�j"ƒe1ejf�d„ƒ�d…�d†„ ƒƒ�Z#�d‡�dˆ„ �Z$e0e	�j%ƒ�dF�d‰�dŠ„ƒ�Z&e0e	�j'ƒ�dG�d‹�dŒ„ƒ�Z(�d��dŽ„ �Z)e2�d��d�„ ƒ�Z*e�d‘ejfƒ�d’�d“„ ƒ�Z+e0e	�j,ƒ�d”�d•„ ƒ�Z-�d–�d—„ �Z.e2�d˜�d™„ ƒ�Z/e0e	�j0ƒ�dš�d›„ ƒ�Z1e0e	�j2ƒ�dœ�d�„ ƒ�Z3e�džejfej±ƒe�džejfej-ƒ�dŸ�d „ ƒƒ�Z4e2�d¡�d¢„ ƒ�Z5e0e	�j6ƒ�ef�d£�d¤„ƒ�Z7e0eƒ�dH�d¥�d¦„ƒ�Z8e0eƒ�dI�d§�d¨„ƒ�Z9�d©�dª„ �Z:�d«�d¬„ �Z;�d­�d®„ �Z<�d¯�d°„ �Z=�d±�d²„ �Z>�d³�d´„ �Z?�dµ�d¶„ �Z@�d·�d¸„ �ZAe2�d¹�dº„ ƒ�ZBe0e	�jCƒ�dJ�d»�d¼„ƒ�ZD�d½�d¾„ �ZE�d¿�dÀ„ �ZF�dÁ�dÂ„ �ZG�dÃ�dÄ„ �ZHe2�dÅ�dÆ„ ƒ�ZIe0e	�jHƒ�dÇ�dÈ„ ƒ�ZJ�dÉ�dÊ„ �ZK�dË�dÌ„ �ZLe0e	�jMƒ�dÍ�dÎ„ ƒ�ZNe0e	�jOƒ�dÏ�dÐ„ ƒ�ZPe0e	�jQƒ�dÑ�dÒ„ ƒ�ZR�dÓ�dÔ„ �ZS�dÕ�dÖ„ �ZT�d×�dØ„ �ZU�dÙ�dÚ„ �ZVe2�dÛ�dÜ„ ƒ�ZWe0e	�jXƒ�dK�dÝ�dÞ„ƒ�ZY�dß�dà„ �ZZe2�dá�dâ„ ƒ�Z[e0e	�j\ƒ�dã�dä„ ƒ�Z]�då�dæ„ �Z^e2�dç�dè„ ƒ�Z_e0e	�j`ƒ�dL�dé�dê„ƒ�Za�dë�dì„ �Zbe2�dí�dî„ ƒ�Zce0e	�jdƒ�dï�dð„ ƒ�Zee2�dñ�dò„ ƒ�Zfe0e	�jgƒ�dó�dô„ ƒ�Zhe2�dõ�dö„ ƒ�Zie0e	�jjƒ�d÷�dø„ ƒ�Zke 1ejf�dù¡�dú�dû„ ƒ�Zle 1ejf�dü¡�dý�dþ„ ƒ�Zme0e	�jnƒ�dÿ�d „ ƒ�Zoe0e	�jpƒ�d�d„ ƒ�Zqe2�d�d„ ƒ�Zre0e	�jsƒ�d�d„ ƒ�Zte0e	�juƒ�dM�d�d„ƒ�Zve0e	�jwƒ�dN�d	�d
„ƒ�Zxi �Zy�d�d„ �Zz�dO�d�d„�Z{e�dejfƒ�d�d„ ƒ�Z|e0e	�j}ƒ�d�d„ ƒ�Z~e�dejfej-ƒee	�jejfej-ƒ�d�d„ ƒƒ�Z€e#ejfejfƒ�d�d„ ƒ�Z�e#ejfe�j‚ƒe#ejfe�jƒƒe#ejfej\ƒe#ejfe�j„ƒe#ejfe�j…ƒe#ejfe�j†ƒe#ejfe�j‡ƒ�d�d„ ƒƒƒƒƒƒƒ�Zˆe#ejfe�j‚ƒ�d�d„ ƒ�Z‰�d�d„ �ZŠe� ‹�eŠ¡�d �d!„ ƒ�ZŒe�eŠejfej_ej_ƒ�d"�d#„ ƒ�Z�e 0e	�jŽ�j��j�¡�dP�d$�d%„ƒ�Z�e 0e	�jŽ�j��j‘¡�dQ�d&�d'„ƒ�Z‘e0�e’ƒ�d(�d)„ ƒ�Z“e0e	�j”ƒ�d*�d+„ ƒ�Z•e/�d,�d-„ ƒ�Z–e0e	�j—ƒ�d.�d/„ ƒ�Z˜e0e	�j™ƒ�dR�d2�d3„ƒ�ZšdS (S  z[
Implementation of operations on Array objects and objects supporting
the buffer protocol.
é    N)Úir)ÚConstant)ÚpndindexÚliteral_unroll)ÚtypesÚtypingÚerrorsÚcgutilsÚ	extending)Úas_dtypeÚcarrayÚfarrayÚis_contiguousÚ
is_fortranÚcheck_is_integerÚtype_is_scalar)Útype_can_asarrayÚis_nonelikeÚnumpy_version)Úlower_builtinÚlower_getattrÚlower_getattr_genericÚlower_setattr_genericÚ
lower_castÚlower_constantÚiternext_implÚimpl_ret_borrowedÚimpl_ret_new_refÚimpl_ret_untrackedÚRefType)Ú	signature)ÚStringLiteral)Úregister_jitableÚoverloadÚoverload_methodÚ	intrinsicÚoverload_attribute)Ú	quicksortÚ	mergesort)Úslicing)Útuple_setitemÚbuild_full_slice_tuple)Úoverload_classmethod)Úparse_dtypeÚparse_shapeÚ_parse_nested_sequenceÚ_sequence_of_arraysÚ_choose_concatenation_layoutc                 C   s4   t |j|ƒt |j|ƒg}| j |¡}| d|¡ dS )zz
    Set the "range" metadata on a load instruction.
    Note the interval is in the form [lower_bound, upper_bound).
    ÚrangeN)r   ÚtypeÚmoduleÚadd_metadataÚset_metadata)ÚbuilderÚloadÚlower_boundÚupper_boundZrange_operandsÚmd© r<   úN/var/www/website-v5/atlas_env/lib/python3.8/site-packages/numba/np/arrayobj.pyÚset_range_metadata+   s
    

ÿr>   c                 C   s&   d|j jd > d }t| |d|ƒ dS )zF
    Mark the result of a load instruction as positive (or zero).
    é   r   N)r3   Úwidthr>   )r7   r8   r:   r<   r<   r=   Úmark_positive6   s    rA   c                    s6   ˆj ‰t ˆ¡‰ˆj‰G ‡ ‡‡‡‡fdd„dˆƒ‰ ˆ S )zë
    Return the Structure representation of the given *array_type*
    (an instance of types.ArrayCompatible).

    Note this does not call __array_wrap__ in case a new array structure
    is being created (rather than populated).
    c                       s4   e Zd Z‡‡ ‡‡fdd„Ze‡‡fdd„ƒZ‡  ZS )zmake_array.<locals>.ArrayStructc                    sŽ   t ˆˆƒ}z| j d|¡}W n$ tk
r@   tˆ | ƒ |¡ Y S X | jjˆ }|  |¡}|d krttj	| j
|dd�}n|}|| j
|fƒ}||fS )NÚ	__array__T)Úzfill)r    Ú_contextÚget_functionÚNotImplementedErrorÚsuperÚ
_make_refsÚdata_model_managerÚ_get_be_typer	   Úalloca_onceÚ_builder)ÚselfÚrefÚsigZ
array_implÚ	datamodelÚbe_typeÚ	outer_ref)ÚArrayStructÚ	__class__Ú
array_typeÚreal_array_typer<   r=   rH   L   s    


ÿz*make_array.<locals>.ArrayStruct._make_refsc                    sp   | j }ˆdkrˆ  | d¡S |  d¡}g }tˆƒD ]2}t ||d|¡}| |¡}| |¡ t||ƒ q0t 	||¡S )z\
            Override .shape to inform LLVM that its elements are all positive.
            r   Úshape)
rL   Ú__getattr__Ú_get_ptr_by_namer2   r	   Úgep_inboundsr8   ÚappendrA   Ú
pack_array)rM   r7   ÚptrÚdimsÚiZdimptrr8   )ÚbaseÚndimr<   r=   rW   `   s    


z%make_array.<locals>.ArrayStruct.shape)Ú__name__Ú
__module__Ú__qualname__rH   ÚpropertyrW   Ú__classcell__r<   ©rS   rU   r`   ra   rV   )rT   r=   rS   J   s   rS   )Úas_arrayr	   Úcreate_struct_proxyra   )rU   r<   rg   r=   Ú
make_array>   s
    
-rj   c                 C   s   |   |j¡}|  |¡S )zB
    Return the item size for the given array or buffer type.
    )Úget_data_typeÚdtypeÚget_abi_sizeof)ÚcontextrU   Úlltyr<   r<   r=   Úget_itemsizez   s    rp   c                 C   s"   |j r
dnd}| j||j||d�S )z3
    Load the item at the given array pointer.
    Nr?   ©Úalign)ÚalignedÚunpack_valuerl   )rn   r7   Úarraytyr]   rr   r<   r<   r=   Ú	load_item‚   s    ÿrv   c                 C   s$   |j r
dnd}| j||j|||d�S )z4
    Store the item at the given array pointer.
    Nr?   rq   )rs   Ú
pack_valuerl   )rn   r7   ru   Úvalr]   rr   r<   r<   r=   Ú
store_item‹   s    ry   c                 C   s>   |j r(|  |||tj¡}t |||¡}n|  |||tj¡}|S )zM
    Fix the integer index' type and value for the given dimension size.
    )ÚsignedÚcastr   Úintpr)   Z	fix_indexÚuintp)rn   r7   ÚidxtyÚidxÚsizeÚindr<   r<   r=   Úfix_integer_index“   s
    r‚   c                 C   s^   t |tjƒrR|jdkrRt |jtjƒs(t‚t|ƒ| ||ƒ}t| |||j	ƒ}|j|fS ||fS dS )zS
    Normalize the index type and value.  0-d arrays are converted to scalars.
    r   N)
Ú
isinstancer   ÚArrayra   rl   ÚIntegerÚAssertionErrorrj   rv   Údata)rn   r7   r~   r   ÚidxaryZidxvalr<   r<   r=   Únormalize_indexŸ   s    
r‰   c                    s2   t |ƒr*t‡ ‡fdd„t||ƒD ƒŽ \}}||fS )z^
    Same as normalize_index(), but operating on sequences of
    index types and values.
    c                    s   g | ]\}}t ˆˆ ||ƒ‘qS r<   )r‰   )Ú.0r~   r   ©r7   rn   r<   r=   Ú
<listcomp>²   s   þÿz%normalize_indices.<locals>.<listcomp>)ÚlenÚzip)rn   r7   Úindex_typesÚindicesr<   r‹   r=   Únormalize_indices¬   s
    þr‘   c                 C   sÌ  | j }| j}| j}	t tjdd¡}
|j|
 }t|jƒ}t|	jƒ}||@ |kr†|| }d| j	› dt
|ƒdkrndnd› d|› d�}t|ƒ‚|d	kr¤t| |	 d
¡¡d	ƒ}| tj¡}t|ttfƒrÌt |||¡}t|ttfƒrèt |||¡}t|tƒrú||ƒ}t|||||d�}|d	k�r2t| |	 d¡¡d	ƒ|d< n||d< | tjd¡}t |||jj¡}|D ]}|j||dgd�}�q^||d< t| ¡ ƒ}||k�r¨td || ¡ƒ‚| ¡ D ]\}}t| ||ƒ �q°| S )z¤
    Helper function for populating array structures.
    This avoids forgetting to set fields.

    *shape* and *strides* can be Python tuples or LLVM arrays.
    r?   ÚCzThe datamodel for type z is missing fieldÚsÚ ú Ú.NÚmeminfo)rW   Ústridesr‡   Úitemsizer—   ÚparentÚnsw©ÚflagsÚnitemszmissing {0}) rD   rL   Ú
_datamodelr   r„   Úfloat64rI   ÚsetÚ_fieldsÚ_fe_typer�   Ú
ValueErrorr   Úget_value_typeÚget_typer|   rƒ   ÚtupleÚlistr	   r\   ÚintÚdictÚget_constantÚunpack_tupler3   ÚcountÚmulÚkeysÚformatÚitemsÚsetattr)Úarrayr‡   rW   r˜   r™   r—   rš   rn   r7   rP   Zstandard_arrayZstandard_array_type_datamodelZrequired_fieldsZdatamodel_fieldsÚmissingÚmsgÚintp_tÚattrsrž   Úunpacked_shapeÚaxlenZ
got_fieldsÚkÚvr<   r<   r=   Úpopulate_array¹   s`    


*ÿÿ
ü
ÿÿ

r¼   c                 C   sh   |j }|j}| tjd¡}t ||j| j¡}|D ]}|j	||dgd�}q0||_
| tjt|| ƒ¡|_dS )z‡
    Update some auxiliary information in *array* after some of its fields
    were changed.  `itemsize` and `nitems` are updated.
    r?   r›   rœ   N)rD   rL   r«   r   r|   r	   r¬   rW   ra   r®   rž   rp   r™   )Úarytyr³   rn   r7   rž   r¸   r¹   r<   r<   r=   Úupdate_array_infoþ   s    ÿr¾   c                 C   s
   t ƒ ‚dS )z/Constrain axis values to valid positive values.N©rF   ©Ú	func_nameÚarg_namera   Úaxisr<   r<   r=   Únormalize_axis  s    rÄ   c                    sL   t | tƒst d¡‚t |tƒs(t d¡‚| j› d|j› d�‰ ‡ fdd„}|S )Nz func_name must be a str literal.zarg_name must be a str literal.z: Argument z* out of bounds for dimensions of the arrayc                    s,   |dk r||7 }|dk s ||kr(t ˆ ƒ‚|S ©Nr   ©r¤   rÀ   ©rµ   r<   r=   Úimpl"  s
    z&normalize_axis_overloads.<locals>.impl)rƒ   r!   r   ÚTypingErrorÚliteral_value)rÁ   rÂ   ra   rÃ   rÈ   r<   rÇ   r=   Únormalize_axis_overloads  s    



ÿrË   Úgetiterc                 C   st   |j \}|\}|  ||j¡}|  tjd¡}t ||¡}||_||_	| j
rX| j |||¡ | ¡ }	t| ||j|	ƒ}
|
S rÅ   )ÚargsÚmake_helperÚreturn_typer«   r   r|   r	   Úalloca_once_valueÚindexr³   Ú
enable_nrtÚnrtÚincrefÚ	_getvaluer   )rn   r7   rO   rÍ   ru   r³   ÚiterobjÚzeroÚindexptrÚresÚoutr<   r<   r=   Úgetiter_array-  s    rÛ   c              	   C   s¤   t j||j|jd�}t j||j|jd�}| |d |¡}t  ||j|¡}	|dd… }
|dd… }t|t	j
ƒrŠt| |||||	|
|ƒ}| ¡ S |
r’t‚t| |||	ƒS dS )z1 Evaluate `ary[idx]`, where idx is a single int. ©r­   r   r?   N)r	   r¬   rW   ra   r˜   r®   Úpointer_addr‡   rƒ   r   ÚBufferÚ	make_viewrÕ   r†   rv   )rn   r7   rÏ   r½   Úaryr   Úshapesr˜   ÚoffsetÚdataptrÚview_shapesÚview_stridesÚretaryr<   r<   r=   Ú_getitem_array_single_intE  s      ÿrç   Úiternextc              	   C   sÂ   |j \}|\}|j}| j|||d�}t|ƒ| ||jd�}	tj||	jdd�\}
| |j	¡}| 
d||
¡}| |¡ | |¡�> t| ||j||	|ƒ}| |¡ t ||¡}| ||j	¡ W 5 Q R X d S )N©Úvaluer?   rÜ   ú<)rÍ   rU   rÎ   rj   r³   r	   r¬   rW   r8   rÑ   Úicmp_signedÚ	set_validÚif_thenrç   Ú
yield_typeÚyield_Úincrement_indexÚstore)rn   r7   rO   rÍ   ÚresultÚitertyÚiterru   rÖ   rà   rž   rÑ   Úis_validrê   Únindexr<   r<   r=   Úiternext_arrayZ  s*    
     ÿ
rø   c              	   C   sD  |   tjd¡}|   tjd¡}t ||j|j¡}	t ||j|j¡}
g }g }g }tdd„ |D ƒƒ}d}t	||ƒD �]n\}}|tj
krÔ|jt|ƒ d | }t|ƒD ]2}| |¡ | |	| ¡ | |
| ¡ |d7 }qžqlt|tjƒ�rT| j|||d�}t | |||¡ t |||	| ¡ | |j¡ t ||¡}t |||
| ¡}| |¡ | |¡ n€t|tjƒ�ržt| ||||	| ƒ}|�r’t | |||	| |¡ | |¡ n6t|ƒ�rÆ| |¡ | |¡ |d8 }ntd|f ƒ‚|d7 }ql||jk�sît‚||jk �r"| |	| ¡ | |
| ¡ |d7 }�qîtj| ||||ddd�}|||fS )	z“
    Perform basic indexing on the given array.
    A (data pointer, shapes, strides) tuple is returned describing
    the corresponding view.
    r   r?   c                 S   s   g | ]}t |ƒr|‘qS r<   ©r   ©rŠ   r   r<   r<   r=   rŒ   ‡  s      z"basic_indexing.<locals>.<listcomp>ré   úunexpected index type: %sF©Ú
wraparoundÚboundscheck)r«   r   r|   r	   r¬   rW   ra   r˜   r�   rŽ   Úellipsisr2   r[   rƒ   Ú	SliceTyperÎ   r)   Úguard_invalid_sliceÚ	fix_sliceÚstartÚget_slice_lengthZ
fix_strider…   r‚   Údo_boundscheckr   rF   r†   Úget_item_pointer)rn   r7   r½   rà   r�   r�   rþ   r×   Úonerá   r˜   Zoutput_indicesZoutput_shapesZoutput_stridesÚnum_newaxesÚaxÚindexvalr~   Ú	n_missingr_   ÚsliceÚshÚstr�   rã   r<   r<   r=   Úbasic_indexingv  sf    




ÿ




 þr  c           	   	   C   s.   t |ƒ| |ƒ}t|||||j|j|jd� |S )zF
    Build a view over the given array with the given parameters.
    ©r‡   rW   r˜   r™   r—   rš   )rj   r¼   r™   r—   rš   )	rn   r7   r½   rà   rÏ   r‡   rá   r˜   ræ   r<   r<   r=   rß   º  s    úrß   c              	   C   sb   t | |||||| jd�\}}}	t|tjƒrHt| |||||||	ƒ}
|
 ¡ S |rPt‚t| |||ƒS dS )zp
    Return the result of indexing *ary* with the given *indices*,
    returning either a scalar or a view.
    ©rþ   N)	r  Úenable_boundscheckrƒ   r   rÞ   rß   rÕ   r†   rv   )rn   r7   rÏ   r½   rà   r�   r�   rã   rä   rå   ræ   r<   r<   r=   Ú_getitem_array_genericÊ  s    ÿÿ  ÿr  c           	      C   sZ   |j \}}|\}}|jdks t‚t|ƒ| ||ƒ}t| ||j|||f|fƒ}t| ||j|ƒS )z4
    Basic indexing with an integer or a slice.
    r?   )rÍ   ra   r†   rj   r  rÏ   r   ©	rn   r7   rO   rÍ   r½   r~   rà   r   rÙ   r<   r<   r=   Úgetitem_arraynd_intpß  s    

   ÿr  c              	   C   sœ   |j \}}|\}}t|ƒ| ||ƒ}|j}tj||t|ƒd�}	t| |||	ƒ\}}	tdd„ |D ƒƒrvt| |||||||	ƒS t	| ||j
||||	ƒ}
t| ||j
|
ƒS )z2
    Basic or advanced indexing with a tuple.
    rÜ   c                 s   s   | ]}t |tjƒV  qd S ©N©rƒ   r   r„   )rŠ   Útyr<   r<   r=   Ú	<genexpr>ÿ  s     z&getitem_array_tuple.<locals>.<genexpr>)rÍ   rj   r   r	   r¬   r�   r‘   ÚanyÚfancy_getitemr  rÏ   r   )rn   r7   rO   rÍ   r½   Útuptyrà   Útupr�   r�   rÙ   r<   r<   r=   Úgetitem_array_tupleð  s.    
 ÿ
   ÿ
   ÿr  c              	   C   sì   |j \}}}|\}}}	t|tjƒr>|j}
tj||t|ƒd�}n|f}
|f}t|ƒ| ||ƒ}t| ||
|ƒ\}
}z"t	| ||||
|| j
d�\}}}W n tk
r¦   d}Y n
X t|ƒ}|rÆt| ||||
|ƒS |  ||	||j¡}	t| |||	|ƒ dS )zH
    array[a] = scalar_or_array
    array[a,..,b] = scalar_or_array
    rÜ   r  TN)rÍ   rƒ   r   Ú	BaseTupler	   r¬   r�   rj   r‘   r  r  rF   ÚboolÚfancy_setslicer{   rl   ry   )rn   r7   rO   rÍ   r½   r~   Úvaltyrà   r   rx   r�   r�   rã   rá   r˜   Zuse_fancy_indexingr<   r<   r=   Úsetitem_array	  s6    
 ÿÿÿ

 ÿr#  c           	      C   sD   |j \}|\}t|ƒ}|| ||ƒ}|j}| |d¡}t| ||j|ƒS rÅ   )rÍ   rj   rW   Úextract_valuer   rÏ   )	rn   r7   rO   rÍ   r½   rà   ZarysttyZshapearyrÙ   r<   r<   r=   Ú	array_len2  s    r%  z
array.itemc              	   C   st   |j \}|\}t|ƒ| ||ƒ}|j}|j| d|| d¡¡dd�� d}| j |t|f¡ W 5 Q R X t	| |||j
ƒS )Nú!=r?   F©Úlikelyz>item(): can only convert an array of size 1 to a Python scalar)rÍ   rj   rž   rî   rì   r3   Ú	call_convÚreturn_user_excr¤   rv   r‡   )rn   r7   rO   rÍ   r½   rà   rž   rµ   r<   r<   r=   Ú
array_item=  s    ÿr+  zarray.itemsetc           
   	   C   s�   |j \}}|\}}||jks t‚t|ƒ| ||ƒ}|j}|j| d|| d¡¡dd�� d}	| j 	|t
|	f¡ W 5 Q R X t| ||||jƒ |  ¡ S )Nr&  r?   Fr'  z/itemset(): can only write to an array of size 1)rÍ   rl   r†   rj   rž   rî   rì   r3   r)  r*  r¤   ry   r‡   Úget_dummy_value)
rn   r7   rO   rÍ   r½   r"  rà   rx   rž   rµ   r<   r<   r=   Úarray_itemsetL  s    
ÿr-  c                   @   s@   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dS )ÚIndexerzq
    Generic indexer interface, for generating indices over a fancy indexed
    array on a single dimension.
    c                 C   s   t ‚dS )ze
        Prepare the indexer by initializing any required variables, basic
        blocks...
        Nr¿   ©rM   r<   r<   r=   Úprepareg  s    zIndexer.preparec                 C   s   t ‚dS )z=
        Return this dimension's size as an integer.
        Nr¿   r/  r<   r<   r=   Úget_sizen  s    zIndexer.get_sizec                 C   s   t ‚dS )z;
        Return this dimension's shape as a tuple.
        Nr¿   r/  r<   r<   r=   Ú	get_shapet  s    zIndexer.get_shapec                 C   s   t ‚dS )z}
        Return a half-open [lower, upper) range of indices this dimension
        is guaranteed not to step out of.
        Nr¿   r/  r<   r<   r=   Úget_index_boundsz  s    zIndexer.get_index_boundsc                 C   s   t ‚dS )aW  
        Start indexation loop.  Return a (index, count) tuple.
        *index* is an integer LLVM value representing the index over this
        dimension.
        *count* is either an integer LLVM value representing the current
        iteration count, or None if this dimension should be omitted from
        the indexation result.
        Nr¿   r/  r<   r<   r=   Ú	loop_head�  s    	zIndexer.loop_headc                 C   s   t ‚dS )z)
        Finish indexation loop.
        Nr¿   r/  r<   r<   r=   Ú	loop_tailŒ  s    zIndexer.loop_tailN)
rb   rc   rd   Ú__doc__r0  r1  r2  r3  r4  r5  r<   r<   r<   r=   r.  a  s   r.  c                   @   sH   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dd„ Z
dS )ÚEntireIndexerz:
    Compute indices along an entire array dimension.
    c                 C   s2   || _ || _|| _|| _|| _| j  tj¡| _d S r  )	rn   r7   r½   rà   Údimr¥   r   r|   Úll_intp)rM   rn   r7   r½   rà   r8  r<   r<   r=   Ú__init__˜  s    zEntireIndexer.__init__c                 C   sB   | j }| | jj| j¡| _t || j¡| _	| 
¡ | _| 
¡ | _d S r  )r7   r$  rà   rW   r8  r€   r	   rK   r9  rÑ   Úappend_basic_blockÚbb_startÚbb_end©rM   r7   r<   r<   r=   r0     s
    
zEntireIndexer.preparec                 C   s   | j S r  ©r€   r/  r<   r<   r=   r1  §  s    zEntireIndexer.get_sizec                 C   s   | j fS r  r?  r/  r<   r<   r=   r2  ª  s    zEntireIndexer.get_shapec                 C   s   |   d¡| jfS rÅ   ©r9  r€   r/  r<   r<   r=   r3  ­  s    zEntireIndexer.get_index_boundsc              	   C   s|   | j }| j  t| jdƒ| j¡ | | j¡ | | j¡ | | j¡}|j	| 
d|| j¡dd�� | | j¡ W 5 Q R X ||fS ©Nr   ú>=Fr'  )r7   rò   r   r9  rÑ   Úbranchr<  Úposition_at_endr8   rî   rì   r€   r=  )rM   r7   Ú	cur_indexr<   r<   r=   r4  ±  s    ÿzEntireIndexer.loop_headc                 C   sD   | j }t || | j¡¡}| || j¡ | | j¡ | | j	¡ d S r  )
r7   r	   rñ   r8   rÑ   rò   rC  r<  rD  r=  ©rM   r7   Ú
next_indexr<   r<   r=   r5  ½  s
    zEntireIndexer.loop_tailN©rb   rc   rd   r6  r:  r0  r1  r2  r3  r4  r5  r<   r<   r<   r=   r7  “  s   r7  c                   @   sH   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dd„ Z
dS )ÚIntegerIndexerz0
    Compute indices from a single integer.
    c                 C   s&   || _ || _|| _| j  tj¡| _d S r  )rn   r7   r   r¥   r   r|   r9  )rM   rn   r7   r   r<   r<   r=   r:  Ê  s    zIntegerIndexer.__init__c                 C   s   d S r  r<   r/  r<   r<   r=   r0  Ð  s    zIntegerIndexer.preparec                 C   s   t | jdƒS ©Nr?   )r   r9  r/  r<   r<   r=   r1  Ó  s    zIntegerIndexer.get_sizec                 C   s   dS ©Nr<   r<   r/  r<   r<   r=   r2  Ö  s    zIntegerIndexer.get_shapec                 C   s   | j | j | j |  ¡ ¡fS r  )r   r7   Úaddr1  r/  r<   r<   r=   r3  Ù  s    zIntegerIndexer.get_index_boundsc                 C   s
   | j d fS r  )r   r/  r<   r<   r=   r4  Ý  s    zIntegerIndexer.loop_headc                 C   s   d S r  r<   r/  r<   r<   r=   r5  à  s    zIntegerIndexer.loop_tailNrH  r<   r<   r<   r=   rI  Å  s   rI  c                   @   sH   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dd„ Z
dS )ÚIntegerArrayIndexerz;
    Compute indices from an array of integer indices.
    c                 C   s@   || _ || _|| _|| _|| _|jdks,t‚| j  tj	¡| _
d S rJ  )rn   r7   r~   rˆ   r€   ra   r†   r¥   r   r|   r9  )rM   rn   r7   r~   rˆ   r€   r<   r<   r=   r:  é  s    zIntegerArrayIndexer.__init__c                 C   sD   | j }t || jj¡d | _t || j¡| _| 	¡ | _
| 	¡ | _d S rÅ   )r7   r	   r¬   rˆ   rW   Úidx_sizerK   r9  Ú	idx_indexr;  r<  r=  r>  r<   r<   r=   r0  ò  s
    
zIntegerArrayIndexer.preparec                 C   s   | j S r  ©rN  r/  r<   r<   r=   r1  ù  s    zIntegerArrayIndexer.get_sizec                 C   s   | j fS r  rP  r/  r<   r<   r=   r2  ü  s    zIntegerArrayIndexer.get_shapec                 C   s   |   d¡| jfS rÅ   r@  r/  r<   r<   r=   r3  ÿ  s    z$IntegerArrayIndexer.get_index_boundsc              	   C   s°   | j }| j  t| jdƒ| j¡ | | j¡ | | j¡ | | j¡}|j	| 
d|| j¡dd�� | | j¡ W 5 Q R X t| j|| jj| j| j|ƒ}t| j|| jj|| jƒ}||fS rA  )r7   rò   r   r9  rO  rC  r<  rD  r8   rî   rì   rN  r=  rç   rn   r~   rl   rˆ   r‚   r€   )rM   r7   rE  rÑ   r<   r<   r=   r4    s0    þ    þ  ÿzIntegerArrayIndexer.loop_headc                 C   sD   | j }t || | j¡¡}| || j¡ | | j¡ | | j	¡ d S r  )
r7   r	   rñ   r8   rO  rò   rC  r<  rD  r=  rF  r<   r<   r=   r5    s    
ÿzIntegerArrayIndexer.loop_tailNrH  r<   r<   r<   r=   rM  ä  s   	rM  c                   @   sH   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dd„ Z
dS )ÚBooleanArrayIndexerz>
    Compute indices from an array of boolean predicates.
    c                 C   sH   || _ || _|| _|| _|jdks&t‚| j  tj¡| _	t
| j	dƒ| _d S ©Nr?   r   )rn   r7   r~   rˆ   ra   r†   r¥   r   r|   r9  r   r×   )rM   rn   r7   r~   rˆ   r<   r<   r=   r:  &  s    zBooleanArrayIndexer.__init__c                 C   s^   | j }t || jj¡d | _t || j¡| _t || j¡| _	| 
¡ | _| 
¡ | _| 
¡ | _d S rÅ   )r7   r	   r¬   rˆ   rW   r€   rK   r9  rO  r­   r;  r<  Úbb_tailr=  r>  r<   r<   r=   r0  /  s    

zBooleanArrayIndexer.preparec              	   C   s‚   | j }t || j¡}t || j¡�P}| |¡}t| j|| j	j
| j	| j|jƒ}| || ||j¡¡}| ||¡ W 5 Q R X | |¡S r  )r7   r	   rÐ   r×   Ú	for_ranger€   r8   rç   rn   r~   rl   rˆ   rÑ   rL  Úzextr3   rò   )rM   r7   r­   ÚloopÚcÚpredr<   r<   r=   r1  8  s    
    þzBooleanArrayIndexer.get_sizec                 C   s
   |   ¡ fS r  ©r1  r/  r<   r<   r=   r2  G  s    zBooleanArrayIndexer.get_shapec                 C   s   |   d¡| jfS rÅ   r@  r/  r<   r<   r=   r3  J  s    z$BooleanArrayIndexer.get_index_boundsc              	   C   sò   | j }| j  | j| j¡ | j  | j| j¡ | | j¡ | | j¡ | | j¡}| | j¡}|j	| 
d|| j¡dd�� | | j¡ W 5 Q R X t| j|| jj| j| j|ƒ}| 	| |¡¡� | | j¡ W 5 Q R X t ||¡}| || j¡ ||fS )NrB  Fr'  )r7   rò   r×   rO  r­   rC  r<  rD  r8   rî   rì   r€   r=  rç   rn   r~   rl   rˆ   Únot_rS  r	   rñ   )rM   r7   rE  Ú	cur_countrX  Ú
next_countr<   r<   r=   r4  O  s0    ÿ    þzBooleanArrayIndexer.loop_headc                 C   s\   | j }| | j¡ | | j¡ t || | j¡¡}| || j¡ | | j	¡ | | j
¡ d S r  )r7   rC  rS  rD  r	   rñ   r8   rO  rò   r<  r=  rF  r<   r<   r=   r5  g  s    
ÿzBooleanArrayIndexer.loop_tailNrH  r<   r<   r<   r=   rQ  !  s   		rQ  c                   @   sH   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dd„ Z
dS )ÚSliceIndexerz(
    Compute indices along a slice.
    c                 C   sL   || _ || _|| _|| _|| _|| _|| _| j  tj	¡| _
t| j
dƒ| _d S rÅ   )rn   r7   r½   rà   r8  r~   r  r¥   r   r|   r9  r   r×   )rM   rn   r7   r½   rà   r8  r~   r  r<   r<   r=   r:  w  s    zSliceIndexer.__init__c                 C   sŒ   | j }| | jj| j¡| _t | j|| j	| j
¡ t || j
| j¡ t || j
j¡| _t || j¡| _t || j¡| _| ¡ | _| ¡ | _d S r  )r7   r$  rà   rW   r8  Údim_sizer)   r  rn   r~   r  r  r	   Ú
is_neg_intÚstepÚis_step_negativerK   r9  rÑ   r­   r;  r<  r=  r>  r<   r<   r=   r0  ‚  s    ÿ
zSliceIndexer.preparec                 C   s   t  | j| j¡S r  )r)   r  r7   r  r/  r<   r<   r=   r1  �  s    zSliceIndexer.get_sizec                 C   s
   |   ¡ fS r  rY  r/  r<   r<   r=   r2  “  s    zSliceIndexer.get_shapec                 C   s   t  | j| j¡\}}||fS r  )r)   Zget_slice_boundsr7   r  )rM   ÚlowerÚupperr<   r<   r=   r3  –  s    zSliceIndexer.get_index_boundsc              	   C   s¶   | j }| j  | jj| j¡ | j  | j| j¡ | | j¡ | 	| j¡ | 
| j¡}| 
| j¡}| | j| d|| jj¡| d|| jj¡¡}|j|dd�� | | j¡ W 5 Q R X ||fS )Nz<=rB  Fr'  )r7   rò   r  r  rÑ   r×   r­   rC  r<  rD  r8   Úselectra  rì   Ústoprî   r=  )rM   r7   rE  r[  Zis_finishedr<   r<   r=   r4  š  s$    ÿÿýzSliceIndexer.loop_headc                 C   sp   | j }|j| | j¡| jjdgd�}| || j¡ t || | j	¡¡}| || j	¡ | 
| j¡ | | j¡ d S )Nr›   rœ   )r7   rL  r8   rÑ   r  r`  rò   r	   rñ   r­   rC  r<  rD  r=  )rM   r7   rG  r\  r<   r<   r=   r5  ¬  s    ÿzSliceIndexer.loop_tailNrH  r<   r<   r<   r=   r]  r  s   r]  c                   @   s@   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dS )ÚFancyIndexerz4
    Perform fancy indexing on the given array.
    c              	   C   sˆ  || _ || _|| _t ||j|j¡| _t ||j|j¡| _| j  	t
j¡| _g | _g }tdd„ |D ƒƒ}d}	d}
t||ƒD �]”\}}|t
jkrÜ|jt|ƒ d | }t|ƒD ].}t|||||	ƒ}| |¡ |	d7 }	|
d7 }
qªqxt|t
jƒ�r| |||¡}t|||||	||ƒ}| |¡ næt|t
jƒ�rTt||||| j|	 ƒ}t|||ƒ}| |¡ nªt|t
jƒ�rÐt|ƒ|||ƒ}t|jt
jƒ�ršt||||| j|	 ƒ}n*t|jt
jƒ�rºt ||||ƒ}n
d�sÄt!‚| |¡ n.t"|ƒ�rð| j |
¡ |	d8 }	nt!d|f ƒ‚|	d7 }	|
d7 }
qx|	|jk�s*t!|	|jfƒ‚|	|jk �r\t|||||	ƒ}| |¡ |	d7 }	�q*t|ƒ|jk�s~t!t|ƒ|jfƒ‚|| _#d S )Nc                 S   s   g | ]}t |ƒr|‘qS r<   rù   rú   r<   r<   r=   rŒ   Æ  s      z)FancyIndexer.__init__.<locals>.<listcomp>r   r?   rû   )$rn   r7   r½   r	   r¬   rW   ra   rá   r˜   r¥   r   r|   r9  Únewaxesr�   rŽ   rÿ   r2   r7  r[   rƒ   r   rÎ   r]  r…   r‚   rI  r„   rj   rl   rM  ÚBooleanrQ  r†   r   Úindexers)rM   rn   r7   r½   rà   r�   r�   ri  r  r	  Znew_axr
  r~   r  r_   Úindexerr  r�   rˆ   r<   r<   r=   r:  ¼  sz    


 ÿ
ÿ þ ÿ




"zFancyIndexer.__init__c                 C   s^   | j D ]}| ¡  q| j tjd¡}dd„ | j D ƒ}| jD ]}| ||f¡ q:t|dƒ| _	d S )Nr?   c                 S   s   g | ]}|  ¡ ‘qS r<   )r2  ©rŠ   r_   r<   r<   r=   rŒ     s     z(FancyIndexer.prepare.<locals>.<listcomp>r<   )
ri  r0  rn   r«   r   r|   rg  ÚinsertÚsumÚindexers_shape)rM   r_   r  Ú	res_shaper<   r<   r=   r0  þ  s    


zFancyIndexer.preparec                 C   s   | j S )z?
        Get the resulting data shape as Python tuple.
        )rn  r/  r<   r<   r=   r2    s    zFancyIndexer.get_shapec              	   C   s  t |ƒ| jjkst‚| j}tj}|  d¡}|  d¡}|}|}t| j	| j
|ƒD ]†\}	}
}| || d|
|¡¡}|	 ¡ \}}| ||¡}| || ||¡¡}| d||¡}| || |||¡¡}| || |||¡¡}qL| ||¡}| |||¡}| |||¡}||fS )zÊ
        Get a half-open [lower, upper) range of byte offsets spanned by
        the indexer with the given strides and itemsize.  The indexer is
        guaranteed to not go past those bounds.
        r   r?   ú==rë   )r�   r½   ra   r†   r7   r	   Ú	false_bitr9  rŽ   ri  rn  Úor_Úicmp_unsignedr3  r®   Úsubrì   rL  rd  )rM   r˜   r™   r7   Úis_emptyr×   r  rb  rc  rj  rW   ÚstrideZlower_indexZupper_indexZlower_offsetZupper_offsetZis_downwardsr<   r<   r=   Úget_offset_bounds  sB    


ÿÿþÿþÿzFancyIndexer.get_offset_boundsc                 C   s    t dd„ | jD ƒŽ \}}||fS )Nc                 s   s   | ]}|  ¡ V  qd S r  )r4  rk  r<   r<   r=   r  >  s     z+FancyIndexer.begin_loops.<locals>.<genexpr>)rŽ   ri  )rM   r�   Úcountsr<   r<   r=   Úbegin_loops=  s    zFancyIndexer.begin_loopsc                 C   s   t | jƒD ]}| ¡  q
d S r  )Úreversedri  r5  )rM   r_   r<   r<   r=   Ú	end_loopsA  s    zFancyIndexer.end_loopsN)
rb   rc   rd   r6  r:  r0  r2  rw  ry  r{  r<   r<   r<   r=   rf  ·  s   B&rf  c                 C   s  t  ||j¡}t  ||j¡}	|j}
t| |||||ƒ}| ¡  |j}| ¡ }t	| |||ƒ}|j}t  
||  tjd¡¡}| ¡ \}}t j| ||
||	|j|d| jd�	}t| |||ƒ}| |¡}| ||g¡}t| ||||ƒ t  ||¡}| ||¡ | ¡  t| ||| ¡ ƒS )Nr   Frü   )r	   r¬   rW   r˜   r‡   rf  r0  rÏ   r2  Ú_empty_nd_implrÐ   r«   r   r|   ry  Úget_item_pointer2Úlayoutr  rv   r8   Úgepry   rñ   rò   r{  r   rÕ   )rn   r7   rO   rÍ   r½   rà   r�   r�   rá   r˜   r‡   rj  Zout_tyZ
out_shapesrÚ   Zout_dataZout_idxÚ_r]   rx   ÚcurZnext_idxr<   r<   r=   r  F  s<    
 ÿÿ  þ
r  c           	   	   C   s†   |j \}}|\}}t|ƒ| ||ƒ}|jdkrht| |||ƒ\}}t| ||j|||f|fƒ}t| ||j|ƒS t| ||||||f|fƒS dS )z3
    Advanced or basic indexing with an array.
    r   N)rÍ   rj   ra   r‰   r  rÏ   r   r  r  r<   r<   r=   Úfancy_getitem_arrayq  s$    


   ÿ
   ÿr‚  c              	   C   sæ   |j }| d¡}| d¡}|jdkr8|}	| ||j¡}
n¦|}	|}
t|jƒD ]Z}| || | || |¡¡}| d||¡}| 	|| 
|
|¡|
¡}
| 	||	| 
|	|¡¡}	qJ| 
|
|¡}
| d|j|¡}| 	|||
¡}
| 	|||	¡}	|	|
fS )zï
    Compute a half-open range [lower, upper) of byte offsets from the
    array's data pointer, that bound the in-memory extent of the array.

    This mimics offset_bounds_from_strides() from
    numpy/core/src/private/mem_overlap.c
    r   r?   ÚCFrB  rp  )r™   r3   r~  r®   rž   r2   ra   rt  rì   rd  rL  )rn   r7   ÚarrtyÚarrrá   r˜   r™   r×   r  rb  rc  r_   Zmax_axis_offsetZ
is_upwardsru  r<   r<   r=   Úoffset_bounds_from_strides…  s4    



ÿ
 ÿ 
ÿr†  c                 C   s.   |  ||j¡}| ||¡}| ||¡}||fS )z…
    Given [lower, upper) byte offsets and a base data pointer,
    compute the memory pointer bounds as pointer-sized integers.
    )Úptrtointr3   rL  )rn   r7   rb  rc  r‡   Zdata_ptr_as_intr  Úendr<   r<   r=   Úcompute_memory_extents¯  s    r‰  c           	      C   s&   t | |||||ƒ\}}t| ||||ƒS )zr
    Compute a half-open range [start, end) of pointer-sized integers
    which fully contain the array data.
    )r†  r‰  )	rn   r7   r„  r…  rá   r˜   r‡   rb  rc  r<   r<   r=   Úget_array_memory_extentsº  s
    
 ÿrŠ  c                 C   s$   |  | d||¡| d||¡¡}|S )z[
    Whether two memory extents [a_start, a_end) and [b_start, b_end)
    may overlap.
    rë   )Úand_rs  )rn   r7   Úa_startÚa_endZb_startZb_endZmay_overlapr<   r<   r=   Úextents_may_overlapÅ  s
    þrŽ  c                    s  ˆj ‰d‰t ˆ ˆ¡‰ˆ‰d ‰ˆ jˆdd��¨ ˆ  |j|j¡}ˆj ˆ |¡}	|	j ‰ˆ  	|	ˆ¡}	ˆ  
|	ˆ¡ ˆ tj¡}
t ˆ ˆ|
¡�F}t ˆˆ ˆˆˆ	ˆ
j|¡}t ˆˆ |	ˆˆˆ|¡}ˆ  
ˆ  |¡|¡ W 5 Q R X W 5 Q R X ‡ ‡‡‡‡‡‡‡‡‡	‡
‡fdd„}‡ ‡‡‡‡fdd„}||fS )Nr’   Fr'  c                    sª   t  ˆ ˆ¡}ˆ jˆdd��v\}}|�. ˆ  t jˆˆ ˆ  ˆ¡ˆˆˆ| dd�|¡ W 5 Q R X |�* ˆ  t jˆˆ ˆˆˆ	ˆ
j| dd�|¡ W 5 Q R X W 5 Q R X tˆˆ ˆ
ˆ  |¡ƒS )NFr'  ©rý   )r	   rK   Úif_elserò   r}  r8   r~  rv   )Úsource_indicesÚsrc_ptrZif_copyÚ	otherwise)r7   rn   Ú	copy_dataÚcopy_layoutÚcopy_shapesÚcopy_stridesÚptrtyÚsrc_dataÚ
src_shapesÚsrc_stridesÚsrctyÚuse_copyr<   r=   Úsrc_getitemñ  s4      üú
  ýûz&maybe_copy_source.<locals>.src_getitemc               	      sB   ˆ j ˆdd��* ˆ  ˆ¡} ˆ  | ˆ¡} ˆj ˆ | ¡ W 5 Q R X d S )NFr'  )rî   r8   ÚbitcastrÓ   Úfree©r‡   )r7   rn   r”  r�  Ú	voidptrtyr<   r=   Úsrc_cleanup  s    
z&maybe_copy_source.<locals>.src_cleanup)r3   r	   rÐ   rî   r®   r™   rž   rÓ   ÚallocaterŸ  rò   r¥   r   r|   Ú	loop_nestr}  r~  r8   )rn   r7   r�  rœ  Úsrcrš  r›  r™  Ú	allocsizer‡   r¶   r�   r’  Údest_ptrrž  r£  r<   )r7   rn   r”  r•  r–  r—  r˜  r™  rš  r›  rœ  r�  r¢  r=   Úmaybe_copy_sourceÒ  s:    
  þ
  þ&"r©  c           
   	      sþ   |   tjd¡}|   tjd¡‰t|ƒt|ƒkrZt|ƒt|ƒ }ˆg| | }|g| | }nœt|ƒt|ƒk röt|ƒt|ƒ }‡ ‡fdd„|d|… D ƒ}t ˆ j|tj¡}ˆ j	ˆ  
|¡dd�� d}	| j ˆ t|	f¡ W 5 Q R X ||d… }||d… }||fS )	ae  
    Preprocess dimension for broadcasting.
    Returns (shapes, strides) such that the ndim match *target_shape*.
    When expanding to higher ndim, the returning shapes and strides are
    prepended with ones and zeros, respectively.
    When truncating to lower ndim, the shapes are checked (in runtime).
    All extra dimension must have size of 1.
    r   r?   c                    s   g | ]}ˆ   d |ˆ¡‘qS ©rp  )rs  ©rŠ   r  ©r7   r  r<   r=   rŒ   %  s   ÿz(_bc_adjust_dimension.<locals>.<listcomp>NFr'  z,cannot broadcast source array for assignment)r«   r   r}   r�   Ú	functoolsÚreducer‹  r	   Útrue_bitrî   rZ  r)  r*  r¤   )
rn   r7   rá   r˜   Útarget_shaper×   Znd_diffZ
dim_is_oneÚacceptedrµ   r<   r¬  r=   Ú_bc_adjust_dimension  s(    	
ÿ
ÿr²  c           
         s¤   g }g }|   tjd¡‰|   tjd¡‰‡ fdd„t||ƒD ƒ}‡ ‡fdd„|D ƒ}‡ fdd„t||ƒD ƒ}	‡ fdd„t|	||ƒD ƒ}‡ ‡fdd„t|	|ƒD ƒ}||fS )	zü
    Broadcast shapes and strides to target_shape given that their ndim already
    matches.  For each location where the shape is 1 and does not match the
    dim for target, it is set to the value at the target and the stride is
    set to zero.
    r   r?   c                    s   g | ]\}}ˆ   d ||¡‘qS )r&  ©rì   )rŠ   ÚtarÚold©r7   r<   r=   rŒ   @  s   ÿz,_bc_adjust_shape_strides.<locals>.<listcomp>c                    s   g | ]}ˆ   d |ˆ¡‘qS rª  r³  )rŠ   rµ  r¬  r<   r=   rŒ   B  s     c                    s   g | ]\}}ˆ   ||¡‘qS r<   )r‹  )rŠ   ÚxÚyr¶  r<   r=   rŒ   C  s     c                    s    g | ]\}}}ˆ   |||¡‘qS r<   ©rd  )rŠ   Úpr´  rµ  r¶  r<   r=   rŒ   D  s   ÿc                    s   g | ]\}}ˆ   |ˆ|¡‘qS r<   r¹  )rŠ   rº  rµ  )r7   r×   r<   r=   rŒ   F  s   ÿ)r«   r   r}   rŽ   )
rn   r7   rá   r˜   r°  Z	bc_shapesZ
bc_stridesÚmismatchZ
src_is_oneÚpredsr<   )r7   r  r×   r=   Ú_bc_adjust_shape_strides4  s     
ÿ

ÿÿr½  c           	   	   C   sš   t  ||j¡}t  ||j¡}t| ||||ƒ\}}t| ||||ƒ\}}|jt|ƒdd�}t|ƒ| |ƒ}t	||j
t  ||¡t  ||¡|j|j|jd� ||fS )zX
    Broadcast the given array to the target_shape.
    Returns (array_type, array)
    ÚA©ra   r~  r  )r	   r¬   rW   r˜   r²  r½  Úcopyr�   rj   r¼   r‡   r\   r™   r—   rš   )	rn   r7   Úarrtyper…  r°  rá   r˜   Znew_arrtypeZnew_arrr<   r<   r=   Ú_broadcast_to_shapeK  s(    
ÿ ÿ

úrÂ  c                 C   s,   |j |jddd�}|||ƒ}dd„ }||fS )Nr¾  T)ra   r~  Úreadonlyc           
   	   S   sz   |\}}|j d }t|ƒ| ||ƒ}t ||¡}t| ||||ƒ\}}t|dt|  |j 	d¡¡d ƒƒ | 
¡ }	t| ||j|	ƒS )Nr   rš   )rÍ   rj   r	   r¬   rÂ  r²   r   r¥   rŸ   r¦   rÕ   r   rÏ   )
rn   r7   rO   rÍ   r¦  Zshape_rœ  r€  ÚdestrÙ   r<   r<   r=   Úcodegenj  s    
þz$_numpy_broadcast_to.<locals>.codegen)rÀ  r­   )Ú	typingctxr³   rW   ÚretrO   rÅ  r<   r<   r=   Ú_numpy_broadcast_toe  s    
rÈ  c                 C   s$   |j dd�}||ƒ}dd„ }||fS )NT©rÃ  c                 S   sH   |\}|j d }t|ƒ| ||ƒ}t |jj¡|_| ¡ }t| ||j|ƒS rÅ   )	rÍ   rj   r	   Úget_null_valuerš   r3   rÕ   r   rÏ   )rn   r7   rO   rÍ   r¦  rœ  rÄ  rÙ   r<   r<   r=   rÅ  ‚  s    
z#get_readonly_array.<locals>.codegen)rÀ  )rÆ  r…  rÇ  rO   rÅ  r<   r<   r=   Úget_readonly_array|  s    	rË  c           
      C   s”   | j }t|ƒ}t|ƒ}||kr&tdƒ‚|D ]}|dk r*tdƒ‚q*d}|| }||k r�|| }|| }	||	kst|dkr†|d7 }|d7 }qLtdƒ‚qLd S )NzDinput operand has more dimensions than allowed by the axis remappingr   z4all elements of broadcast shape must be non-negativer?   z=operands could not be broadcast together with remapped shapes)rW   r�   r¤   )
r³   Z
dest_shapeZ	src_shapeZsrc_ndimZ	dest_ndimr€   Z	src_indexZ
dest_indexZsrc_dimZdest_dimr<   r<   r=   Ú_can_broadcastŽ  s"    

rÌ  c                 C   s   t  | ¡} t| |ƒ t| |ƒS r  )ÚnpÚasarrayrÌ  rÈ  ©r³   rW   r<   r<   r=   Ú_default_broadcast_to_impl®  s    

rÐ  c                 C   s  t | ƒst d¡‚t|tjƒr*dd„ }|S t|tjƒrVt|jtjƒsRd}t |¡‚tS t|tj	ƒr˜|j
dkr˜tdd„ |D ƒƒs”d|› d	�}t |¡‚tS t|tj	ƒrì|j
dkrìt| tjƒoÂ| jdk}t| ƒsÐ|rÜd
d„ }|S d}t |¡‚nd| }t |¡‚d S )Nz-The first argument "array" must be array-likec                 S   s   t  | |f¡S r  )rÍ  Úbroadcast_torÏ  r<   r<   r=   rÈ   »  s    z numpy_broadcast_to.<locals>.implz7The second argument "shape" must be a tuple of integersr   c                 S   s   g | ]}t |tjƒ‘qS r<   )rƒ   r   ÚIntegerLiteral)rŠ   Útypr<   r<   r=   rŒ   Ç  s     z&numpy_broadcast_to.<locals>.<listcomp>ú"z," object cannot be interpreted as an integerc                 S   s   t  | ¡} t| ƒS r  )rÍ  rÎ  rË  rÏ  r<   r<   r=   rÈ   Ï  s    
z/Cannot broadcast a non-scalar to a scalar arrayz:The argument "shape" must be a tuple or an integer. Got %s)r   r   rÉ   rƒ   r   r…   ÚUniTuplerl   rÐ  ÚTupler­   Úallr„   ra   r   )r³   rW   rÈ   rµ   Zis_scalar_arrayr<   r<   r=   Únumpy_broadcast_to´  s4    


ÿrØ  c                 C   sr   t t|ƒƒD ]`}|t|ƒ | }|| }|dk r8tdƒ‚|dkrBq| | dkrX|| |< q| | |krtdƒ‚qd S )Nr   ú#negative dimensions are not allowedr?   z=shape mismatch: objects cannot be broadcast to a single shape)r2   r�   r¤   )ÚrÚmrW   r_   rº   Útmpr<   r<   r=   Únumpy_broadcast_shapes_listß  s    
rÝ  c                     sô   t | ƒD ]n\}}t|tjƒ}t|tjƒo4t|jtjƒ}t|tjƒoNt|jƒdk}|s|s|sd|› d|› �}t 	|¡‚qd‰| D ]6}t|tjƒrœt
ˆdƒ‰q€t|tjƒr€t
ˆt|ƒƒ‰q€ˆdkrÈdd„ S dˆ ‰ddlm‰  ‡ ‡‡fd	d
„}|S d S )Nr   z	Argument z* must be either an int or tuple[int]. Got r?   c                  W   s   dS rK  r<   ©rÍ   r<   r<   r=   Ú<lambda>  ó    z+ol_numpy_broadcast_shapes.<locals>.<lambda>©r?   )Ú_isinstance_no_warnc                     sz   dgˆ }ˆ}t | ƒD ]@}ˆ |tƒr>t|ƒdkr>t|ˆ|ƒ qˆ |tƒrt|ˆ|fƒ qt|ƒD ]\}}t|||ƒ}q`|S rR  )r   r§   r�   rÝ  r©   Ú	enumerater*   )rÍ   rÚ  r  Úargr   Úelem©râ  rÛ  Útup_initr<   r=   rÈ     s    

z'ol_numpy_broadcast_shapes.<locals>.impl)rã  rƒ   r   r…   rÕ  rl   rÖ  r�   r   rÉ   Úmaxr  Únumba.cpython.builtinsrâ  )rÍ   r   rä  Zis_intZis_int_tupleZis_empty_tuplerµ   rÈ   r<   ræ  r=   Úol_numpy_broadcast_shapesð  s*    ÿrê  c                     sþ   t | ƒD ]"\}}t|ƒst d|› d�¡‚qd }d }| D ]H}t|tjtjfƒrV|j}n|}|d krh|}q8||kr8t d| › �¡‚q8d‰ t | ƒD ]T\}}t|tj	ƒr°t
ˆ |jƒ‰ qŽt|tjtjtjfƒrÒt
ˆ dƒ‰ qŽt d|› �¡‚qŽdˆ  ‰‡ ‡fdd	„}|S )
Nz
Argument "z" must be array-likezTMismatch of argument types. Numba cannot broadcast arrays with different types. Got r   r?   zUnhandled type )r   c                     s|   dgˆ  }t | ƒD ]}t|ˆ t |¡jƒ qˆ}tˆ ƒD ]}t|||| ƒ}q8g }t | ƒD ]}| t t |¡|¡¡ qZ|S rJ  )	r   rÝ  rÍ  rÎ  rW   r2   r*   r[   rÑ  )rÍ   rW   r³   r  r_   Úouts©rÛ  rç  r<   r=   rÈ   >  s    
z$numpy_broadcast_arrays.<locals>.impl)rã  r   r   rÉ   rƒ   r   r„   r  rl   ÚArrayCompatiblerè  ra   ÚNumberrh  )rÍ   r   rä  Zunified_dtypeÚdtrÈ   r<   rì  r=   Únumpy_broadcast_arrays  s.    rð  c           '         s  |j \}}‰|\}}‰t|ƒˆˆ |ƒ}t ˆ |j¡}	t ˆ |j¡}
|j}tˆˆ ||||ƒ}| ¡  t	ˆt
jƒ�r¤ˆj‰| ¡ }tˆƒˆˆ ˆƒ‰tˆˆ ˆˆ|ƒ\‰‰t ˆ ˆj¡}t ˆ ˆj¡}ˆj}tj}t|ƒt|ƒksÞt‚t||ƒD ]\}}ˆ  |ˆ  d||¡¡}qèˆ j|dd�� d}ˆj ˆ t|f¡ W 5 Q R X tˆˆ ˆˆ|||ƒ\}}| |
|j¡\}}tˆˆ |||ƒ\}}tˆˆ ||||ƒ}tˆˆ |ˆˆ|||ƒ\}}nÆt	ˆt
jƒ�rRˆj‰| ¡ }t|ƒdk�sÒt‚ˆ  tt!t
j"ˆƒ¡}|ˆ ˆfƒ}ˆ  d|d |¡}ˆ j|dd�� d}ˆj ˆ t|f¡ W 5 Q R X ‡ ‡‡‡‡fdd„}d	d
„ }nˆ‰‡fdd„}dd
„ }ˆ #t
j$d¡} | %¡ \}!}"t&|"ƒ}"|j'D ]}#|" (|#| ¡ �q’dd„ |"D ƒ}$||$ƒ}%ˆ )ˆ |%ˆ|j¡}%tj*ˆˆ ||	|
|j+|!dˆj,d�	}&t-ˆˆ ||%|&ƒ | .¡  |ƒ  ˆ /¡ S )zÇ
    Implement slice assignment for arrays.  This implementation works for
    basic as well as fancy indexing, since there's no functional difference
    between the two for indexed assignment.
    r&  Fr'  z0cannot assign slice from input of different sizer?   r   c                    s,   | \}ˆ  tjtˆˆtjƒ¡}|ˆ ˆ|fƒS r  )rE   ÚoperatorÚgetitemr    r   r|   )r‘  r   Úgetitem_impl©r7   rn   r¦  Z	src_dtyperœ  r<   r=   rž     s    þz#fancy_setslice.<locals>.src_getitemc                   S   s   d S r  r<   r<   r<   r<   r=   r£  ¨  s    z#fancy_setslice.<locals>.src_cleanupc                    s   ˆ S r  r<   )r‘  )r¦  r<   r=   rž  °  s    c                   S   s   d S r  r<   r<   r<   r<   r=   r£  ³  s    c                 S   s   g | ]}|d k	r|‘qS r  r<   )rŠ   rW  r<   r<   r=   rŒ   Ç  s      z"fancy_setslice.<locals>.<listcomp>rü   )0rÍ   rj   r	   r¬   rW   r˜   r‡   rf  r0  rƒ   r   rÞ   rl   r2  rÂ  rq  r�   r†   rŽ   rr  rì   rî   r)  r*  r¤   rŠ  rw  r™   r‰  rŽ  r©  ÚSequencerE   r    r|   r«   r}   ry  r¨   rg  rl  r{   r}  r~  r  ry   r{  r,  )'rn   r7   rO   rÍ   r�   r�   r½   r€  rà   Zdest_shapesÚdest_stridesÚ	dest_datarj  Zindex_shaperš  r›  r™  Zshape_errorÚur»   rµ   Z	src_startZsrc_endZ
dest_lowerZ
dest_upperZ
dest_startZdest_endr�  rž  r£  Úlen_implZseq_lenr×   Zdest_indicesrx  r_   r‘  rx   r¨  r<   rô  r=   r!  U  s´    

 ÿ
ÿÿ  þÿ þ
 ÿ   þ



  ür!  c                    sŽ   |j d }|j dd … }|d }|dd … }‡ ‡fdd„t||ƒD ƒ}t ˆ ||d j¡}tjtjt|ƒd�}	t	 
|j||	¡}
||f}|
|fS )Nr   r?   c                    s"   g | ]\}}ˆ  ˆ ||tj¡‘qS r<   ©r{   r   r|   )rŠ   r  rx   r‹   r<   r=   rŒ   è  s   ÿz#vararg_to_tuple.<locals>.<listcomp>©rl   r­   )rÍ   rŽ   r	   r\   r3   r   rÕ  r|   r�   r   r    rÏ   )rn   r7   rO   rÍ   r½   Zdimtysrà   r^   rW   ÚshapetyÚnew_sigÚnew_argsr<   r‹   r=   Úvararg_to_tupleá  s    
ÿrÿ  zarray.transposec                 C   s   t | ||jd |d ƒS rÅ   )Úarray_TrÍ   ©rn   r7   rO   rÍ   r<   r<   r=   Úarray_transposeô  s    r  c                 C   sn   t | ƒt t| ƒƒkrtdƒ‚t |ƒ}| D ] }||ks@t|ƒ|kr(tdƒ‚q(||  |d d …< ||  |d d …< d S )Nzrepeated axis in transposez2axis is out of bounds for array of given dimension)r�   r¡   r¤   Úabs)rÃ   rW   r˜   r8  r·  r<   r<   r=   Úpermute_arraysù  s    
r  c              
      s˜  |j d }t|ƒˆˆ |d ƒ}|j d |d  }}|j|j }}	ˆ tj¡}
t |
|¡‰||j	|j
g}‡ ‡fdd„|D ƒ}t||ƒD ]\}}ˆ  ||¡ q„tj|	ddd�‰ˆ tjˆ |
¡¡}‡ ‡‡fdd„|D ƒ}t||ƒD ]6\}}t|ˆ  ||
 ¡ ¡ˆ tj|¡g|g|d d� qÞˆ ˆ tt tjˆˆˆ¡d	d„ |D ƒ¡ t|jƒˆˆ ƒ}t||jˆ  |d ¡ˆ  |d
 ¡|j|j|jd� | ¡ }tˆˆ |j|ƒS )Nr   r?   c                    s   g | ]}t  ˆ ˆ¡‘qS r<   ©r	   rK   ©rŠ   r€  )r7   Úll_ary_sizer<   r=   rŒ     s     z)array_transpose_tuple.<locals>.<listcomp>r’   ©rl   ra   r~  c                    s   g | ]}t ˆƒˆˆ ƒ‘qS r<   ©rj   r  )r7   rn   Ú	np_ary_tyr<   r=   rŒ      s     ©r‡   rW   r˜   r™   r—   c                 S   s   g | ]}|  ¡ ‘qS r<   ©rÕ   ©rŠ   Úar<   r<   r=   rŒ   0  s     é   r  ) rÍ   rj   r­   rl   r¥   r   r|   r   Ú	ArrayTyperW   r˜   rŽ   rò   r„   r«   rm   r¼   rŸ  Ú
as_pointerÚcompile_internalr  r   r    ÚvoidrÏ   r‡   r8   r™   r—   rš   rÕ   r   )rn   r7   rO   rÍ   r½   rà   ZaxistyrÃ   Znum_axisrl   r9  ÚarysZll_arysr¦  ÚdstZnp_itemsizeZnp_arysZnp_aryZll_aryrÇ  rÙ   r<   )r7   rn   r  r
  r=   Úarray_transpose_tuple  sT    
ÿû	  ÿýúr  c                 C   s    t | |||ƒ\}}t| |||ƒS r  )rÿ  r  ©rn   r7   rO   rÍ   rý  rþ  r<   r<   r=   Úarray_transpose_vararg?  s    r  c                 C   s8   t | tjƒrt d¡‚|d kr*ddd„}n
ddd„}|S )Nz#np.transpose does not accept tuplesc                 S   s   |   ¡ S r  ©Ú	transpose©r  Úaxesr<   r<   r=   Únp_transpose_implK  s    z*numpy_transpose.<locals>.np_transpose_implc                 S   s
   |   |¡S r  r  r  r<   r<   r=   r  N  s    )N)N)rƒ   r   r  r   ÚUnsupportedError)r  r  r  r<   r<   r=   Únumpy_transposeE  s    

r  ÚTc           	      C   sª   |j dkr|}nŒt|ƒ| ||ƒ}t|ƒ| |ƒ}t ||j|j ¡}t ||j|j ¡}t||jt ||d d d… ¡t ||d d d… ¡|j	|j
|jd� | ¡ }t| |||ƒS )Nr?   éÿÿÿÿr  )ra   rj   r	   r¬   rW   r˜   r¼   r‡   r\   r™   r—   rš   rÕ   r   )	rn   r7   rÓ  rê   rÙ   rà   rÇ  rá   r˜   r<   r<   r=   r   T  s     
úr   é2   c                 C   sT   t | tjƒst d¡‚t |tjƒs,t d¡‚t |ttjfƒsFt d¡‚ddd„}|S )Nz+The first argument "start" must be a numberz+The second argument "stop" must be a numberz+The third argument "num" must be an integerr"  c                 S   s   t  | ||¡}t  d|¡S )Ng      $@)rÍ  ÚlinspaceÚpower)r  re  Únumr¸  r<   r<   r=   rÈ   q  s    znumpy_logspace.<locals>.impl)r"  )rƒ   r   rî  r   rÉ   r©   r…   )r  re  r%  rÈ   r<   r<   r=   Únumpy_logspaceh  s    



r&  r?   c                 C   sR   t |ttjfƒst d¡‚t | tjƒs0t d¡‚| jdk rDt d¡‚ddd„}|S )	Nz*The second argument "k" must be an integerú)The first argument "arr" must be an arrayr  úInput must be >= 2-d.r?   c                 S   st   |d }|dkr| d d … S |dkr8t  t  | ¡dd¡S |dkrPt  t  | ¡¡S |dkrlt  t  | dd¡¡S t‚d S )Né   r   r?   r  é   )rÍ  ÚswapaxesÚfliplrÚflipudr†   )r…  rº   r<   r<   r=   rÈ   ƒ  s    znumpy_rot90.<locals>.impl)r?   )	rƒ   r©   r   r…   r   rÉ   r„   ra   ÚNumbaValueError)r…  rº   rÈ   r<   r<   r=   Únumpy_rot90x  s    




r/  c                 C   sÔ   |   tj¡}| ¡ }|   tj¡}	t |	||||||||	g¡}
t |j	|
d¡}||j
ƒ}t || d¡dd¡}t || d¡dd¡}||ƒ}t ||dd¡}t ||dd¡}|	dƒ}| ||||||||j|g¡}|S )a  
    Call into Numba_attempt_nocopy_reshape() for the given array type
    and instance, and the specified new shape.

    Return value is non-zero if successful, and the array pointed to
    by *newstrides* will be filled up with the computed results.
    Znumba_attempt_nocopy_reshaperW   r   r˜   )r¥   r   r|   r  Úintcr   ÚFunctionTyper	   Úget_or_insert_functionr4   ra   rZ   rY   Úcallr™   )rn   r7   r½   rà   ÚnewndÚnewshapeÚ
newstridesr9  Zll_intp_starZll_intcÚfntyÚfnÚndrW   r˜   Z
is_f_orderrÙ   r<   r<   r=   Ú_attempt_nocopy_reshape“  sD    	     ú
ÿ
 ÿ   þr:  c           	      C   s¦   d}d}t |ƒD ]&\}}|dk r.|d7 }|}q||9 }q|dkrR| |kr¢tdƒ‚nP|dkrš|dkrpd}| dk}n| | }| | dk}|s�tdƒ‚|||< ntdƒ‚d S )Nr   r?   z)total size of new array must be unchangedzmultiple negative shape values)rã  r¤   )	ZorigsizerW   Znum_neg_valueZ
known_sizer	  r“   Zneg_axÚinferredÚokr<   r<   r=   Únormalize_reshape_value·  s(    



r=  zarray.reshapec              	   C   s®  |j d }|j}|j d }|d }|  tj¡}t ||j¡}	t|ƒ| ||d ƒ}
t	 
||	¡}| ||¡ tj|jddd�}t|ƒ| |ƒ}|  tj|  |¡¡}t|| || ¡ ¡|  tj|j¡g|g|d d� |
j}|  |tt tjtj|¡|| ¡ g¡ |j}t	 
||	¡}t| |||
|||ƒ}| d|| d¡¡}| |¡� d}| j  |t!|f¡ W 5 Q R X t|ƒ| |ƒ}t||
j"| #|¡| #|¡|
j$|
j%|
j&d� | ¡ }t'| ||j|ƒS )	Nr   r?   r’   r  r  rp  zincompatible shape for arrayr  )(rÍ   rÏ   r¥   r   r|   r   r  r­   rj   r	   rK   rò   r„   rl   r«   rm   r¼   rŸ  r  rž   r  r=  r   r    r  r}   rÕ   r:  rs  r3   rî   r)  r*  rF   r‡   r8   r™   r—   rš   r   )rn   r7   rO   rÍ   r½   Úrettyrü  rW   r9  Zll_shaperà   r5  Zshape_ary_tyÚ	shape_aryZshape_itemsizer€   r4  r6  r<  Úfailrµ   rÇ  rÙ   r<   r<   r=   Úarray_reshapeÕ  sd    

ÿû ÿ
ý ÿúrA  c                 C   s    t | |||ƒ\}}t| |||ƒS r  )rÿ  rA  r  r<   r<   r=   Úarray_reshape_vararg  s    rB  c                 C   s   dd„ }|S )Nc                 S   s
   |   |¡S r  )Úreshape)r  rW   r<   r<   r=   Únp_reshape_impl  s    z#np_reshape.<locals>.np_reshape_implr<   )r  rW   rD  r<   r<   r=   Ú
np_reshape  s    rE  c                 C   s\   t | ƒst d¡‚t |ƒs$t d¡‚t|ƒr8ddd„}n t|tjƒsNt d¡‚ddd„}|S )	Nz+The first argument "arr" must be array-likez/The second argument "values" must be array-likec                 S   s.   t  t  | ¡¡} t  t  |¡¡}t  | |f¡S r  )rÍ  ÚravelrÎ  Úconcatenate©r…  ÚvaluesrÃ   r<   r<   r=   rÈ   .  s    znp_append.<locals>.implz,The third argument "axis" must be an integerc                 S   s   t j| |f|d�S ©N©rÃ   ©rÍ  rG  rH  r<   r<   r=   rÈ   8  s    )N)N)r   r   rÉ   r   rƒ   r   r…   )r…  rI  rÃ   rÈ   r<   r<   r=   Ú	np_append#  s    



rM  zarray.ravelc                 C   sN   dd„ }dd„ }|j d jdkr&|}n|}|  ||||¡}t| ||j|ƒ}|S )Nc                 S   s   |   | j¡S )zNo copy version)rC  r€   ©rà   r<   r<   r=   Ú
imp_nocopy@  s    zarray_ravel.<locals>.imp_nocopyc                 S   s   |   ¡ S )zCopy version)ÚflattenrN  r<   r<   r=   Úimp_copyD  s    zarray_ravel.<locals>.imp_copyr   r’   )rÍ   r~  r  r   rÏ   )rn   r7   rO   rÍ   rO  rQ  ÚimprÙ   r<   r<   r=   Úarray_ravel=  s    rS  c                 C   s   dd„ }|   ||||¡S )Nc                 S   s   |   ¡ S r  )rF  ©r  r<   r<   r=   Únp_ravel_implV  s    znp_ravel.<locals>.np_ravel_impl)r  )rn   r7   rO   rÍ   rU  r<   r<   r=   Únp_ravelT  s    rV  zarray.flattenc                 C   s,   dd„ }|   ||||¡}t| ||j|ƒ}|S )Nc                 S   s   |   ¡  | j¡S r  )rÀ  rC  r€   rN  r<   r<   r=   rR  _  s    zarray_flatten.<locals>.imp)r  r   rÏ   )rn   r7   rO   rÍ   rR  rÙ   r<   r<   r=   Úarray_flatten\  s    rW  c                 C   sl   |d krt  | ¡n|}t  | ||¡\}}}t  |j¡D ]0}|| }	|| }
|| }tt|	|
ƒ|ƒ||< q6|S r  )rÍ  Ú
empty_likeÚbroadcast_arraysÚndindexrW   Úminrè  )r  Úa_minÚa_maxrÚ   rÇ  Úa_bÚa_min_bÚa_max_brÑ   Úval_aZ	val_a_minZ	val_a_maxr<   r<   r=   Ú_np_clip_implg  s    rb  c                 C   sH   t  | j¡D ]6}| | }|| }|r4t||ƒ||< qt||ƒ||< q|S r  )rÍ  rZ  rW   r[  rè  )r  ÚbZuse_minrÚ   rÑ   ra  Zval_br<   r<   r=   Ú_np_clip_impl_noneu  s    rd  c                 C   sv  t | ƒst d¡‚t|tjƒs0t |ƒs0t d¡‚t|tjƒsNt |ƒsNt d¡‚t|tjƒspt|ƒspd}t |¡‚|d kp‚t|tjƒ}|d kp–t|tjƒ}|r®|r®ddd„}|S t|tjƒ}t|tjƒ}	|rÜ|	rÜddd„}
|
S |�r|	�s|� rüdd	d
„}|S ddd„}|S nf|�s<|	�r<|�r,ddd„}|S ddd„}|S n6|�rPddd„}|S |�rdddd„}|S ddd„}|S d S ) Nú#The argument "a" must be array-likez6The argument "a_min" must be a number or an array-likez6The argument "a_max" must be a number or an array-likez5The argument "out" must be an array if it is providedc                 S   s   t dƒ‚d S )Nz&array_clip: must set either max or minrÆ   ©r  r\  r]  rÚ   r<   r<   r=   Ú
np_clip_nnš  s    znp_clip.<locals>.np_clip_nnc                 S   sH   |d krt  | ¡n|}t  | j¡D ] }| | }tt||ƒ|ƒ||< q"|S r  )rÍ  rX  rZ  rW   r[  rè  ©r  r\  r]  rÚ   rÇ  rÑ   ra  r<   r<   r=   Ú
np_clip_ss£  s
    znp_clip.<locals>.np_clip_ssc                 S   sB   |d krt  | ¡n|}t  | j¡D ]}| | }t||ƒ||< q"|S r  )rÍ  rX  rZ  rW   rè  rh  r<   r<   r=   Ú
np_clip_sn±  s
    znp_clip.<locals>.np_clip_snc                 S   s   t  | |¡}t| |||ƒS r  ©rÍ  Ú	full_likerb  )r  r\  r]  rÚ   Z
a_min_fullr<   r<   r=   Ú
np_clip_sa¾  s    znp_clip.<locals>.np_clip_sac                 S   sB   |d krt  | ¡n|}t  | j¡D ]}| | }t||ƒ||< q"|S r  )rÍ  rX  rZ  rW   r[  rh  r<   r<   r=   Ú
np_clip_nsÉ  s
    znp_clip.<locals>.np_clip_nsc                 S   s   t  | |¡}t| |||ƒS r  rk  )r  r\  r]  rÚ   Z
a_max_fullr<   r<   r=   Ú
np_clip_asÖ  s    znp_clip.<locals>.np_clip_asc                 S   s4   |d krt  | ¡n|}t  | |¡\}}t||d|ƒS )NT©rÍ  rX  rY  rd  )r  r\  r]  rÚ   rÇ  r^  r`  r<   r<   r=   Ú
np_clip_naâ  s    znp_clip.<locals>.np_clip_nac                 S   s4   |d krt  | ¡n|}t  | |¡\}}t||d|ƒS )NFrp  )r  r\  r]  rÚ   rÇ  r^  r_  r<   r<   r=   Ú
np_clip_anê  s    znp_clip.<locals>.np_clip_anc                 S   s   t | |||ƒS r  )rb  rf  r<   r<   r=   Ú
np_clip_aaò  s    znp_clip.<locals>.np_clip_aa)N)N)N)N)N)N)N)N)N)	r   r   rÉ   rƒ   r   ÚNoneTyper„   r   rî  )r  r\  r]  rÚ   rµ   Za_min_is_noneZa_max_is_nonerg  Za_min_is_scalarZa_max_is_scalarri  rj  rm  rn  ro  rq  rr  rs  r<   r<   r=   Únp_clip�  sV    
ÿ
ÿ










ru  Úclipc                 C   s   ddd„}|S )Nc                 S   s   t  | |||¡S r  )rÍ  rv  rf  r<   r<   r=   rÈ   ý  s    zarray_clip.<locals>.impl)NNNr<   )r  r\  r]  rÚ   rÈ   r<   r<   r=   Ú
array_clipû  s    
rw  c              	      sÔ  |j |j kst‚|j|jks t‚t|jƒ}tdƒ‰ tdƒ‰tdƒ‰tj‰‡ ‡‡‡fdd„}|  tjt| |ƒ¡}|  tjt| |ƒ¡}|  tj|j ¡}	t	 
|| d¡dd¡}
t	 
|| d¡dd¡}tjtjd	dd
�}|  |¡}t	 ||  tj|j ¡g¡}|  |  tj¡¡}|  tj|¡}t	 ||g¡}|| |ƒ}t||
|||dd� || |ƒ}t|||||dd� | ¡ }| ¡ }|	|||||  tj|¡g}ttjtj||tjtjtjƒ}|  ||||¡}t||ƒ t| ||j|ƒ}|S )a  
    Attempt to fix up *ary* for switching from *oldty* to *newty*.

    See Numpy's array_descr_set()
    (np/core/src/multiarray/getset.c).
    Attempt to fix the array's shape and strides for a new dtype.
    False is returned on failure, True on success.
    r¾  r’   ÚFc           	         sÜ   |ˆ kr2|d |krˆˆƒ}n|d |kr2ˆˆƒ}||krN|ˆ ksJ| dkrNdS |ˆkr`| d }nd}||k rž|| dkr|dS || }||  |9  < |||< n:||krØ|| | }|| dkrÂdS || ||< |||< n dS )Nr!  r   Fr?   Tr<   )	r9  r^   r˜   Úold_itemsizeÚnew_itemsizer~  r_   ÚnewdimZ
bytelength©Z
any_layoutZc_layoutZf_layoutÚint8r<   r=   rR  	  s.    



z_change_dtype.<locals>.imprW   r   r˜   r?   r  Nr  )ra   r†   r~  Úordr   r}  r«   r|   rp   r	   rZ   rY   r„   rj   r\   rm   rk   r¼   rÕ   r    Úbooleanr  r¾   r   rÏ   )rn   r7   ÚoldtyÚnewtyrà   Z
new_layoutrR  ry  rz  r9  Z
shape_dataZstrides_dataZshape_strides_array_typeÚaryclsZshape_constantÚsizeof_intpZstrides_constantr?  Zstrides_aryrW   r˜   rÍ   rO   rÙ   r<   r|  r=   Ú_change_dtype	  s†    	
0ÿÿ ÿ  ÿ
ÿÿ
û
û
ÿú	
r„  c                 C   s   t | ƒst d¡‚dd„ }|S )Nz+The argument to np.shape must be array-likec                 S   s   t  | ¡jS r  )rÍ  rÎ  rW   rT  r<   r<   r=   rÈ   …	  s    znp_shape.<locals>.impl©r   r   rÉ   ©r  rÈ   r<   r<   r=   Únp_shape€	  s    
r‡  c                 C   s   dd„ }|S )Nc                    sJ   t  |  ¡ ¡‰ tˆ d d… ƒ}‡ fdd„tˆ dd … ƒD ƒ}t  || ¡S )Nr?   c                    s    g | ]\}}ˆ | |kr|‘qS r<   r<   )rŠ   r_   r·  ©rc  r<   r=   rŒ   ‘	  s      z5np_unique.<locals>.np_unique_impl.<locals>.<listcomp>)rÍ  ÚsortrF  r¨   rã  r³   )r  ÚheadÚtailr<   rˆ  r=   Únp_unique_implŽ	  s    z!np_unique.<locals>.np_unique_implr<   )r  rŒ  r<   r<   r=   Ú	np_uniqueŒ	  s    r�  c                 C   sh   dd„ }t | tjtjtjtjtjfƒrdt |tjƒr6tS t |tjtjfƒrZt |j	tjƒrZ|S t
 d¡‚d S )Nc           	      S   sÂ   t j|t jd�}|jd dkr,t| |d ƒS t  |dk ¡rBtdƒ‚t  | ¡}| ¡ }|jd }|j|jkrrtdƒ‚t jt  	|¡|j
d�}d}t|ƒD ](}|| |||||  …< ||| 7 }q”|S )N©rl   r   r?   rÙ  z(operands could not be broadcast together)rÍ  rÎ  Úint64rW   Únp_repeat_impl_repeats_scalerr  r¤   rF  Úemptyrm  rl   r2   )	r  ÚrepeatsZrepeats_arrayÚasaÚaravelÚnÚ	to_returnÚposr_   r<   r<   r=   Ú!np_repeat_impl_repeats_array_like›	  s$    

ÿz4np_repeat.<locals>.np_repeat_impl_repeats_array_likezIThe repeats argument must be an integer or an array-like of integer dtype)rƒ   r   r„   ÚListr  rî  rh  r…   r�  rl   r   rÉ   )r  r’  r˜  r<   r<   r=   Ú	np_repeat–	  s    üÿrš  c                 C   sœ   |dk rt dƒ‚t | ¡}| ¡ }|jd }|dkrDtjd|jd�S |dkrVt |¡S tj|| |jd�}t|ƒD ] }|| ||| |d | …< qr|S d S )Nr   rÙ  rŽ  r?   )	r¤   rÍ  rÎ  rF  rW   r‘  rl   rÀ  r2   )r  r’  r“  r”  r•  r–  r_   r<   r<   r=   r�  Ã	  s    


r�  Úrepeatc                 C   s   dd„ }|S )Nc                 S   s   t  | |¡S r  )rÍ  r›  )r  r’  r<   r<   r=   Úarray_repeat_impl×	  s    z'array_repeat.<locals>.array_repeat_implr<   )r  r’  rœ  r<   r<   r=   Úarray_repeatÕ	  s    r�  c                 C   s   t  |¡}dd„ }||fS )z"Computes the itemsize of the dtypec                 S   s,   |   |jd j¡}|   |j¡}||  |¡ƒS rÅ   )rk   rÍ   rl   rÏ   rm   )Úcgctxr7   rO   Úllargsro   Úllintpr<   r<   r=   rÅ  â	  s    z%_intrin_get_itemsize.<locals>.codegen)r   r|   )Útyctxrl   rO   rÅ  r<   r<   r=   Ú_intrin_get_itemsizeÝ	  s    
r¢  c                 C   s   d S r  r<   )r  rl   r<   r<   r=   Ú_compatible_viewé	  s    r£  Úgeneric)Útargetc                 C   s   dd„ }|S )zDDetermines if the array and dtype are compatible for forming a view.c                 S   sÎ   t |ƒ}|| jkrÊ| jdkr*d}t|ƒ‚n | jd }| j| dk}| jdk}| j| | jk}|rt|rt|rtd}t|ƒ‚|| jk r¢|dks”| j| dkrÊd}	t|	ƒ‚n(| j| | j }
|
| dkrÊd}t|ƒ‚d S )Nr   zOChanging the dtype of a 0d array is only supported if the itemsize is unchangedr?   zJTo change to a dtype of a different size, the last axis must be contiguouszZWhen changing to a smaller dtype, its size must be a divisor of the size of original dtypezuWhen changing to a larger dtype, its size must be a divisor of the total size in bytes of the last axis of the array.)r¢  r™   ra   r¤   rW   r€   r˜   )r  rl   Z
dtype_sizeZmsg1rÃ   Úp1Úp2Úp3Zmsg2Zmsg3r{  Zmsg4r<   r<   r=   rÈ   ó	  s(    






z ol_compatible_view.<locals>.implr<   ©r  rl   rÈ   r<   r<   r=   Úol_compatible_viewí	  s    #rª  z
array.viewc              	   C   s,  |j d }|j}t|ƒ| ||d ƒ}t|ƒ| |ƒ}t|jjƒ}t|ƒD ]:}	t||	ƒ}
|	dkrt|jj	}| 
|
|¡|_qFt||	|
ƒ qFtdkrÂ| j}| t¡}| ||j ˜i ¡}|  ||¡}|||ƒ t| ||||ƒ}| d|t|j	dƒ¡}| |¡� d}| j |t|f¡ W 5 Q R X | ¡ }t| ||j|ƒS )Nr   r‡   )r?   é   rp  z"new type not compatible with array)rÍ   rÏ   rj   r¡   rŸ   r¢   ÚsortedÚgetattrr‡   r3   rŸ  r²   r   Útyping_contextÚresolve_value_typer£  Úget_call_typerE   r„  rs  r   rî   r)  r*  r¤   rÕ   r   )rn   r7   rO   rÍ   r½   r>  rà   rÇ  Úfieldsrº   rx   r˜  r¡  r7  Z_compatible_view_sigrÈ   r<  r@  rµ   rÙ   r<   r<   r=   Ú
array_view
  s0    



r²  rl   c                 C   s   |   ¡ }t| |||ƒS r  )r,  r   ©rn   r7   rÓ  rê   rÙ   r<   r<   r=   Úarray_dtypeD
  s    r´  rW   c                 C   s(   t |ƒ}|| ||ƒ}|j}t| |||ƒS r  )rj   rW   r   ©rn   r7   rÓ  rê   ru   r³   rÙ   r<   r<   r=   Úarray_shapeJ
  s    r¶  r˜   c                 C   s(   t |ƒ}|| ||ƒ}|j}t| |||ƒS r  )rj   r˜   r   rµ  r<   r<   r=   Úarray_stridesS
  s    r·  ra   c                 C   s   |   tj|j¡}t| |||ƒS r  )r«   r   r|   ra   r   r³  r<   r<   r=   Ú
array_ndim\
  s    r¸  r€   c                 C   s(   t |ƒ}|| ||ƒ}|j}t| |||ƒS r  )rj   rž   r   rµ  r<   r<   r=   Ú
array_sizec
  s    r¹  r™   c                 C   s(   t |ƒ}|| ||ƒ}|j}t| |||ƒS r  )rj   r™   r   rµ  r<   r<   r=   Úarray_itemsizek
  s    rº  Únbytesc                 C   s2   t |ƒ}|| ||ƒ}| |j|j¡}t| |||ƒS )z"
    nbytes = size * itemsize
    )rj   r®   rž   r™   r   rµ  r<   r<   r=   Úarray_nbytest
  s    r¼  Ú
contiguousc                 C   s   |   tj|j¡}t| |||ƒS r  )r«   r   r  Ú	is_contigr   r³  r<   r<   r=   Úarray_contiguous€
  s    r¿  Úc_contiguousc                 C   s   |   tj|j¡}t| |||ƒS r  )r«   r   r  Úis_c_contigr   r³  r<   r<   r=   Úarray_c_contiguous†
  s    rÂ  Úf_contiguousc                 C   s   |   tj|j¡}t| |||ƒS r  )r«   r   r  Úis_f_contigr   r³  r<   r<   r=   Úarray_f_contiguousŒ
  s    rÅ  rÃ  c                 C   s    |   tj|j ¡}t| |||ƒS r  )r«   r   r  Úmutabler   r³  r<   r<   r=   Úarray_readonly’
  s    rÇ  Úctypesc           	      C   sP   t |ƒ}|| ||ƒ}t |¡}|  ||¡}|j|_|j|_| ¡ }t| |||ƒS r  )rj   r   ÚArrayCTypesrÎ   r‡   r—   rÕ   r   )	rn   r7   rÓ  rê   ru   r³   ZactÚctinforÙ   r<   r<   r=   Úarray_ctypesš
  s    
rË  r‡   c                 C   s8   | j |||d�}|j}| ||  tj¡¡}t| |||ƒS ©Nré   )rÎ   r‡   r‡  r¥   r   r|   r   )rn   r7   rÓ  rê   rÊ  rÙ   r<   r<   r=   Úarray_ctypes_data§
  s    rÍ  c                 C   s6   | j |||d�}|j}| ||  |¡¡}t| |||ƒS rÌ  )rÎ   r‡   rŸ  r¥   r   )rn   r7   ÚfromtyÚtotyrx   rÊ  rÙ   r<   r<   r=   Úarray_ctypes_to_pointer°
  s    rÐ  c           
      C   sr   t |ƒ|||d�}t tj|j¡}| | |j¡¡}ttj	||tjƒ}|j
|j| tj|¡g}| || ||¡}	|	S )a)  Helper to invoke the contiguous checker function on an array

    Args
    ----
    checker :
        ``numba.numpy_supports.is_contiguous``, or
        ``numba.numpy_supports.is_fortran``.
    context : target context
    builder : llvm ir builder
    aryty : numba type
    ary : llvm value
    ré   )rj   r   rÕ  r|   ra   rm   r¥   rl   r    Úbool_rW   r˜   r«   r  )
Úcheckerrn   r7   r½   rà   Ztup_intpr™   Z	check_sigZ
check_argsr¾  r<   r<   r=   Ú_call_contiguous_check¹
  s    ÿ
ÿrÓ  r�   c                 C   s>   |   |t |¡¡}||_| ¡ }| j |||¡ t| |||ƒS r  )rÎ   r   Ú
ArrayFlagsrš   rÕ   rÓ   rÔ   r   )rn   r7   rÓ  rê   ÚflagsobjrÙ   r<   r<   r=   Úarray_flagsÓ
  s
    rÖ  c                 C   sZ   |j jdkr2| j|||d�}tt| ||j |jƒ}n|j jdk}|  tj|¡}t	| |||ƒS )Nr’   ré   )
rU   r~  rÎ   rÓ  r   rš   r«   r   r  r   )rn   r7   rÓ  rê   rÕ  rÙ   rx   r<   r<   r=   Úarray_flags_c_contiguousÜ
  s     ÿr×  c                 C   sr   |j jdkr2| j|||d�}tt| ||j |jƒ}n2|j j}|j jdkrN|dkn|dk}|  tj	|¡}t
| |||ƒS )Nrx  ré   r?   rƒ  )rU   r~  rÎ   rÓ  r   rš   ra   r«   r   r  r   )rn   r7   rÓ  rê   rÕ  rÙ   r~  rx   r<   r<   r=   Úarray_flags_f_contiguousê
  s     ÿrØ  Úrealc                 C   sL   |j tjkrt| |||dd�S |j tjkr8t| |||ƒS td tj ¡ƒ‚d S )NrÙ  ©Úattrzunsupported .real for {})	rl   r   Úcomplex_domainÚarray_complex_attrÚnumber_domainr   rF   r°   r3   )rn   r7   rÓ  rê   r<   r<   r=   Úarray_real_partû
  s
    rß  Úimagc                 C   s¤   |j tjkrt| |||dd�S |j tjkr�t|jdd�|ƒ}t| |||gƒ\}}t| |||ƒ}t	 
||j| |j|j¡d¡ t| ||j| ¡ ƒS td tj ¡ƒ‚d S )Nrà  rÚ  TrÉ  r   zunsupported .imag for {})rl   r   rÜ  rÝ  rÞ  r    rÀ  Ú_parse_empty_like_argsr|  r	   Úmemsetr‡   r®   r™   rž   r   rÏ   rÕ   rF   r°   r3   )rn   r7   rÓ  rê   rO   rÁ  rá   rà   r<   r<   r=   Úarray_imag_part  s    ÿÿ
ÿrã  c                 C   sÞ   |dks|j tjkr"td |¡ƒ‚t|ƒ}|| ||ƒ}|j j}|  |  |¡¡}|j	 
|¡}	|  |¡ ¡ }
| |j|
¡}|dkr–| |t d¡dƒg¡}|j|dd�}t|ƒ| |ƒ}t||	d�}t |||¡ t| ||| ¡ ƒS )	a¼  
    Given a complex array, it's memory layout is:

        R C R C R C
        ^   ^   ^

    (`R` indicates a float for the real part;
     `C` indicates a float for the imaginary part;
     the `^` indicates the start of each element)

    To get the real part, we can simply change the dtype and itemsize to that
    of the underlying float type.  The new layout is:

        R x R x R x
        ^   ^   ^

    (`x` indicates unused)

    A load operation will use the dtype to determine the number of bytes to
    load.

    To get the imaginary part, we shift the pointer by 1 float offset and
    change the dtype and itemsize.  The new layout is:

        x C x C x C
          ^   ^   ^
    )rÙ  rà  zcannot get attribute `{}`rà  é    r?   r¾  ©rl   r~  )r‡   r™   )rl   r   rÜ  rF   r°   rj   Úunderlying_floatrm   rk   r™   r3   r¥   r  rŸ  r‡   r  r   ÚIntTyperÀ  rª   r	   Úcopy_structr   rÕ   )rn   r7   rÓ  rê   rÛ  ru   r³   ZfltyZsizeof_fltyr™   Z
llfltptrtyrã   Zresulttyró   Úreplr<   r<   r=   rÝ    s     rÝ  ÚconjÚ	conjugatec                 C   s   dd„ }|S )Nc                 S   s
   t  | ¡S r  )rÍ  rê  ©r…  r<   r<   r=   rÈ   Q  s    zarray_conj.<locals>.implr<   ©r…  rÈ   r<   r<   r=   Ú
array_conjN  s    rî  c                 C   s   |   ¡ S r  )r,  )rn   r7   ZdtypetyZdtypevalr<   r<   r=   Ú
dtype_typeY  s    rï  r3   ÚkindÚstatic_getitemc                 C   s@   |j }t|tjƒr.|  |¡dƒ}t| |||ƒS d}t |¡‚dS )zåThis handles the "static_getitem" when a Numba type is subscripted e.g:
    var = typed.List.empty_list(float64[::1, :])
    It only allows this on simple numerical types. Compound types, like
    records, are not supported.
    NzlUnreachable; the definition of __getitem__ on the numba.types.abstract.Type metaclass should prevent access.)rÏ   rƒ   r   r„   r¥   r   r   ÚLoweringError)rn   r7   rO   rÍ   r>  rÙ   rµ   r<   r<   r=   Ústatic_getitem_number_clazzf  s    ró  c              	      s„  t |ƒ}|ˆ ||ƒ}|j}t|tjƒs6td||f ƒ‚| |¡}| |¡}	t|tjƒrr|j	|j|j
|j
 dd�}
n|j	|dd�}
t |
ƒ}|ˆ |ƒ}ˆ  tj|	¡}tj||j||jjd�}t|tjƒ�r.t ||j|j
¡}|‡ fdd„|jD ƒ7 }t ||j|j
¡}|‡ fdd„|jD ƒ7 }ˆ  ˆ  |j¡¡}n|j}|j}ˆ  ˆ  |¡¡}t||||ˆ  tj|¡|j|jd	� | ¡ }tˆ ||
|ƒS )
zq
    Generic getattr() implementation for record arrays: fetch the given
    record member, i.e. a subarray.
    zattribute %r of %s not definedr¾  r  rå  )rÏ   c                    s   g | ]}ˆ   tj|¡‘qS r<   ©r«   r   r|   rk  ©rn   r<   r=   rŒ      s     z(array_record_getattr.<locals>.<listcomp>c                    s   g | ]}ˆ   tj|¡‘qS r<   rô  rk  rõ  r<   r=   rŒ   £  s     r  )rj   rl   rƒ   r   ÚRecordrF   Útypeofrâ   ÚNestedArrayrÀ  ra   r«   r|   r	   rÝ   r‡   r3   r¬   rW   r˜   rm   rk   r¼   r—   rš   rÕ   r   )rn   r7   rÓ  rê   rÛ  ru   r³   Zrectyperl   râ   ÚrestyZrarytyZraryZconstoffsetZ
newdataptrrW   r˜   ZdatasizerÙ   r<   rõ  r=   Úarray_record_getattr~  sX    ÿ

 
 ÿ
   ÿúrú  c                 C   s0   |d }t |tƒst‚t| ||jd |d |ƒS rR  )rƒ   ÚstrrF   rú  rÍ   )rn   r7   rO   rÍ   rÑ   r<   r<   r=   Úarray_record_getitem¶  s    
rü  c              	      s  ˆ   ||¡ | |¡}| |¡}t|tjƒrÊt|ƒ}|ˆ |ƒ}|j}	‡ fdd„|jD ƒ}
‡ fdd„|j	D ƒ}t
 |||ˆ  |	¡¡}t||t
 ||
¡t
 ||¡ˆ  tj|j¡ddd� | ¡ }tˆ |||ƒS t
 |||ˆ  |¡¡}|jrêdnd}ˆ  ||||¡}tˆ |||ƒS dS )zT
    Generic getattr() implementation for records: get the given record member.
    c                    s   g | ]}ˆ   tj|¡‘qS r<   rô  ©rŠ   r“   rõ  r<   r=   rŒ   Î  s     z"record_getattr.<locals>.<listcomp>c                    s   g | ]}ˆ   tj|¡‘qS r<   rô  rý  rõ  r<   r=   rŒ   Ð  s     Nr  r?   )Úsentry_record_alignmentrâ   r÷  rƒ   r   rø  rj   rl   rW   r˜   r	   Úget_record_memberrk   r¼   r\   r«   r|   r€   rÕ   r   rs   rt   )rn   r7   rÓ  rê   rÛ  râ   Úelemtyr½   rà   rl   r5  r6  ÚnewdatarÙ   Údptrrr   r<   rõ  r=   Úrecord_getattr¿  sB    



ÿ
ÿ
ÿ

ù	
ÿr  c              	   C   sÚ   |j \}}|\}}|  ||¡ | |¡}	| |¡}
t|
tjƒrŽt |¡| ||d d�}|j	}t 
|||	|jj¡}t ||||  tj|
j¡¡ nHt 
|||	|  |
¡¡}|  ||||
¡}|jr¾dnd}| j||
|||d� dS )zT
    Generic setattr() implementation for records: set the given record member.
    r?   ré   Nrq   )rÍ   rþ  râ   r÷  rƒ   r   rø  r	   ri   r‡   rÿ  r3   ÚpointeeÚmemcpyr«   r|   rž   rk   r{   rs   rw   )rn   r7   rO   rÍ   rÛ  rÓ  r"  r¥  rx   râ   r   Z
val_structr¦  rÄ  r  rr   r<   r<   r=   Úrecord_setattrç  s,    


ÿ
ÿ
ÿ
ÿr  c                 C   s4   |   |jd |d ¡}|| ||jd |d |d ƒS )ú3
    Record.__getitem__ redirects to getattr()
    r   r?   )Úget_getattrrÍ   )rn   r7   rO   rÍ   rÈ   r<   r<   r=   Úrecord_static_getitem_str  s    r	  c                 C   s^   |j d j}t|j d jƒ}|  |j|| ¡}|  |j d |¡}|| ||j d |d || ƒS )r  r?   r   )rÍ   rÊ   r¨   r±  Úinsert_const_stringr4   r  )rn   r7   rO   rÍ   r   r±  Zll_fieldrÈ   r<   r<   r=   Úrecord_static_getitem_int  s
    r  Ústatic_setitemc                 C   sJ   |j \}}}|\}}}	t|j||ƒ}
|  ||
¡}|dk	s<t‚||||	fƒS )ú3
    Record.__setitem__ redirects to setattr()
    N)rÍ   r    rÏ   Úget_setattrr†   )rn   r7   rO   rÍ   Úrectyr€  r"  Úrecr   rx   Úgetattr_sigrÈ   r<   r<   r=   Úrecord_static_setitem_str  s    
r  c                 C   s^   |j \}}}|\}}}	t|j||ƒ}
t|j d jƒ}|  || |
¡}|dk	sPt‚||||	fƒS )r  r   N)rÍ   r    rÏ   r¨   r±  r  r†   )rn   r7   rO   rÍ   r  r€  r"  r  r   rx   r  r±  rÈ   r<   r<   r=   Úrecord_static_setitem_int'  s    
r  c                 C   s   |   |||¡S )zB
    Create a constant array (mechanism is target-dependent).
    )Úmake_constant_array)rn   r7   r  Úpyvalr<   r<   r=   Úconstant_array9  s    r  c                 C   s0   t  t  d¡|j¡}|t| ¡ ƒƒ}t ||¡S )zG
    Create a record constant as a stack-allocated array of bytes.
    é   )r   r  rç  r»  Ú	bytearrayÚtostringr	   rÐ   )rn   r7   r  r  Últyrx   r<   r<   r=   Úconstant_recordA  s    r  c                 C   s"   t jt|ƒt jd�}|  |||¡S )zM
    Create a constant array from bytes (mechanism is target-dependent).
    rŽ  )rÍ  r³   r  Úuint8r  )rn   r7   r  r  Úbufr<   r<   r=   Úconstant_bytesK  s    r  c                 C   s0   |j \}}||krtjS dd„ }|  ||||¡S )Nc                 S   s(   | j |j ko&| j|jko&| jj|jjkS r  )rW   r˜   rÈ  r‡   ©r  rc  r<   r<   r=   Úarray_is_impl]  s
    
ÿþzarray_is.<locals>.array_is_impl)rÍ   r	   rq  r  )rn   r7   rO   rÍ   ÚatyÚbtyr   r<   r<   r=   Úarray_isW  s
    
r#  Ú__hash__c                 C   s   dd„ S )Nc                 S   s   d S r  r<   rì  r<   r<   r=   rß  j  rà  zol_array_hash.<locals>.<lambda>r<   rì  r<   r<   r=   Úol_array_hashh  s    r%  c                 C   s
   t | dƒS )zq
    Return the Structure representation of the given *flatiterty* (an
    instance of types.NumpyFlatType).
    Úflat©Ú_make_flattening_iter_cls)Ú
flatitertyr<   r<   r=   Úmake_array_flat_clsp  s    r*  c                 C   s
   t | dƒS )zv
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdEnumerateType).
    Úndenumerater'  ©Únditertyr<   r<   r=   Úmake_array_ndenumerate_clsx  s    r.  c              
   C   sþ   |   tjd¡}| d¡}	|d k	r.| tj|¡ tt|ƒƒD ]”}
t 	|||
¡}t 
|| |¡¡}||
 }| d||¡}t ||¡�, | ||¡ |d k	rž||
ƒ | |	¡ W 5 Q R X | ||¡ |d k	r:||
ƒ q:|d k	ræ| tj|¡ | |	¡ | |	¡ d S )Nr   Zend_incrementrë   )r«   r   r|   r;  rò   r	   Ú
false_byterz  r2   rZ   rñ   r8   rì   Ú	if_likelyrC  Ú	true_byterD  )rn   r7   ra   rW   r�   Úend_flagÚloop_continueÚ
loop_breakr×   Úbbendr8  Úidxptrr   r­   Ú	in_boundsr<   r<   r=   Ú_increment_indices€  s*    


r8  c                 C   s*   t  ||j|j¡}t| ||j|||ƒ d S r  )r	   r¬   rW   ra   r8  )rn   r7   r„  r…  r�   r2  rW   r<   r<   r=   Ú_increment_indices_array¡  s    r9  c                    s¸   ˆj ‰ˆj‰tˆjƒ‰ˆjr ˆnd‰	G dd„ dtƒ}G dd„ d|ƒ‰ G ‡fdd„d|ƒ‰G dd	„ d	|ƒ‰G d
d„ d|ƒ‰G dd„ d|ƒ‰G ‡ ‡‡‡‡‡‡‡‡‡	f
dd„dt ˆ¡ƒ}|S )zq
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdIterType).
    r?   c                   @   sF   e Zd ZdZdd„ Zdd„ Zejdd„ ƒZdd	„ Z	d
d„ Z
dd„ ZdS )z$make_nditer_cls.<locals>.BaseSubIterzF
        Base class for sub-iterators of a nditer() instance.
        c                 S   s&   || _ || _|| _|| _|| | _d S r  )ÚnditerÚmember_nameÚ	start_dimÚend_dimra   )rM   r:  r;  r<  r=  r<   r<   r=   r:  ¶  s
    z-make_nditer_cls.<locals>.BaseSubIter.__init__c                 S   s   t | j| j|ƒ d S r  )r²   r:  r;  )rM   r]   r<   r<   r=   Úset_member_ptr½  s    z3make_nditer_cls.<locals>.BaseSubIter.set_member_ptrc                 S   s   t | j| jƒS r  )r­  r:  r;  r/  r<   r<   r=   Ú
member_ptrÀ  s    z/make_nditer_cls.<locals>.BaseSubIter.member_ptrc                 S   s   d S r  r<   ©rM   rn   r7   r<   r<   r=   Úinit_specificÄ  s    z2make_nditer_cls.<locals>.BaseSubIter.init_specificc                 S   s   d S r  r<   ©rM   rn   r7   Úlogical_dimr<   r<   r=   r3  Ç  s    z2make_nditer_cls.<locals>.BaseSubIter.loop_continuec                 S   s   d S r  r<   rB  r<   r<   r=   r4  Ê  s    z/make_nditer_cls.<locals>.BaseSubIter.loop_breakN)rb   rc   rd   r6  r:  r>  r­  Úcached_propertyr?  rA  r3  r4  r<   r<   r<   r=   ÚBaseSubIter±  s   
rE  c                   @   s0   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
S )z$make_nditer_cls.<locals>.FlatSubIterzŸ
        Sub-iterator walking a contiguous array in physical order, with
        support for broadcasting (the index is reset on the outer dimension).
        c                 S   s$   |  tjd¡}|  t ||¡¡ d S rÅ   )r«   r   r|   r>  r	   rÐ   )rM   rn   r7   r×   r<   r<   r=   rA  Ó  s    z2make_nditer_cls.<locals>.FlatSubIter.init_specificc                 S   s   |  | j¡}| |j|g¡S r  )r8   r?  r  r‡   )rM   rn   r7   r�   r„  r…  rÑ   r<   r<   r=   Úcompute_pointer×  s    z4make_nditer_cls.<locals>.FlatSubIter.compute_pointerc                 S   s8   || j d kr4| | j¡}t ||¡}| || j¡ d S rJ  )ra   r8   r?  r	   rñ   rò   )rM   rn   r7   rC  rÑ   r<   r<   r=   r3  Û  s    z2make_nditer_cls.<locals>.FlatSubIter.loop_continuec                 S   s^   |dkr&|  tjd¡}| || j¡ n4|| jd krZ| | j¡}t ||¡}| || j¡ d S ©Nr   r?   )	r«   r   r|   rò   r?  ra   r8   r	   rñ   )rM   rn   r7   rC  r×   rÑ   r<   r<   r=   r4  â  s    z/make_nditer_cls.<locals>.FlatSubIter.loop_breakN)rb   rc   rd   r6  rA  rF  r3  r4  r<   r<   r<   r=   ÚFlatSubIterÍ  s
   rH  c                       s$   e Zd ZdZ‡ fdd„Zdd„ ZdS )z+make_nditer_cls.<locals>.TrivialFlatSubIterzx
        Sub-iterator walking a contiguous array in physical order,
        *without* support for broadcasting.
        c                    s   ˆ j r
t‚d S r  )Úneed_shaped_indexingr†   r@  r,  r<   r=   rA  ó  s    z9make_nditer_cls.<locals>.TrivialFlatSubIter.init_specificc                 S   s&   t |ƒdkstt |ƒƒ‚| |j|¡S rJ  )r�   r†   r  r‡   ©rM   rn   r7   r�   r„  r…  r<   r<   r=   rF  ö  s    z;make_nditer_cls.<locals>.TrivialFlatSubIter.compute_pointerN)rb   rc   rd   r6  rA  rF  r<   r,  r<   r=   ÚTrivialFlatSubIterí  s   rK  c                   @   s   e Zd ZdZdd„ ZdS )z'make_nditer_cls.<locals>.IndexedSubIterzA
        Sub-iterator walking an array in logical order.
        c                 S   s(   t |ƒ| jkst‚tj|||||dd�S ©NFr�  )r�   ra   r†   r	   r  rJ  r<   r<   r=   rF  ÿ  s
     ÿz7make_nditer_cls.<locals>.IndexedSubIter.compute_pointerN©rb   rc   rd   r6  rF  r<   r<   r<   r=   ÚIndexedSubIterú  s   rN  c                   @   s   e Zd ZdZdd„ ZdS )z'make_nditer_cls.<locals>.ZeroDimSubIterz5
        Sub-iterator "walking" a 0-d array.
        c                 S   s   |j S r  r¡  rJ  r<   r<   r=   rF  	  s    z7make_nditer_cls.<locals>.ZeroDimSubIter.compute_pointerNrM  r<   r<   r<   r=   ÚZeroDimSubIter  s   rO  c                   @   s   e Zd ZdZdd„ ZdS )z&make_nditer_cls.<locals>.ScalarSubIterz8
        Sub-iterator "walking" a scalar value.
        c                 S   s   |S r  r<   rJ  r<   r<   r=   rF    s    z6make_nditer_cls.<locals>.ScalarSubIter.compute_pointerNrM  r<   r<   r<   r=   ÚScalarSubIter  s   rP  c                       s|   e Zd ZdZej‡ ‡‡‡‡‡fdd„ƒZ‡‡‡‡	fdd„Z‡fdd„Zdd	„ Z	d
d„ Z
‡‡‡‡	fdd„Zdd„ Zdd„ ZdS )zmake_nditer_cls.<locals>.NdIterz½
        .nditer() implementation.

        Note: 'F' layout means the shape is iterated in reverse logical order,
        so indices and shapes arrays have to be reversed as well.
        c                    sd   g }ˆj rˆ nˆˆˆˆdœ}tˆjƒD ]8\}}|\}}}}d| }	|| }
| |
| |	||ƒ¡ q&|S )N)r&  ÚindexedÚ0dÚscalarzindex%d)rI  rã  ri  r[   )rM   ÚlZ	factoriesr_   rt  rð  r<  r=  r€  r;  Úfactory)rH  rN  rP  rK  rO  r-  r<   r=   Úsubiters  s    
üz(make_nditer_cls.<locals>.NdIter.subitersc                    s@  |  tjd¡}| |t |¡|¡| _t|ƒD ]8\}}t|tjƒs,d| }t	 
||| ¡}	t| ||	ƒ q,|  ||||¡}t tjˆ¡}
d}d}t|ƒD ]6\}}t|tjƒr”|jˆkr”|| j}|| j} qôq”ˆdksØt‚| ||
d¡}|  tjd¡}dd„ }t||ƒD ]T\}}t|tjƒ�r|jdk�rttjt tj|j¡|
ƒ}| ||||j|f¡ �qt	 ||¡}ˆ dk�r€|ddd	… }| d
||¡}| |t	jt	j¡}ˆj�s®|f}t|ƒˆk�sÀt‚t	j||jˆd�}tˆƒD ] }t	  |||¡}| !||¡ �qÚ|| _"t	 #|||j¡| _t	 
||¡| _$| j%D ]}| &||¡ �q(dS )zY
            Initialize the nditer() instance for the specific array inputs.
            r   úscalar%dNr<   r?   c                 S   s>   t | ƒ}t|ƒD ](}| | |t |ƒ| |  krtdƒ‚qd S )Nz2nditer(): operands could not be broadcast together)r�   r2   r¤   )rW   Ú
main_shaper•  r_   r<   r<   r=   Úcheck_shapeO  s    zBmake_nditer_cls.<locals>.NdIter.init_specific.<locals>.check_shaperx  r!  rp  r?  )'r«   r   r|   Ú
make_tuplerÖ  Úarraysrã  rƒ   r„   r	   rÐ   r²   Ú_arrays_or_scalarsrÕ  ra   rW   rž   r†   rŽ   r    Únoner  r¬   rì   rd  r1  r/  rI  r�   rK   r3   r2   rZ   rò   r�   r\   Ú	exhaustedrV  rA  )rM   rn   r7   Úarrtysr[  r×   r_   r  r;  ÚslotZmain_shape_tyrX  Zmain_nitemsr„  rY  r…  rO   rá   Zshape_is_emptyr^  r�   r8  r6  Úsubiter)r~  ra   r-  Únshapesr<   r=   rA  ,  sf    ÿ

þ ÿ

ÿ
z-make_nditer_cls.<locals>.NdIter.init_specificc                    s*  |  d¡}t || | j¡¡}t ||¡� | d¡ | |¡ W 5 Q R X ˆ j}t 	|| j¡}|  
||||¡}| j}| d¡ |  |||||¡}	dd„ |	D ƒ}	t|	ƒdkrº| |	d ¡ n| | |ˆ j|	¡¡ t 	|| j¡}
t||t|
ƒ|
|| jt | j||¡t | j||¡ƒ | |¡ | |¡ dS )	zJ
            Compute next iteration of the nditer() instance.
            rˆ  FTc                 S   s   g | ]}|  ¡ ‘qS r<   r  ©rŠ   r»   r<   r<   r=   rŒ   �  s     zEmake_nditer_cls.<locals>.NdIter.iternext_specific.<locals>.<listcomp>r?   r   N)r;  r	   Úas_bool_bitr8   r^  Úif_unlikelyrí   rC  r[  r¬   r\  r�   Ú_make_viewsr�   rð   rZ  rï   rW   r8  r­  ÚpartialÚ_loop_continueÚ_loop_breakrD  )rM   rn   r7   ró   r5  r^  r_  r[  r�   ÚviewsrW   r,  r<   r=   Úiternext_specific{  sD    

ÿ

ÿ þþû

z1make_nditer_cls.<locals>.NdIter.iternext_specificc                 S   s@   | j D ]4}|j|  kr"|jk rn q| ||||j ¡ qd S r  )rV  r<  r=  r3  ©rM   rn   r7   r8  rt  r<   r<   r=   rh  ¥  s    
z.make_nditer_cls.<locals>.NdIter._loop_continuec                 S   s@   | j D ]4}|j|  kr"|jk rn q| ||||j ¡ qd S r  )rV  r<  r=  r4  rl  r<   r<   r=   ri  ª  s    
z+make_nditer_cls.<locals>.NdIter._loop_breakc                    sð   dgˆ }ˆj }| j}ˆj}	t|	tjƒr2t|	ƒ}	n|	g}	‡ ‡fdd„tˆƒD ƒ‰t||ƒD ]z\}
}|
\}}}}ˆ|j	|j
… }ˆdkr”|ddd… }|D ]:}|| dks¬t‚|  |ˆ ||	| || || |¡||< q˜qZtdd„ |D ƒƒsìt‚|S )z:
            Compute the views to be yielded.
            Nc              	      s    g | ]}ˆ   t ˆ ˆ|¡¡‘qS r<   ©r8   r	   rZ   rk  ©r7   r�   r<   r=   rŒ   »  s   ÿz?make_nditer_cls.<locals>.NdIter._make_views.<locals>.<listcomp>rx  r!  c                 s   s   | ]
}|V  qd S r  r<   rc  r<   r<   r=   r  È  s     z>make_nditer_cls.<locals>.NdIter._make_views.<locals>.<genexpr>)ri  rV  rï   rƒ   r   r  r¨   r2   rŽ   r<  r=  r†   Ú
_make_viewr×  )rM   rn   r7   r�   r_  r[  rj  ri  rV  Úrettysrt  ra  r€  Úarray_indicesZsub_indicesr_   )r~  Únarraysr-  rb  rn  r=   rf  ¯  s2    

ÿ
  þz+make_nditer_cls.<locals>.NdIter._make_viewsc                 S   sŽ   t |tjƒr|jdkst‚| |||||¡}| |¡||ƒ}	t||ƒ}
| |t 	tj
d¡d¡}| |t 	tj
d¡d¡}t|	||||
dd� |	S )zD
            Compute a 0d view for a given input array.
            r   r<   N)r—   )rƒ   r   r„   ra   r†   rF  rj   rp   rZ  rÕ  r|   r¼   )rM   rn   r7   r�   r>  r„  r…  ra  r]   Úviewr™   rW   r˜   r<   r<   r=   ro  Ë  s    
ÿÿz*make_nditer_cls.<locals>.NdIter._make_viewc           	      S   s`   g }t t||ƒƒD ]H\}\}}t|tjƒrF| | |¡|||d�¡ q| t| d| ƒ¡ q|S )Nré   rW  )rã  rŽ   rƒ   r   r„   r[   rj   r­  )	rM   rn   r7   r_  r[  rT  r_   r„  r…  r<   r<   r=   r\  ß  s    þ
z2make_nditer_cls.<locals>.NdIter._arrays_or_scalarsN)rb   rc   rd   r6  r­  rD  rV  rA  rk  rh  ri  rf  ro  r\  r<   ©
rH  rN  rP  rK  rO  r~  rr  ra   r-  rb  r<   r=   ÚNdIter  s   O*ru  )ra   r~  r�   r[  rI  Úobjectr	   ri   )r-  rE  ru  r<   rt  r=   Úmake_nditer_cls§  s    
 
, Yrw  c                    s$   | j ‰ G ‡ fdd„dt | ¡ƒ}|S )zr
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdIndexType).
    c                       s(   e Zd ZdZ‡ fdd„Z‡ fdd„ZdS )z%make_ndindex_cls.<locals>.NdIndexIterz,
        .ndindex() implementation.
        c              
      s¾   |  tjd¡}tj||j|  tjˆ ¡d�}t |tj¡}tˆ ƒD ]Z}t 	|||¡}| 
||¡ || }	| d|	|¡}
t ||
¡� | 
tj|¡ W 5 Q R X q@|| _|| _t |||j¡| _d S ©Nr   r?  rp  )r«   r   r|   r	   rK   r3   rÐ   r/  r2   rZ   rò   rs  re  r1  r�   r^  r\   rW   )rM   rn   r7   rá   r×   r�   r^  r8  r6  r^  Údim_is_empty©ra   r<   r=   rA  û  s"    
ÿÿz3make_ndindex_cls.<locals>.NdIndexIter.init_specificc           
   	      sâ   |  tjd¡}ˆ  d¡}t ˆ ˆ  ˆj¡¡}t ˆ |¡� | 	d¡ ˆ  
|¡ W 5 Q R X ‡ ‡fdd„tˆƒD ƒ}|D ]}tˆ |ƒ qt| t ˆ ||j¡¡ | 	d¡ t ˆ ˆjˆ¡}	t|ˆ ˆ|	ˆjˆjƒ ˆ  
|¡ ˆ  |¡ d S )Nr   rˆ  Fc              	      s"   g | ]}ˆ   t ˆ ˆj|¡¡‘qS r<   )r8   r	   rZ   r�   ©rŠ   r8  ©r7   rM   r<   r=   rŒ     s
   ý
þzKmake_ndindex_cls.<locals>.NdIndexIter.iternext_specific.<locals>.<listcomp>T)r«   r   r|   r;  r	   rd  r8   r^  re  rí   rC  r2   rA   rð   r\   r3   r¬   rW   r8  r�   rD  )
rM   rn   r7   ró   r×   r5  r^  r�   r8   rW   rz  r|  r=   rk    s,    

ÿ
ý

 ÿ
z7make_ndindex_cls.<locals>.NdIndexIter.iternext_specificN)rb   rc   rd   r6  rA  rk  r<   rz  r<   r=   ÚNdIndexIterö  s   r}  )ra   r	   ri   )r-  r}  r<   rz  r=   Úmake_ndindex_clsï  s    7r~  c                    s\   ˆ dkst ‚| j}|jdkr:G ‡ fdd„dt | ¡ƒ}|S G ‡ fdd„dt | ¡ƒ}|S d S )N)r&  r+  r’   c                       s8   e Zd ZdZ‡ fdd„Z‡ fdd„Zdd„ Zdd	„ Zd
S )z6_make_flattening_iter_cls.<locals>.CContiguousFlatIterzZ
            .flat() / .ndenumerate() implementation for C-contiguous arrays.
            c           	         s~   |  tjd¡}t ||¡| _|j| _ˆ dkrztj||j	|  tj|j
¡d�}t|j
ƒD ]}t |||¡}| ||¡ qT|| _d S )Nr   r+  r?  )r«   r   r|   r	   rÐ   rÑ   r™   rv  rK   r3   ra   r2   rZ   rò   r�   )	rM   rn   r7   r„  r…  r×   r�   r8  r6  ©rð  r<   r=   rA  ;  s     þzD_make_flattening_iter_cls.<locals>.CContiguousFlatIter.init_specificc              	      sè   |j }|j}ˆ  | j¡}ˆ  d||¡}	| |	¡ t ˆ |	¡�¢ ˆ  |j	|g¡}
t
|ˆ ||
ƒ}ˆdkrp| |¡ nP| j‰‡ ‡fdd„t|ƒD ƒ}t ˆ |¡}| t ˆ ||g¡¡ t|ˆ ||ˆƒ t ˆ |¡}ˆ  || j¡ W 5 Q R X d S )Nrë   r&  c              	      s    g | ]}ˆ   t ˆ ˆ|¡¡‘qS r<   rm  r{  rn  r<   r=   rŒ   d  s
   ý
þz\_make_flattening_iter_cls.<locals>.CContiguousFlatIter.iternext_specific.<locals>.<listcomp>)ra   rž   r8   rÑ   rì   rí   r	   r0  r  r‡   rv   rð   r�   r2   r\   Úmake_anonymous_structr9  rñ   rò   )rM   rn   r7   r„  r…  ró   ra   rž   rÑ   rö   r]   rê   ÚidxvalsÚidxtupler  rn  r=   rk  T  s4    
ýÿÿ ÿzH_make_flattening_iter_cls.<locals>.CContiguousFlatIter.iternext_specificc                 S   s   |  |j|g¡}t||||ƒS r  )r  r‡   rv   ©rM   rn   r7   r„  r…  rÑ   r]   r<   r<   r=   rò  r  s    z>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.getitemc                 S   s$   |  |j|g¡}t|||||ƒ d S r  )r  r‡   ry   ©rM   rn   r7   r„  r…  rÑ   rê   r]   r<   r<   r=   Úsetitemv  s    z>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.setitemN)rb   rc   rd   r6  rA  rk  rò  r…  r<   r  r<   r=   ÚCContiguousFlatIter6  s
   r†  c                       s<   e Zd ZdZdd„ Z‡ fdd„Zdd„ Zdd	„ Zd
d„ ZdS )z+_make_flattening_iter_cls.<locals>.FlatIterzÛ
            Generic .flat() / .ndenumerate() implementation for
            non-contiguous arrays.
            It keeps track of pointers along each dimension in order to
            minimize computations.
            c              
   S   s  |  tjd¡}|j}|j}t ||j|¡}tj||j	|  tj|j¡d�}	tj||j	|  tj|j¡d�}
t 
|tj¡}t|ƒD ]t}t ||	|¡}t ||
|¡}| ||¡ | ||¡ || }| d||¡}t ||¡� | tj|¡ W 5 Q R X q||	| _|
| _|| _d S rx  )r«   r   r|   r‡   ra   r	   r¬   rW   rK   r3   rÐ   r/  r2   rZ   rò   rs  re  r1  r�   Úpointersr^  )rM   rn   r7   r„  r…  r×   r‡   ra   rá   r�   r‡  r^  r8  r6  Úptrptrr^  ry  r<   r<   r=   rA  …  sB      ÿÿ  ÿÿÿz9_make_flattening_iter_cls.<locals>.FlatIter.init_specificc              
      s"  |j }t ˆ |j|¡}t ˆ |j|¡}| j‰| j}	| tj	d¡}
ˆ  
d¡}t ˆ ˆ  | j¡¡}t ˆ |¡� | d¡ ˆ  |¡ W 5 Q R X | d¡ t ˆ |	|d ¡}ˆ  |¡}t|ˆ ||ƒ}ˆdkrÒ| |¡ n:‡ ‡fdd„t|ƒD ƒ}t ˆ |¡}| t ˆ ||g¡¡ tt|ƒƒD ]à}t ˆ ˆ|¡}t ˆ ˆ  |¡¡}|| }|| }ˆ  d	||¡}t ˆ |¡�~ ˆ  ||¡ t ˆ |	|¡}ˆ  |¡}t ˆ ||¡}ˆ  ||¡ t|d |ƒD ] }t ˆ |	|¡}ˆ  ||¡ �q´ˆ  |¡ W 5 Q R X ˆ  |
|¡ �qˆ  tj| j¡ ˆ  |¡ ˆ  |¡ d S )
Nr   rˆ  FTr?   r&  c              	      s    g | ]}ˆ   t ˆ ˆ|¡¡‘qS r<   rm  r{  rn  r<   r=   rŒ   Á  s
   ý
þzQ_make_flattening_iter_cls.<locals>.FlatIter.iternext_specific.<locals>.<listcomp>rë   )ra   r	   r¬   rW   r˜   r�   r‡  r«   r   r|   r;  rd  r8   r^  re  rí   rC  rZ   rv   rð   r2   r\   r€  rz  rñ   rì   r0  rò   rÝ   r1  rD  )rM   rn   r7   r„  r…  ró   ra   rá   r˜   r‡  r×   r5  Zis_exhaustedZlast_ptrr]   rê   r�  r‚  r8  r6  r   r­   rv  r7  rˆ  Z	inner_dimr  rn  r=   rk  ¦  sl    
 
ÿ


ýÿÿÿ
þ
z=_make_flattening_iter_cls.<locals>.FlatIter.iternext_specificc              	   S   sŒ   |j }tj||j|d�}tj||j|d�}g }	tt|ƒƒD ]*}
|	 | |||
 ¡¡ | 	|||
 ¡}q:|	 
¡  t |||j|||j|	¡}|S )NrÜ   )ra   r	   r¬   rW   r˜   rz  r2   r[   ÚuremÚudivÚreverser}  r‡   r~  )rM   rn   r7   r„  r…  rÑ   ra   rá   r˜   r�   r8  r]   r<   r<   r=   Ú_ptr_for_indexë  s      þz:_make_flattening_iter_cls.<locals>.FlatIter._ptr_for_indexc                 S   s    |   |||||¡}t||||ƒS r  )rŒ  rv   rƒ  r<   r<   r=   rò  ü  s    z3_make_flattening_iter_cls.<locals>.FlatIter.getitemc                 S   s&   |   |||||¡}t|||||ƒ d S r  )rŒ  ry   r„  r<   r<   r=   r…     s    z3_make_flattening_iter_cls.<locals>.FlatIter.setitemN)	rb   rc   rd   r6  rA  rk  rŒ  rò  r…  r<   r  r<   r=   ÚFlatIter}  s   !Er�  )r†   rU   r~  r	   ri   )r)  rð  rU   r†  r�  r<   r  r=   r(  0  s    
D r(  r&  c                 C   sh   t t |¡ƒ}|| |ƒ}||_|  |¡}|| || d¡d�}| | |||¡ | ¡ }t| |t |¡|ƒS ©Nr³   )rN   )	r*  r   ÚNumpyFlatTyper³   rj   rY   rA  rÕ   r   )rn   r7   r„  r…  ÚflatiterclsÚflatiterÚarrclsrÙ   r<   r<   r=   Úmake_array_flatiter  s    

r“  c                 C   sZ   |j \}|\}t|ƒ}|| ||d�}|j}|  |¡}	|	| ||jd�}
| | |||
|¡ d S rÌ  )rÍ   r*  rU   rj   r³   rk  )rn   r7   rO   rÍ   ró   r)  r‘  r�  r„  r’  r…  r<   r<   r=   Úiternext_numpy_flatiter  s    
r”  c                 C   sj   |j d }|\}}t|ƒ}|| ||d�}|j}|  |¡}	|	| ||jd�}
| | |||
|¡}t| ||j|ƒS ©Nr   ré   )rÍ   r*  rU   rj   r³   rò  r   rÏ   )rn   r7   rO   rÍ   r)  r‘  rÑ   r�  r„  r’  r…  rÙ   r<   r<   r=   Úiternext_numpy_getitem'  s    

r–  c                 C   sf   |j d }|\}}}t|ƒ}|| ||d�}|j}	|  |	¡}
|
| ||jd�}| | ||	|||¡ |  ¡ S r•  )rÍ   r*  rU   rj   r³   r…  r,  )rn   r7   rO   rÍ   r)  r‘  rÑ   rê   r�  r„  r’  r…  r<   r<   r=   Úiternext_numpy_getitem_any7  s    


r—  c           	      C   sF   |j d }t|ƒ}|| ||d d�}|  |j¡}|| ||jd�}|jS r•  )rÍ   r*  rj   rU   r³   rž   )	rn   r7   rO   rÍ   r)  r�  r‘  r’  r…  r<   r<   r=   Úiternext_numpy_getitem_flatH  s    
r˜  c           
      C   sr   |j \}|\}tt |¡ƒ}|| |ƒ}||_|  |¡}|| || d¡d�}| | |||¡ | ¡ }	t	| ||j
|	ƒS rŽ  )rÍ   r.  r   ÚNumpyNdEnumerateTyper³   rj   rY   rA  rÕ   r   rÏ   )
rn   r7   rO   rÍ   r„  r…  Ú	nditerclsr:  r’  rÙ   r<   r<   r=   Úmake_array_ndenumerateS  s    

r›  c                 C   sZ   |j \}|\}t|ƒ}|| ||d�}|j}|  |¡}	|	| ||jd�}
| | |||
|¡ d S rÌ  )rÍ   r.  rU   rj   r³   rk  )rn   r7   rO   rÍ   ró   r-  r:  rš  r„  r’  r…  r<   r<   r=   Úiternext_numpy_nditere  s    
rœ  c                    s^   ‡ ‡fdd„t |j|ƒD ƒ}tt t|ƒ¡ƒ}|ˆˆ ƒ}| ˆˆ |¡ | ¡ }tˆˆ |j	|ƒS )zndindex(*shape)c                    s"   g | ]\}}ˆ  ˆ ||tj¡‘qS r<   rú  )rŠ   Úargtyrä  r‹   r<   r=   rŒ   y  s   ÿz&make_array_ndindex.<locals>.<listcomp>)
rŽ   rÍ   r~  r   ÚNumpyNdIndexTyper�   rA  rÕ   r   rÏ   )rn   r7   rO   rÍ   rW   rš  r:  rÙ   r<   r‹   r=   Úmake_array_ndindexu  s    
ÿ
rŸ  c           
         s�   |j j}|dkrJ|jd j‰|d }t ˆ ||¡}‡ ‡‡fdd„|D ƒ}ng }tt t	|ƒ¡ƒ}|ˆˆ ƒ}| 
ˆˆ |¡ | ¡ }	tˆˆ |j |	ƒS )zndindex(shape)r   c                    s   g | ]}ˆ  ˆ |ˆtj¡‘qS r<   rú  rú   ©r7   rn   r~   r<   r=   rŒ   Ž  s   ÿz,make_array_ndindex_tuple.<locals>.<listcomp>)rÏ   ra   rÍ   rl   r	   r¬   r~  r   rž  r�   rA  rÕ   r   )
rn   r7   rO   rÍ   ra   r  rW   rš  r:  rÙ   r<   r   r=   Úmake_array_ndindex_tuple„  s    ÿ
r¡  c                 C   s6   |j \}|\}t|ƒ}|| ||d�}| | ||¡ d S rÌ  )rÍ   r~  rk  )rn   r7   rO   rÍ   ró   r-  r:  rš  r<   r<   r=   Úiternext_numpy_ndindex›  s
    r¢  c           	      C   sn   |j }|j}t|jd tjƒr0t ||d ¡}n
|d g}t|ƒ| |ƒ}| 	| |||¡ | 
¡ }t| |||ƒS )z
    nditer(...)
    r   )rÏ   r[  rƒ   rÍ   r   r  r	   r¬   rw  rA  rÕ   r   )	rn   r7   rO   rÍ   r-  r_  r[  r:  rÙ   r<   r<   r=   Úmake_array_nditer§  s    
r£  c                 C   s2   |j \}|\}t|ƒ| ||d�}| | ||¡ d S rÌ  )rÍ   rw  rk  )rn   r7   rO   rÍ   ró   r-  r:  r<   r<   r=   Úiternext_numpy_nditer2»  s    r¤  c              	   C   sP  t |ƒ}|| |ƒ}|  |j¡}|  tjt| |ƒ¡}|  tjd¡}tt 	d¡dƒ}	|D ]0}
| 
||
¡}| |d¡}| |	| |d¡¡}	qT|jdkr–d}nž|jdkrà|g}t|dd… ƒD ]}| | |d |¡¡ q¶tt|ƒƒ}nT|jdk�r$|g}|dd… D ]}| | |d |¡¡ qþt|ƒ}ntd |j¡ƒ‚| 
||¡}| |d¡}| |	| |d¡¡}	|j|	d	d
�� | j |td¡ W 5 Q R X |j}|  |¡}|  tj|¡}|  ¡ ||f}t tj¡}t t|ƒ¡}t ||tjtjƒ}|  !|t"||¡}| j# $||¡}|  %tj¡}t&j'|||d�}t&j'|||d�}t(|| )|| *¡ ¡||||d� |S )a	  Utility function used for allocating a new array during LLVM code
    generation (lowering).  Given a target context, builder, array
    type, and a tuple or list of lowered dimension sizes, returns a
    LLVM value pointing at a Numba runtime allocated array.
    r?   r   r<   r’   Nr!  rx  z3Don't know how to allocate array with layout '{0}'.Fr'  )z[array is too big; `arr.size * arr.dtype.itemsize` is larger than the maximum possible size.)r  r  )+rj   rk   rl   r«   r   r|   rp   r   r   rç  Úsmul_with_overflowr$  rr  ra   r~  rz  r[   r®   r§   rF   r°   rî   r)  r*  r¤   Úget_preferred_array_alignmentÚuint32r,  ÚMemInfoPointerÚvoidptrÚTypeRefr3   r    r  Ú_call_allocatorrÓ   Úmeminfo_datar¥   r	   r\   r¼   rŸ  r  )rn   r7   rÁ  rá   r‚  rà   Údatatyper™   ZarrlenÚoverflowr“   Zarrlen_multr˜   Zdimension_sizeZallocsize_multr§  rl   Ú	align_valrr   rÍ   ÚmipZarytypeclassÚargtypesr—   r‡   r¶   Zshape_arrayZstrides_arrayr<   r<   r=   r|  È  sv    
 
ÿ


ÿÿ þ
ûr|  Ú	_allocatec                 C   s   dd„ }|S )zTImplements a Numba-only default target (cpu) classmethod on the array
    type.
    c                 S   s
   t ||ƒS r  )Úintrin_alloc)Úclsr§  rr   r<   r<   r=   rÈ     s    z _ol_array_allocate.<locals>.implr<   )r´  r§  rr   rÈ   r<   r<   r=   Ú_ol_array_allocate  s    rµ  c                 C   s   |   ||¡S )z9Trampoline to call the intrinsic used for allocation
    )r²  )rÁ  r€   rr   r<   r<   r=   r«  !  s    r«  c                 C   s(   dd„ }t  t j¡}t|||ƒ}||fS )z3Intrinsic to call into the allocator for Array
    c                 S   s   |\}}| j  |||¡}|S r  )rÓ   Zmeminfo_alloc_aligned)rn   r7   r    rÍ   r§  rr   r—   r<   r<   r=   rÅ  +  s    zintrin_alloc.<locals>.codegen)r   r¨  r©  r    )rÆ  r§  rr   rÅ  r°  rO   r<   r<   r=   r³  '  s    r³  c              
   C   sÔ   dd„ }t |tjƒr.d}|  |||tj¡g}n&t |tjƒs>t‚|j}tj	|||d�}g }|D ]}| 
|| ||j|ƒ¡ q\|  |tjd¡}	t|ƒD ]>}
| d||
 |	¡}t ||¡� | j |td¡ W 5 Q R X q�|S )z;
    Parse the shape argument to an array constructor.
    c           
   	   S   s¬   |   tj¡}|j}t |¡}t|d|d > d ƒ}|j|k rJ| ||¡}n^|j|kr¨| d||¡}	|j	|	dd�� | j
 |td¡ W 5 Q R X |j|kr¤| ||¡}n|}|S )z0Cast src to intp only if value can be maintainedr?   ú>Fr'  )z#Cannot safely convert value to intp)r¥   r   r|   r@   r   rç  r   Úsextrì   rî   r)  r*  r¤   Útrunc)
rn   r7   Úsrc_tr¦  r¶   Z
intp_widthZintp_irÚmaxvalrÙ   Z	is_largerr<   r<   r=   Úsafecast_intp9  s$    


 þ
z#_parse_shape.<locals>.safecast_intpr?   rÜ   r   rë   )znegative dimensions not allowed)rƒ   r   r…   r{   r|   r  r†   r­   r	   r¬   r[   r3   Úget_constant_genericr2   rì   re  r)  r*  r¤   )rn   r7   r  rx   r»  ra   Zpassed_shapesrá   r“   r×   r8  Zis_negr<   r<   r=   Ú_parse_shape5  s(      ÿr½  c                 C   s*   |j d }|d }|j}|t| |||ƒfS )zL
    Parse the arguments of a np.empty(), np.zeros() or np.ones() call.
    r   )rÍ   rÏ   r½  )rn   r7   rO   rÍ   ZarrshapetypeZarrshaperÁ  r<   r<   r=   Ú_parse_empty_argse  s    
r¾  c                 C   sX   |j d }t|tjƒrJt|ƒ| ||d d�}tj||j|jd�}|j	|fS |j	dfS dS )z_
    Parse the arguments of a np.empty_like(), np.zeros_like() or
    np.ones_like() call.
    r   ré   rÜ   r<   N)
rÍ   rƒ   r   r„   rj   r	   r¬   rW   ra   rÏ   )rn   r7   rO   rÍ   Úarytyperà   rá   r<   r<   r=   rá  o  s    

rá  c                 C   s&   t |tjƒr"d| › d�}t |¡‚d S )NzIf np.z0 dtype is a string it must be a string constant.)rƒ   r   ÚUnicodeTyper   rÉ   )Úfnamerl   rµ   r<   r<   r=   Ú_check_const_str_dtype}  s    rÂ  c                 C   s"   |j }||||ƒ}dd„ }||fS )Nc                 S   s(   t | |||ƒ\}}t| |||ƒ}| ¡ S r  )r¾  r|  rÕ   ©rž  r7   rO   rŸ  rÁ  rá   rà   r<   r<   r=   rÅ  ˆ  s    znumpy_empty_nd.<locals>.codegen©Úinstance_type)r¡  Zty_shapeÚty_dtypeÚty_retty_refÚty_rettyrO   rÅ  r<   r<   r=   Únumpy_empty_ndƒ  s    rÉ  c                    sœ   t d|ƒ |tks0t|tjƒr(|jtks0t|ƒr8tj}nt|ƒ}t	| ƒ}|d k	r||d k	r|tj
||dd�‰ tf‡ fdd„	}|S d| › d|› d�}t |¡‚d S )	Nr‘  r’   r  c                    s   t | |ˆ ƒS r  )rÉ  )rW   rl   ©r>  r<   r=   rÈ   �  s    zol_np_empty.<locals>.implz.Cannot parse input types to function np.empty(ú, ú))rÂ  Úfloatrƒ   r   ÚFunctionÚ
typing_keyr   ÚdoubleÚty_parse_dtypeÚty_parse_shaper„   r   rÉ   )rW   rl   Únb_dtypera   rÈ   rµ   r<   rÊ  r=   Úol_np_empty�  s"    

ÿÿþrÔ  c                 C   s"   |j }||||ƒ}dd„ }||fS )Nc                 S   s(   t | |||ƒ\}}t| |||ƒ}| ¡ S r  )rá  r|  rÕ   rÃ  r<   r<   r=   rÅ  ª  s    z$numpy_empty_like_nd.<locals>.codegenrÄ  )r¡  Zty_prototyperÆ  rÇ  rÈ  rO   rÅ  r<   r<   r=   Únumpy_empty_like_nd¥  s    rÕ  c                    s¬   t d|ƒ t|ƒst|ƒ}nt| tjƒr0| j}n| }|d k	r~t| tjƒrn| jdkrX| jnd}| j||dd�‰ qšt |dd¡‰ nd| › d|› d	�}t	 
|¡‚d‡ fd
d„	}|S )NrX  r¾  r’   F)rl   r~  rÃ  r   z3Cannot parse input types to function np.empty_like(rË  rÌ  c                    s   t | |ˆ ƒS r  )rÕ  )r…  rl   rÊ  r<   r=   rÈ   Å  s    zol_np_empty_like.<locals>.impl)N)rÂ  r   rÑ  rƒ   r   r„   rl   r~  rÀ  r   rÉ   )r…  rl   rÓ  r~  rµ   rÈ   r<   rÊ  r=   Úol_np_empty_like±  s    


rÖ  c                 C   s   t  |¡}dd„ }||fS )Nc                 S   s<   t |jd ƒ| ||d ƒ}t ||j| |j|j¡d¡ d S rÅ   )rj   rÍ   r	   râ  r‡   r®   r™   rž   )rž  r7   rO   rŸ  rà   r<   r<   r=   rÅ  Î  s    ÿz(_zero_fill_array_method.<locals>.codegen)r   r]  )r¡  rM   rO   rÅ  r<   r<   r=   Ú_zero_fill_array_methodÊ  s    
r×  Ú
_zero_fillc                 C   s   dd„ }|S )z?Adds a `._zero_fill` method to zero fill an array using memset.c                 S   s   t | ƒ d S r  )r×  r/  r<   r<   r=   rÈ   Ø  s    z ol_array_zero_fill.<locals>.implr<   )rM   rÈ   r<   r<   r=   Úol_array_zero_fillÕ  s    rÙ  c                 C   s   t d|ƒ tfdd„}|S )NÚzerosc                 S   s   t j| |d�}| ¡  |S ©NrŽ  )rÍ  r‘  rØ  )rW   rl   r…  r<   r<   r=   rÈ   á  s    zol_np_zeros.<locals>.impl)rÂ  rÍ  ©rW   rl   rÈ   r<   r<   r=   Úol_np_zerosÝ  s    
rÝ  c                 C   s   t d|ƒ ddd„}|S )NÚ
zeros_likec                 S   s   t j| |d�}| ¡  |S rÛ  )rÍ  rX  rØ  )r  rl   r…  r<   r<   r=   rÈ   í  s    zol_np_zeros_like.<locals>.impl)N©rÂ  r©  r<   r<   r=   Úol_np_zeros_likeè  s    

rà  c                 C   s   t d|ƒ ddd„}|S )NÚ	ones_likec                 S   s2   t j| |d�}|j}tt|ƒƒD ]}d||< q |S ©NrŽ  r?   ©rÍ  rX  r&  r2   r�   )r  rl   r…  Úarr_flatr   r<   r<   r=   rÈ   ù  s
    
zol_np_ones_like.<locals>.impl)Nrß  r©  r<   r<   r=   Úol_np_ones_likeô  s    

rå  c                    s2   t d|ƒ t|ƒst|ƒ‰ n|‰ d‡ fdd„	}|S )NÚfullc                    s0   t  | ˆ ¡}|j}tt|ƒƒD ]}|||< q|S r  ©rÍ  r‘  r&  r2   r�   )rW   Ú
fill_valuerl   r…  rä  r   ©rÓ  r<   r=   ræ  
  s
    
zimpl_np_full.<locals>.full)N)rÂ  r   rÑ  )rW   rè  rl   ræ  r<   ré  r=   Úimpl_np_full  s    

rê  c                 C   s   t d|ƒ ddd„}|S )Nrl  c                 S   s0   t  | |¡}|j}tt|ƒƒD ]}|||< q|S r  rã  )r  rè  rl   r…  rä  r   r<   r<   r=   rl    s
    
z$impl_np_full_like.<locals>.full_like)Nrß  )r  rè  rl   rl  r<   r<   r=   Úimpl_np_full_like  s    

rë  c                 C   s   t d|ƒ ddd„}|S )NÚonesc                 S   s2   t j| |d�}|j}tt|ƒƒD ]}d||< q |S râ  rç  )rW   rl   r…  rä  r   r<   r<   r=   rÈ   '  s
    
zol_np_ones.<locals>.impl)Nrß  rÜ  r<   r<   r=   Ú
ol_np_ones!  s    

rí  c                    s4   t d|ƒ t|ƒst|ƒ‰ ntj‰ d‡ fdd„	}|S )NÚidentityc                    s.   t  | | fˆ ¡}t| ƒD ]}d|||f< q|S rJ  )rÍ  rÚ  r2   )r•  rl   r…  r_   ré  r<   r=   rî  8  s    z"impl_np_identity.<locals>.identity)N)rÂ  r   rÑ  r   rÐ  )r•  rl   rî  r<   ré  r=   Úimpl_np_identity0  s    

rï  c                 C   s   d S r  r<   ©ÚNÚMr<   r<   r=   Ú_eye_none_handler@  s    ró  c                 C   s"   t |tjƒrdd„ }ndd„ }|S )Nc                 S   s   | S r  r<   rð  r<   r<   r=   rÈ   G  s    z$_eye_none_handler_impl.<locals>.implc                 S   s   |S r  r<   rð  r<   r<   r=   rÈ   J  s    ©rƒ   r   rt  )rñ  rò  rÈ   r<   r<   r=   Ú_eye_none_handler_implD  s    
rõ  c                    sf   |d kst |tjƒr t t¡‰ n.t |tjtjfƒrDtt	|d|ƒƒ‰ n
t |¡‰ d dtf‡ fdd„	}|S )Nrl   r   c                    s€   t | |ƒ}t | |fˆ ¡}|dkrPt| || ƒ}t|ƒD ]}d|||| f< q8n,t| | |ƒ}t|ƒD ]}d||| |f< qf|S rG  )ró  rÍ  rÚ  r[  r2   )rñ  rò  rº   rl   Ú_Mr…  Údr_   ©rï  r<   r=   rÈ   Z  s    
znumpy_eye.<locals>.impl)
rƒ   r   rt  rÍ  rl   rÍ  Ú	DTypeSpecrî  r   r­  )rñ  rò  rº   rl   rÈ   r<   rø  r=   Ú	numpy_eyeO  s    
rú  c                 C   sD   t | ƒst d¡‚t| tjƒr@| jdkr2t d¡‚ddd„}|S d S )Nz#The argument "v" must be array-like)r?   r  zInput must be 1- or 2-d.r   c                 S   s.  | j dkrŒ| j}|d t|ƒ }t ||f| j¡}|dkrbt|| ƒD ]}| | |||| f< qFn&t|| ƒD ]}| | ||| |f< qn|S | j\}}|dk r¦|| }|dkr¶|| }tt||ƒdƒ}t 	|| j¡}|dk�rt|ƒD ]}| ||| f ||< qæn$t|ƒD ]}| || |f ||< �q
|S d S rR  )
ra   rW   r  rÍ  rÚ  rl   r2   rè  r[  r‘  )r»   rº   r“   r•  rÇ  r_   ÚrowsÚcolsr<   r<   r=   Ú	diag_implr  s.    


zimpl_np_diag.<locals>.diag_impl)r   )r   r   rÉ   rƒ   r   r„   ra   ÚNumbaTypeError)r»   rº   rý  r<   r<   r=   Úimpl_np_diagi  s    



rÿ  Útakec                    s‚   t | tjƒr$t |tjƒr$dd„ }|S tdd„ | |fD ƒƒrT|jdk‰ ‡ fdd„}|S t | tjƒr~t |tjtjfƒr~dd„ }|S d S )Nc                 S   s.   || j d ks|| j  k r"tdƒ‚|  ¡ | S )Nr?   úIndex out of bounds)r€   Ú
IndexErrorrF  )r  r�   r<   r<   r=   Ú	take_impl•  s    znumpy_take.<locals>.take_implc                 s   s   | ]}t |tjƒV  qd S r  r  ©rŠ   rä  r<   r<   r=   r  ›  s     znumpy_take.<locals>.<genexpr>rx  c                    s†   t j|j| jd�}ˆ r | ¡ }n|}t  |¡}d}|  ¡ }|D ]:}|| jd ks\|| j k rdtdƒ‚|| ||< |d }q>| |j	¡S ©NrŽ  r   r?   r  )
rÍ  r‘  r€   rl   rÀ  r:  rF  r  rC  rW   )r  r�   rÇ  ZwalkerÚitr_   r&  r·  ©ÚF_orderr<   r=   r  ž  s    


c                 S   s~   t  |¡}t j|j| jd�}t  |¡}d}|  ¡ }|D ]:}|| jd ksT|| j k r\tdƒ‚|| ||< |d }q6| |j	¡S r  )
rÍ  r³   r‘  r€   rl   r:  rF  r  rC  rW   )r  r�   ÚconvertrÇ  r  r_   r&  r·  r<   r<   r=   r  ±  s    


)rƒ   r   r„   r…   r×  r~  r™  r  )r  r�   r  r<   r  r=   Ú
numpy_take�  s    
ÿr
  c                  G   s|   dd„ | D ƒ}t dd„ |D ƒƒr(tj}nPt dd„ |D ƒƒrBtj}n6ttddt t¡j  ƒ}dd„ |D ƒ}t	||g ƒ}|S )	Nc                 S   s   g | ]}t |tjƒs|‘qS r<   rô  r  r<   r<   r=   rŒ   Á  s      z!_arange_dtype.<locals>.<listcomp>c                 s   s   | ]}t |tjƒV  qd S r  ©rƒ   r   ÚComplexr  r<   r<   r=   r  Ã  s     z _arange_dtype.<locals>.<genexpr>c                 s   s   | ]}t |tjƒV  qd S r  )rƒ   r   ÚFloatr  r<   r<   r=   r  Å  s     zint%sr  c                 S   s   g | ]}t  |¡‘qS r<   )r   Ú	unliteral©rŠ   r·  r<   r<   r=   rŒ   Ô  s     )
r  r   Ú
complex128r    r­  rÍ  rl   r©   r™   rè  )rÍ   Úboundsrl   ZNPY_TYZunliteral_boundsr<   r<   r=   Ú_arange_dtypeÀ  s    r  c                    s  t |tjƒr|j}t |tjƒr$|j}t |tjƒr6|j}|d krDtj}|d krRtj}|d kr`tj}t | tjƒr¢t |tjtjfƒr¢t |tjtjfƒr¢t |tjtjfƒs¦d S t |tjƒrÀt| ||ƒ‰n|j	‰t
dd„ | ||fD ƒƒ‰t| dd ƒ‰ t|dd ƒ‰t|dd ƒ‰d‡ ‡‡‡‡fdd„	}|S )Nc                 S   s   g | ]}t |tjƒ‘qS r<   r  r  r<   r<   r=   rŒ   ö  s   ÿznp_arange.<locals>.<listcomp>rÊ   c                    sð   ˆ d k	rˆ n| }ˆd k	rˆn|}ˆd k	r,ˆn|}|d k	r<|nd}|d krTd| }}	n
|| }}	|dkrnt dƒ‚|	| | }
tt |
j¡ƒ}ˆdkr´tt |
j¡ƒ}tt||ƒdƒ}n
t|dƒ}t 	|ˆ¡}|}t
|ƒD ]}|||  ||< qÖ|S )Nr?   r   zMaximum allowed size exceededT)r¤   r©   ÚmathÚceilrÙ  rà  rè  r[  rÍ  r‘  r2   )r  re  r`  rl   Z	lit_startZlit_stopZlit_stepZ_stepÚ_startÚ_stopÚnitems_cÚnitems_rÚnitems_irž   r…  rx   r_   ©Zstart_valueZ
step_valueZ
stop_valueZ
true_dtypeZuse_complexr<   r=   rÈ   ý  s(    

znp_arange.<locals>.impl)NNN)rƒ   r   ÚOptionalr3   r]  rî  rt  rù  r  rl   r  r­  )r  re  r`  rl   rÈ   r<   r  r=   Ú	np_arangeÚ  s>    ÿþýÿr  c                    sn   t dd„ | |fD ƒƒsd S t|ttjfƒs8d}t |¡‚tdd„ | |fD ƒƒrVtj‰ ntj	‰ d‡ fdd„	}|S )	Nc                 s   s   | ]}t |tjƒV  qd S r  )rƒ   r   rî  r  r<   r<   r=   r     s     z!numpy_linspace.<locals>.<genexpr>z%The argument "num" must be an integerc                 s   s   | ]}t |tjƒV  qd S r  r  r  r<   r<   r=   r  '  s     r"  c                    sŠ   t  |ˆ ¡}| d } |d }|dkr(|S |d }|dkrn||  }t  ||¡}td|ƒD ]}| ||  ||< qVn| |d< |dkr†||d< |S )Ng      ð?r   r?   r!  )rÍ  r‘  Údivider2   )r  re  r%  r…  ÚdivÚdeltar`  r_   rŽ  r<   r=   r#  -  s    z numpy_linspace.<locals>.linspace)r"  )
r×  rƒ   r©   r   r…   r   rÉ   r  r  r    )r  re  r%  rµ   r#  r<   rŽ  r=   Únumpy_linspace  s    
r   c              
   C   s  |j d }t|ƒ| ||d d�}t ||j¡}|j}t| |||ƒ}|j}	|j}
|jdks\t	‚|j|jkr„tj
||
|	|j|jdd� n„t ||j¡}t ||j¡}|  tj¡}t |||¡�H}t | ||	|||j|¡}t | ||
|||j|¡}| | |¡|¡ W 5 Q R X t| ||j| ¡ ƒS )z
    Array copy.
    r   ré   rƒ  r?   rq   )rÍ   rj   r	   r¬   rW   rÏ   r|  r‡   r~  r†   Ú
raw_memcpyrž   r™   r˜   r¥   r   r|   r¥  r}  rò   r8   r   rÕ   )rn   r7   rO   rÍ   r¿  rà   rá   ÚrettyperÇ  r™  r÷  r›  rö  r¶   r�   r’  r¨  r<   r<   r=   Ú_array_copyF  s>    
 ÿ
  þ
  þr#  c                 C   s@   t |tjƒst‚|jdkrdnd}|j|dd�}||ƒ}|tfS )Nrx  r’   F)r~  rÃ  )rƒ   r   r„   r†   r~  rÀ  r#  )rÆ  r  r~  rÇ  rO   r<   r<   r=   Ú_array_copy_intrinsick  s
    r$  z
array.copyc                 C   s   t | |||ƒS r  )r#  r  r<   r<   r=   Ú
array_copyt  s    r%  c                 C   s   t | tjƒrdd„ }|S )Nc                 S   s   t | ƒS r  )r$  rT  r<   r<   r=   Ú
numpy_copy|  s    z#impl_numpy_copy.<locals>.numpy_copyr  )r  r&  r<   r<   r=   Úimpl_numpy_copyy  s    r'  c              
   C   sÒ  |j }|jd }|j|ks"tdƒ‚|jdkrÀ|jdks:t‚t|ƒ| ||d d�}t|ƒ| |ƒ}|  |t tj	d¡d¡}	|  
|t tj	d¡|jf¡}
t||j|	|
|j|j|jƒ t| ||| ¡ ƒS |j|jksà|jdkrò|jdkròt| |||d ƒS |jdk�rÀ|dk�st‚|dk�rtnt}t|| |||d ƒ}| |¡�V\}}|� t| |||d ƒ}|j}W 5 Q R X |� t| |||ƒ}|j}W 5 Q R X W 5 Q R X | |j¡}| ||¡ | ||¡ |S t| |||ƒS d	S )
zd
    Common logic for layout conversion function;
    e.g. ascontiguousarray and asfortranarray
    r   z return-type has incorrect layoutr?   ré   rá  rƒ  r¾  r’   N)rÏ   rÍ   r~  r†   ra   rj   r¼  r   rÕ  r|   rZ  r™   r¼   r‡   r—   rš   r   rÕ   r   r   rÓ  r�  Úblockr#  Úphir3   Úadd_incoming)rn   r7   rO   rÍ   Úoutput_layoutr>  r½   rà   rÇ  rW   r˜   Ú
check_funcr¾  ÚthenÚorelseZout_thenZthen_blkZ
out_orelseZ
orelse_blkZret_phir<   r<   r=   Ú_as_layout_array�  sd    

  ÿþ ÿÿÿüÿr/  c                    sH   t ˆ tjƒst ˆ ¡‚|jˆ jt|jdƒd�}||ˆ ƒ}|‡ fdd„fS )Nr?   )r~  ra   c                    s   t | |||ˆ jd�S )N©r+  )r/  rÊ   )rW  rc  r“   r  r0  r<   r=   rß  Ê  s       ÿz,_as_layout_array_intrinsic.<locals>.<lambda>)	rƒ   r   r!   r   ÚRequireLiteralValuerÀ  rÊ   rè  ra   )rÆ  r  r+  rÇ  rO   r<   r0  r=   Ú_as_layout_array_intrinsicÂ  s
    

r2  c                 C   sF   t | ƒst d¡‚t| tjtjfƒr.dd„ }nt| tjƒrBdd„ }|S )Nre  c                 S   s   t  t  | ¡¡S r  )rÍ  Úascontiguousarrayr³   rT  r<   r<   r=   rÈ   Ô  s    z%array_ascontiguousarray.<locals>.implc                 S   s
   t | dƒS ©Nr’   ©r2  rT  r<   r<   r=   rÈ   ×  s    ©r   r   rÉ   rƒ   r   rî  rh  r„   r†  r<   r<   r=   Úarray_ascontiguousarrayÎ  s    

r7  c                 C   sL   t | ƒst d¡‚t| tjtjfƒr0dd„ }|S t| tjƒrHdd„ }|S d S )Nre  c                 S   s   t  t  | ¡¡S r  )rÍ  Úasfortranarrayr³   rT  r<   r<   r=   rÈ   â  s    z"array_asfortranarray.<locals>.implc                 S   s
   t | dƒS )Nrx  r5  rT  r<   r<   r=   rÈ   æ  s    r6  r†  r<   r<   r=   Úarray_asfortranarrayÜ  s    
r9  zarray.astypec              
   C   s  |j d }t|ƒ| ||d d�}t ||j¡}|j}t| |||ƒ}|j}	|j}
t ||j¡}t ||j¡}|  	t
j¡}t |||¡�h}t | ||	|||j|¡}t | ||
|||j|¡}t| |||ƒ}|  |||j|j¡}t| ||||ƒ W 5 Q R X t| ||j| ¡ ƒS r•  )rÍ   rj   r	   r¬   rW   rÏ   r|  r‡   r˜   r¥   r   r|   r¥  r}  r~  rv   r{   rl   ry   r   rÕ   )rn   r7   rO   rÍ   r¿  rà   rá   r"  rÇ  r™  r÷  r›  rö  r¶   r�   r’  r¨  Úitemr<   r<   r=   Úarray_astypeë  s6    

  þ
  þr;  c                 C   s"   |j }||||ƒ}dd„ }||fS )Nc              	   S   s  |j d }|j}t|ƒ| ||d d�}t|ƒ}|| |ƒ}|j}	t| |ƒ}
t|jj|
ƒ}| |j	|j¡}| 
||¡}t ||¡}|j|dd�� d}| j |t|f¡ W 5 Q R X t || ||¡g¡}t ||g¡}| |j|  |	 d¡¡¡}t||||||j|jd� | ¡ }t| ||j|ƒS )Nr   ré   Fr'  z.buffer size must be a multiple of element sizer‡   r  )rÍ   rÏ   rj   rŸ   rp   r   r™   r3   r®   rž   Úsremr	   Úis_not_nullrî   r)  r*  r¤   r\   ÚsdivrŸ  r‡   r¥   r¦   r¼   r—   rš   rÕ   r   )rn   r7   rO   rÍ   Zbuftyr½   r  Z
out_ary_tyÚout_aryZout_datamodelr™   Úll_itemsizer»  ÚremZis_incompatiblerµ   rW   r˜   r‡   rÙ   r<   r<   r=   rÅ    s<    


 ÿúznp_frombuffer.<locals>.codegenrÄ  )rÆ  Úbufferrl   r>  r  rO   rÅ  r<   r<   r=   Únp_frombuffer
  s    $rC  c                    sº   t d|ƒ t| tjƒr | jdkr4d| › �}t |¡‚|tksZt|tjƒrR|j	tksZt
|ƒrbtj}nt|ƒ}|d k	rŠtj|dd| j d�‰ nd| › d|› d�}t |¡‚tf‡ fd	d
„	}|S )NÚ
frombufferr’   z+Argument "buffer" must be buffer-like. Got r?   )rl   ra   r~  rÃ  z3Cannot parse input types to function np.frombuffer(rË  rÌ  c                    s   t | |ˆ ƒS r  )rC  )rB  rl   rÊ  r<   r=   rÈ   M  s    z impl_np_frombuffer.<locals>.impl)rÂ  rƒ   r   rÞ   r~  r   rÉ   rÍ  rÎ  rÏ  r   rÐ  rÑ  r„   rÆ  )rB  rl   rµ   rÓ  rÈ   r<   rÊ  r=   Úimpl_np_frombuffer6  s*    



ÿÿþ
ÿ
rE  c                    sP   t |ƒr$tdd ƒ‰ d‡ fdd„	}|S t|tjƒrLtd|ƒ‰ d‡ fdd„	}|S d S )Nr’   c                    s
   ˆ | |ƒS r  r<   ©r]   rW   rl   ©Úintrinsic_cfarrayr<   r=   rÈ   W  s    zimpl_carray.<locals>.implc                    s
   ˆ | |ƒS r  r<   rF  rG  r<   r=   rÈ   ]  s    )N)N©r   Úget_cfarray_intrinsicrƒ   r   rù  ©r]   rW   rl   rÈ   r<   rG  r=   Úimpl_carrayR  s    

rL  c                    sP   t |ƒr$tdd ƒ‰ d‡ fdd„	}|S t|tjƒrLtd|ƒ‰ d‡ fdd„	}|S d S )Nrx  c                    s
   ˆ | |ƒS r  r<   rF  rG  r<   r=   rÈ   g  s    zimpl_farray.<locals>.implc                    s
   ˆ | |ƒS r  r<   rF  rG  r<   r=   rÈ   m  s    )N)NrI  rK  r<   rG  r=   Úimpl_farrayb  s    

rM  c                    s   t ‡ ‡fdd„ƒ}|S )Nc           	         sü   |t jkrd }n*t|t jƒr$|j}nd|› d�}t |¡‚ˆ d kr^|d krXd}t |¡‚|}nVtˆ t jƒržˆ j}|d k	r´||kr´d|› d|› d�}t |¡‚ndˆ › d�}t |¡‚t|ƒ}|d krÚd|› d�}t |¡‚t  	||ˆ¡}t
|||ƒ}|tfS )Nz pointer argument expected, got 'ú'z*explicit dtype required for void* argumentzmismatching dtype 'z' for pointer type 'zinvalid dtype spec 'zinvalid shape ')r   r©  rƒ   ÚCPointerrl   r   rþ  rù  rÒ  r„   r    Ú
np_cfarray)	rÆ  r]   rW   Ú	ptr_dtyperµ   rl   ra   r>  rO   ©Údtype_r~  r<   r=   rH  s  s2    




z0get_cfarray_intrinsic.<locals>.intrinsic_cfarray©r%   )r~  rS  rH  r<   rR  r=   rJ  r  s    rJ  c                    s<  |j dd… \}}|dd… \}}|j}|jdks6t‚t|ƒˆˆ ƒ}	tˆ|ƒ}
t |
¡}t|t	j
ƒrrt ˆ |¡}n|f}|f}‡ ‡fdd„t||ƒD ƒ}|}g }|jdkrÌ|D ]}| |¡ ˆ  ||¡}q®n,t|ƒD ]}| |¡ ˆ  ||¡}qÔ| ¡  ˆ  |ˆ |j¡ ¡ ¡}t|	||||dd� |	 ¡ }tˆˆ |j|ƒS )zR
    numba.numpy_support.carray(...) and
    numba.numpy_support.farray(...).
    Nr  rƒ  c                    s"   g | ]\}}ˆ  ˆ ||tj¡‘qS r<   rú  )rŠ   rÎ  rê   r‹   r<   r=   rŒ   «  s   ÿznp_cfarray.<locals>.<listcomp>rx  r  )rÍ   rÏ   r~  r†   rj   rp   r	   r¶   rƒ   r   r  r¬   rŽ   r[   r®   rz  r‹  rŸ  rk   rl   r  r¼   rÕ   r   )rn   r7   rO   rÍ   r˜  rü  r]   rW   r½   r?  r™   r@  rá   Úoffr˜   r“   r‡   rÙ   r<   r‹   r=   rP  –  sH    

ÿ


ÿú	rP  c                 C   sV   t |tjƒr|  tjt|ƒ¡S t |tjƒrJ|  tttj|ƒ¡}|||fƒS dsRt	‚d S rÅ   )
rƒ   r   r  r«   r|   r�   rõ  rE   r    r†   )rn   r7   ÚseqtyÚseqrù  r<   r<   r=   Ú_get_seq_sizeÊ  s    rX  c                    s2   |j ‰ˆ  tjtˆ|tjƒ¡‰‡ ‡‡fdd„}|S )zK
    Return a getitem() implementation that doesn't incref its result.
    c                    s$   ˆ| |ƒ}ˆ j r ˆ j | ˆ|¡ |S r  )rÒ   rÓ   Údecref)r7   rÍ   rÇ  ©rn   ró  r>  r<   r=   ÚwrapÜ  s    
z$_get_borrowing_getitem.<locals>.wrap)rl   rE   rñ  rò  r    r   r|   )rn   rV  r[  r<   rZ  r=   Ú_get_borrowing_getitemÔ  s    ÿr\  c                    st   ˆ  tj¡}t|dƒ‰‡ ‡‡fdd„}g }|| }}	t|ƒD ].}
|
dkrV|||	ƒ\}}	| tˆˆ ||	ƒ¡ q<t|ƒS )zF
    Compute the likely shape of a nested sequence (possibly 0d).
    r   c                    sT   t | tjƒr2t| ƒdkrdS | d ˆ  |d¡fS ntˆ| ƒ}| j|ˆ |ˆfƒfS d S )Nr   )NN)rƒ   r   r  r�   r$  r\  rl   )rV  rW  ró  ©r7   rn   r×   r<   r=   Úget_first_itemì  s    
z.compute_sequence_shape.<locals>.get_first_item)r¥   r   r|   r   r2   r[   rX  r§   )rn   r7   ra   rV  rW  r¶   r^  rá   ÚinnertyÚinnerr_   r<   r]  r=   Úcompute_sequence_shapeå  s    

ra  c                    s0   ‡‡fdd„‰ ‡ ‡‡‡fdd„‰ˆ|||ƒ dS )z?
    Check the nested sequence matches the given *shapes*.
    c                      s   ˆj  ˆ td¡ d S )N)zincompatible sequence shape)r)  r*  r¤   r<   r‹   r<   r=   Ú_fail  s    
ÿz#check_sequence_shape.<locals>._failc              	      s  t |ƒdkrd S tˆˆ| |ƒ}|d }ˆ d||¡}ˆj|dd�� ˆ ƒ  W 5 Q R X t |ƒdkrdd S t| tjƒr¾tˆ| ƒ}t 	ˆ|¡�0}| j
}|ˆ||jfƒ}	ˆ||	|dd … ƒ W 5 Q R X nXt| tjƒ�rtt | ƒƒD ],}
| |
 }ˆ ||
¡}	ˆ||	|dd … ƒ qØnd�st| ƒ‚d S )Nr   r&  Fr'  r?   )r�   rX  rì   rî   rƒ   r   rõ  r\  r	   rT  rl   rÑ   r  r2   r$  r†   )rV  rW  rá   r€   Úexpectedr»  ró  rV  r_  r`  r_   ©rb  r7   Úcheck_seq_sizern   r<   r=   re    s*    
 z,check_sequence_shape.<locals>.check_seq_sizeNr<   )rn   r7   rV  rW  rá   r<   rd  r=   Úcheck_sequence_shape  s    rf  c                    s:   ‡ ‡‡‡‡‡fdd„‰‡‡‡‡fdd„‰ˆ||ˆdƒ dS )zl
    Assign a nested sequence contents to an array.  The shape must match
    the sequence's structure.
    c              
      sB   t jˆˆˆˆˆˆ j| dd�}ˆ ˆ||ˆ j¡}tˆˆˆ ||ƒ d S rL  )r	   r}  r~  r{   rl   ry   )r�   r"  rx   r]   )r„  r7   rn   r‡   rá   r˜   r<   r=   Úassign_item3  s      ÿz-assign_sequence_to_array.<locals>.assign_itemc              	      s  t |ƒdkr2t| tjtjfƒr"t‚ˆ|| |ƒ d S |d }t| tjƒržtˆ| ƒ}t ˆ|¡�:}| j	}|ˆ||j
fƒ}ˆ |||dd … ||j
f ƒ W 5 Q R X nlt| tjƒrütt | ƒƒD ]B}	| |	 }ˆ ||	¡}ˆ tj|	¡}
ˆ |||dd … ||
f ƒ q¶nd�s
t| ƒ‚d S rG  )r�   rƒ   r   rõ  r  r†   r\  r	   rT  rl   rÑ   r2   r$  r«   r|   )rV  rW  rá   r�   r€   ró  rV  r_  r`  r_   rÑ   )Úassignrg  r7   rn   r<   r=   rh  9  s$    
* z(assign_sequence_to_array.<locals>.assignr<   Nr<   )rn   r7   r‡   rá   r˜   r„  rV  rW  r<   )r„  rh  rg  r7   rn   r‡   rá   r˜   r=   Úassign_sequence_to_array,  s    ri  c                 C   s>   t | |ƒ\}}t|ƒr|}nt|ƒ}|d kr0d S t ||d¡S r4  )r/   r   rÑ  r   r„   )rÆ  rv  rl   ra   Z	seq_dtyper<   r<   r=   Únp_array_typerU  s    rj  c                 C   s0   t d|ƒ t| ||ƒ}|||ƒ}dd„ }||fS )Nr³   c           
   	   S   sŠ   |j }|j}|jd }|d }t| ||||ƒ}t|ƒ|ks>t‚t| ||||ƒ t| |||ƒ}	t| ||	j	||	j
|||ƒ t| ||j |	 ¡ ƒS rÅ   )rÏ   ra   rÍ   ra  r�   r†   rf  r|  ri  r‡   r˜   r   rÕ   )
rn   r7   rO   rÍ   r„  ra   rV  rW  rá   r…  r<   r<   r=   rÅ  f  s"    
   ÿ
ÿznp_array.<locals>.codegen)rÂ  rj  )rÆ  Úobjrl   rÇ  rO   rÅ  r<   r<   r=   Únp_array`  s
    

rl  c                 C   sL   t d|ƒ t| ƒst d¡‚t|ƒs>t|ƒd kr>d}t |¡‚ddd„}|S )Nr³   z(The argument "object" must be array-likez:The argument "dtype" must be a data-type if it is providedc                 S   s
   t | |ƒS r  )rl  )rv  rl   r<   r<   r=   rÈ   „  s    zimpl_np_array.<locals>.impl)N)rÂ  r   r   rÉ   r   rÑ  )rv  rl   rµ   rÈ   r<   r<   r=   Úimpl_np_arrayz  s    



rm  c           
   	   C   s�   |  d¡}|  |¡}| d||¡}| || ||¡|¡}| | d||¡| d||¡¡}|j|dd��  d| }	| j |t|	f¡ W 5 Q R X |S )Nr   rë   rB  Fr'  z%s(): axis out of bounds)	r3   rì   rd  rL  rr  rî   r)  r*  r  )
rn   r7   rÁ   ra   rÃ   r×   Zll_ndimZis_neg_axisZaxis_out_of_boundsrµ   r<   r<   r=   Ú_normalize_axis‰  s    

þrn  c              
   C   sÂ   t |ƒ|d kst‚t tj|¡}t ||¡}t d¡}t|d ƒD ]R}t |¡}	| d|	|¡}
|| }| 	|
| 
|	|¡|	¡}| |t ||d|¡¡ qD| |t ||d|¡¡ t || |¡¡S )z’
    Compute shape with the new axis inserted
    e.g. given original shape (2, 3, 4) and axis=2,
    the returned new shape is (2, 3, 1, 4).
    r?   rB  r   ©r�   r†   r   r  r	   r¶   rK   r2   rì   rd  rL  rò   rZ   r¬   r8   )rn   r7   Ú
orig_shapera   rÃ   Úll_shtyrá   r  r8  Úll_dimÚ
after_axisr  r   r<   r<   r=   Ú_insert_axis_in_shapeœ  s    


þrt  c              
   C   sÈ   t |ƒ|d kst‚t tj|¡}t ||¡}t d¡}t d¡}t|d ƒD ]N}	t |	¡}
| d|
|¡}| 	|| 
|
|¡|
¡}| ||	 t ||d|¡¡ qN| |t ||d|¡¡ t || |¡¡S )zD
    Same as _insert_axis_in_shape(), but with a strides array.
    r?   r   rB  ro  )rn   r7   Úorig_stridesra   rÃ   rq  r˜   r  r×   r8  rr  rs  r   r<   r<   r=   Ú_insert_axis_in_strides¹  s"    



þ
ÿrv  c              	   C   sœ   |j }|j}|jd }t|ƒ| ||d d�}t|ƒ| |ƒ}	t ||j¡}
t ||j¡}t| ||
||ƒ}t	| ||||ƒ}t
|	|j|||j|j|jd� |	 ¡ S )z/
    np.expand_dims() with the given axis.
    r   ré   r  )rÏ   ra   rÍ   rj   r	   r¬   rW   r˜   rt  rv  r¼   r‡   r™   r—   rš   rÕ   )rn   r7   rO   rÍ   rÃ   r>  ra   r„  r…  rÇ  rá   r˜   Ú
new_shapesZnew_stridesr<   r<   r=   Úexpand_dimsÖ  s$    
úrx  c                 C   sB   |j dkr|jnd}|j|j d |d�}|||ƒ}dd„ }||fS )Nr?   r¾  r¿  c                 S   sP   |   ||d |jd tj¡}t| |d|jj|ƒ}t| ||||ƒ}t| ||j|ƒS )Nr?   znp.expand_dims)	r{   rÍ   r   r|   rn  rÏ   ra   rx  r   )rn   r7   rO   rÍ   rÃ   rÇ  r<   r<   r=   rÅ  ø  s     ÿznp_expand_dims.<locals>.codegen)ra   r~  rÀ  )rÆ  r  rÃ   r~  rÇ  rO   rÅ  r<   r<   r=   Únp_expand_dimsò  s
    
ry  c                 C   sL   t | tjƒs d| › �}t |¡‚t |tjƒs@d|› �}t |¡‚dd„ }|S )Nz)First argument "a" must be an array. Got z(Argument "axis" must be an integer. Got c                 S   s
   t | |ƒS r  )ry  )r  rÃ   r<   r<   r=   rÈ     s    z!impl_np_expand_dims.<locals>.impl)rƒ   r   r„   r   rÉ   r…   )r  rÃ   rµ   rÈ   r<   r<   r=   Úimpl_np_expand_dims  s    



rz  c                    s   t ‡ ‡fdd„ƒ‰‡fdd„S )Nc                    sX   |‰ ‡fdd„|D ƒ‰‡ ‡‡‡fdd„}t tˆƒdkr@t ˆ¡nˆd tj |¡ƒ|fS )Nc                    s    g | ]}|j t|jˆ ƒd �‘qS )rz  )rÀ  rè  ra   r  )Úminimumr<   r=   rŒ     s     z-_atleast_nd.<locals>.impl.<locals>.<listcomp>c                    sn   t ˆˆƒ‰t ˆ |d ¡}‡ ‡‡fdd„t|ˆˆƒD ƒ}t|ƒdkrVˆ ˆ |j|¡}n|d }tˆˆ |j|ƒS )Nr   c                    s"   g | ]\}}}ˆˆˆ |||ƒ‘qS r<   r<   )rŠ   r…  r„  r>  ©r7   rn   Ú	transformr<   r=   rŒ     s   ÿz>_atleast_nd.<locals>.impl.<locals>.codegen.<locals>.<listcomp>r?   )Ú_atleast_nd_transformr	   r¬   rŽ   r�   rZ  rÏ   r   )rn   r7   rO   rÍ   ÚarrsÚretsrÇ  )r_  r  r{  rp  r|  r=   rÅ    s    

ÿz*_atleast_nd.<locals>.impl.<locals>.codegenr?   r   )r    r�   r   rÖ  ÚStarArgTupleÚ
from_types)ÚtypingcontextrÍ   rÅ  )r  r{  )r_  rp  r=   rÈ     s    
ÿÿz_atleast_nd.<locals>.implc                     s   ˆ | Ž S r  r<   rÞ  )rÈ   r<   r=   rß  (  rà  z_atleast_nd.<locals>.<lambda>rT  )r{  r  r<   )r  rÈ   r{  r=   Ú_atleast_nd  s    r„  c                    s"   ˆt ˆ ƒkst‚‡ ‡fdd„}|S )z`
    Return a callback successively inserting 1-sized dimensions at the
    following axes.
    c           	         sb   t ˆƒD ]T}|d }|j|k rt ˆ | ¡}|j|jd d�}t| |t ||¡|f|ƒ}|}q|S )Nr?   rz  )r2   ra   r	   r¶   rÀ  rx  r   r    )	rn   r7   r…  r„  r>  r_   ra   rÃ   Znewarrty©r  Úmin_ndimr<   r=   r}  2  s    

 þz(_atleast_nd_transform.<locals>.transform)r�   r†   )r†  r  r}  r<   r…  r=   r~  +  s    r~  c                  G   s"   t dd„ | D ƒƒrtddgƒS d S )Nc                 s   s   | ]}t |tjƒV  qd S r  r  r  r<   r<   r=   r  D  s     z np_atleast_1d.<locals>.<genexpr>r?   r   ©r×  r„  rÞ  r<   r<   r=   Únp_atleast_1dB  s    rˆ  c                  G   s$   t dd„ | D ƒƒr tdddgƒS d S )Nc                 s   s   | ]}t |tjƒV  qd S r  r  r  r<   r<   r=   r  J  s     z np_atleast_2d.<locals>.<genexpr>r  r   r‡  rÞ  r<   r<   r=   Únp_atleast_2dH  s    r‰  c                  G   s&   t dd„ | D ƒƒr"tddddgƒS d S )Nc                 s   s   | ]}t |tjƒV  qd S r  r  r  r<   r<   r=   r  P  s     z np_atleast_3d.<locals>.<genexpr>r*  r   r  r‡  rÞ  r<   r<   r=   Únp_atleast_3dN  s    rŠ  c	                 C   sŽ  t |ƒt |ƒ  kr.t |ƒ  kr.t |ƒks4n t‚t d¡}	t| |||ƒ}
t ||
j¡}g }|D ]d}|	}tt||ƒƒD ]B\}\}}| 	d| 
|¡|¡}| ||¡}| || ||¡|¡}qx| |¡ qb|
j}t|||||ƒD ]ª\}}}}}|j}tj||tj|jd�}|�h}t | |||||j|¡}t| |||ƒ}|  |||j|j¡}t | |||||j|¡}t| ||||ƒ W 5 Q R X t |||¡}qÞ|
S )z2
    Concatenate arrays along the given axis.
    r   rp  )Úorder)r�   r†   r	   r¶   r|  r¬   r˜   rã  rŽ   rì   r3   r®   rd  rL  r[   r‡   r¥  r~  r}  rv   r{   rl   ry   rÝ   )rn   r7   rÃ   r_  r  Ú
arr_shapesÚarr_stridesr>  Ú
ret_shapesr×   rÇ  Zret_stridesZcopy_offsetsZarr_shrâ   r8  r€   rv  Úis_axisÚaddendZret_datar„  r…  Zarr_stZarr_datar¥  r�   r’  rx   r¨  r<   r<   r=   Ú_do_concatenateT  sT    4

þ ÿÿ
  þ
  þr‘  c                    s¬  |j }‡ ‡fdd„t||ƒD ƒ}tˆˆ d||ƒ}‡ fdd„|D ƒ}‡ fdd„|D ƒ}‡ fdd„|d D ƒ}	t|ƒD ]ü‰ˆ  d| ˆ¡|¡}
|	ˆ }ˆ  |¡}‡fd	d„|d
d … D ƒ}ˆ  |
¡�¨\}}|�& t 	ˆ j
||g ¡}ˆ  ||¡ W 5 Q R X |�d tj}|D ]}ˆ  |ˆ  d||¡¡}�qˆ jˆ  |¡dd�� ˆj ˆ tdˆ f¡ W 5 Q R X W 5 Q R X W 5 Q R X qr‡ fdd„|	D ƒ}	tˆˆ |||||||	ƒ	}tˆˆ || ¡ ƒS )Nc                    s"   g | ]\}}t |ƒˆˆ |d �‘qS ©ré   r	  ©rŠ   r!  r  r‹   r<   r=   rŒ   ”  s   ÿz#_np_concatenate.<locals>.<listcomp>únp.concatenatec                    s   g | ]}t  ˆ |j¡‘qS r<   )r	   r¬   rW   ©rŠ   r…  r¶  r<   r=   rŒ   š  s     c                    s   g | ]}t  ˆ |j¡‘qS r<   ©r	   r¬   r˜   r•  r¶  r<   r=   rŒ   ›  s     c                    s   g | ]}t  ˆ |¡‘qS r<   )r	   rÐ   r«  r¶  r<   r=   rŒ      s   ÿr   rp  c                    s   g | ]}|ˆ  ‘qS r<   r<   r«  )r8  r<   r=   rŒ   §  s     r?   Fr'  z<np.concatenate(): input sizes over dimension %d do not matchc                    s   g | ]}ˆ   |¡‘qS r<   )r8   r«  r¶  r<   r=   rŒ   »  s     )ra   rŽ   rn  r2   rì   r3   r8   r�  r­  r®  rL  rò   r	   r¯  r‹  rî   rZ  r)  r*  r¤   r‘  r   rÕ   )rn   r7   r_  r  r>  rÃ   ra   rŒ  r�  rŽ  r�  Zret_shape_ptrZret_shZother_shapesZon_axisZon_other_dimr  Úis_okrÇ  r<   )r7   rn   r8  r=   Ú_np_concatenate‘  s\    ÿ
ÿ
þÿ ÿþ$    þr˜  c                    sö  |j }t d¡}t d¡}t t|ƒ¡}	‡ ‡fdd„t||ƒD ƒ}tˆˆ d||ƒ}t ˆ |d j¡}
|dd … D ]n}tj}tt ˆ |j¡|
ƒD ]N\}}ˆ  	|ˆ  
d||¡¡}ˆ jˆ  |¡dd�� ˆj ˆ td	¡ W 5 Q R X qŽqp‡ fd
d„|D ƒ}t tj|¡‰t ˆ ˆ¡}t ˆ ˆ¡}t|d ƒD ]l}t |¡}ˆ  
d||¡}|
| }ˆ  |ˆ  ||¡|¡}ˆ  |t ˆ |d|¡¡ ˆ  |t ˆ |d|¡¡ �q$ˆ  |t ˆ |d|¡¡ ˆ  |	t ˆ |d|¡¡ t ˆ ˆ  |¡¡}|gt|ƒ }t ˆ ˆ  |¡¡}‡ ‡fdd„tt|ƒƒD ƒ}t|d ƒD ]l}t |¡}ˆ  
d||¡}ˆ  |ˆ  ||¡|¡}tt|ƒƒD ]*}ˆ  || | t ˆ || d|¡¡ �qZ�qtt|ƒƒD ]"}ˆ  |t ˆ || d|¡¡ �q–‡ fdd„|D ƒ}tˆˆ |||||||ƒ	}tˆˆ || ¡ ƒS )Nr   r?   c                    s"   g | ]\}}t |ƒˆˆ |d �‘qS r’  r	  r“  r‹   r<   r=   rŒ   Ê  s   ÿz_np_stack.<locals>.<listcomp>únp.stackrp  Fr'  )z5np.stack(): all input arrays must have the same shapec                    s   g | ]}t  ˆ |j¡‘qS r<   r–  r•  r¶  r<   r=   rŒ   Ü  s     rB  c                    s   g | ]}t  ˆ ˆ¡‘qS r<   r  rk  )r7   rq  r<   r=   rŒ   ý  s   ÿc                    s   g | ]}t  ˆ ˆ  |¡¡‘qS r<   )r	   r¬   r8   )rŠ   r  r¶  r<   r=   rŒ     s   ÿ)ra   r	   r¶   r�   rŽ   rn  r¬   rW   r¯  r‹  rì   rî   rZ  r)  r*  r¤   r   r  rK   r2   rd  rL  rò   rZ   r8   r‘  r   rÕ   )rn   r7   r_  r  r>  rÃ   ra   r×   r  Z
ll_narraysrp  r…  r—  r  Zorig_shru  Úinput_shapesrŽ  r8  rr  rs  r   Zinput_stridesr_   rÇ  r<   )r7   rn   rq  r=   Ú	_np_stackÃ  s˜    

ÿÿ þ

þý
ÿ

þÿÿÿ

ÿ    þr›  c                 C   sN   |d k	rt |tjƒsd S t| d|ƒ\}}|dkr8tdƒ‚t|ƒ}t |||¡S )Nr”  r   z.zero-dimensional arrays cannot be concatenated)rƒ   r   r…   r0   Ú	TypeErrorr1   r„   )rÆ  r[  rÃ   rl   ra   r~  r<   r<   r=   Únp_concatenate_typer  s     ÿr�  c                 C   s6   t | ||ƒ}t|tjƒst‚|||ƒ}dd„ }||fS )Nc              	   S   sF   |   ||d |jd tj¡}t| |t|jd ƒt ||d ¡|j|ƒS rR  )	r{   rÍ   r   r|   r˜  r¨   r	   r¬   rÏ   ©rn   r7   rO   rÍ   rÃ   r<   r<   r=   rÅ  3  s    üznp_concatenate.<locals>.codegen)r�  rƒ   r   r„   r†   )rÆ  r[  rÃ   rÇ  rO   rÅ  r<   r<   r=   Únp_concatenate-  s
    
rŸ  c                 C   s   t | tjƒrddd„}|S d S )Nr   c                 S   s
   t | |ƒS r  )rŸ  ©r[  rÃ   r<   r<   r=   rÈ   A  s    z!impl_np_concatenate.<locals>.impl)r   ©rƒ   r   r  ©r[  rÃ   rÈ   r<   r<   r=   Úimpl_np_concatenate>  s    
r£  c                 C   s*   |D ] }|j dk s|j dkrtdƒ‚qdS )Nr?   r  z7np.column_stack() is only defined on 1-d and 2-d arrays)ra   rœ  )rn   rÁ   r[  r  r<   r<   r=   Ú_column_stack_dimsF  s    
r¤  c                 C   sB   t | d|td�\}}t|ƒ}t |||¡}||ƒ}dd„ }||fS )Nznp.column_stack)Údim_chooserc                 S   sÈ   t |jd ƒ}t ||d ¡}g }g }|  tjd¡}t||ƒD ]t\}	}
|	jdkrf| 	|	¡ | 	|
¡ q>|	jdkstt
‚|	jdd�}t ||	¡}t| |||
f|ƒ}| 	|¡ | 	|¡ q>t| ||||j|ƒS )Nr   r?   r  rz  )r¨   rÍ   r	   r¬   r«   r   r|   rŽ   ra   r[   r†   rÀ  r   r    rx  r˜  rÏ   )rn   r7   rO   rÍ   Zorig_arrtysZ	orig_arrsr_  r  rÃ   r„  r…  r�  Ú
expand_sigZnewarrr<   r<   r=   rÅ  X  s&    



 ÿz np_column_stack.<locals>.codegen)r0   r¤  r1   r   r„   )rÆ  r  rl   ra   r~  rÇ  rO   rÅ  r<   r<   r=   Únp_column_stackO  s     þ
r§  c                 C   s   t | tjƒrdd„ }|S d S )Nc                 S   s   t | ƒS r  )r§  ©r  r<   r<   r=   rÈ   x  s    zimpl_column_stack.<locals>.implr¡  ©r  rÈ   r<   r<   r=   Úimpl_column_stacku  s    rª  c              	   C   s*   t | |t|jd ƒt ||d ¡|j|ƒS )z/
    np.stack() with the given axis value.
    r   )r›  r¨   rÍ   r	   r¬   rÏ   rž  r<   r<   r=   Ú_np_stack_common}  s    ür«  c           	      C   sV   t | d|ƒ\}}tdd„ |D ƒƒr&dnd}t ||d |¡}|||ƒ}dd„ }||fS )	Nr™  c                 s   s   | ]}|j d kV  qdS )rx  N)r~  r  r<   r<   r=   r  �  s     z"np_stack_common.<locals>.<genexpr>rx  r’   r?   c                 S   s,   |   ||d |jd tj¡}t| ||||ƒS rJ  )r{   rÍ   r   r|   r«  rž  r<   r<   r=   rÅ  ‘  s    z np_stack_common.<locals>.codegen)r0   r×  r   r„   )	rÆ  r[  rÃ   rl   ra   r~  rÇ  rO   rÅ  r<   r<   r=   Únp_stack_commonˆ  s     ÿ
r¬  c                 C   s   t | tjƒrddd„}|S d S )Nr   c                 S   s
   t | |ƒS r  )r¬  r   r<   r<   r=   rÈ   ›  s    zimpl_np_stack.<locals>.impl)r   r¡  r¢  r<   r<   r=   Úimpl_np_stack˜  s    
r­  c                 C   s4   t | ||ƒ\}}t||ƒ}t|ƒ}t |||¡}|S r  )r0   rè  r1   r   r„   )rÆ  rÁ   r[  Úndim_minrl   ra   r~  rÇ  r<   r<   r=   ÚNdStack_typer   s
    
r¯  c                 C   s&   t | d|dƒ}||ƒ}dd„ }||fS )Nz	np.hstackr?   c                    sj   |j d }|d j}|dkr:|  tjd¡‰ t| |||ˆ ƒS |dkrFdnd‰ ‡ fdd„}|  ||||¡S d S )Nr   r?   c                    s   t j| ˆ d�S rJ  rL  ©r[  rK  r<   r=   Únp_hstack_impl¼  s    z3_np_hstack.<locals>.codegen.<locals>.np_hstack_impl©rÍ   ra   r«   r   r|   r«  r  )rn   r7   rO   rÍ   r  ra   r±  r<   rK  r=   rÅ  ®  s    

z_np_hstack.<locals>.codegen©r¯  ©rÆ  r  rÇ  rO   rÅ  r<   r<   r=   Ú
_np_hstack©  s    rµ  c                 C   s   t | tjƒrdd„ }|S d S )Nc                 S   s   t | ƒS r  )rµ  r¨  r<   r<   r=   rÈ   Ç  s    zimpl_np_hstack.<locals>.implr¡  r©  r<   r<   r=   Úimpl_np_hstackÄ  s    r¶  c                 C   s&   t | d|dƒ}||ƒ}dd„ }||fS )Nz	np.vstackr  c                 S   sd   |j d }|d j}|dkr&dd„ }n.|dkrL|  tjd¡}t| ||||ƒS dd„ }|  ||||¡S )Nr   c                 S   s   t  t  | ¡d¡S rJ  )rÍ  rx  Úhstackr°  r<   r<   r=   Únp_vstack_implÖ  s    z3_np_vstack.<locals>.codegen.<locals>.np_vstack_implr?   c                 S   s   t j| dd�S )Nr   rK  rL  r°  r<   r<   r=   r¸  ß  s    r²  )rn   r7   rO   rÍ   r  ra   r¸  rÃ   r<   r<   r=   rÅ  Ñ  s    


z_np_vstack.<locals>.codegenr³  r´  r<   r<   r=   Ú
_np_vstackÌ  s    r¹  c                 C   s   t | tjƒrdd„ }|S d S )Nc                 S   s   t | ƒS r  )r¹  r¨  r<   r<   r=   rÈ   ê  s    zimpl_np_vstack.<locals>.implr¡  r©  r<   r<   r=   Úimpl_np_vstackç  s    rº  c                 C   s&   t | d|dƒ}||ƒ}dd„ }||fS )Nz	np.dstackr*  c                 S   sò   |j d }|j}|d j}|dkr:dd„ }|  ||||¡S |dkr°|  tjd¡}|j|jd d�}	tj	|	f|j žŽ }
t
| ||
||ƒ}|  tjd¡}t 	||	¡}t| |||f|ƒS |dkrÖ|  tjd¡}t
| ||||ƒS dd„ }|  ||||¡S d S )Nr   c                 S   s   t  | ¡ ddd¡S )Nr?   r!  )rÍ  r·  rC  r°  r<   r<   r=   r¸  ú  s    z3_np_dstack.<locals>.codegen.<locals>.np_vstack_implr?   rz  r  c                 S   s   t j| dd�S )Nr  rK  rL  r°  r<   r<   r=   r¸    s    )rÍ   rÏ   ra   r  r«   r   r|   rÀ  r   r    r«  rx  )rn   r7   rO   rÍ   r  r>  ra   r¸  rÃ   Zstack_rettyZ	stack_sigZ	stack_retr¦  r<   r<   r=   rÅ  ô  s*    


ÿz_np_dstack.<locals>.codegenr³  r´  r<   r<   r=   Ú
_np_dstackï  s    "r»  c                 C   s   t | tjƒrdd„ }|S d S )Nc                 S   s   t | ƒS r  )r»  r¨  r<   r<   r=   rÈ     s    zimpl_np_dstack.<locals>.implr¡  r©  r<   r<   r=   Úimpl_np_dstack  s    r¼  Úfillc                 C   s   dd„ }|S )Nc                 S   s   || d d …< d S r  r<   )r…  rx   r<   r<   r=   Ú	fill_impl$  s    zarr_fill.<locals>.fill_implr<   )r…  rx   r¾  r<   r<   r=   Úarr_fill!  s    r¿  Údotc                 C   s   dd„ }|S )Nc                 S   s   t  | |¡S r  )rÍ  rÀ  )r…  Úotherr<   r<   r=   Údot_impl-  s    zarray_dot.<locals>.dot_implr<   )r…  rÁ  rÂ  r<   r<   r=   Ú	array_dot+  s    rÃ  c                 C   s"   t | ƒst d|  ¡‚dd„ }|S )NzCannot np.fliplr on %s typec                 S   s4   t  | ¡}|jdk rtdƒ‚|d d …d d d…df S )Nr  r(  r!  .©rÍ  rÎ  ra   r¤   ©r  r¾  r<   r<   r=   rÈ   9  s    

znp_flip_lr.<locals>.implr…  r†  r<   r<   r=   Ú
np_flip_lr3  s    rÆ  c                 C   s"   t | ƒst d|  ¡‚dd„ }|S )NzCannot np.flipud on %s typec                 S   s.   t  | ¡}|jdk rtdƒ‚|d d d…df S )Nr?   zInput must be >= 1-d.r!  .rÄ  rÅ  r<   r<   r=   rÈ   J  s    

znp_flip_ud.<locals>.implr…  r†  r<   r<   r=   Ú
np_flip_udD  s    rÇ  c                    sN   t |tjƒst |¡‚t|jƒ‰ tjtjˆ d�‰ˆ|ƒ}‡ ‡fdd„}||fS )zY Creates a tuple of slices for np.flip indexing like
    `(slice(None, None, -1),) * sz` rû  c                    sX   dd„ }t jˆg}tjˆf|žŽ }|  t j¡}|  ˆ¡}|ˆ ƒ|g}	|  ||||	¡}
|
S )Nc                 S   s*   |}t | ƒD ]}t||td d dƒƒ}q|S )Nr!  )r2   r*   r  )ÚlengthÚempty_tuplerÚ   r_   r<   r<   r=   rÈ   `  s    z6_build_flip_slice_tuple.<locals>.codegen.<locals>.impl)r   r|   r   r    r¥   Úget_constant_undefr  )rn   r7   r    rÍ   rÈ   Úinner_argtypesÚ	inner_sigÚll_idx_typerÉ  Ú
inner_argsrÙ   ©r€   Ú
tuple_typer<   r=   rÅ  _  s    

z(_build_flip_slice_tuple.<locals>.codegen)	rƒ   r   rÒ  r   r1  r©   rÊ   rÕ  Úslice3_type)r¡  ÚszrO   rÅ  r<   rÏ  r=   Ú_build_flip_slice_tupleU  s    

rÓ  c                 C   s&   t | tjƒst d|  ¡‚dd„ }|S )NzCannot np.flip on %s typec                 S   s   t | jƒ}| | S r  )rÓ  ra   )r  Úslr<   r<   r=   rÈ   z  s    
znp_flip.<locals>.impl)rƒ   r   r„   r   rÉ   r†  r<   r<   r=   Únp_flips  s    rÕ  c                 C   sš   t | tjtjtjfƒr$d	dd„}|S t |tjƒr>d
dd„}|S t |tjƒrht |jjtjƒrhddd„}|S t |tj	ƒr–t
dd„ |jD ƒƒr–ddd„}|S d S )Nr   c                 S   s   t jt  | ¡||d�S rJ  )rÍ  Úarray_splitrÎ  ©rà   Úindices_or_sectionsrÃ   r<   r<   r=   rÈ   „  s
    ýznp_array_split.<locals>.implc                 S   sP   t | j| |ƒ\}}t t |d g| |g|| d   ¡¡}tj| ||d�S )Nr?   rK  )ÚdivmodrW   rÍ  Úcumsumr³   rÖ  )rà   rØ  rÃ   rT  rA  r�   r<   r<   r=   rÈ   Ž  s    ÿÿc              	   S   sp   t | jƒ}tdd| j|ƒ}g }d}|D ](}t||t||ƒƒ}| | | ¡ |}q&| | t||t|d ƒƒ ¡ |S ©Nznp.splitrÃ   r   )r+   ra   rÄ   r*   r  r[   ©rà   rØ  rÃ   Z	slice_tuprÚ   Úprevr�  r   r<   r<   r=   rÈ   Ÿ  s    
c                 s   s   | ]}t |tjƒV  qd S r  ©rƒ   r   r…   )rŠ   Útr<   r<   r=   r  ¯  s     z!np_array_split.<locals>.<genexpr>c              	   S   st   t | jƒ}tdd| j|ƒ}g }d}t|ƒD ](}t||t||ƒƒ}| | | ¡ |}q*| | t||t|d ƒƒ ¡ |S rÛ  )r+   ra   rÄ   r   r*   r  r[   rÜ  r<   r<   r=   rÈ   ±  s    
)r   )r   )r   )r   )rƒ   r   rÕ  ÚListTyper™  r…   ÚIterableTypeÚiterator_typerï   rÖ  r×  ©rà   rØ  rÃ   rÈ   r<   r<   r=   Únp_array_split�  s*    


ÿþþ

ÿþ
rä  c                 C   sP   t | tjtjtjfƒr$ddd„}|S t |tjƒr>ddd„}|S t| ||d�S d S )Nr   c                 S   s   t jt  | ¡||d�S rJ  )rÍ  ÚsplitrÎ  r×  r<   r<   r=   rÈ   Å  s    znp_split.<locals>.implc                 S   s4   t | j| |ƒ\}}|dkr$tdƒ‚tj| ||d�S )Nr   z0array split does not result in an equal divisionrK  )rÙ  rW   r¤   rÍ  rÖ  )rà   rØ  rÃ   r€  rA  r<   r<   r=   rÈ   Ë  s    ÿ  ÿrK  )r   )r   )rƒ   r   rÕ  rà  r™  r…   rä  rã  r<   r<   r=   Únp_splitÀ  s    


ræ  c                 C   s   | |k pt  |¡ot  | ¡ S r  )rÍ  Úisnanr  r<   r<   r=   Ú	lt_floatsá  s    rè  Fc                 C   s†   | ||f}z
t | W S  tk
r€   | dkrLtj|r8tnd|dd�}|j}n$| dkrptj|r`tnd|d�}|j}|t |< | Y S X dS )z6
    Get a sort implementation of the given kind.
    r'   NT)ÚltÚ
is_argsortZis_np_arrayr(   )ré  rê  )	Ú_sortsÚKeyErrorr'   Zmake_jit_quicksortrè  Zrun_quicksortr(   Zmake_jit_mergesortZrun_mergesort)rð  Úis_floatrê  Úkeyr‰  Úfuncr<   r<   r=   Úget_sort_funcé  s&    


ý
þrð  z
array.sortc                    s<   |j d }tdt|jtjƒd�‰ ‡ fdd„}|  ||||¡S )Nr   r'   )rð  rí  c                    s   ˆ | ƒ d S r  r<   rì  ©Z	sort_funcr<   r=   Úarray_sort_impl  s    z#array_sort.<locals>.array_sort_impl)rÍ   rð  rƒ   rl   r   r  r  )rn   r7   rO   rÍ   r¿  rò  r<   rñ  r=   Ú
array_sort   s    
ÿró  c                 C   s   t | ƒst d¡‚dd„ }|S )NzArgument "a" must be array-likec                 S   s   |   ¡ }| ¡  |S r  )rÀ  r‰  )r  rÙ   r<   r<   r=   Únp_sort_impl  s    z"impl_np_sort.<locals>.np_sort_implr…  )r  rô  r<   r<   r=   Úimpl_np_sort  s    
rõ  zarray.argsortc           	         sb   |j \}}t|jt|jtjƒdd�‰ ‡ fdd„}|j|j d d… d�}|d d… }|  ||||¡S )NT)rð  rí  rê  c                    s   ˆ | ƒS r  r<   rì  rñ  r<   r=   Úarray_argsort_impl"  s    z)array_argsort.<locals>.array_argsort_implr?   rÞ  )	rÍ   rð  rÊ   rƒ   rl   r   r  Úreplacer  )	rn   r7   rO   rÍ   r¿  rð  rö  ZinnersigÚ	innerargsr<   rñ  r=   Úarray_argsort  s    
þ ÿrù  c                 C   s   |j |j ks|jdkst‚|S )Nr¾  )rÆ  r~  r†   )rn   r7   rÎ  rÏ  rx   r<   r<   r=   Úarray_to_array.  s    rú  c                 C   s4   dd„ }t ||ƒ}|  ||||g¡}t| ||j|ƒS )Nc                 S   s
   |   d¡S rÅ   )r   rT  r<   r<   r=   rÈ   =  s    zarray0d_to_scalar.<locals>.impl)r    r  r   rÏ   ©rn   r7   rÎ  rÏ  rx   rÈ   rO   rÙ   r<   r<   r=   Úarray0d_to_scalar5  s    
rü  c                 C   s4   dd„ }t ||ƒ}|  ||||g¡}t| ||j|ƒS )Nc                 S   s   t | d ƒS rK  )rû  rT  r<   r<   r=   rÈ   H  s    z array_to_unichrseq.<locals>.impl)r    r  r   rÏ   rû  r<   r<   r=   Úarray_to_unichrseqF  s    
rý  c                 C   s   t ‚dS )zR
    An intrinsic returning a derived array with the given shape and strides.
    Nr¿   ©r  rW   r˜   r<   r<   r=   Úreshape_uncheckedS  s    rÿ  c                    s   dd„ ‰ ‡ fdd„}|S )Nc                 S   s   t | tjƒotdd„ | D ƒƒS )Nc                 s   s   | ]}t |tjƒV  qd S r  rÞ  rc  r<   r<   r=   r  ^  s     z>type_reshape_unchecked.<locals>.check_shape.<locals>.<genexpr>)rƒ   r   r  r×  ©rW   r<   r<   r=   rY  \  s    ÿz+type_reshape_unchecked.<locals>.check_shapec                    sJ   t | tjƒsd S ˆ |ƒr ˆ |ƒs$d S t|ƒt|ƒkr8d S | jt|ƒdd�S )Nr¾  r¿  )rƒ   r   r„   r�   rÀ  rþ  ©rY  r<   r=   Útyper`  s    z%type_reshape_unchecked.<locals>.typerr<   )rn   r  r<   r  r=   Útype_reshape_uncheckedZ  s    	r  c                 C   s‚   |j d }|j}t|ƒ| ||d ƒ}t|ƒ| |ƒ}t ||d ¡}t ||d ¡}	t||j||	|j|jd� | 	¡ }
t
| |||
ƒS )Nr   r?   r  r  )rÍ   rÏ   rj   r	   r¬   r¼   r‡   r™   r—   rÕ   r   )rn   r7   rO   rÍ   r½   r>  rà   rÚ   rW   r˜   rÙ   r<   r<   r=   Úimpl_shape_uncheckedl  s    
ûr  c                    s`   |d t jfkrtdd„ ƒ‰ ntdd„ ƒ‰ |d t jfkr@tdƒ‚ntdd„ ƒ‰d	‡ ‡fdd„	}|S )
Nc                 S   s   | j S r  r   ©r·  rW   r<   r<   r=   r2  …  s    zas_strided.<locals>.get_shapec                 S   s   |S r  r<   r  r<   r<   r=   r2  ‰  s    z*as_strided() strides argument is mandatoryc                 S   s   |S r  r<   )r·  r˜   r<   r<   r=   Úget_strides”  s    zas_strided.<locals>.get_stridesc                    s   t | ˆ | |ƒˆ| |ƒƒ} | S r  )rÿ  )r·  rW   r˜   ©r2  r  r<   r=   Úas_strided_impl˜  s    z#as_strided.<locals>.as_strided_impl)NN)r   r]  r"   rF   )r·  rW   r˜   r  r<   r  r=   Ú
as_strided‚  s    


r	  c                    s  t |tjƒr>tt| jd ƒƒ‰tt| jd ƒƒ‰tdd„ ƒ‰n^t |tjƒr’t |jtjƒr’tt| jt	|ƒ ƒƒ‰tt| jt	|ƒ ƒƒ‰tdd„ ƒ‰n
t
 d¡‚t|ƒr²tdd„ ƒ‰ nLt |tjƒrÌtdd„ ƒ‰ n2t |tjƒrôt |jtjƒrôtd	d„ ƒ‰ n
t
 d
¡‚d‡ ‡‡‡fdd„	}|S )Nr?   c                 S   s   | fS r  r<   ©Úwindow_shaper<   r<   r=   Úget_window_shape©  s    z-sliding_window_view.<locals>.get_window_shapec                 S   s   | S r  r<   r
  r<   r<   r=   r  ²  s    z4window_shape must be an integer or tuple of integersc                 S   s   t t|ƒƒS r  )r¨   r2   ©r  rÃ   ra   r<   r<   r=   Úget_axis½  s    z%sliding_window_view.<locals>.get_axisc                 S   s   t dd||ƒgS )NÚsliding_window_viewrÃ   ©rÄ   r  r<   r<   r=   r  Â  s    ÿc                    s   ‡ fdd„|D ƒS )Nc                    s   g | ]}t d dˆ |ƒ‘qS )r  rÃ   r  r  rz  r<   r=   rŒ   Ì  s   ÿz9sliding_window_view.<locals>.get_axis.<locals>.<listcomp>r<   r  r<   rz  r=   r  Ê  s    
ÿz2axis must be None, an integer or tuple of integersc           
         sú   ˆ|ƒ}ˆ ||| j ƒ}t|ƒt|ƒkr.tdƒ‚ˆ}ˆ}t| j ƒD ](}t||| j| ƒ}t||| j| ƒ}q@| j }t||ƒD ]n\}}|dk r’tdƒ‚|| |k r¦tdƒ‚|| | d }t|||ƒ}t|||ƒ}t||| j| ƒ}|d7 }qzt| ||ƒ}	|	S )Nz2Must provide matching length window_shape and axisr   z-`window_shape` cannot contain negative valuesz4window_shape cannot be larger than input array shaper?   )	ra   r�   r¤   r2   r*   rW   r˜   rŽ   rÿ  )
r·  r  rÃ   Ú	out_shapeÚout_stridesr_   r	  r8  Útrimmedrs  ©r  r  Zshape_bufferZstride_bufferr<   r=   Úsliding_window_view_implÔ  s8    ÿÿÿ
z5sliding_window_view.<locals>.sliding_window_view_impl)N)rƒ   r   r…   r§   r2   ra   r"   rÕ  rl   r�   r   rÉ   r   )r·  r  rÃ   r  r<   r  r=   r  Ÿ  s>    ÿÿÿÿ'r  c                 C   s   t | tjƒrdd„ }|S d S )Nc                 S   s6   | j dkrdS | j dkr&t|  d¡ƒS d}t|ƒ‚d S )Nr   Fr?   z[The truth value of an array with more than one element is ambiguous. Use a.any() or a.all())r€   r   r   r¤   )r…  rµ   r<   r<   r=   rÈ     s    

zol_bool.<locals>.implr  rí  r<   r<   r=   Úol_boolþ  s    	r  c                    sn   t |ttjfƒst d¡‚t |ttjfƒs4t d¡‚t | tjƒsJt d¡‚| j‰tt	ˆƒƒ‰ ‡ ‡fdd„}|S )Nz.The second argument "axis1" must be an integerz-The third argument "axis2" must be an integerr'  c                    s`   t ddˆ|ƒ}t ddˆ|ƒ}|dk r,|ˆ7 }|dk r<|ˆ7 }tˆ ||ƒ}t|||ƒ}t | |¡S )Nznp.swapaxesÚaxis1Úaxis2r   )rÄ   r*   rÍ  r  )r…  r  r  Z
axes_tuple©Ú	axes_listra   r<   r=   rÈ     s    znumpy_swapaxes.<locals>.impl)
rƒ   r©   r   r…   r   rÉ   r„   ra   r§   r2   )r…  r  r  rÈ   r<   r  r=   Únumpy_swapaxes  s    


r  c                 C   sÀ  t dd| j|ƒ}t| jƒ}d||< tt||jƒƒD ]H\}\}}	|dkrL|	}
n"|	dkrZ|}
n||	krjtdƒ‚|}
t|||
ƒ}q2t||| j| ƒ}t 	| |¡} t 	||¡}|}t
|ƒdkrÚtt
|ƒƒD ]}t||| j| ƒ}qÂ|}t
|ƒdk�rtt
|ƒƒD ]}t||| j|d |  ƒ}qø|j| }t ||f | | j¡}td d d ƒf}t |¡D ]h}t |¡D ]V}| || |  }||| |  }||| |  }t|ƒD ]}|||  ||< �qœ�q`�qR|S )Nznp.take_along_axisrÃ   r?   z*`arr` and `indices` dimensions don't matchr   )rÄ   ra   r¨   rW   rã  rŽ   r¤   r*   rÍ  rÑ  r�   r2   r‘  rl   r  rZ  )r…  r�   rÃ   ZNi_origZNk_origÚindices_broadcast_shapeÚ	arr_shaper_   Úd1Úd2Únew_valZarr_broadcast_shapeÚNiÚNkÚJrÚ   Znp_s_ÚiiÚkkZa_1dZ
indices_1dZout_1dÚjr<   r<   r=   Ú_take_along_axis_impl-  sX    
ÿ  ÿ  ÿ
r'  c                    s  t | tjƒst d¡‚t |tjƒs,t d¡‚t |jtjƒsDt d¡‚t|ƒrRd}n| j}||jkrlt d¡‚t	t
|jƒƒ‰t|ƒr�‡fdd„}n„t|dƒ t |tjƒs°t d	¡‚|j}|d
k rÈ| j| }|d
k sÚ|| jkrät d¡‚t	t
|ƒƒ‰ t	t
|d | jƒƒ‰‡ ‡‡fdd„}|S )Nr'  z.The second argument "indices" must be an arrayz'The indices array must contain integersr?   z;`indices` and `arr` must have the same number of dimensionsc                    s   t |  ¡ |dddˆ ƒS )Nr   r<   )r'  rP  ©r…  r�   rÃ   )r  r<   r=   Útake_along_axis_impl~  s    ÿz1arr_take_along_axis.<locals>.take_along_axis_implrÃ   zaxis must be a literal valuer   zaxis is out of boundsc                    s   t | ||ˆ ˆˆƒS r  )r'  r(  ©r!  r"  r  r<   r=   r)  �  s    ÿ)rƒ   r   r„   r   rÉ   rl   r…   r   ra   r§   r2   r   rÒ  r.  rÊ   )r…  r�   rÃ   Úarr_ndimr)  r<   r*  r=   Úarr_take_along_axisi  s<    
ÿ

ÿ



r,  Tç        c                 C   sÐ   t | tjƒr`t | tjƒr$ddd„}qÌt | tjƒr<ddd„}qÌt | tjƒrTddd„}qÌt d¡‚nlt| ƒrÂt | j	tjƒr‚ddd„}qÌt | j	tjƒrœdd	d„}qÌt | j	tjƒr¶dd
d„}qÌt d¡‚n
t d¡‚|S )NTr-  c                 S   s   | S r  r<   ©r·  rÀ  Únanr<   r<   r=   rÈ   š  s    znan_to_num_impl.<locals>.implc                 S   sF   t  | ¡r|S t  | ¡r(t  t| ƒ¡jS t  | ¡rBt  t| ƒ¡jS | S r  )rÍ  rç  ÚisneginfÚfinfor3   r[  Úisposinfrè  r.  r<   r<   r=   rÈ   ž  s    


c                 S   s*   t j| j|d�}t j| j|d�}t||ƒS )N)r/  )rÍ  Ú
nan_to_numrÙ  rà  Úcomplex)r·  rÀ  r/  rÚ  rW  r<   r<   r=   rÈ   §  s    z4Only Integer, Float, and Complex values are acceptedc                 S   s   | S r  r<   r.  r<   r<   r=   rÈ   ³  s    c           	      S   s˜   t  | j¡j}t  | j¡j}t  | ¡}|r4t  |¡n|}|j}t|j	ƒD ]J}t  
|| ¡rd|||< qHt  || ¡r||||< qHt  || ¡rH|||< qH|S r  )rÍ  r1  rl   r[  rè  rÎ  rÀ  r&  r2   r€   rç  r0  r2  )	r·  rÀ  r/  Zmin_infZmax_infÚx_ÚoutputZoutput_flatr_   r<   r<   r=   rÈ   ¶  s    



c                 S   sD   t  | ¡}|rt  |¡n|}t j|jd|d� t j|jd|d� |S )NF)rÀ  r/  )rÍ  rÎ  rÀ  r3  rÙ  rà  )r·  rÀ  r/  r5  r6  r<   r<   r=   rÈ   Ç  s
    
z4The first argument must be a scalar or an array-like)Tr-  )Tr-  )Tr-  )Tr-  )Tr-  )Tr-  )
rƒ   r   rî  r…   r  r  r   rÉ   r   rl   )r·  rÀ  r/  rÈ   r<   r<   r=   Únan_to_num_impl•  s,    ÿÿ
r7  )N)N)N)r"  )r?   )N)N)NNN)NNN)N)N)N)N)N)N)N)N)r   )NNN)r"  )N)N)N)r   )r   )r   )r   )F)NN)N)Tr-  (›  r6  r­  r  rñ  Úllvmliter   Úllvmlite.irr   ÚnumpyrÍ  Únumbar   r   Ú
numba.corer   r   r   r	   r
   Únumba.np.numpy_supportr   r   r   r   r   r   r   r   r   r   Únumba.core.imputilsr   r   r   r   r   r   r   r   r   r   r   Únumba.core.typingr    Únumba.core.typesr!   Únumba.core.extendingr"   r#   r$   r%   r&   Ú
numba.miscr'   r(   Únumba.cpythonr)   Únumba.cpython.unsafe.tupler*   r+   r,   Znumba.core.typing.npydeclr-   rÑ  r.   rÒ  r/   r0   r1   r>   rA   rj   rp   rv   ry   r‚   r‰   r‘   r¼   r¾   rÄ   rË   rÞ   rÛ   rç   ÚArrayIteratorÚBORROWEDrø   r  rß   r  rò  r…   r   r  r  r  r…  ÚAnyr#  r�   r%  r„   r+  r-  rv  r.  r7  rI  rM  rQ  r]  rf  r  r‚  r†  r‰  rŠ  rŽ  r©  r²  r½  rÂ  rÈ  rË  rÌ  rÐ  rÑ  rØ  rÝ  Úbroadcast_shapesrê  rY  rð  r!  rÿ  r  r  r  ÚVarArgr  r  r  r   Úlogspacer&  Úrot90r/  r:  r=  rA  rB  rC  rE  r[   rM  rS  rF  rV  rW  rb  rd  rv  ru  rw  r„  rW   r‡  Úuniquer�  r›  rš  r�  r�  r¢  r£  rª  rù  r²  r´  Ú
MemoryViewr¶  r·  r¸  r¹  rº  r¼  r¿  rÂ  rÅ  rÇ  rË  rÉ  rÍ  rO  r©  rÐ  rÓ  rÖ  rÔ  r×  rØ  rß  rã  rÝ  rî  rï  ÚDTypeÚNumberClassró  rú  rü  rö  r  r  r	  rÒ  r  r  r  r  r  ÚBytesr  Úis_r#  r%  r*  r.  r8  r9  rw  r~  r(  r“  r�  r”  r–  r—  r˜  r+  r›  r™  rœ  rZ  rŸ  r¡  rž  r¢  r:  r£  ÚNumpyNdIterTyper¤  r|  rµ  r«  r³  r½  r¾  rá  rÂ  rÉ  r‘  rÍ  rÔ  rÕ  rX  rÖ  r×  rÙ  rÚ  rÝ  rÞ  rà  rá  rå  ræ  rê  rl  rë  rì  rí  rî  rï  ró  rõ  Úeyerú  Údiagrÿ  r   r
  r  Úaranger  r#  r   r#  r$  r%  rÀ  r'  r/  r2  r3  r7  r8  r9  r;  rC  rD  rE  rL  rM  rJ  rP  rX  r\  ra  rf  ri  rj  rl  r³   rm  rn  rt  rv  rx  ry  rz  r„  r~  Ú
atleast_1drˆ  Ú
atleast_2dr‰  Ú
atleast_3drŠ  r‘  r˜  r›  r�  rŸ  rG  r£  r¤  r§  Úcolumn_stackrª  r«  r¬  Ústackr­  r¯  rµ  r·  r¶  r¹  Úvstackrº  r»  Údstackr¼  r¿  rÃ  r,  rÆ  r-  rÇ  rÓ  ÚfliprÕ  rÖ  rä  rå  ræ  rë  rè  rð  ró  r‰  rõ  Úargsortrù  rú  ÚUnicodeCharSeqr  r  rh  ÚNPTimedeltaÚ
NPDatetimerü  rý  rÿ  Útype_callabler  r  ÚlibÚstride_tricksr	  r  r   r  r+  r  r'  Útake_along_axisr,  r3  r7  r<   r<   r<   r=   Ú<module>   s¬  $4<	ÿ
E



ÿ
D

(





22=QE +
*=%



*

*
9 


6


$
@









y
~

	
,




+
*





































7	7'	   ÿ"ÿ  JA X
ÿ






O	0














&
.
C
'%
A

+
$4
))




=2Y
	%

	

)
	



>


^
;
+
