o
    ŽôjB- ã                	   @   sê  d Z ddl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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l0m1Z1 ddl2m3Z3m4Z4m5Z5m6Z6m7Z7 ddl8m9Z9m:Z: ddl;m<Z< ddl=m>Z>m?Z? ddl@mAZAmBZB ddl2mCZC ddlDmEZFmGZHmIZImJZJmKZK ddlLmZM dd„ ZNdd„ ZOdd„ ZPdd„ ZQdd„ ZRdd„ ZSd d!„ ZTd"d#„ ZUd$d%„ ZV	�dkd&d'„ZWd(d)„ ZXd*d+„ ZYe4eYƒd,d-„ ƒZZd.d/„ Z[e4e[ƒd0d1„ ƒZ\e#d2ej]ƒd3d4„ ƒZ^d5d6„ Z_e#d7ej`ƒe)e-jaƒd8d9„ ƒƒZb	�dkd:d;„Zcd<d=„ Zdd>d?„ Zee#ejfej]ejgƒe#ejfej]ejhƒe#ejfej]ejiƒd@dA„ ƒƒƒZje#ejfej]ejkƒdBdC„ ƒZle#ejmej]ejnejnƒdDdE„ ƒZoe#epej]ƒdFdG„ ƒZqe#dHejrƒdIdJ„ ƒZse!dKk �r™e#dLejrejnƒdMdN„ ƒZtdOdP„ ZuG dQdR„ dRevƒZwG dSdT„ dTewƒZxG dUdV„ dVewƒZyG dWdX„ dXewƒZzG dYdZ„ dZewƒZ{G d[d\„ d\ewƒZ|G d]d^„ d^ewƒZ}G d_d`„ d`evƒZ~dadb„ Zdcdd„ Z€e#ejfej]ejrƒdedf„ ƒZ�dgdh„ Z‚didj„ Zƒdkdl„ Z„dmdn„ Z…dodp„ Z†dqdr„ Z‡dsdt„ Zˆdudv„ Z‰e6dwdx„ ƒZŠe6dydz„ ƒZ‹e3d{d|„ ƒZŒd}d~„ Z�e4e
jŽƒdd€„ ƒZ�e3d�d‚„ ƒZ�e4e
j‘ƒdƒd„„ ƒZ’e4e
j“ƒd…d†„ ƒZ”d‡dˆ„ Z•e4e•d‰dŠ�d‹dŒ„ ƒZ–e4e•d�dŠ�dŽd�„ ƒZ—d�d‘„ Z˜d’d“„ Z™e#d”ejrƒd•d–„ ƒZšd—d˜„ Z›e#d”ejrejkƒd™dš„ ƒZœe#d”ejre �ejn¡ƒd›dœ„ ƒZže4e
jŸƒ�dkd�dž„ƒZ e$ejrdŸƒd d¡„ ƒZ¡e4e
j¢ƒ�dld£d¤„ƒZ£e4e
j¤ƒ�dld¥d¦„ƒZ¥e4e
j¦ƒ�dmd¨d©„ƒZ§dªd«„ Z¨d¬d­„ Z©e#d®ejrejkƒd¯d°„ ƒZªe#d®ejre �ejn¡ƒd±d²„ ƒZ«e!d³k �rúe4e
j¬ƒd´dµ„ ƒZ­n	e4e
j¬ƒd¶dµ„ ƒZ­e4e
j®ƒd·d¸„ ƒZ¯e4e
j°ƒ�dkd¹dº„ƒZ±e#d»ejrƒd¼d½„ ƒZ²e#e
j³ejrƒd¾d¿„ ƒZ´e#dÀejrƒdÁdÂ„ ƒZµe3dÃdÄ„ ƒZ¶e3dÅdÆ„ ƒZ·e3dÇdÈ„ ƒZ¸e4e
j¹ƒ�dkdÉdÊ„ƒZºe5ejrdËƒ�dndÌdÍ„ƒZ»dÎdÏ„ Z¼e4e
j½ƒdÐdÑ„ ƒZ¾e4e
j¿ƒdÒdÓ„ ƒZÀe4e
jÁƒdÔdÕ„ ƒZÂe4e
jÃƒdÖd×„ ƒZÄe3dØdÙ„ ƒZÅe 5ejrdÚ¡dÛdÜ„ ƒZÆe6dÝdÞ„ ƒZÇdßdà„ ZÈe4eÈd‰dŠ�dádâ„ ƒZÉe#dãejrejÊƒdädå„ ƒZËe$ejrdæƒdçdè„ ƒZÌe$ejrdéƒe$ejÍdéƒdêdë„ ƒƒZÎe$ejrdìƒe$ejÍdìƒdídî„ ƒƒZÏe$ejrdïƒe$ejÍdïƒdðdñ„ ƒƒZÐe$ejrdòƒdódô„ ƒZÑe$ejrdõƒe$ejÍdõƒdöd÷„ ƒƒZÒe$ejrdøƒ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jr�dƒ�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jr�dƒ�d�d„ ƒZße$ejàdûƒe$ejàdþƒ�d�d„ ƒƒZáe$ejà�dƒ�d�d„ ƒZâe$ejr�dƒ�d�d„ ƒZãe$ejr�dƒ�d�d„ ƒZä�d�d„ Zåe5ejr�d ƒe5ejr�d!ƒ�d"�d#„ ƒƒZæ�d$�d%„ Zçe$ejè�d&ƒeçƒ e$ejè�d'ƒeçƒ e#�d(ejéejnƒ�d)�d*„ ƒZêe%ejrƒ�d+�d,„ ƒZëe#�d(ejrej1ƒ�d-�d.„ ƒZìe%ejíƒ�d/�d0„ ƒZîe&ejíƒ�d1�d2„ ƒZïe#�d(ejíej1ƒ�d3�d4„ ƒZðe#�d(ejíejñƒ�d5�d6„ ƒZòe#�d7ejíej1ejnƒ�d8�d9„ ƒZóe#�d7ejíejñejnƒ�d:�d;„ ƒZôe(ejrƒ�d<�d=„ ƒZõe(ejíƒ�d>�d?„ ƒZöe(ej÷ƒ�d@�dA„ ƒZøe#ejùejrejrƒ�dB�dC„ ƒZúe7ejr�dDƒ�dE�dF„ ƒZû�dG�dH„ Zü�dI�dJ„ Zý		�dn�dK�dL„Zþ	�dk�dM�dN„Zÿ�dO�dP„ �Z �dQ�dR„ �Z�dS�dT„ �Ze$ejr�dUƒ�dV�dW„ ƒ�Ze#d7e�jƒe)e-jaƒ�dX�dY„ ƒƒ�Ze#ejfe�jejgƒ�dZ�d[„ ƒ�Ze#ejme�jejgejnƒ�d\�d]„ ƒ�Ze#epe�jƒ�d^�d_„ ƒ�Ze#e
�j	ejrƒ�d`�da„ ƒ�Z
e#d7e�jƒe)e-jaƒ�db�dc„ ƒƒ�Ze#ee �ejg¡ƒe#e
�je �ejg¡ƒ�dd�de„ ƒƒ�Ze#eejkƒe#e
�jejkƒ�df�dg„ ƒƒ�Ze#d7e�jƒe)e-jaƒ�dh�di„ ƒƒ�Ze#e
�jejnƒ�dj�dk„ ƒ�Ze#d7e�jƒe)e-jaƒ�dl�dm„ ƒƒ�Ze#e�jejèejèƒ�dn�do„ ƒ�Z�dp�dq„ �ZeCejr�drd�dŠ��ds�dt„ ƒ�Z�du�dv„ �Ze6�dw�dx„ ƒ�Z�dy�dz„ �Z�d{�d|„ �Z�d}�d~„ �Z�d�d€„ �Ze6�d��d‚„ ƒ�Z e4e
�j!ƒ�e"f�dƒ�d„„ƒ�Z#e6�d…�d†„ ƒ�Z$e4e
�j%ƒ�dk�d‡�dˆ„ƒ�Z&e6�d‰�dŠ„ ƒ�Z'e5ejr�d‹ƒ�dŒ�d�„ ƒ�Z(e4e
�j)ƒ�e"f�dŽ�d�„ƒ�Z*e4e
�j+ƒ�dk�d��d‘„ƒ�Z,e4e
�j-ƒ�dk�d’�d“„ƒ�Z.e4e
�j/ƒ�dk�d”�d•„ƒ�Z0e4e
�j1ƒ�dk�d–�d—„ƒ�Z2e4e
�j3ƒ�dk�d˜�d™„ƒ�Z4e4e
�j5ƒ�dk�dš�d›„ƒ�Z6�dœ�d�„ �Z7e 4�e7¡�dž�dŸ„ ƒ�Z8e 4e
�j9¡dd�e"f�d �d¡„ƒ�Z:e4e
�j;ƒ�do�d¢�d£„ƒ�Z<e4e
�j=ƒ�d¤�d¥„ ƒ�Z>e4e
�j?ƒ�do�d¦�d§„ƒ�Z@�d¨�d©„ �ZAe4e
�jBƒe5ejr�dªƒ�dk�d«�d¬„ƒƒ�ZC�d­�d®„ �ZDe4e
�jEƒ�dn�d¯�d°„ƒ�ZFe4e
�jGƒ�dl�d±�d²„ƒ�ZH�d³�d´„ �ZIe6�dµ�d¶„ ƒ�ZJe#�d·ejrƒ�d¸�d¹„ ƒ�ZKe4e
�jLƒ�dº�d»„ ƒ�ZM�d¼�d½„ �ZNe6�d¾�d¿„ ƒ�ZOe4e
�jPƒ�dÀ�dÁ„ ƒ�ZQe4e
�jRƒ�dÂ�dÃ„ ƒ�ZSe#�dÄejrejÊƒe#�dÄejrej1ƒ�dÅ�dÆ„ ƒƒ�ZTe6�dÇ�dÈ„ ƒ�ZUe5ejr�dÉƒ�dÊ�dË„ ƒ�ZVe6�dÌ�dÍ„ ƒ�ZWe4e
�jXƒ�e"�dÎdf�dÏ�dÐ„ƒ�ZYe4eƒ�dk�dÑ�dÒ„ƒ�ZZe4eƒ�dk�dÓ�dÔ„ƒ�Z[�dÕ�dÖ„ �Z\�d×�dØ„ �Z]�dÙ�dÚ„ �Z^�dÛ�dÜ„ �Z_�dÝ�dÞ„ �Z`�dß�dà„ �Za�dá�dâ„ �Zb�dã�dä„ �Zce6�då�dæ„ ƒ�Zde4e
�jeƒ�dk�dç�dè„ƒ�Zf�dé�dê„ �Zg�dë�dì„ �Zh�dí�dî„ �Zi�dï�dð„ �Zje6�dñ�dò„ ƒ�Zke4e
�jjƒ�dó�dô„ ƒ�Zl�dõ�dö„ �Zm�d÷�dø„ �Zne4e
�joƒ�dù�dú„ ƒ�Zpe4e
�jqƒ�dû�dü„ ƒ�Zre4e
�jsƒ�dý�dþ„ ƒ�Zt�dÿ�d „ �Zu�d�d„ �Zv�d�d„ �Zw�d�d„ �Zxe6�d�d„ ƒ�Zye4e
�jzƒ�do�d	�d
„ƒ�Z{�d�d„ �Z|e6�d�d„ ƒ�Z}e4e
�j~ƒ�d�d„ ƒ�Z�d�d„ �Z€e6�d�d„ ƒ�Z�e4e
�j‚ƒ�do�d�d„ƒ�Zƒ�d�d„ �Z„e6�d�d„ ƒ�Z…e4e
�j†ƒ�d�d„ ƒ�Z‡e6�d�d„ ƒ�Zˆe4e
�j‰ƒ�d�d „ ƒ�ZŠe!dKk�
r„e!�d!k �
r„e4e
�j‹ƒ�eŠƒ e6�d"�d#„ ƒ�ZŒe4e
�j�ƒ�d$�d%„ ƒ�ZŽe 5ejr�d&¡�d'�d(„ ƒ�Z�e 5ejr�d)¡�d*�d+„ ƒ�Z�e4e
�j‘ƒ�d,�d-„ ƒ�Z’e4e
�j“ƒ�d.�d/„ ƒ�Z”e6�d0�d1„ ƒ�Z•e4e
�j–ƒ�d2�d3„ ƒ�Z—e4e
�j˜ƒ�do�d4�d5„ƒ�Z™e4e
�jšƒ�do�d6�d7„ƒ�Z›e4e
�jœƒ�d8�d9„ ƒ�Z�e4e
�jžƒ�d:�d;„ ƒ�ZŸe4e
�j ƒ�d<�d=„ ƒ�Z¡i �Z¢�d>�d?„ �Z£�dp�dA�dB„�Z¤�dC�dD„ �Z¥e#�dEejrej1ƒ�dF�dG„ ƒ�Z¦e4e
�j§ƒ�dH�dI„ ƒ�Z¨e#�dJejrej1ƒe#e
�j©ejrej1ƒ�dK�dL„ ƒƒ�Zªe'ejrejrƒ�dM�dN„ ƒ�Z«e'ejre�j¬ƒe'ejre�j­ƒe'ejrejgƒe'ejre�j®ƒe'ejre�j¯ƒe'ejreM�j°ƒe'ejreM�j±ƒ�dO�dP„ ƒƒƒƒƒƒƒ�Z²e'ejre�j¬ƒ�dQ�dR„ ƒ�Z³�dS�dT„ �Z´e� µ�e´¡�dU�dV„ ƒ�Z¶e#�e´ejrejkejkƒ�dW�dX„ ƒ�Z·e 4e
�j¸�j¹�jº¡�dq�dY�dZ„ƒ�Zºe 4e
�j¸�j¹�j»¡�dk�d[�d\„ƒ�Z»e4�e¼ƒ�d]�d^„ ƒ�Z½e4e
�j¾ƒ�d_�d`„ ƒ�Z¿e4e
�jÀƒ�da�db„ ƒ�ZÁe3�dc�dd„ ƒ�ZÂe4e
�jÃƒ�de�df„ ƒ�ZÄe4e
�jÅƒ�dr�di�dj„ƒ�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Ú
from_dtypeÚcarrayÚfarrayÚis_contiguousÚ
is_fortranÚcheck_is_integerÚtype_is_scalarÚ
lt_complexÚ	lt_floats)Ú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)Ú_make_constant_bytesÚ
bytes_type)Útuple_setitemÚbuild_full_slice_tuple)Úoverload_classmethod)Úparse_dtypeÚparse_shapeÚ_parse_nested_sequenceÚ_sequence_of_arraysÚ_choose_concatenation_layout)r   c                 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© rA   úb/var/www/html/academy/tools/voices/clone/sv-venv/lib/python3.10/site-packages/numba/np/arrayobj.pyÚset_range_metadata/   s
   

ÿrC   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)r8   ÚwidthrC   )r<   r=   r?   rA   rA   rB   Úmark_positive:   s   rF   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y   tˆ | ƒ |¡ Y S w | jjˆ }|  |¡}|d u r9t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_typerA   rB   rM   P   s   
ÿ

ÿz*make_array.<locals>.ArrayStruct._make_refsc                    sp   | j }ˆdkrˆ  | d¡S |  d¡}g }tˆƒD ]}t ||d|¡}| |¡}| |¡ t||ƒ qt 	||¡S )z\
            Override .shape to inform LLVM that its elements are all positive.
            r   Úshape)
rQ   Ú__getattr__Ú_get_ptr_by_namer7   r	   Úgep_inboundsr=   ÚappendrF   Ú
pack_array)rR   r<   ÚptrÚdimsÚiZdimptrr=   )ÚbaseÚndimrA   rB   r\   d   s   


z%make_array.<locals>.ArrayStruct.shape)Ú__name__Ú
__module__Ú__qualname__rM   Úpropertyr\   Ú__classcell__rA   ©rX   rZ   re   rf   r[   )rY   rB   rX   N   s    rX   )Úas_arrayr	   Úcreate_struct_proxyrf   )rZ   rA   rl   rB   Ú
make_arrayB   s
   
-ro   c                 C   s   |   |j¡}|  |¡S )zB
    Return the item size for the given array or buffer type.
    )Úget_data_typeÚdtypeÚget_abi_sizeof)ÚcontextrZ   ÚlltyrA   rA   rB   Úget_itemsize~   s   
ru   c                 C   s"   |j rdnd}| j||j||d�S )z3
    Load the item at the given array pointer.
    NrD   ©Úalign)ÚalignedÚunpack_valuerq   )rs   r<   Úarraytyrb   rw   rA   rA   rB   Ú	load_item†   s   ÿr{   c                 C   s$   |j rdnd}| j||j|||d�S )z4
    Store the item at the given array pointer.
    NrD   rv   )rx   Ú
pack_valuerq   )rs   r<   rz   Úvalrb   rw   rA   rA   rB   Ú
store_item�   s   r~   c                 C   s@   |j r|  |||tj¡}t |||¡}|S |  |||tj¡}|S )zM
    Fix the integer index' type and value for the given dimension size.
    )ÚsignedÚcastr   Úintpr,   Z	fix_indexÚuintp)rs   r<   ÚidxtyÚidxÚsizeÚindrA   rA   rB   Úfix_integer_index—   s   ÿr‡   c                 C   sZ   t |tjƒr)|jdkr)t |jtjƒsJ ‚t|ƒ| ||ƒ}t| |||jƒ}|j|fS ||fS )zS
    Normalize the index type and value.  0-d arrays are converted to scalars.
    r   )	Ú
isinstancer   ÚArrayrf   rq   ÚIntegerro   r{   Údata)rs   r<   rƒ   r„   ÚidxaryZidxvalrA   rA   rB   Ú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 rA   )r�   )Ú.0rƒ   r„   ©r<   rs   rA   rB   Ú
<listcomp>¶   s
    þÿz%normalize_indices.<locals>.<listcomp>)ÚlenÚzip)rs   r<   Úindex_typesÚindicesrA   r�   rB   Únormalize_indices°   s
   þr•   c                 C   sÄ  | j }| j}| j}	t tjdd¡}
|j|
 }t|jƒ}t|	jƒ}||@ |krC|| }d| j	› dt
|ƒdkr7dnd› d|› d�}t|ƒ‚|d	u rRt| |	 d
¡¡d	ƒ}| tj¡}t|ttfƒrft |||¡}t|ttfƒrtt |||¡}t|tƒr}||ƒ}t|||||d�}|d	u r˜t| |	 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.
    rD   ÚCzThe datamodel for type z is missing fieldÚsÚ ú Ú.NÚmeminfo)r\   Ústridesr‹   Úitemsizer›   ÚparentÚnsw©ÚflagsÚnitemszmissing {0}) rI   rQ   Ú
_datamodelr   r‰   Úfloat64rN   ÚsetÚ_fieldsÚ_fe_typer‘   Ú
ValueErrorr   Úget_value_typeÚget_typer�   rˆ   ÚtupleÚlistr	   ra   ÚintÚdictÚget_constantÚunpack_tupler8   ÚcountÚmulÚkeysÚformatÚitemsÚsetattr)Úarrayr‹   r\   rœ   r�   r›   rž   rs   r<   rU   Zstandard_arrayZstandard_array_type_datamodelZrequired_fieldsZdatamodel_fieldsÚmissingÚmsgÚintp_tÚattrsr¢   Úunpacked_shapeÚaxlenZ
got_fieldsÚkÚvrA   rA   rB   Úpopulate_array½   sh   



ÿÿÿÿ
üÿ
ÿrÀ   c                 C   sh   |j }|j}| tjd¡}t ||j| j¡}|D ]}|j	||dgd�}q||_
| tjt|| ƒ¡|_dS )z‡
    Update some auxiliary information in *array* after some of its fields
    were changed.  `itemsize` and `nitems` are updated.
    rD   rŸ   r    N)rI   rQ   r¯   r   r�   r	   r°   r\   rf   r²   r¢   ru   r�   )Úarytyr·   rs   r<   r¢   r¼   r½   rA   rA   rB   Úupdate_array_info  s   
ÿrÂ   c                 C   ó   t ƒ ‚)z/Constrain axis values to valid positive values.©rK   ©Ú	func_nameÚarg_namerf   ÚaxisrA   rA   rB   Únormalize_axis  ó   rÉ   c                    sL   t | tƒs
t d¡‚t |tƒst d¡‚| j› d|j› d�‰ ‡ fdd„}|S )Nú func_name must be a str literal.úarg_name must be a str literal.ú: Argument ú* out of bounds for dimensions of the arrayc                    s,   |dk r||7 }|dk s||krt ˆ ƒ‚|S ©Nr   ©r¨   rÅ   ©r¹   rA   rB   Úimpl&  s
   z&normalize_axis_overloads.<locals>.impl)rˆ   r$   r   ÚTypingErrorÚliteral_value©rÆ   rÇ   rf   rÈ   rÒ   rA   rÑ   rB   Únormalize_axis_overloads  s   



ÿrÖ   c                 C   rÃ   )zFNormalizes an axis argument into a tuple of non-negative integer axes.rÄ   rÅ   rA   rA   rB   Únormalize_axis_tuple1  rÊ   r×   c                    s’   t | tƒs
t d¡‚t |tƒst d¡‚| j› d|j› d�‰| j› d|j› d�‰t |tjƒr6‡fdd„}|S t|ƒ‰ d	ˆ  ‰‡ ‡‡‡fd
d„}|S )NrË   rÌ   rÍ   rÎ   z: repeated axis in z	 argumentc                    s.   |dk r||7 }|dk s||krt ˆ ƒ‚|fS rÏ   rÐ   rÅ   )Úinvalid_axis_msgrA   rB   rÒ   I  s
   z,normalize_axis_tuple_overloads.<locals>.impl©r   c                    sf   ˆ}t |ƒD ]\}}|dk r||7 }|dk s||krtˆƒ‚t|||ƒ}qtt|ƒƒˆ kr1tˆƒ‚|S rÏ   )Ú	enumerater¨   r/   r‘   r¥   )rÆ   rÇ   rf   rÈ   Z	norm_axisrd   Úax©Zaxis_lenrØ   Znorm_axis_initZrepeated_axis_msgrA   rB   rÒ   U  s   )rˆ   r$   r   rÓ   rÔ   r   rŠ   r‘   rÕ   rA   rÜ   rB   Únormalize_axis_tuple_overloads6  s"   



ÿÿÿïrÝ   Úgetiterc                 C   st   |j \}|\}|  ||j¡}|  tjd¡}t ||¡}||_||_	| j
r,| j |||¡ | ¡ }	t| ||j|	ƒ}
|
S rÏ   )ÚargsÚmake_helperÚreturn_typer¯   r   r�   r	   Úalloca_once_valueÚindexr·   Ú
enable_nrtÚnrtÚincrefÚ	_getvaluer    )rs   r<   rT   rß   rz   r·   ÚiterobjÚzeroZindexptrÚresÚoutrA   rA   rB   Úgetiter_arrayf  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
ƒrEt| |||||	|
|ƒ}| ¡ S |
rIJ ‚t| |||	ƒS )z1 Evaluate `ary[idx]`, where idx is a single int. ©r±   r   rD   N)r	   r°   r\   rf   rœ   r²   Úpointer_addr‹   rˆ   r   ÚBufferÚ	make_viewrç   r{   )rs   r<   rá   rÁ   Úaryr„   Úshapesrœ   ÚoffsetÚdataptrÚview_shapesÚview_stridesÚretaryrA   rA   rB   Ú_getitem_array_single_int~  s   ÿrø   Úiternextc                 C   sØ   |j \}|\}|j}| j|||d�}t|ƒ| ||jd�}	tj||	jdd�\}
| |j	¡}| 
d||
¡}| |¡ | |¡�% t| ||j||	|ƒ}| |¡ t ||¡}| ||j	¡ W d   ƒ d S 1 sew   Y  d S )N©ÚvaluerD   rí   ú<)rß   rZ   rà   ro   r·   r	   r°   r\   r=   rã   Úicmp_signedÚ	set_validÚif_thenrø   Ú
yield_typeÚyield_Úincrement_indexÚstore)rs   r<   rT   rß   ÚresultÚitertyÚiterrz   rè   rñ   r¢   rã   Úis_validrû   ZnindexrA   rA   rB   Úiternext_array“  s"   
ÿ
"úr  c              	   C   s>  |   tjd¡}|   tjd¡}t ||j|j¡}	t ||j|j¡}
g }g }g }tdd„ |D ƒƒ}d}t	||ƒD ]³\}}|tj
u ri|jt|ƒ d | }t|ƒD ]}| |¡ | |	| ¡ | |
| ¡ |d7 }qNq6t|tjƒr¨| j|||d�}t | |||¡ t |||	| ¡ | |j¡ t ||¡}t |||
| ¡}| |¡ | |¡ n=t|tjƒrËt| ||||	| ƒ}|rÅt | |||	| |¡ | |¡ nt|ƒrÞ| |¡ | |¡ |d8 }ntd|f ƒ‚|d7 }q6||jksñJ ‚||jk �r| |	| ¡ | |
| ¡ |d7 }||jk s÷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   rD   c                 S   ó   g | ]}t |ƒr|‘qS rA   ©r   ©rŽ   r„   rA   rA   rB   r�   À  ó    z"basic_indexing.<locals>.<listcomp>rú   úunexpected index type: %sF©Ú
wraparoundÚboundscheck)r¯   r   r�   r	   r°   r\   rf   rœ   r‘   r’   Úellipsisr7   r`   rˆ   Ú	SliceTyperà   r,   Úguard_invalid_sliceÚ	fix_sliceÚstartÚget_slice_lengthZ
fix_striderŠ   r‡   Údo_boundscheckr   rK   Úget_item_pointer)rs   r<   rÁ   rñ   r“   r”   r  ré   Úonerò   rœ   Úoutput_indicesZoutput_shapesÚoutput_stridesÚnum_newaxesrÛ   Úindexvalrƒ   Ú	n_missingrd   ÚsliceÚshÚstr†   rô   rA   rA   rB   Úbasic_indexing¯  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‹   r\   rœ   r�   r›   rž   )ro   rÀ   r�   r›   rž   )	rs   r<   rÁ   rñ   rá   r‹   rò   rœ   r÷   rA   rA   rB   rð   ó  s   úrð   c              	   C   s^   t | |||||| jd�\}}}	t|tjƒr$t| |||||||	ƒ}
|
 ¡ S |r(J ‚t| |||ƒS )zp
    Return the result of indexing *ary* with the given *indices*,
    returning either a scalar or a view.
    ©r  )r"  Úenable_boundscheckrˆ   r   rï   rð   rç   r{   )rs   r<   rá   rÁ   rñ   r“   r”   rô   rõ   rö   r÷   rA   rA   rB   Ú_getitem_array_generic  s   ÿÿÿr&  c           	      C   sf   |j \}}|\}}t|tjƒs|jdksJ ‚t|ƒ| ||ƒ}t| ||j|||f|fƒ}t| ||j|ƒS )z9
    Basic indexing with an integer, slice, or None.
    rD   )	rß   rˆ   r   ÚNoneTyperf   ro   r&  rá   r   ©	rs   r<   rT   rß   rÁ   rƒ   rñ   r„   rê   rA   rA   rB   Úgetitem_arraynd_intp  s   

ÿr)  c              	   C   sœ   |j \}}|\}}t|ƒ| ||ƒ}|j}tj||t|ƒd�}	t| |||	ƒ\}}	tdd„ |D ƒƒr;t| |||||||	ƒS t	| ||j
||||	ƒ}
t| ||j
|
ƒS )z2
    Basic or advanced indexing with a tuple.
    rí   c                 s   ó   � | ]	}t |tjƒV  qd S ©N©rˆ   r   r‰   )rŽ   ÚtyrA   rA   rB   Ú	<genexpr>;  ó   € z&getitem_array_tuple.<locals>.<genexpr>)rß   ro   r   r	   r°   r‘   r•   ÚanyÚfancy_getitemr&  rá   r   )rs   r<   rT   rß   rÁ   Útuptyrñ   Útupr“   r”   rê   rA   rA   rB   Úgetitem_array_tuple,  s    
ÿ
ÿ
ÿr4  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yR   d}Y nw t|ƒ}|rbt| ||||
|ƒ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‘   ro   r•   r"  r%  rK   ÚboolÚfancy_setslicer€   rq   r~   )rs   r<   rT   rß   rÁ   rƒ   Úvaltyrñ   r„   r}   r“   r”   rô   rò   rœ   Zuse_fancy_indexingrA   rA   rB   Úsetitem_arrayE  s4   
ÿÿÿÿ
ÿr9  c           	      C   sD   |j \}|\}t|ƒ}|| ||ƒ}|j}| |d¡}t| ||j|ƒS rÏ   )rß   ro   r\   Úextract_valuer!   rá   )	rs   r<   rT   rß   rÁ   rñ   ZarysttyZshapearyrê   rA   rA   rB   Ú	array_lenn  s   r;  z
array.itemc                 C   sˆ   |j \}|\}t|ƒ| ||ƒ}|j}|j| d|| d¡¡dd�� d}| j |t|f¡ W d   ƒ n1 s7w   Y  t	| |||j
ƒS )Nú!=rD   F©Úlikelyz>item(): can only convert an array of size 1 to a Python scalar)rß   ro   r¢   rÿ   rý   r8   Ú	call_convÚreturn_user_excr¨   r{   r‹   )rs   r<   rT   rß   rÁ   rñ   r¢   r¹   rA   rA   rB   Ú
array_itemy  s   ÿýrA  ©é   r   zarray.itemsetc           
      C   s¤   |j \}}|\}}||jksJ ‚t|ƒ| ||ƒ}|j}|j| d|| d¡¡dd�� d}	| j |t	|	f¡ W d   ƒ n1 s@w   Y  t
| ||||jƒ |  ¡ S )Nr<  rD   Fr=  z/itemset(): can only write to an array of size 1)rß   rq   ro   r¢   rÿ   rý   r8   r?  r@  r¨   r~   r‹   Úget_dummy_value)
rs   r<   rT   rß   rÁ   r8  rñ   r}   r¢   r¹   rA   rA   rB   Úarray_itemset‰  s   
ÿýrE  c              
   C   sH   t  |j|j|jg¡}| j d|jg|¡}|  |||  || d¡¡g¡S )a  
    Map a loop counter onto a dimension that is broadcast against it, i.e.
    whose extent is either 1 or the full loop extent.

    Previous versions of this code used to use the LLVM signed remainder
    instructions `srem`. However, since domain of the arguments when
    broadcasting an index is restricted, it is sufficient (and faster) to use
    the unsigned minimum instrinsic `umin` here. The `idx` parameter is
    guaranteed to be in the range `[0, n-1]`  and the `extent` parameter is
    guaranteed to be either `1` or `n` exactly -- where `n` is the true extent
    of the dimension of the array being broadcast. Importantly `idx` can never
    take on negative values, since Numba controls the loop iteration and will
    loop any variable from `0` to `n-1`.  Additionally, `extent` can be neither
    `0` nor a value between `1` and `n`. If extent were `0` there is no
    dimension to broadcast and the loop would never run. If `extent` were
    something other than `1` or `n` this would be an illegal broadcast which
    would have been rejected long before this code is executed.
    Computationally, the advantage is that the unsigned minimum `umin`
    intrinsic is significantly less computationally intensive as it lowers to a
    simple combination of compare and select  instructions whereas computing
    the signed remainder `srem` requires multiple divisions, subtractions and
    shuffling.

    See also: https://github.com/numba/numba/issues/10851
    See also: https://github.com/numba/numba/pull/10852

    z	llvm.uminrD   )r   ÚFunctionTyper8   r9   Údeclare_intrinsicÚcallÚsub)r<   r„   ÚextentÚfntyZuminrA   rA   rB   Úbroadcast_indexž  s   rL  c                   @   óH   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 )ÚIndexerzq
    Generic indexer interface, for generating indices over a fancy indexed
    array on a single dimension.
    c                 C   ó   t ‚)ze
        Prepare the indexer by initializing any required variables, basic
        blocks...
        rÄ   ©rR   rA   rA   rB   ÚprepareÅ  ó   zIndexer.preparec                 C   rO  )z=
        Return this dimension's size as an integer.
        rÄ   rP  rA   rA   rB   Úget_sizeÌ  ó   zIndexer.get_sizec                 C   rO  )z;
        Return this dimension's shape as a tuple.
        rÄ   rP  rA   rA   rB   Ú	get_shapeÒ  rT  zIndexer.get_shapec                 C   rO  )z}
        Return a half-open [lower, upper) range of indices this dimension
        is guaranteed not to step out of.
        rÄ   rP  rA   rA   rB   Úget_index_boundsØ  rR  zIndexer.get_index_boundsc                 C   rO  )z—
        Start indexation loop.  Returns a index.
        *index* is an integer LLVM value representing the index over this
        dimension.
        rÄ   rP  rA   rA   rB   Ú	loop_headß  s   zIndexer.loop_headc                 C   rO  )z)
        Finish indexation loop.
        rÄ   rP  rA   rA   rB   Ú	loop_tailç  rT  zIndexer.loop_tailc                 C   rO  )zL
        Return the source index for this dimension, if applicable.
        rÄ   rP  rA   rA   rB   Úget_src_idxí  rT  zIndexer.get_src_idxN)rg   rh   ri   Ú__doc__rQ  rS  rU  rV  rW  rX  rY  rA   rA   rA   rB   rN  ¿  s    rN  c                   @   óP   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d„ ZdS )ÚEntireIndexerz:
    Compute indices along an entire array dimension.
    c                 C   s2   || _ || _|| _|| _|| _| j  tj¡| _d S r+  )	rs   r<   rÁ   rñ   Údimr©   r   r�   Úll_intp)rR   rs   r<   rÁ   rñ   r]  rA   rA   rB   Ú__init__ù  s   zEntireIndexer.__init__c                 C   sB   | j }| | jj| j¡| _t || j¡| _	| 
¡ | _| 
¡ | _d S r+  )r<   r:  rñ   r\   r]  r…   r	   rP   r^  rã   Úappend_basic_blockÚbb_startÚbb_end©rR   r<   rA   rA   rB   rQ    s
   
zEntireIndexer.preparec                 C   ó   | j S r+  ©r…   rP  rA   rA   rB   rS    ó   zEntireIndexer.get_sizec                 C   s   | j fS r+  re  rP  rA   rA   rB   rU    ó   zEntireIndexer.get_shapec                 C   ó   |   d¡| jfS rÏ   ©r^  r…   rP  rA   rA   rB   rV    ó   zEntireIndexer.get_index_boundsc                 C   sŽ   | j }| j  t| jdƒ| j¡ | | j¡ | | j¡ | | j¡}|j	| 
d|| j¡dd�� | | j¡ W d   ƒ |S 1 s@w   Y  |S )Nr   ú>=Fr=  )r<   r  r   r^  rã   Úbranchra  Úposition_at_endr=   rÿ   rý   r…   rb  )rR   r<   Ú	cur_indexrA   rA   rB   rW    s   ÿ
þýzEntireIndexer.loop_headc                 C   sD   | j }t || | j¡¡}| || j¡ | | j¡ | | j	¡ d S r+  )
r<   r	   r  r=   rã   r  rl  ra  rm  rb  )rR   r<   Ú
next_indexrA   rA   rB   rX    s
   zEntireIndexer.loop_tailc                 C   ó   | j  | j¡fS r+  )r<   r=   rã   rP  rA   rA   rB   rY  %  ó   zEntireIndexer.get_src_idxN©rg   rh   ri   rZ  r_  rQ  rS  rU  rV  rW  rX  rY  rA   rA   rA   rB   r\  ô  s    r\  c                   @   r[  )ÚIntegerIndexerz0
    Compute indices from a single integer.
    c                 C   s&   || _ || _|| _| j  tj¡| _d S r+  )rs   r<   r„   r©   r   r�   r^  )rR   rs   r<   r„   rA   rA   rB   r_  .  s   zIntegerIndexer.__init__c                 C   ó   d S r+  rA   rP  rA   rA   rB   rQ  4  ó   zIntegerIndexer.preparec                 C   s   t | jdƒS ©NrD   )r   r^  rP  rA   rA   rB   rS  7  ó   zIntegerIndexer.get_sizec                 C   ó   dS ©NrA   rA   rP  rA   rA   rB   rU  :  ru  zIntegerIndexer.get_shapec                 C   s   | j | j | j |  ¡ ¡fS r+  )r„   r<   ÚaddrS  rP  rA   rA   rB   rV  =  s   zIntegerIndexer.get_index_boundsc                 C   rd  r+  )r„   rP  rA   rA   rB   rW  A  rf  zIntegerIndexer.loop_headc                 C   rt  r+  rA   rP  rA   rA   rB   rX  D  ru  zIntegerIndexer.loop_tailc                 C   rx  ry  rA   rP  rA   rA   rB   rY  G  ru  zIntegerIndexer.get_src_idxNrr  rA   rA   rA   rB   rs  )  s    rs  c                   @   r[  )ÚIntegerArrayIndexerz;
    Compute indices from an array of integer indices.
    c                 C   sN   || _ || _|| _t ||j¡| _|| _| j  t	j
¡| _|| _|| _d | _d S r+  )rs   r<   Úglobal_ary_idx_listr	   r°   r\   Ú	idx_shaper…   r©   r   r�   r^  rƒ   rŒ   Úsrc_idx)rR   rs   r<   rƒ   rŒ   r…   r|  rA   rA   rB   r_  P  s   
zIntegerArrayIndexer.__init__c                 C   sH   | j }|  d¡| _| jD ]}| j  | j|¡| _q| ¡ | _| ¡ | _d S rv  )r<   r^  Úidx_sizer}  r²   r`  ra  rb  )rR   r<   Ú_shaperA   rA   rB   rQ  ^  s   

zIntegerArrayIndexer.preparec                 C   rd  r+  )r  rP  rA   rA   rB   rS  f  rf  zIntegerArrayIndexer.get_sizec                 C   rx  ry  rA   rP  rA   rA   rB   rU  i  ru  zIntegerArrayIndexer.get_shapec                 C   rh  rÏ   ri  rP  rA   rA   rB   rV  l  rj  z$IntegerArrayIndexer.get_index_boundsc              	      s¶   ˆj ‰ ˆ  ˆj¡ ˆ  ˆj¡ ‡ fdd„ˆjtˆjƒtˆjƒ d … D ƒ‰‡ ‡‡fdd„ttˆjƒƒD ƒ‰tˆj	ˆj ˆj
jˆj
ˆjdd„ ˆjD ƒtˆƒƒ}tˆj	ˆ ˆj
j|ˆjƒ}|S )Nc                    ó   g | ]}ˆ   |¡‘qS rA   ©r=   r  ©r<   rA   rB   r�   w  s    
ÿz1IntegerArrayIndexer.loop_head.<locals>.<listcomp>c                    s"   g | ]}t ˆ ˆ| ˆj| ƒ‘qS rA   )rL  r}  ©rŽ   rd   ©r<   r”   rR   rA   rB   r�   {  s    ÿÿc                 S   s   g | ]}t j‘qS rA   ©r   r�   ©rŽ   Ú_rA   rA   rB   r�   ƒ  s    )r<   rl  ra  rm  r|  r‘   r}  r7   r&  rs   rƒ   rq   rŒ   r«   r‡   r…   )rR   rã   rA   r…  rB   rW  p  s(   
ÿÿþýÿzIntegerArrayIndexer.loop_headc                 C   s"   | j }| | j¡ | | j¡ d S r+  )r<   rl  rb  rm  rc  rA   rA   rB   rX  ‰  s   zIntegerArrayIndexer.loop_tailc                 C   rx  ry  rA   rP  rA   rA   rB   rY  Ž  ru  zIntegerArrayIndexer.get_src_idxNrr  rA   rA   rA   rB   r{  K  s    r{  c                   @   r[  )ÚBooleanArrayIndexerz>
    Compute indices from an array of boolean predicates.
    c                 C   sH   || _ || _|| _|| _|jdksJ ‚| j  tj¡| _t	| jdƒ| _
d S ©NrD   r   )rs   r<   rƒ   rŒ   rf   r©   r   r�   r^  r   ré   )rR   rs   r<   rƒ   rŒ   rA   rA   rB   r_  —  s   zBooleanArrayIndexer.__init__c                 C   s^   | j }t || jj¡d | _t || j¡| _t || j¡| _	| 
¡ | _| 
¡ | _| 
¡ | _d S rÏ   )r<   r	   r°   rŒ   r\   r…   rP   r^  Ú	idx_indexr~  r`  ra  Úbb_tailrb  rc  rA   rA   rB   rQ     s   

zBooleanArrayIndexer.preparec                 C   s–   | j }t || j¡}t || j¡�-}| |¡}t| j|| j	j
| j	| j|jƒ}| || ||j¡¡}| ||¡ W d   ƒ n1 sAw   Y  | |¡S r+  )r<   r	   râ   ré   Ú	for_ranger…   r=   rø   rs   rƒ   rq   rŒ   rã   rz  Úzextr8   r  )rR   r<   r±   ÚloopÚcÚpredrA   rA   rB   rS  ª  s   
þù
	zBooleanArrayIndexer.get_sizec                 C   ó
   |   ¡ fS r+  ©rS  rP  rA   rA   rB   rU  ¹  ó   
zBooleanArrayIndexer.get_shapec                 C   rh  rÏ   ri  rP  rA   rA   rB   rV  ¼  s   z$BooleanArrayIndexer.get_index_boundsc                 C   sò   | j }| j  | j| j¡ | j  | j| j¡ | | j¡ | | j¡ | | j¡}|j	| 
d|| j¡dd�� | | j¡ W d   ƒ n1 sEw   Y  t| j|| jj| j| j|ƒ}| 	| |¡¡� | | j¡ W d   ƒ |S 1 srw   Y  |S )Nrk  Fr=  )r<   r  ré   r‹  r~  rl  ra  rm  r=   rÿ   rý   r…   rb  rø   rs   rƒ   rq   rŒ   Únot_rŒ  )rR   r<   rn  r‘  rA   rA   rB   rW  Á  s*   ÿþþ
ÿþzBooleanArrayIndexer.loop_headc                 C   s~   | j }t || | j¡¡}| || j¡ | | j¡ | | j¡ t || | j	¡¡}| || j	¡ | | j
¡ | | j¡ d S r+  )r<   r	   r  r=   r~  r  rl  rŒ  rm  r‹  ra  rb  )rR   r<   r~  ro  rA   rA   rB   rX  Õ  s   
þ
þzBooleanArrayIndexer.loop_tailc                 C   rp  r+  ©r<   r=   r~  rP  rA   rA   rB   rY  æ  rj  zBooleanArrayIndexer.get_src_idxNrr  rA   rA   rA   rB   r‰  ’  s    	
r‰  c                   @   r[  )ÚSliceIndexerz(
    Compute indices along a slice.
    c                 C   sL   || _ || _|| _|| _|| _|| _|| _| j  tj	¡| _
t| j
dƒ| _d S rÏ   )rs   r<   rÁ   rñ   r]  rƒ   r  r©   r   r�   r^  r   ré   )rR   rs   r<   rÁ   rñ   r]  rƒ   r  rA   rA   rB   r_  ð  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+  )r<   r:  rñ   r\   r]  Údim_sizer,   r  rs   rƒ   r  r  r	   Ú
is_neg_intÚstepÚis_step_negativerP   r^  rã   r~  r`  ra  rb  rc  rA   rA   rB   rQ  û  s   ÿ
zSliceIndexer.preparec                 C   s   t  | j| j¡S r+  )r,   r  r<   r  rP  rA   rA   rB   rS  
  rq  zSliceIndexer.get_sizec                 C   r’  r+  r“  rP  rA   rA   rB   rU    r”  zSliceIndexer.get_shapec                 C   s   t  | j| j¡\}}||fS r+  )r,   Zget_slice_boundsr<   r  )rR   ÚlowerÚupperrA   rA   rB   rV    s   zSliceIndexer.get_index_boundsc              	   C   s¼   | j }| j  | jj| j¡ | j  | j| j¡ | | j¡ | 	| j¡ | 
| j¡}| | j| d|| jj¡| d|| jj¡¡}|j|dd�� | | j¡ W d   ƒ |S 1 sWw   Y  |S )Nz<=rk  Fr=  )r<   r  r  r  rã   ré   r~  rl  ra  rm  r=   Úselectr›  rý   Ústoprÿ   rb  )rR   r<   rn  Úis_finishedrA   rA   rB   rW    s(   ÿÿý
ÿþzSliceIndexer.loop_headc                 C   s|   | j }|j| | j¡| jjdgd�}|j| | j¡|  d¡dgd�}| || j¡ | || j¡ | 	| j
¡ | | j¡ d S )NrŸ   r    rD   )r<   rz  r=   rã   r  rš  r~  r^  r  rl  ra  rm  rb  )rR   r<   ro  Znext_src_idxrA   rA   rB   rX  %  s   
ý
ýzSliceIndexer.loop_tailc                 C   rp  r+  r–  rP  rA   rA   rB   rY  6  rj  zSliceIndexer.get_src_idxNrr  rA   rA   rA   rB   r—  ë  s    r—  c                   @   sL   e 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d„ Z
dS )ÚSubspaceIndexerc                 C   sV   || _ || _|| _|| _| j  tj¡| _|  d¡| _| jD ]}| j 	| j|¡| _qd S rv  )
rs   r<   r|  Úshape_tupler©   r   r�   r^  r…   r²   )rR   rs   r<   r¢  r|  r€  rA   rA   rB   r_  <  s   
ÿzSubspaceIndexer.__init__c                    s6   | j ‰ ‡ fdd„| jD ƒ| _‡ fdd„| jD ƒ| _d S )Nc                    ó   g | ]}ˆ   ¡ ‘qS rA   ©r`  r‡  rƒ  rA   rB   r�   I  ó    ÿz+SubspaceIndexer.prepare.<locals>.<listcomp>c                    r£  rA   r¤  r‡  rƒ  rA   rB   r�   L  r¥  )r<   r|  Ú	bb_startsÚbb_endsrP  rA   rƒ  rB   rQ  G  s   
ÿ
ÿzSubspaceIndexer.preparec                 C   rd  r+  re  rP  rA   rA   rB   rS  P  rf  zSubspaceIndexer.get_sizec                 C   rd  r+  )r¢  rP  rA   rA   rB   rU  S  rf  zSubspaceIndexer.get_shapec                 C   rh  rÏ   ri  rP  rA   rA   rB   rV  V  rj  z SubspaceIndexer.get_index_boundsc              	   C   s¸   | j }tt| jƒƒD ]O}| | j| ¡ | | j| ¡ | | j| ¡}|j| 	d|| j
| ¡dd�� | j  t| jdƒ| j| ¡ | | j| ¡ W d   ƒ n1 sTw   Y  q
d S )Nrk  Fr=  r   )r<   r7   r‘   r|  rl  r¦  rm  r=   rÿ   rý   r¢  r  r   r^  r§  )rR   r<   rd   rn  rA   rA   rB   rW  Z  s"   þ
þø€üzSubspaceIndexer.loop_headc                 C   sl   | j }ttt| jƒƒƒD ]'}t || | j| ¡¡}| || j| ¡ | 	| j
| ¡ | | j| ¡ qd S r+  )r<   Úreversedr7   r‘   r|  r	   r  r=   r  rl  r¦  rm  r§  )rR   r<   rd   ro  rA   rA   rB   rX  r  s   þùzSubspaceIndexer.loop_tailc                    s   t ‡ fdd„ˆ jD ƒƒS )Nc                 3   s   � | ]	}ˆ j  |¡V  qd S r+  )r<   r=   r  rP  rA   rB   r.  ~  r/  z.SubspaceIndexer.get_src_idx.<locals>.<genexpr>)r«   r|  rP  rA   rP  rB   rY  }  s   zSubspaceIndexer.get_src_idxN)rg   rh   ri   r_  rQ  rS  rU  rV  rW  rX  rY  rA   rA   rA   rB   r¡  ;  s    	r¡  c                   @   rM  )ÚFancyIndexerz4
    Perform fancy indexing on the given array.
    c              	      sr  |ˆ_ ˆ ˆ_|ˆ_t ˆ |j|j¡ˆ_t ˆ |j|j¡ˆ_ˆj  	t
j¡ˆ_|ˆ_‡ ‡fdd„tt|ƒƒD ƒˆ_ˆjD ]}ˆj tˆjdƒ|¡ q:g }	tdd„ |D ƒƒ}
d}d}g ˆ_t||ƒD ]Ê\}}|t
ju r�|jt|ƒ d |
 }t|ƒD ]}t|ˆ |||ƒ}|	 |¡ |d7 }|d7 }qwq_t|t
jƒr­| ˆ ||¡}t|ˆ |||||ƒ}|	 |¡ ntt|t
jƒrÎt|ˆ ||ˆj| ƒ}t|ˆ |ƒ}|	 |¡ |d8 }nSt|t
jƒ�r
t |ƒ|ˆ |ƒ}t|j!t
jƒròt"|ˆ ||ˆj| ˆjƒ}nt|j!t
j#ƒ�rt$|ˆ ||ƒ}nJ ‚|	 |¡ nt%|ƒ�rˆj |¡ |d8 }nt&d|f ƒ‚|d7 }|d7 }q_||jk�s7J ||jfƒ‚||jk �rTt|ˆ |||ƒ}|	 |¡ |d7 }||jk �s=t|	ƒ|jk�seJ t|	ƒ|jfƒ‚t'|ˆ |ˆjƒˆ_(d}d}d }t)dd„ |	D ƒƒ�r±t*|	ƒD ]$\}}t|t"tfƒ�r |�s—d	}|d7 }|d u �rž|}�q‚|�r¥d}�q‚|�r±|dk�r±d}|ˆ_+|	ˆ_,d S )
Nc                    s   g | ]	}t  ˆ ˆj¡‘qS rA   )r	   rP   r^  r‡  ©r<   rR   rA   rB   r�   �  s    ÿÿz)FancyIndexer.__init__.<locals>.<listcomp>r   c                 S   r	  rA   r
  r  rA   rA   rB   r�   –  r  rD   r  Fc                 S   s   g | ]}t |tƒ‘qS rA   )rˆ   r{  r„  rA   rA   rB   r�   ×  ó    T)-rs   r<   rÁ   r	   r°   r\   rf   rò   rœ   r©   r   r�   r^  Úsubspace_shaper7   r‘   r|  r  r   Únewaxesr’   r  r\  r`   rˆ   r  rà   r—  rŠ   r‡   rs  r‰   ro   rq   r{  ÚBooleanr‰  r   ÚAssertionErrorr¡  Úsubspace_indexerr0  rÚ   Úsubspace_indexÚindexers)rR   rs   r<   rÁ   rñ   r“   r”   Úsubspace_shape_tupler„   r²  r  rÛ   Znew_axr  rƒ   r  rd   Úindexerr  r†   rŒ   Znum_subspacesZin_subspacer±  rA   rª  rB   r_  †  s²   
þ



ÿ
ÿ

ýÿ



ý"
ÿ
€€

zFancyIndexer.__init__c                 C   s®   | j  tjd¡}t| jƒD ]\}}|| jkr| j ¡  | ¡  qg }| jD ]}| 	t
| ¡ ƒ¡ q%| jd urB| | jt
| j ¡ ƒ¡ t|g ƒ| _| jD ]	}| j ||¡ qKd S rv  )rs   r¯   r   r�   rÚ   r²  r±  r°  rQ  r`   r¬   rU  ÚinsertÚsumÚindexers_shaper­  )rR   r  r„   rd   Z	res_shaperA   rA   rB   rQ  ê  s"   




þ
ÿzFancyIndexer.preparec                 C   rd  )z?
        Get the resulting data shape as Python tuple.
        )r·  rP  rA   rA   rB   rU    s   zFancyIndexer.get_shapec              	   C   s  t |ƒ| jjks
J ‚| j}tj}|  d¡}|  d¡}|}|}t| j| j	|ƒD ]C\}	}
}| 
|| d|
|¡¡}|	 ¡ \}}| ||¡}| || ||¡¡}| d||¡}| || |||¡¡}| || |||¡¡}q&| ||¡}| |||¡}| |||¡}||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   rD   ú==rü   )r‘   rÁ   rf   r<   r	   Ú	false_bitr^  r’   r²  r·  Úor_Úicmp_unsignedrV  r²   rI  rý   rz  rž  )rR   rœ   r�   r<   Úis_emptyré   r  rœ  r�  r´  r\   ÚstrideZlower_indexZupper_indexZlower_offsetZupper_offsetZis_downwardsrA   rA   rB   Úget_offset_bounds  sB   


ÿÿþÿþÿzFancyIndexer.get_offset_boundsc                 C   sB   g }t | jƒD ]\}}|| jkr| j ¡  | | ¡ ¡ qt|ƒS r+  )rÚ   r²  r±  r°  rW  r`   r«   )rR   r”   r„   rd   rA   rA   rB   Úbegin_loops2  s   

zFancyIndexer.begin_loopsc                 C   sF   t | jƒd }t| jƒD ]}| ¡  || jkr| j ¡  |d8 }qd S rv  )r‘   r²  r¨  rX  r±  r°  )rR   r„   rd   rA   rA   rB   Ú	end_loops:  s   


üzFancyIndexer.end_loopsc                 C   sb   dd„ | j D ƒ}| jd ur| | jt| j ¡ ƒ¡ t|g ƒ}| jD ]}| ||  d¡¡ q!t	|ƒS )Nc                 S   s   g | ]}t | ¡ ƒ‘qS rA   )r¬   rY  r  rA   rA   rB   r�   C  r  z0FancyIndexer.get_src_indices.<locals>.<listcomp>r   )
r²  r±  rµ  r¬   r°  rY  r¶  r­  r^  r«   )rR   r”   rd   rA   rA   rB   Úget_src_indicesB  s   
þ

zFancyIndexer.get_src_indicesN)rg   rh   ri   rZ  r_  rQ  rU  r¾  r¿  rÀ  rÁ  rA   rA   rA   rB   r©  �  s    d&r©  c                 C   sª   t |ƒdkrtt ||d d j¡ƒS tdd„ |D ƒƒ}dd„ }t tdd	„ |D ƒƒ¡}tjtj	|d
�}|  
||t||ƒt |tdd„ |D ƒƒ¡f¡}tt ||¡ƒ}|S )NrD   r   é   c                 S   ó   g | ]}|d  j ‘qS )rC  ©rf   )rŽ   rñ   rA   rA   rB   r�   T  r«  z&get_subspace_shape.<locals>.<listcomp>c                  W   s
   t j| Ž S r+  )ÚnpÚbroadcast_shapes©rß   rA   rA   rB   Úbdcast_idx_shapesV  r”  z-get_subspace_shape.<locals>.bdcast_idx_shapesc                 s   s&   � | ]}t jt j|d  jd�V  qdS )rC  rí   N)r   ÚUniTupler�   rf   ©rŽ   Zary_idxrA   rA   rB   r.  Z  s   € þÿz%get_subspace_shape.<locals>.<genexpr>rí   c                 S   rÃ  )rÂ  ©r\   rÊ  rA   rA   rB   r�   b  r«  )r‘   r«   r	   r°   r\   Úmaxr   ÚStarArgTuplerÉ  r�   Úcompile_internalr#   Úpack_struct)rs   r<   Úarray_indicesZmax_dimsrÈ  ZinptyÚrettyr¬  rA   rA   rB   Úget_subspace_shapeP  s$   þÿÿþrÒ  c                 C   s^  t  ||j¡}t  ||j¡}	|j}
g }t|ƒD ]\}}|| }t|tjƒr6t	|ƒ| ||ƒ}| 
||||f¡ qt| ||ƒ}t| ||||||ƒ}| ¡  |j}| ¡ }t| |||ƒ}|j}t  ||  tjd¡¡}| ¡ }t j| ||
||	|j|d| jd�	}t| |||ƒ}| |¡}| ||g¡}t| ||||ƒ t  ||¡}| ||¡ | ¡  t| |||  ¡ ƒS )Nr   Fr  )!r	   r°   r\   rœ   r‹   rÚ   rˆ   r   r‰   ro   r`   rÒ  r©  rQ  rá   rU  Ú_empty_nd_implrâ   r¯   r�   r¿  Úget_item_pointer2Úlayoutr%  r{   r=   Úgepr~   r  r  rÀ  r    rç   )rs   r<   rT   rß   rÁ   rñ   r“   r”   rò   rœ   r‹   rÐ  rd   rƒ   r„   Úidx_maker³  r´  Zout_tyZ
out_shapesrë   Zout_dataZout_idxrb   r}   ÚcurÚnext_idxrA   rA   rB   r1  k  sF   €
ÿÿþ
r1  c           	   	   C   s‚   |j \}}|\}}t|ƒ| ||ƒ}|jdkr4t| |||ƒ\}}t| ||j|||f|fƒ}t| ||j|ƒS t| ||||||f|fƒS )z3
    Advanced or basic indexing with an array.
    r   )rß   ro   rf   r�   r&  rá   r   r1  r(  rA   rA   rB   Úfancy_getitem_arrayŸ  s   


ÿ
ÿrÚ  c              	   C   sì   |j }| d¡}| d¡}|jdv r|}	| ||j¡}
|	|
fS |}	|}
t|jƒD ]-}| || | || |¡¡}| d||¡}| 	|| 
|
|¡|
¡}
| 	||	| 
|	|¡¡}	q(| 
|
|¡}
| 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   rD   ÚCFrk  r¸  )r�   r8   rÕ  r²   r¢   r7   rf   rI  rý   rž  rz  )rs   r<   ÚarrtyÚarrrò   rœ   r�   ré   r  rœ  r�  rd   Zmax_axis_offsetZ
is_upwardsr¼  rA   rA   rB   Úoffset_bounds_from_strides³  s2   


ë
ÿÿÿ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.
    )Úptrtointr8   rz  )rs   r<   rœ  r�  r‹   Zdata_ptr_as_intr  ÚendrA   rA   rB   Ú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á  )	rs   r<   rÜ  rÝ  rò   rœ   r‹   rœ  r�  rA   rA   rB   Ú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_r»  )rs   r<   Úa_startÚa_endZb_startZb_endZmay_overlaprA   rA   rB   Úextents_may_overlapó  s
   þræ  c	                    sB  ˆj ‰d‰t ˆ ˆ¡‰ˆ	‰d ‰ˆ jˆdd��c ˆ  |j|j¡}	ˆj ˆ |	¡}
|
j ‰ˆ  	|
ˆ¡}
ˆ  
|
ˆ¡ ˆ tj¡}t ˆ ˆ	|¡�(}t ˆˆ ˆˆ	ˆ
ˆj|¡}t ˆˆ |
ˆˆˆ|¡}ˆ  
ˆ  |¡|¡ W d   ƒ n1 smw   Y  W d   ƒ n1 s|w   Y  ‡ ‡‡‡‡‡‡‡‡‡	‡
‡‡fdd„}‡ ‡‡‡‡fdd„}||fS )Nr–   Fr=  c                     sV  t  ˆˆ¡} ˆ ¡ tˆ
ƒ d … ‰ tˆ
ƒtˆ ƒkr/ˆ tjd¡}|gtˆ
ƒtˆ ƒ  tˆ ƒ ‰ ‡‡ ‡
fdd„ttˆ
ƒƒD ƒ‰ ˆj	ˆdd��T\}}|� ˆ 
t jˆˆˆ ˆ¡ˆˆˆˆ dd�| ¡ W d   ƒ n1 siw   Y  |� ˆ 
t jˆˆˆ	ˆ
ˆˆjˆ dd�| ¡ W d   ƒ n1 s�w   Y  W d   ƒ n1 sœw   Y  tˆˆˆˆ | ¡ƒS )Nr   c                    s    g | ]}t ˆ ˆ| ˆ| ƒ‘qS rA   )rL  r„  )r<   Úsrc_indicesÚ
src_shapesrA   rB   r�   ,  s    ÿÿz:maybe_copy_source.<locals>.src_getitem.<locals>.<listcomp>Fr=  ©r  )r	   rP   rÁ  r‘   r¯   r   r�   r¬   r7   Úif_elser  rÔ  r=   rÕ  r{   )Úsrc_ptrré   Zif_copyÚ	otherwise)r<   rs   Ú	copy_dataÚcopy_layoutÚcopy_shapesÚcopy_stridesr´  ÚptrtyÚsrc_datarè  Úsrc_stridesÚsrctyÚuse_copy)rç  rB   Úsrc_getitem  sL   
ÿÿÿ
þüúÿ
ýûÿ€÷z&maybe_copy_source.<locals>.src_getitemc                     sX   ˆ j ˆdd�� ˆ  ˆ¡} ˆ  | ˆ¡} ˆj ˆ | ¡ W d   ƒ d S 1 s%w   Y  d S )NFr=  )rÿ   r=   Úbitcastrå   Úfree©r‹   )r<   rs   rí  rõ  Ú	voidptrtyrA   rB   Úsrc_cleanupB  s
   
"ýz&maybe_copy_source.<locals>.src_cleanup)r8   r	   râ   rÿ   r²   r�   r¢   rå   Úallocater÷  r  r©   r   r�   Ú	loop_nestrÔ  rÕ  r=   )rs   r<   rõ  r´  rô  Úsrcrè  ró  rò  Ú	allocsizer‹   rº   r”   rë  Údest_ptrrö  rû  rA   )r<   rs   rí  rî  rï  rð  r´  rñ  rò  rè  ró  rô  rõ  rú  rB   Úmaybe_copy_source   s8   
þ
þù€ó$#r  c           
         s  |   tjd¡}|   tjd¡‰t|ƒt|ƒkr0t|ƒt|ƒ }ˆg| | }|g| | }||fS t|ƒt|ƒk rˆt|ƒt|ƒ }‡ ‡fdd„|d|… D ƒ}t ˆ j|tj¡}ˆ j	ˆ  
|¡dd�� d}	| j ˆ t|	f¡ W d  ƒ n1 sww   Y  ||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   rD   c                    ó   g | ]	}ˆ   d |ˆ¡‘qS ©r¸  )r»  ©rŽ   r   ©r<   r  rA   rB   r�   b  ó    ÿz(_bc_adjust_dimension.<locals>.<listcomp>NFr=  z,cannot broadcast source array for assignment)r¯   r   r‚   r‘   Ú	functoolsÚreducerã  r	   Útrue_bitrÿ   r•  r?  r@  r¨   )
rs   r<   rò   rœ   Útarget_shaperé   Znd_diffZ
dim_is_oneÚacceptedr¹   rA   r  rB   Ú_bc_adjust_dimensionL  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   rD   c                    s   g | ]\}}ˆ   d ||¡‘qS )r<  ©rý   )rŽ   ÚtarÚoldrƒ  rA   rB   r�   }  ó    ÿz,_bc_adjust_shape_strides.<locals>.<listcomp>c                    r  r  r  )rŽ   r  r  rA   rB   r�     ó    c                    s   g | ]
\}}ˆ   ||¡‘qS rA   )rã  )rŽ   ÚxÚyrƒ  rA   rB   r�   €  ó    c                    s    g | ]\}}}ˆ   |||¡‘qS rA   ©rž  )rŽ   Úpr  r  rƒ  rA   rB   r�   �  s    ÿc                    s   g | ]\}}ˆ   |ˆ|¡‘qS rA   r  )rŽ   r  r  )r<   ré   rA   rB   r�   ƒ  r  )r¯   r   r‚   r’   )
rs   r<   rò   rœ   r
  Z	bc_shapesZ
bc_stridesÚmismatchZ
src_is_oneÚpredsrA   )r<   r  ré   rB   Ú_bc_adjust_shape_stridesq  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©rf   rÕ  r#  )r	   r°   r\   rœ   r  r  Úcopyr‘   ro   rÀ   r‹   ra   r�   r›   rž   )	rs   r<   ÚarrtyperÝ  r
  rò   rœ   Znew_arrtypeZnew_arrrA   rA   rB   Ú_broadcast_to_shapeˆ  s&   
ÿÿ

úr  c                 C   s,   |j |jddd�}|||ƒ}dd„ }||fS )Nr  T)rf   rÕ  Úreadonlyc           
   	   S   sz   |\}}|j d }t|ƒ| ||ƒ}t ||¡}t| ||||ƒ\}}t|dt|  |j 	d¡¡d ƒƒ | 
¡ }	t| ||j|	ƒS )Nr   rž   )rß   ro   r	   r°   r  r¶   r   r©   r£   rª   rç   r   rá   )
rs   r<   rT   rß   rþ  Úshape_rô  rˆ  Údestrê   rA   rA   rB   Úcodegen§  s   
þz$_numpy_broadcast_to.<locals>.codegen)r  r±   )Ú	typingctxr·   r\   ÚretrT   r"  rA   rA   rB   Ú_numpy_broadcast_to¢  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ß   ro   r	   Úget_null_valuerž   r8   rç   r   rá   )rs   r<   rT   rß   rþ  rô  r!  rê   rA   rA   rB   r"  ¿  s   
z#get_readonly_array.<locals>.codegen)r  )r#  rÝ  r$  rT   r"  rA   rA   rB   Úget_readonly_array¹  s   	r(  c           
      C   sž   | j }t|ƒ}t|ƒ}||krtdƒ‚|D ]
}|dk rtdƒ‚qd}|| }||k rM|| }|| }	||	ks:|dkrC|d7 }|d7 }ntdƒ‚||k s*d S d S )NzDinput operand has more dimensions than allowed by the axis remappingr   z4all elements of broadcast shape must be non-negativerD   z=operands could not be broadcast together with remapped shapes)r\   r‘   r¨   )
r·   Ú
dest_shapeÚ	src_shapeÚsrc_ndimÚ	dest_ndimr…   Ú	src_indexÚ
dest_indexZsrc_dimZdest_dimrA   rA   rB   Ú_can_broadcastË  s&   ÿ
ôr/  c                 C   s   t  | ¡} t| |ƒ t| |ƒS r+  )rÅ  Úasarrayr/  r%  ©r·   r\   rA   rA   rB   Ú_default_broadcast_to_implë  s   


r2  c                 C   sü   t | ƒs	t d¡‚t|tjƒrdd„ }|S t|tjƒr+t|jtjƒs)d}t |¡‚tS t|tj	ƒrL|j
dkrLtdd„ |D ƒƒsJd|› d	�}t |¡‚tS t|tj	ƒru|j
dkrut| tjƒoa| jdk}t| ƒsh|rnd
d„ }|S d}t |¡‚d| }t |¡‚)Nz-The first argument "array" must be array-likec                 S   s   t  | |f¡S r+  )rÅ  Úbroadcast_tor1  rA   rA   rB   rÒ   ø  ó   z numpy_broadcast_to.<locals>.implz7The second argument "shape" must be a tuple of integersr   c                 S   ó   g | ]}t |tjƒ‘qS rA   )rˆ   r   ÚIntegerLiteral)rŽ   ÚtyprA   rA   rB   r�     r  z&numpy_broadcast_to.<locals>.<listcomp>ú"z," object cannot be interpreted as an integerc                 S   s   t  | ¡} t| ƒS r+  )rÅ  r0  r(  r1  rA   rA   rB   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Š   rÉ  rq   r2  ÚTupler±   Úallr‰   rf   r   )r·   r\   rÒ   r¹   Zis_scalar_arrayrA   rA   rB   Únumpy_broadcast_toñ  s4   



ÿ
r;  c                 C   sr   t t|ƒƒD ]0}|t|ƒ | }|| }|dk rtdƒ‚|dkr!q| | dkr,|| |< q| | |kr6tdƒ‚qd S )Nr   ú#negative dimensions are not allowedrD   z=shape mismatch: objects cannot be broadcast to a single shape)r7   r‘   r¨   )ÚrÚmr\   rd   r¾   ÚtmprA   rA   rB   Únumpy_broadcast_shapes_list  s   
ÿ÷r@  c                     sâ   t | ƒD ]7\}}t|tjƒ}t|tjƒot|jtjƒ}t|tjƒo't|jƒdk}|s;|s;|s;d|› d|› �}t 	|¡‚qd‰ | D ]}t|tjƒrNt
ˆ dƒ‰ q@t|tjƒr[t
ˆ t|ƒƒ‰ q@ˆ dkrddd„ S dˆ  ‰‡ ‡fdd	„}|S )
Nr   z	Argument z* must be either an int or tuple[int]. Got rD   c                  W   rx  ry  rA   rÇ  rA   rA   rB   Ú<lambda>C  ó    z+ol_numpy_broadcast_shapes.<locals>.<lambda>©rD   c                     sz   dgˆ  }ˆ}t | ƒD ] }t|tƒrt|ƒdkrt|ˆ |ƒ qt|tƒr+t|ˆ |fƒ qt|ƒD ]
\}}t|||ƒ}q0|S rŠ  )r   rˆ   r«   r‘   r@  r­   rÚ   r/   )rß   r=  r3  Úargr„   Úelem©r>  Útup_initrA   rB   rÒ   G  s   

€z'ol_numpy_broadcast_shapes.<locals>.impl)rÚ   rˆ   r   rŠ   rÉ  rq   r9  r‘   r   rÓ   rÌ  r5  )rß   r„   rD  Úis_intZis_int_tupleÚis_empty_tupler¹   rÒ   rA   rF  rB   Úol_numpy_broadcast_shapes-  s0   ÿÿ
€€rJ  c                     sü   t | ƒD ]\}}t|ƒst d|› d�¡‚qd }d }| D ]$}t|tjtjfƒr+|j}n|}|d u r4|}q||kr@t d| › �¡‚qd‰ t | ƒD ])\}}t|tj	ƒrXt
ˆ |jƒ‰ qGt|tjtjtjfƒrit
ˆ dƒ‰ qGt d|› �¡‚dˆ  ‰‡ ‡fdd	„}|S )
Nz
Argument "z" must be array-likezTMismatch of argument types. Numba cannot broadcast arrays with different types. Got r   rD   zUnhandled type rÙ   c                     s|   dgˆ  }t | ƒD ]}t|ˆ t |¡jƒ q	ˆ}tˆ ƒD ]
}t|||| ƒ}qg }t | ƒD ]}| t t |¡|¡¡ q-|S rv  )	r   r@  rÅ  r0  r\   r7   r/   r`   r3  )rß   r\   r·   r3  rd   ÚoutsrF  rA   rB   rÒ   y  s   
z$numpy_broadcast_arrays.<locals>.impl)rÚ   r   r   rÓ   rˆ   r   r‰   r5  rq   ÚArrayCompatiblerÌ  rf   ÚNumberr®  )rß   r„   rD  Zunified_dtypeÚdtrÒ   rA   rF  rB   Únumpy_broadcast_arraysV  s6   ÿþÿrO  c                 C   rO  )z¶Targets should implement this if they wish to specialize the error
    handling/messages. The overload implementation takes two tuples as arguments
    and should raise a ValueError.rÄ   ©rè  Úindex_shaperA   rA   rB   Úraise_with_shape_context�  rT  rR  Úgeneric)Útargetc                 C   óN   t | tjƒrt |tjƒr!| j|jkr#t | jtjƒr%dd„ }|S d S d S d S d S )Nc                 S   ó   t dƒ‚)Nz0cannot assign slice from input of different sizerÐ   rP  rA   rA   rB   rÒ      rg  z1ol_raise_with_shape_context_generic.<locals>.impl©rˆ   r   rÉ  rq   rŠ   ©rè  rQ  rÒ   rA   rA   rB   Ú#ol_raise_with_shape_context_generic—  s   
ÿÿùrY  ÚCPUc                 C   rU  )Nc                 S   sŒ   t | ƒdkrd| d › d�}ndd dd„ | D ƒ¡› d�}t |ƒdkr,d|d › d�}ndd d	d„ |D ƒ¡› d�}d
|› d|› �}t|ƒ‚)NrD   ú(r   z,)ú, c                 S   ó   g | ]}t |ƒ‘qS rA   ©Ústr©rŽ   r  rA   rA   rB   r�   °  ó    zAol_raise_with_shape_context_cpu.<locals>.impl.<locals>.<listcomp>ú)c                 S   r]  rA   r^  r`  rA   rA   rB   r�   ´  ra  zcannot assign slice of shape z from input of shape )r‘   Újoinr¨   )rè  rQ  Z	shape_strZ	index_strr¹   rA   rA   rB   rÒ   ¬  s   ÿz-ol_raise_with_shape_context_cpu.<locals>.implrW  rX  rA   rA   rB   Úol_raise_with_shape_context_cpu¥  s   
ÿÿïrd  c           -         s„  |j \}}‰|\}}‰t|ƒˆˆ |ƒ}t ˆ |j¡}	t ˆ |j¡}
|j}g }t|ƒD ]\}}|| }t|t	j
ƒrIt|ƒˆˆ |ƒ}| ||||f¡ q*t|ƒrUtˆˆ |ƒ}nd}tˆˆ |||||ƒ}| ¡  dd„ }tˆt	jƒ�r…ˆj‰| ¡ }tˆƒˆˆ ˆƒ‰t ˆ ˆj¡}t ˆ ˆj¡}ˆj}ˆ t	jd¡}t|ƒt|ƒkr³|ft|ƒt|ƒ  t|ƒ }t|ƒ}n$t|ƒt|ƒk rÏ|ft|ƒt|ƒ  t|ƒ }t|ƒ}nt|ƒ}t|ƒ}tt|ƒƒD ]>}ˆ  d|| || ¡}ˆ  d|| |¡}ˆ  ˆ  ||¡¡}ˆ j|dd�� |ˆˆ ||ƒ W d  ƒ n	1 �sw   Y  qÝtˆˆ ˆˆ|||ƒ\}}| |
|j¡\} }!tˆˆ | |!|ƒ\}"}#tˆˆ |||"|#ƒ}$t ˆˆ |$|ˆˆ|||ƒ	\}%}&| !¡ }'tj"ˆˆ ||	|
|j#|'dˆj$d	�	}(|%ƒ })ˆ %ˆ |)ˆ|j¡})t&ˆˆ ||)|(ƒ | '¡  |&ƒ  ˆ -¡ S tˆt	j(ƒ�rˆj‰| ¡ }t|ƒdk�sœJ ‚ˆ )tt*t	j+ˆƒ¡}*|*ˆ ˆfƒ}+ˆ  d
|d |+¡}ˆ j|dd�� |ˆˆ |+f|d fƒ W d  ƒ n	1 �sÓw   Y  ‡ ‡‡‡‡fdd„}%t ,ˆ ˆ t	j+d¡¡},| !¡ }'tj"ˆˆ ||	|
|j#|'dˆj$d	�	}(|%|,ƒ})ˆ %ˆ |)ˆ|j¡})t&ˆˆ ||)|(ƒ | '¡  ˆ -¡ S | !¡ }'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.
    rA   c                 S   s~   | j  t¡}t tjt|ƒ¡t tjt|ƒ¡f}| | j |i ¡}|  ||¡}|||  	||j
d |¡|  	||j
d |¡fƒ d S ©Nr   rD   )Útyping_contextÚresolve_value_typerR  r   rÉ  Úint64r‘   Úget_call_typerJ   Ú
make_tuplerß   )rs   r<   rè  rQ  rK  ÚargtysÚ	raise_sigÚfuncrA   rA   rB   Úraise_shape_mismatch_errorÛ  s   ÿÿÿÿ
þz2fancy_setslice.<locals>.raise_shape_mismatch_errorrD   r¸  Fr=  Nr  r<  r   c                    sL   ˆ   | ¡}ˆ tjtˆˆtjƒ¡}|ˆ ˆ|fƒ}t ˆ |¡}ˆ  	|| ¡ |S r+  )
r=   rJ   ÚoperatorÚgetitemr#   r   r�   r	   r  r  )r~  rØ  Úgetitem_implr}   rÙ  ©r<   rs   rþ  Ú	src_dtyperô  rA   rB   rö  C  s   
þz#fancy_setslice.<locals>.src_getitem).rß   ro   r	   r°   r\   rœ   r‹   rÚ   rˆ   r   r‰   r`   r‘   rÒ  r©  rQ  rï   rq   rU  r¯   r‚   r«   r7   rý   r•  rº  rÿ   râ  r¾  r�   rá  ræ  r  r¿  rÔ  rÕ  r%  r€   r~   rÀ  ÚSequencerJ   r#   r�   râ   rD  )-rs   r<   rT   rß   r“   r”   rÁ   rˆ  rñ   Zdest_shapesÚdest_stridesÚ	dest_datarÐ  rd   rƒ   r„   r×  r³  r´  rn  rQ  rè  ró  rò  r  Znew_src_shapesZnew_index_shapeZ	dim_matchZsrc_dim_is_oneZshape_errorZ	src_startZsrc_endZ
dest_lowerZ
dest_upperZ
dest_startZdest_endrõ  rö  rû  Zdest_indicesr   r}   Úlen_implÚseq_lenr~  rA   rr  rB   r7  »  sü   
€ÿ
ÿÿþ
ÿþ
ÿÿÿ€þÿþ
ÿý
ý:È
ÿÿÿ
ýö
ýr7  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   rD   c                    ó"   g | ]\}}ˆ  ˆ ||tj¡‘qS rA   ©r€   r   r�   )rŽ   r-  r}   r�   rA   rB   r�   y  ó    ÿz#vararg_to_tuple.<locals>.<listcomp>©rq   r±   )rß   r’   r	   ra   r8   r   rÉ  r�   r‘   r   r#   rá   )rs   r<   rT   rß   rÁ   Zdimtysrñ   rc   r\   ÚshapetyÚnew_sigÚnew_argsrA   r�   rB   Úvararg_to_tupler  s   
ÿr€  zarray.transposec                 C   s   t | ||jd |d ƒS rÏ   )Úarray_Trß   ©rs   r<   rT   rß   rA   rA   rB   Ú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È   r\   rœ   r]  r  rA   rA   rB   Ú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 ]
\}}ˆ  ||¡ qBtj|	ddd�‰ˆ tjˆ |
¡¡}‡ ‡‡fdd„|D ƒ}t||ƒD ]\}}t|ˆ  ||
 ¡ ¡ˆ tj|¡g|g|d d� qoˆ ˆ tt tjˆˆˆ¡d	d„ |D ƒ¡ t|jƒˆˆ ƒ}t||jˆ  |d ¡ˆ  |d
 ¡|j|j|jd� | ¡ }tˆˆ |j|ƒS )Nr   rD   c                    ó   g | ]}t  ˆ ˆ¡‘qS rA   ©r	   rP   r‡  )r<   Úll_ary_sizerA   rB   r�   ¦  r  z)array_transpose_tuple.<locals>.<listcomp>r–   ©rq   rf   rÕ  c                    s   g | ]	}t ˆƒˆˆ ƒ‘qS rA   ©ro   r‡  )r<   rs   Ú	np_ary_tyrA   rB   r�   ±  r  ©r‹   r\   rœ   r�   r›   c                 S   ó   g | ]}|  ¡ ‘qS rA   ©rç   ©rŽ   ÚarA   rA   rB   r�   Á  ra  rC  r#  ) rß   ro   r±   rq   r©   r   r�   r   Ú	ArrayTyper\   rœ   r’   r  r‰   r¯   rr   rÀ   r÷  Ú
as_pointerrÎ  r…  r   r#   Úvoidrá   r‹   r=   r�   r›   rž   rç   r   )rs   r<   rT   rß   rÁ   rñ   ZaxistyrÈ   Znum_axisrq   r^  ÚarysZll_arysrþ  ÚdstZnp_itemsizeZnp_arysZnp_aryZll_aryr$  rê   rA   )r<   rs   rˆ  r‹  rB   Úarray_transpose_tuple™  sP   
ÿû	ÿýúr–  c                 C   ó    t | |||ƒ\}}t| |||ƒS r+  )r€  r–  ©rs   r<   rT   rß   r~  r  rA   rA   rB   Úarray_transpose_varargÐ  ó   r™  c                 C   s:   t | tjƒrt d¡‚|d u rddd„}|S ddd„}|S )Nz#np.transpose does not accept tuplesc                 S   ó   |   ¡ S r+  ©Ú	transpose©r�  ÚaxesrA   rA   rB   Únp_transpose_implÜ  rg  z*numpy_transpose.<locals>.np_transpose_implc                 S   ó
   |   |¡S r+  rœ  rž  rA   rA   rB   r   ß  r”  r+  )rˆ   r   r5  r   rÓ   )r�  rŸ  r   rA   rA   rB   Únumpy_transposeÖ  s   


ýr¢  ÚTc           	      C   sª   |j dkr|}nFt|ƒ| ||ƒ}t|ƒ| |ƒ}t ||j|j ¡}t ||j|j ¡}t||jt ||d d d… ¡t ||d d d… ¡|j	|j
|jd� | ¡ }t| |||ƒS )NrD   éÿÿÿÿr#  )rf   ro   r	   r°   r\   rœ   rÀ   r‹   ra   r�   r›   rž   rç   r   )	rs   r<   r7  rû   rê   rñ   r$  rò   rœ   rA   rA   rB   r�  å  s    
úr�  é2   c                 C   sT   t | tjƒst d¡‚t |tjƒst d¡‚t |ttjfƒs#t 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  rŸ  Únumr  rA   rA   rB   rÒ   	  s   znumpy_logspace.<locals>.impl©r¥  )rˆ   r   rM  r   rÓ   r­   rŠ   )r  rŸ  r¨  rÒ   rA   rA   rB   Únumpy_logspaceù  s   



rª  c                    s¢   t | tjƒsd}t |¡‚t |tjƒsd}t |¡‚t |ttjfƒs)d}t |¡‚tdd„ | |fD ƒƒrJtt	 
t| ƒt|ƒd ¡ƒ‰ d
‡ fdd„	}|S d
d	d„}|S )Nz%The argument "start" must be a numberz$The argument "stop" must be a numberú%The argument "num" must be an integerc                 s   r*  r+  ©rˆ   r   ÚComplex©rŽ   rD  rA   rA   rB   r.  	  r/  z"numpy_geomspace.<locals>.<genexpr>r¥  c           	         sô   | dks|dkrt dƒ‚ˆ | ƒ} ˆ |ƒ}tdk rH| jdk|jdk@ }t | ¡dkt |¡dk@ }d}|r<| j} |j}d}|rG|  } | }| }nt | ¡}| | } || }t | ¡}t |¡}t |||¡}|dkrv| |d< |dkrv||d< || S )Nr   ú&Geometric sequence cannot include zerorB  r¤  rD   y              ð?)r¨   r   ÚrealrÅ  ÚsignÚimagÚlog10Úlogspace)	r  rŸ  r¨  Zboth_imaginaryÚboth_negativeÚout_signÚlogstartÚlogstopr  ©Úresult_dtyperA   rB   rÒ   	  s8   €


znumpy_geomspace.<locals>.implc                 S   s˜   | dks|dkrt dƒ‚t | ¡dkt |¡dk@ }d}|r'|  } | }| }t | ¡}t |¡}t |||¡}|dkrH| |d< |dkrH||d< || S )Nr   r¯  r¤  rD   )r¨   rÅ  r±  r³  r´  )r  rŸ  r¨  rµ  r¶  r·  r¸  r  rA   rA   rB   rÒ   >	  s    

r©  )rˆ   r   rM  r   rÓ   r­   rŠ   r0  r   rÅ  Úresult_typer   )r  rŸ  r¨  r¹   rÒ   rA   r¹  rB   Únumpy_geomspace		  s"   


ÿ8
ër¼  rD   c                 C   sR   t |ttjfƒst d¡‚t | tjƒst d¡‚| jdk r"t d¡‚ddd„}|S )	Nz*The second argument "k" must be an integerz'The first argument "m" must be an arrayrC  úInput must be >= 2-d.rD   c                 S   sp   |d }|dkr| d d … S |dkrt  t  | ¡dd¡S |dkr(t  t  | ¡¡S |dkr6t  t  | dd¡¡S t‚)Né   r   rD   rC  rÂ  )rÅ  ÚswapaxesÚfliplrÚflipudr¯  )r>  r¾   rA   rA   rB   rÒ   a	  s   znumpy_rot90.<locals>.implrC  )	rˆ   r­   r   rŠ   r   rÓ   r‰   rf   ÚNumbaValueError)r>  r¾   rÒ   rA   rA   rB   Únumpy_rot90V	  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_reshaper\   r   rœ   )r©   r   r�   r’  Úintcr   rF  r	   Úget_or_insert_functionr9   rf   r_   r^   rH  r�   )rs   r<   rÁ   rñ   ÚnewndÚnewshapeÚ
newstridesr^  Zll_intp_starZll_intcrK  ÚfnÚndr\   rœ   Z
is_f_orderrê   rA   rA   rB   Ú_attempt_nocopy_reshapeq	  s2   	ú
ÿ
ÿþrË  c           	      C   s¦   d}d}t |ƒD ]\}}|dk r|d7 }|}q||9 }q|dkr*| |kr(tdƒ‚d S |dkrO|dkr9d}| dk}n
| | }| | dk}|sItdƒ‚|||< d S tdƒ‚)Nr   rD   z)total size of new array must be unchangedzmultiple negative shape values)rÚ   r¨   )	Úorigsizer\   Znum_neg_valueZ
known_sizerÛ   r—   Zneg_axÚinferredÚokrA   rA   rB   Ú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 d   ƒ n1 s´w   Y  t|ƒ| |ƒ}t||
j"| #|¡| #|¡|
j$|
j%|
j&d� | ¡ }t'| ||j|ƒS )	Nr   rD   r–   r‰  rŒ  r¸  zincompatible shape for arrayr#  )(rß   rá   r©   r   r�   r   r‘  r±   ro   r	   rP   r  r‰   rq   r¯   rr   rÀ   r÷  r’  r¢   rÎ  rÏ  r   r#   r“  r‚   rç   rË  r»  r8   rÿ   r?  r@  rK   r‹   r=   r�   r›   rž   r   )rs   r<   rT   rß   rÁ   rÑ  r}  r\   r^  Zll_shaperñ   rÇ  Zshape_ary_tyÚ	shape_aryZshape_itemsizer…   rÆ  rÈ  rÎ  Úfailr¹   r$  rê   rA   rA   rB   Úarray_reshape³	  sb   

ÿûÿ
ýÿþúrÒ  c                 C   r—  r+  )r€  rÒ  r˜  rA   rA   rB   Úarray_reshape_varargô	  rš  rÓ  )rC  rD   c                 C   ó   dd„ }|S )Nc                 S   r¡  r+  ©Úreshape)r�  rÇ  rA   rA   rB   Únp_reshape_implý	  r”  ú#np_reshape.<locals>.np_reshape_implrA   )r�  rÇ  r×  rA   rA   rB   Ú
np_reshapeû	  ó   rÙ  c                 C   rÔ  )Nc                 S   r¡  r+  rÕ  )r�  r\   rA   rA   rB   r×  
  r”  rØ  rA   )r�  r\   r×  rA   rA   rB   rÙ  
  rÚ  c                 C   sV   t | ƒsd}t |¡‚t|tjƒrt|jtjƒs%t|tjƒs%d}t |¡‚dd„ }|S )Nú#The argument "a" must be array-likezBThe argument "new_shape" must be an integer or a tuple of integersc           	      S   sÎ   t  | ¡} t  | ¡} t|tƒr(d}t  |¡D ]}||9 }|dk r&d}t|ƒ‚qn|dk r2d}t|ƒ‚|}| jdkrBt  |¡ | j	¡S | | j  }| }t
|d ƒD ]	}t  || f¡}qQ|d |… }t  ||¡S )NrD   r   z0All elements of `new_shape` must be non-negative)rÅ  r0  Úravelrˆ   r«   r¨   r…   ÚzerosÚastyperq   r7   ÚconcatenaterÖ  )	r�  Ú	new_shapeÚnew_sizeÚ
dim_lengthr¹   Úmsg2Úrepeatsrê   rd   rA   rA   rB   rÒ   
  s.   


þþ
znumpy_resize.<locals>.impl)r   r   rÓ   rˆ   r   rÉ  rq   rŠ   )r�  rà  r¹   rÒ   rA   rA   rB   Únumpy_resize
  s   
þ
ü
rå  c                 C   s^   t | ƒs	t d¡‚t |ƒst d¡‚t|ƒrddd„}|S t|tjƒs(t 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Å  rÜ  r0  rß  ©rÝ  ÚvaluesrÈ   rA   rA   rB   rÒ   B
  s   znp_append.<locals>.implz,The third argument "axis" must be an integerc                 S   s   t j| |f|d�S ©N©rÈ   ©rÅ  rß  ræ  rA   rA   rB   rÒ   L
  ó   r+  )r   r   rÓ   r   rˆ   r   rŠ   )rÝ  rç  rÈ   rÒ   rA   rA   rB   Ú	np_append7
  s   


ú

rì  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)rÖ  r…   ©rñ   rA   rA   rB   Ú
imp_nocopyT
  ó   zarray_ravel.<locals>.imp_nocopyc                 S   r›  )zCopy version)Úflattenrí  rA   rA   rB   Úimp_copyX
  ó   zarray_ravel.<locals>.imp_copyr   r–   )rß   rÕ  rÎ  r    rá   )rs   r<   rT   rß   rî  rñ  Úimprê   rA   rA   rB   Úarray_ravelQ
  s   rô  c                 C   s   dd„ }|   ||||¡S )Nc                 S   r›  r+  )rÜ  ©r�  rA   rA   rB   Únp_ravel_implj
  rg  znp_ravel.<locals>.np_ravel_impl)rÎ  )rs   r<   rT   rß   rö  rA   rA   rB   Únp_ravelh
  s   r÷  zarray.flattenc                 C   s,   dd„ }|   ||||¡}t| ||j|ƒ}|S )Nc                 S   s   |   ¡  | j¡S r+  )r  rÖ  r…   rí  rA   rA   rB   ró  s
  rq  zarray_flatten.<locals>.imp)rÎ  r    rá   )rs   r<   rT   rß   ró  rê   rA   rA   rB   Úarray_flattenp
  s   rø  c                 C   s(   |d u r	t  | ¡S |j|krtdƒ‚|S )NzIclip: the shape of the 'out' array does not match the shape of the result)rÅ  Ú
empty_liker\   r¨   )r�  r\   rë   rA   rA   rB   Ú_np_clip_prepare_out{
  s
   

rú  c                 C   sd   t  | ||¡\}}}t| |j|ƒ}t  |j¡D ]}|| }	|| }
|| }tt|	|
ƒ|ƒ||< q|S r+  )rÅ  Úbroadcast_arraysrú  r\   ÚndindexÚminrÌ  )r�  Úa_minÚa_maxrë   Úa_bÚa_min_bÚa_max_br$  rã   Úval_aZ	val_a_minZ	val_a_maxrA   rA   rB   Ú_np_clip_implŠ
  s   r  c                 C   sH   t  | j¡D ]}| | }|| }|rt||ƒ||< qt||ƒ||< q|S r+  )rÅ  rü  r\   rý  rÌ  )r�  ÚbZuse_minrë   rã   r  Úval_brA   rA   rB   Ú_np_clip_impl_none˜
  s   r  c                 C   sš  t | ƒs	t d¡‚t|tjƒst |ƒst d¡‚t|tjƒs't |ƒs't d¡‚t|tjƒs8t|ƒs8d}t |¡‚tdd„ | ||fD ƒƒ}t|tjƒrV|j	|krVd}t |¡‚|d u p_t|tjƒ}|d u pit|tjƒ}|ru|rud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 |	s´|
r´|r­ddd„}|S ddd„}|S |r½ddd„}|S |rÆddd„}|S ddd„}|S )NrÛ  z6The 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ƒV  qdS )rf   r   N)Úgetattr©rŽ   ÚtrA   rA   rB   r.  ¹
  r/  znp_clip.<locals>.<genexpr>zHThe argument "out" must have the same number of dimensions as the resultc                 S   rV  )Nz&array_clip: must set either max or minrÐ   ©r�  rþ  rÿ  rë   rA   rA   rB   Ú
np_clip_nnÅ
  rg  znp_clip.<locals>.np_clip_nnc                 S   s@   t | | j|ƒ}t | j¡D ]}| | }tt||ƒ|ƒ||< q|S r+  )rú  r\   rÅ  rü  rý  rÌ  ©r�  rþ  rÿ  rë   r$  rã   r  rA   rA   rB   Ú
np_clip_ssÎ
  s
   znp_clip.<locals>.np_clip_ssc                 S   s:   t | | j|ƒ}t | j¡D ]}| | }t||ƒ||< q|S r+  )rú  r\   rÅ  rü  rÌ  r  rA   rA   rB   Ú
np_clip_snÜ
  ó
   znp_clip.<locals>.np_clip_snc                 S   s   t  | |¡}t| |||ƒS r+  ©rÅ  Ú	full_liker  )r�  rþ  rÿ  rë   Z
a_min_fullrA   rA   rB   Ú
np_clip_saé
  ó   znp_clip.<locals>.np_clip_sac                 S   s:   t | | j|ƒ}t | j¡D ]}| | }t||ƒ||< q|S r+  )rú  r\   rÅ  rü  rý  r  rA   rA   rB   Ú
np_clip_nsô
  r  znp_clip.<locals>.np_clip_nsc                 S   s   t  | |¡}t| |||ƒS r+  r  )r�  rþ  rÿ  rë   Z
a_max_fullrA   rA   rB   Ú
np_clip_as  r  znp_clip.<locals>.np_clip_asc                 S   s,   t  | |¡\}}t| |j|ƒ}t||d|ƒS )NT©rÅ  rû  rú  r\   r  )r�  rþ  rÿ  rë   r   r  r$  rA   rA   rB   Ú
np_clip_na  ó   znp_clip.<locals>.np_clip_nac                 S   s,   t  | |¡\}}t| |j|ƒ}t||d|ƒS )NFr  )r�  rþ  rÿ  rë   r   r  r$  rA   rA   rB   Ú
np_clip_an  r  znp_clip.<locals>.np_clip_anc                 S   ó   t | |||ƒS r+  )r  r  rA   rA   rB   Ú
np_clip_aa  s   znp_clip.<locals>.np_clip_aar+  )r   r   rÓ   rˆ   r   r'  r‰   r   rÌ  rf   rM  )r�  rþ  rÿ  rë   r¹   Úresult_ndimZa_min_is_noneZa_max_is_noner  Za_min_is_scalarZa_max_is_scalarr  r  r  r  r  r  r  r  rA   rA   rB   Únp_clip¤
  s^   
ÿ
ÿ











r  Úclipc                 C   s   ddd„}|S )Nc                 S   s   t  | |||¡S r+  )rÅ  r  r  rA   rA   rB   rÒ   (  rq  zarray_clip.<locals>.impl©NNNrA   )r�  rþ  rÿ  rë   rÒ   rA   rA   rB   Ú
array_clip&  s   
r!  c              	      sÔ  |j |j ksJ ‚|j|jksJ ‚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r|d |krˆˆƒ}n
|d |krˆˆƒ}||kr'|ˆ ks%| dkr'dS |ˆkr0| d }nd}||k rP|| dkr>dS || }||  |9  < |||< dS ||krn|| | }|| dkrbdS || ||< |||< dS 	 dS )Nr¤  r   FrD   TrA   )	rÊ  rc   rœ   Úold_itemsizeÚnew_itemsizerÕ  rd   ÚnewdimZ
bytelength©Z
any_layoutZc_layoutZf_layoutÚint8rA   rB   ró  @  s4   

ñþz_change_dtype.<locals>.impr\   r   rœ   rD   r‰  NrŒ  )rf   rÕ  Úordr   r'  r¯   r�   ru   r	   r_   r^   r‰   ro   ra   rr   rp   rÀ   rç   r#   ÚbooleanrÎ  rÂ   r   rá   )rs   r<   ÚoldtyÚnewtyrñ   Z
new_layoutró  r#  r$  rÊ  Z
shape_dataZstrides_dataZshape_strides_array_typeÚaryclsZshape_constantÚsizeof_intpZstrides_constantrÐ  Zstrides_aryr\   rœ   rß   rT   rê   rA   r&  rB   Ú_change_dtype-  s€   	
0ÿÿÿÿ
ÿÿ
û
û
ÿú	
r.  c                 C   ó   t | ƒs	t d¡‚dd„ }|S )Nz+The argument to np.shape must be array-likec                 S   ó   t  | ¡jS r+  )rÅ  r0  r\   rõ  rA   rA   rB   rÒ   °  rw  znp_shape.<locals>.impl©r   r   rÓ   ©r�  rÒ   rA   rA   rB   Únp_shape«  ó   
r3  c                 C   r/  )Nz*The argument to np.size must be array-likec                 S   r0  r+  )rÅ  r0  r…   rõ  rA   rA   rB   rÒ   º  rw  znp_size.<locals>.implr1  r2  rA   rA   rB   Únp_sizeµ  r4  r5  c                 C   ó   dd„ }|S )Nc                    sT   dd„ ‰t  |  ¡ ¡‰ tˆ d d… ƒ}‡ ‡fdd„tˆ dd … ƒD ƒ}t  || ¡S )Nc                 S   s
   | | k S r+  rA   )r  rA   rA   rB   ÚisnanÄ  ó   
z0np_unique.<locals>.np_unique_impl.<locals>.isnanrD   c                    s4   g | ]\}}ˆ | |krˆˆ | ƒrˆ|ƒs|‘qS rA   rA   )rŽ   rd   r  ©r  r7  rA   rB   r�   É  s
     ÿz5np_unique.<locals>.np_unique_impl.<locals>.<listcomp>)rÅ  ÚsortrÜ  r¬   rÚ   r·   )ÚarÚheadÚtailrA   r9  rB   Únp_unique_implÃ  s   ÿz!np_unique.<locals>.np_unique_implrA   )r;  r>  rA   rA   rB   Ú	np_uniqueÁ  s   r?  c                 C   sh   dd„ }t | tjtjtjtjtjfƒr2t |tjƒrtS t |tjtjfƒr-t |j	tjƒr-|S t
 d¡‚d S )Nc           	      S   sÂ   t j|t jd�}|jd dkrt| |d ƒS t  |dk ¡r!tdƒ‚t  | ¡}| ¡ }|jd }|j|jkr9tdƒ‚t jt  	|¡|j
d�}d}t|ƒD ]}|| |||||  …< ||| 7 }qJ|S )N©rq   r   rD   r<  z(operands could not be broadcast together)rÅ  r0  rh  r\   Únp_repeat_impl_repeats_scalerr0  r¨   rÜ  Úemptyr¶  rq   r7   )	r�  rä  Zrepeats_arrayÚasaÚaravelÚnÚ	to_returnÚposrd   rA   rA   rB   Ú!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‰   ÚListr5  rM  r®  rŠ   rA  rq   r   rÓ   )r�  rä  rH  rA   rA   rB   Ú	np_repeatÑ  s    üÿórJ  c                 C   s˜   |dk rt dƒ‚t | ¡}| ¡ }|jd }|dkr"tjd|jd�S |dkr+t |¡S tj|| |jd�}t|ƒD ]}|| ||| |d | …< q9|S )Nr   r<  r@  rD   )	r¨   rÅ  r0  rÜ  r\   rB  rq   r  r7   )r�  rä  rC  rD  rE  rF  rd   rA   rA   rB   rA  þ  s   


rA  Úrepeatc                 C   rÔ  )Nc                 S   ó   t  | |¡S r+  )rÅ  rK  )r�  rä  rA   rA   rB   Úarray_repeat_impl  rw  z'array_repeat.<locals>.array_repeat_implrA   )r�  rä  rM  rA   rA   rB   Úarray_repeat  ó   rN  c                 C   ó   t  |¡}dd„ }||fS )z"Computes the itemsize of the dtypec                 S   s,   |   |jd j¡}|   |j¡}||  |¡ƒS rÏ   )rp   rß   rq   rá   rr   )Úcgctxr<   rT   Úllargsrt   ÚllintprA   rA   rB   r"    s   z%_intrin_get_itemsize.<locals>.codegenr†  )Útyctxrq   rT   r"  rA   rA   rB   Ú_intrin_get_itemsize  s   
rU  c                 C   rt  r+  rA   )r�  rq   rA   rA   rB   Ú_compatible_view$  ru  rV  c                 C   rÔ  )zDDetermines if the array and dtype are compatible for forming a view.c                 S   sÔ   t |ƒ}|| jkrf| jdkrd}t|ƒ‚	 | jd }| j| dk}| jdk}| j| | jk}|r:|r:|r:d}t|ƒ‚|| jk rR|dksJ| j| dkrPd}	t|	ƒ‚d S | j| | j }
|
| dkrhd}t|ƒ‚d S d S )Nr   zOChanging the dtype of a 0d array is only supported if the itemsize is unchangedrD   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.)rU  r�   rf   r¨   r\   r…   rœ   )r�  rq   Z
dtype_sizeZmsg1rÈ   Úp1Úp2Úp3rã  Zmsg3r%  Zmsg4rA   rA   rB   rÒ   .  s0   




ýàz ol_compatible_view.<locals>.implrA   ©r�  rq   rÒ   rA   rA   rB   Úol_compatible_view(  s   #r[  z
array.viewc                 C   sD  |j d }|j}t|ƒ| ||d ƒ}t|ƒ| |ƒ}t|jjƒ}t|ƒD ]}	t||	ƒ}
|	dkr:|jj	}| 
|
|¡|_q#t||	|
ƒ q#tdkrc| j}| t¡}| |g |j ¢R i ¡}|  ||¡}|||ƒ t| ||||ƒ}| d|t|j	dƒ¡}| |¡� d}| j |t|f¡ W d   ƒ n1 s‘w   Y  | ¡ }t| ||j|ƒS )Nr   r‹   )rD   é   r¸  z"new type not compatible with array)rß   rá   ro   r¥   r£   r¦   Úsortedr  r‹   r8   r÷  r¶   r   rf  rg  rV  ri  rJ   r.  r»  r   rÿ   r?  r@  r¨   rç   r   )rs   r<   rT   rß   rÁ   rÑ  rñ   r$  Úfieldsr¾   r}   rñ  rT  rK  Z_compatible_view_sigrÒ   rÎ  rÑ  r¹   rê   rA   rA   rB   Ú
array_viewT  s2   



þr_  rq   c                 C   s   |   ¡ }t| |||ƒS r+  )rD  r!   ©rs   r<   r7  rû   rê   rA   rA   rB   Úarray_dtype  s   ra  r\   c                 C   ó(   t |ƒ}|| ||ƒ}|j}t| |||ƒS r+  )ro   r\   r!   ©rs   r<   r7  rû   rz   r·   rê   rA   rA   rB   Úarray_shape…  ó   rd  rœ   c                 C   rb  r+  )ro   rœ   r!   rc  rA   rA   rB   Úarray_stridesŽ  re  rf  rf   c                 C   ó   |   tj|j¡}t| |||ƒS r+  )r¯   r   r�   rf   r!   r`  rA   rA   rB   Ú
array_ndim—  s   rh  r…   c                 C   rb  r+  )ro   r¢   r!   rc  rA   rA   rB   Ú
array_sizež  s   ri  r�   c                 C   rb  r+  )ro   r�   r!   rc  rA   rA   rB   Úarray_itemsize¦  re  rj  Únbytesc                 C   s2   t |ƒ}|| ||ƒ}| |j|j¡}t| |||ƒS )z"
    nbytes = size * itemsize
    )ro   r²   r¢   r�   r!   rc  rA   rA   rB   Úarray_nbytes¯  s   rl  Ú
contiguousc                 C   rg  r+  )r¯   r   r)  Ú	is_contigr!   r`  rA   rA   rB   Úarray_contiguous»  ó   ro  Úc_contiguousc                 C   rg  r+  )r¯   r   r)  Úis_c_contigr!   r`  rA   rA   rB   Úarray_c_contiguousÁ  rp  rs  Úf_contiguousc                 C   rg  r+  )r¯   r   r)  Úis_f_contigr!   r`  rA   rA   rB   Úarray_f_contiguousÇ  rp  rv  r  c                 C   s    |   tj|j ¡}t| |||ƒS r+  )r¯   r   r)  Úmutabler!   r`  rA   rA   rB   Úarray_readonlyÍ  rš  rx  Úctypesc           	      C   sP   t |ƒ}|| ||ƒ}t |¡}|  ||¡}|j|_|j|_| ¡ }t| |||ƒS r+  )ro   r   ÚArrayCTypesrà   r‹   r›   rç   r   )	rs   r<   r7  rû   rz   r·   ÚactÚctinforê   rA   rA   rB   Úarray_ctypesÕ  s   
r}  r‹   c                 C   s8   | j |||d�}|j}| ||  tj¡¡}t| |||ƒS ©Nrú   )rà   r‹   rß  r©   r   r�   r!   )rs   r<   r7  rû   r|  rê   rA   rA   rB   Úarray_ctypes_dataâ  s   r  c                 C   s6   | j |||d�}|j}| ||  |¡¡}t| |||ƒS r~  )rà   r‹   r÷  r©   r!   )rs   r<   ÚfromtyÚtotyr}   r|  rê   rA   rA   rB   Ú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ú   )ro   r   rÉ  r�   rf   rr   r©   rq   r#   Úbool_r\   rœ   r¯   rÎ  )
Úcheckerrs   r<   rÁ   rñ   Ztup_intpr�   Z	check_sigÚ
check_argsrn  rA   rA   rB   Ú_call_contiguous_checkô  s   ÿ
ÿr†  r¡   c                 C   s>   |   |t |¡¡}||_| ¡ }| j |||¡ t| |||ƒS r+  )rà   r   Ú
ArrayFlagsrž   rç   rå   ræ   r    )rs   r<   r7  rû   Úflagsobjrê   rA   rA   rB   Úarray_flags  s
   r‰  c                 C   sZ   |j jdkr| j|||d�}tt| ||j |jƒ}n|j jdk}|  tj|¡}t	| |||ƒS )Nr–   rú   )
rZ   rÕ  rà   r†  r   rž   r¯   r   r)  r!   )rs   r<   r7  rû   rˆ  rê   r}   rA   rA   rB   Úarray_flags_c_contiguous  s   ÿrŠ  c                 C   sr   |j jdkr| j|||d�}tt| ||j |jƒ}n|j j}|j jdkr'|dkn|dv }|  tj	|¡}t
| |||ƒS )Nr"  rú   rD   rÛ  )rZ   rÕ  rà   r†  r   rž   rf   r¯   r   r)  r!   )rs   r<   r7  rû   rˆ  rê   rÕ  r}   rA   rA   rB   Úarray_flags_f_contiguous%  s   ÿr‹  r°  c                 C   sH   |j tjv rt| |||dd�S |j tjv rt| |||ƒS td tj ¡ƒ‚)Nr°  ©Úattrzunsupported .real for {})	rq   r   Úcomplex_domainÚarray_complex_attrÚnumber_domainr   rK   r´   r8   )rs   r<   r7  rû   rA   rA   rB   Úarray_real_part6  s
   r‘  r²  c                 C   s    |j tjv rt| |||dd�S |j tjv rHt|jdd�|ƒ}t| |||gƒ\}}t| |||ƒ}t	 
||j| |j|j¡d¡ t| ||j| ¡ ƒS td tj ¡ƒ‚)Nr²  rŒ  Tr&  r   zunsupported .imag for {})rq   r   rŽ  r�  r�  r#   r  Ú_parse_empty_like_argsrÓ  r	   Úmemsetr‹   r²   r�   r¢   r    rá   rç   rK   r´   r8   )rs   r<   r7  rû   rT   r  rò   rñ   rA   rA   rB   Úarray_imag_partA  s   ÿÿ
ÿr”  c                 C   sÞ   |dvs
|j tjvrtd |¡ƒ‚t|ƒ}|| ||ƒ}|j j}|  |  |¡¡}|j	 
|¡}	|  |¡ ¡ }
| |j|
¡}|dkrK| |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²  é    rD   r  ©rq   rÕ  )r‹   r�   )rq   r   rŽ  rK   r´   ro   Úunderlying_floatrr   rp   r�   r8   r©   r’  r÷  r‹   rÖ  r   ÚIntTyper  r®   r	   Úcopy_structr   rç   )rs   r<   r7  rû   r�  rz   r·   ZfltyZsizeof_fltyr�   Z
llfltptrtyrô   Zresulttyr  ÚreplrA   rA   rB   r�  R  s    r�  ÚconjÚ	conjugatec                 C   r6  )Nc                 S   ó
   t  | ¡S r+  )rÅ  r›  ©rÝ  rA   rA   rB   rÒ   Œ  r”  zarray_conj.<locals>.implrA   ©rÝ  rÒ   rA   rA   rB   Ú
array_conj‰  ó   r   c                 C   r›  r+  )rD  )rs   r<   ZdtypetyZdtypevalrA   rA   rB   Ú
dtype_type”  rò  r¢  r8   ÚkindÚstatic_getitemc                 C   s<   |j }t|tjƒr|  |¡dƒ}t| |||ƒS d}t |¡‚)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)rs   r<   rT   rß   rÑ  rê   r¹   rA   rA   rB   Ústatic_getitem_number_clazz¡  s   
r¦  c              	      s‚  t |ƒ}|ˆ ||ƒ}|j}t|tjƒstd||f ƒ‚| |¡}| |¡}	t|tjƒr9|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                    ó   g | ]	}ˆ   tj|¡‘qS rA   ©r¯   r   r�   r„  ©rs   rA   rB   r�   Û  r  z(array_record_getattr.<locals>.<listcomp>c                    r§  rA   r¨  r„  r©  rA   rB   r�   Þ  r  r#  )ro   rq   rˆ   r   ÚRecordrK   Útypeofró   ÚNestedArrayr  rf   r¯   r�   r	   rî   r‹   r8   r°   r\   rœ   rr   rp   rÀ   r›   rž   rç   r   )rs   r<   r7  rû   r�  rz   r·   Zrectyperq   ró   ÚrestyZrarytyZraryZconstoffsetZ
newdataptrr\   rœ   Zdatasizerê   rA   r©  rB   Úarray_record_getattr¹  sN   ÿ

ÿ
ÿúr®  c                 C   s0   |d }t |tƒst‚t| ||jd |d |ƒS rŠ  )rˆ   r_  rK   r®  rß   )rs   r<   rT   rß   rã   rA   rA   rB   Úarray_record_getitemñ  s   
r¯  c              	      s  ˆ   ||¡ | |¡}| |¡}t|tjƒret|ƒ}|ˆ |ƒ}|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rudnd}ˆ  ||||¡}tˆ |||ƒS )zT
    Generic getattr() implementation for records: get the given record member.
    c                    r§  rA   r¨  ©rŽ   r—   r©  rA   rB   r�   	  r  z"record_getattr.<locals>.<listcomp>c                    r§  rA   r¨  r°  r©  rA   rB   r�     r  Nr#  rD   )Úsentry_record_alignmentró   r«  rˆ   r   r¬  ro   rq   r\   rœ   r	   Úget_record_memberrp   rÀ   ra   r¯   r�   r…   rç   r   rx   ry   )rs   r<   r7  rû   r�  ró   ÚelemtyrÁ   rñ   rq   rÇ  rÈ  Únewdatarê   Údptrrw   rA   r©  rB   Úrecord_getattrú  sB   



ÿ
ÿ
ÿ

ù	
ÿr¶  c              	   C   sÜ   |j \}}|\}}|  ||¡ | |¡}	| |¡}
t|
tjƒrHt |¡| ||d d�}|j	}t 
|||	|jj¡}t ||||  tj|
j¡¡ dS t 
|||	|  |
¡¡}|  ||||
¡}|jr`dnd}| j||
|||d� dS )zT
    Generic setattr() implementation for records: set the given record member.
    rD   rú   Nrv   )rß   r±  ró   r«  rˆ   r   r¬  r	   rn   r‹   r²  r8   ÚpointeeÚmemcpyr¯   r�   r¢   rp   r€   rx   r|   )rs   r<   rT   rß   r�  r7  r8  rT  r}   ró   r³  Z
val_structrþ  r!  rµ  rw   rA   rA   rB   Úrecord_setattr"  s,   


ÿ
ÿ
ÿ
ÿr¹  c                 C   s4   |   |jd |d ¡}|| ||jd |d |d ƒS )ú3
    Record.__getitem__ redirects to getattr()
    r   rD   )Úget_getattrrß   )rs   r<   rT   rß   rÒ   rA   rA   rB   Úrecord_static_getitem_str@  s   r¼  c                 C   s^   |j d j}t|j d jƒ}|  |j|| ¡}|  |j d |¡}|| ||j d |d || ƒS )rº  rD   r   )rß   rÔ   r¬   r^  Úinsert_const_stringr9   r»  )rs   r<   rT   rß   r„   r^  Zll_fieldrÒ   rA   rA   rB   Úrecord_static_getitem_intI  s
   r¾  Ústatic_setitemc                 C   sJ   |j \}}}|\}}}	t|j||ƒ}
|  ||
¡}|dusJ ‚||||	fƒS )ú3
    Record.__setitem__ redirects to setattr()
    N)rß   r#   rá   Úget_setattr)rs   r<   rT   rß   Úrectyrˆ  r8  Úrecr„   r}   Úgetattr_sigrÒ   rA   rA   rB   Úrecord_static_setitem_strU  s   
rÅ  c                 C   s^   |j \}}}|\}}}	t|j||ƒ}
t|j d jƒ}|  || |
¡}|dus(J ‚||||	fƒS )rÀ  r   N)rß   r#   rá   r¬   r^  rÁ  )rs   r<   rT   rß   rÂ  rˆ  r8  rÃ  r„   r}   rÄ  r^  rÒ   rA   rA   rB   Úrecord_static_setitem_intb  s   
rÆ  c                 C   s   |   |||¡S )zB
    Create a constant array (mechanism is target-dependent).
    )Úmake_constant_array)rs   r<   r-  ÚpyvalrA   rA   rB   Úconstant_arrayt  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˜  rk  Ú	bytearrayÚtobytesr	   râ   )rs   r<   r-  rÈ  Últyr}   rA   rA   rB   Úconstant_record|  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Ç  )rs   r<   r-  rÈ  ÚbufrA   rA   rB   Úconstant_bytes†  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+  )r\   rœ   ry  r‹   ©r�  r  rA   rA   rB   Úarray_is_impl˜  s
   
ÿþzarray_is.<locals>.array_is_impl)rß   r	   r¹  rÎ  )rs   r<   rT   rß   ÚatyÚbtyrÓ  rA   rA   rB   Úarray_is’  s
   
rÖ  Ú__hash__c                 C   s   dd„ S )Nc                 S   rt  r+  rA   rž  rA   rA   rB   rA  ¥  rB  zol_array_hash.<locals>.<lambda>rA   rž  rA   rA   rB   Úol_array_hash£  rò  rØ  c                 C   ó
   t | dƒS )zq
    Return the Structure representation of the given *flatiterty* (an
    instance of types.NumpyFlatType).
    Úflat©Ú_make_flattening_iter_cls)Ú
flatitertyrA   rA   rB   Úmake_array_flat_cls«  ó   
rÞ  c                 C   rÙ  )zv
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdEnumerateType).
    ÚndenumeraterÛ  ©ÚnditertyrA   rA   rB   Úmake_array_ndenumerate_cls³  rß  rã  c              	   C   s  |   tjd¡}| d¡}	|d ur| tj|¡ tt|ƒƒD ]T}
t 	|||
¡}t 
|| |¡¡}||
 }| d||¡}t ||¡� | ||¡ |d urO||
ƒ | |	¡ W d   ƒ n1 s^w   Y  | ||¡ |d urq||
ƒ q|d ur}| tj|¡ | |	¡ | |	¡ d S )Nr   Zend_incrementrü   )r¯   r   r�   r`  r  r	   Ú
false_byter¨  r7   r_   r  r=   rý   Ú	if_likelyrl  Ú	true_byterm  )rs   r<   rf   r\   r”   Úend_flagÚloop_continueÚ
loop_breakré   Úbbendr]  Úidxptrr„   r±   Ú	in_boundsrA   rA   rB   Ú_increment_indices»  s.   
û€
rí  c                 C   s*   t  ||j|j¡}t| ||j|||ƒ d S r+  )r	   r°   r\   rf   rí  )rs   r<   rÜ  rÝ  r”   rç  r\   rA   rA   rB   Ú_increment_indices_arrayÜ  s   rî  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).
    rD   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_dimrf   )rR   rï  rð  rñ  rò  rA   rA   rB   r_  ñ  s
   z-make_nditer_cls.<locals>.BaseSubIter.__init__c                 S   s   t | j| j|ƒ d S r+  )r¶   rï  rð  )rR   rb   rA   rA   rB   Úset_member_ptrø  ó   z3make_nditer_cls.<locals>.BaseSubIter.set_member_ptrc                 S   s   t | j| jƒS r+  )r  rï  rð  rP  rA   rA   rB   Ú
member_ptrû  ó   z/make_nditer_cls.<locals>.BaseSubIter.member_ptrc                 S   rt  r+  rA   ©rR   rs   r<   rA   rA   rB   Úinit_specificÿ  ru  z2make_nditer_cls.<locals>.BaseSubIter.init_specificc                 S   rt  r+  rA   ©rR   rs   r<   Úlogical_dimrA   rA   rB   rè    ru  z2make_nditer_cls.<locals>.BaseSubIter.loop_continuec                 S   rt  r+  rA   rù  rA   rA   rB   ré    ru  z/make_nditer_cls.<locals>.BaseSubIter.loop_breakN)rg   rh   ri   rZ  r_  ró  r  Úcached_propertyrõ  rø  rè  ré  rA   rA   rA   rB   ÚBaseSubIterì  s    
rü  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â   )rR   rs   r<   ré   rA   rA   rB   rø    s   z2make_nditer_cls.<locals>.FlatSubIter.init_specificc                 S   s   |  | j¡}| |j|g¡S r+  )r=   rõ  rÖ  r‹   )rR   rs   r<   r”   rÜ  rÝ  rã   rA   rA   rB   Úcompute_pointer  s   z4make_nditer_cls.<locals>.FlatSubIter.compute_pointerc                 S   s<   || j d kr| | j¡}t ||¡}| || j¡ d S d S rv  )rf   r=   rõ  r	   r  r  )rR   rs   r<   rú  rã   rA   rA   rB   rè    s
   üz2make_nditer_cls.<locals>.FlatSubIter.loop_continuec                 S   sd   |dkr|  tjd¡}| || j¡ d S || jd kr0| | j¡}t ||¡}| || j¡ d S d S re  )	r¯   r   r�   r  rõ  rf   r=   r	   r  )rR   rs   r<   rú  ré   rã   rA   rA   rB   ré    s   üz/make_nditer_cls.<locals>.FlatSubIter.loop_breakN)rg   rh   ri   rZ  rø  rý  rè  ré  rA   rA   rA   rB   ÚFlatSubIter  s    rþ  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J ‚d S r+  )Úneed_shaped_indexingr÷  rá  rA   rB   rø  .  r4  z9make_nditer_cls.<locals>.TrivialFlatSubIter.init_specificc                 S   s&   t |ƒdksJ t |ƒƒ‚| |j|¡S rv  )r‘   rÖ  r‹   ©rR   rs   r<   r”   rÜ  rÝ  rA   rA   rB   rý  1  s   z;make_nditer_cls.<locals>.TrivialFlatSubIter.compute_pointerN)rg   rh   ri   rZ  rø  rý  rA   rá  rA   rB   ÚTrivialFlatSubIter(  s    r  c                   @   ó   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	J ‚tj|||||dd�S ©NFré  )r‘   rf   r	   r  r   rA   rA   rB   rý  :  s   ÿz7make_nditer_cls.<locals>.IndexedSubIter.compute_pointerN©rg   rh   ri   rZ  rý  rA   rA   rA   rB   ÚIndexedSubIter5  ó    r  c                   @   r  )z'make_nditer_cls.<locals>.ZeroDimSubIterz5
        Sub-iterator "walking" a 0-d array.
        c                 S   s   |j S r+  rù  r   rA   rA   rB   rý  D  rf  z7make_nditer_cls.<locals>.ZeroDimSubIter.compute_pointerNr  rA   rA   rA   rB   ÚZeroDimSubIter?  r  r  c                   @   r  )z&make_nditer_cls.<locals>.ScalarSubIterz8
        Sub-iterator "walking" a scalar value.
        c                 S   s   |S r+  rA   r   rA   rA   rB   rý  L  ru  z6make_nditer_cls.<locals>.ScalarSubIter.compute_pointerNr  rA   rA   rA   rB   ÚScalarSubIterG  r  r  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 ]\}}|\}}}}d| }	|| }
| |
| |	||ƒ¡ q|S )N)rÚ  ÚindexedÚ0dÚscalarzindex%d)rÿ  rÚ   r²  r`   )rR   ÚlÚ	factoriesrd   rI  r£  rñ  rò  rˆ  rð  Úfactory)rþ  r  r  r  r  râ  rA   rB   ÚsubitersW  s   
üz(make_nditer_cls.<locals>.NdIter.subitersc                    s2  |  tjd¡}| |t |¡|¡| _t|ƒD ]\}}t|tjƒs2d| }t	 
||| ¡}	t| ||	ƒ q|  ||||¡}t tjˆ¡}
d}d}t|ƒD ]\}}t|tjƒre|jˆkre|| j}|| j} nqJˆdkslJ ‚| ||
d¡}|  tjd¡}dd„ }t||ƒD ]'\}}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ÚJ ‚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%dNrA   rD   c                 S   s>   t | ƒ}t|ƒD ]}| | |t |ƒ| |  krtdƒ‚qd S )Nz2nditer(): operands could not be broadcast together)r‘   r7   r¨   )r\   Ú
main_shaperE  rd   rA   rA   rB   Úcheck_shapeŠ  s   ÿÿzBmake_nditer_cls.<locals>.NdIter.init_specific.<locals>.check_shaper"  r¤  r¸  re  )&r¯   r   r�   rj  r9  ÚarraysrÚ   rˆ   r‰   r	   râ   r¶   Ú_arrays_or_scalarsrÉ  rf   r\   r¢   r’   r#   ÚnonerÎ  r°   rý   rž  ræ  rä  rÿ  r‘   rP   r8   r7   r_   r  r”   ra   Ú	exhaustedr  rø  )rR   rs   r<   Úarrtysr  ré   rd   r-  rð  ÚslotZmain_shape_tyr  Zmain_nitemsrÜ  r  rÝ  rT   rò   Zshape_is_emptyr  r”   r]  rë  Úsubiter)rÕ  rf   râ  ÚnshapesrA   rB   rø  g  sl   ÿ€

€þ
ÿ€
ÿ
ÿz-make_nditer_cls.<locals>.NdIter.init_specificc                    s>  |  d¡}t || | j¡¡}t ||¡� | d¡ | |¡ W d  ƒ n1 s*w   Y  ˆ j}t 	|| j¡}|  
||||¡}| j}| d¡ |  |||||¡}	dd„ |	D ƒ}	t|	ƒdkrg| |	d ¡ n| | |ˆ j|	¡¡ t 	|| j¡}
t||t|
ƒ|
|| jt | j||¡t | j||¡ƒ | |¡ | |¡ dS )	zJ
            Compute next iteration of the nditer() instance.
            rà  FNTc                 S   r�  rA   rŽ  ©rŽ   r¿   rA   rA   rB   r�   Ë  ra  zEmake_nditer_cls.<locals>.NdIter.iternext_specific.<locals>.<listcomp>rD   r   )r`  r	   Úas_bool_bitr=   r  Úif_unlikelyrþ   rl  r  r°   r  r”   Ú_make_viewsr‘   r  rj  r   r\   rí  r  ÚpartialÚ_loop_continueÚ_loop_breakrm  )rR   rs   r<   r  rê  r  r  r  r”   Úviewsr\   rá  rA   rB   Úiternext_specific¶  sD   

ÿ
þ
ÿþþû

z1make_nditer_cls.<locals>.NdIter.iternext_specificc                 S   ó@   | j D ]}|j|  kr|jk rn q| ||||j ¡ qd S r+  )r  rñ  rò  rè  ©rR   rs   r<   r]  rI  rA   rA   rB   r   à  ó
   
€þz.make_nditer_cls.<locals>.NdIter._loop_continuec                 S   r$  r+  )r  rñ  rò  ré  r%  rA   rA   rB   r!  å  r&  z+make_nditer_cls.<locals>.NdIter._loop_breakc                    sð   dgˆ }ˆj }| j}ˆj}	t|	tjƒrt|	ƒ}	n|	g}	‡ ‡fdd„tˆƒD ƒ‰t||ƒD ]=\}
}|
\}}}}ˆ|j	|j
… }ˆdkrJ|ddd… }|D ]}|| du sVJ ‚|  |ˆ ||	| || || |¡||< qLq-tdd„ |D ƒƒsvJ ‚|S )z:
            Compute the views to be yielded.
            Nc              	      ó    g | ]}ˆ   t ˆ ˆ|¡¡‘qS rA   ©r=   r	   r_   r„  ©r<   r”   rA   rB   r�   ö  s    ÿz?make_nditer_cls.<locals>.NdIter._make_views.<locals>.<listcomp>r"  r¤  c                 s   s   � | ]}|V  qd S r+  rA   r  rA   rA   rB   r.    s   € z>make_nditer_cls.<locals>.NdIter._make_views.<locals>.<genexpr>)r²  r  r   rˆ   r   r5  r¬   r7   r’   rñ  rò  Ú
_make_viewr:  )rR   rs   r<   r”   r  r  r"  r²  r  ÚrettysrI  r  rˆ  rÐ  Zsub_indicesrd   )rÕ  Únarraysrâ  r  r)  rB   r  ê  s0   

ÿ

þþz+make_nditer_cls.<locals>.NdIter._make_viewsc                 S   sŽ   t |tjƒr|jdksJ ‚| |||||¡}| |¡||ƒ}	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   rA   N)r›   )rˆ   r   r‰   rf   rý  ro   ru   rj  rÉ  r�   rÀ   )rR   rs   r<   r”   rÑ  rÜ  rÝ  r  rb   Úviewr�   r\   rœ   rA   rA   rB   r*    s   
ÿÿz*make_nditer_cls.<locals>.NdIter._make_viewc           	      S   s`   g }t t||ƒƒD ]$\}\}}t|tjƒr#| | |¡|||d�¡ q	| t| d| ƒ¡ q	|S )Nrú   r  )rÚ   r’   rˆ   r   r‰   r`   ro   r  )	rR   rs   r<   r  r  r  rd   rÜ  rÝ  rA   rA   rB   r    s   
þz2make_nditer_cls.<locals>.NdIter._arrays_or_scalarsN)rg   rh   ri   rZ  r  rû  r  rø  r#  r   r!  r  r*  r  rA   ©
rþ  r  r  r  r  rÕ  r,  rf   râ  r  rA   rB   ÚNdIterO  s    O*r/  )rf   rÕ  r‘   r  rÿ  Úobjectr	   rn   )râ  rü  r/  rA   r.  rB   Úmake_nditer_clsâ  s   
 
, Yr1  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 ]7}t 	|||¡}| 
||¡ || }	| d|	|¡}
t ||
¡� | 
tj|¡ W d   ƒ n1 sRw   Y  q || _|| _t |||j¡| _d S ©Nr   re  r¸  )r¯   r   r�   r	   rP   r8   râ   rä  r7   r_   r  r»  r  ræ  r”   r  ra   r\   )rR   rs   r<   rò   ré   r”   r  r]  rë  r˜  Údim_is_emptyrÄ  rA   rB   rø  6  s&   
ÿÿÿ€z3make_ndindex_cls.<locals>.NdIndexIter.init_specificc           
         sö   |  tjd¡}ˆ  d¡}t ˆ ˆ  ˆj¡¡}t ˆ |¡� | 	d¡ ˆ  
|¡ W d   ƒ n1 s1w   Y  ‡ ‡fdd„tˆƒD ƒ}|D ]}tˆ |ƒ qD| t ˆ ||j¡¡ | 	d¡ t ˆ ˆjˆ¡}	t|ˆ ˆ|	ˆjˆjƒ ˆ  
|¡ ˆ  |¡ d S )Nr   rà  Fc              	      s"   g | ]}ˆ   t ˆ ˆj|¡¡‘qS rA   )r=   r	   r_   r”   ©rŽ   r]  rª  rA   rB   r�   W  s    
ý
þzKmake_ndindex_cls.<locals>.NdIndexIter.iternext_specific.<locals>.<listcomp>T)r¯   r   r�   r`  r	   r  r=   r  r  rþ   rl  r7   rF   r  ra   r8   r°   r\   rí  r”   rm  )
rR   rs   r<   r  ré   rê  r  r”   r=   r\   rÄ  rª  rB   r#  L  s,   

ÿ
þý

ÿ
z7make_ndindex_cls.<locals>.NdIndexIter.iternext_specificN)rg   rh   ri   rZ  rø  r#  rA   rÄ  rA   rB   ÚNdIndexIter1  s    r5  )rf   r	   rn   )râ  r5  rA   rÄ  rB   Úmake_ndindex_cls*  s   7r6  c                    sX   ˆ dv sJ ‚| j }|jdkrG ‡ fdd„dt | ¡ƒ}|S G ‡ fdd„dt | ¡ƒ}|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r?tj||j	|  tj|j
¡d�}t|j
ƒD ]}t |||¡}| ||¡ q*|| _d S d S )Nr   rà  re  )r¯   r   r�   r	   râ   rã   r�   r½  rP   r8   rf   r7   r_   r  r”   )	rR   rs   r<   rÜ  rÝ  ré   r”   r]  rë  ©r£  rA   rB   rø  v  s   þ
özD_make_flattening_iter_cls.<locals>.CContiguousFlatIter.init_specificc                    s
  |j }|j}ˆ  | j¡}ˆ  d||¡}	| |	¡ t ˆ |	¡�] ˆ  |j	|g¡}
t
|ˆ ||
ƒ}ˆdkr8| |¡ n.| j‰‡ ‡fdd„t|ƒD ƒ}tjˆ || tj¡d�}| t ˆ ||g¡¡ t|ˆ ||ˆƒ t ˆ |¡}ˆ  || j¡ W d   ƒ d S 1 s~w   Y  d S )Nrü   rÚ  c              	      r'  rA   r(  r4  r)  rA   rB   r�   Ÿ  ó    
ý
þz\_make_flattening_iter_cls.<locals>.CContiguousFlatIter.iternext_specific.<locals>.<listcomp>©r-  )rf   r¢   r=   rã   rý   rþ   r	   rå  rÖ  r‹   r{   r  r”   r7   ra   rp   r   r�   Úmake_anonymous_structrî  r  r  )rR   rs   r<   rÜ  rÝ  r  rf   r¢   rã   r  rb   rû   ÚidxvalsÚidxtupler7  r)  rB   r#  �  s<   
ýÿÿÿÿÿ"êzH_make_flattening_iter_cls.<locals>.CContiguousFlatIter.iternext_specificc                 S   s   |  |j|g¡}t||||ƒS r+  )rÖ  r‹   r{   ©rR   rs   r<   rÜ  rÝ  rã   rb   rA   rA   rB   rp  ¯  s   z>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.getitemc                 S   s$   |  |j|g¡}t|||||ƒ d S r+  )rÖ  r‹   r~   ©rR   rs   r<   rÜ  rÝ  rã   rû   rb   rA   rA   rB   Úsetitem³  s   z>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.setitemN)rg   rh   ri   rZ  rø  r#  rp  r?  rA   r7  rA   rB   ÚCContiguousFlatIterq  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 ]D}t ||	|¡}t ||
|¡}| ||¡ | ||¡ || }| d||¡}t ||¡� | tj|¡ W d   ƒ n1 s}w   Y  q>|	| _|
| _|| _d S r2  )r¯   r   r�   r‹   rf   r	   r°   r\   rP   r8   râ   rä  r7   r_   r  r»  r  ræ  r”   Úpointersr  )rR   rs   r<   rÜ  rÝ  ré   r‹   rf   rò   r”   rA  r  r]  rë  Úptrptrr˜  r3  rA   rA   rB   rø  Â  s>   ÿÿÿÿÿÿ€
z9_make_flattening_iter_cls.<locals>.FlatIter.init_specificc              	      sH  |j }t ˆ |j|¡}t ˆ |j|¡}| j‰| j}	| tj	d¡}
ˆ  
d¡}t ˆ ˆ  | j¡¡}t ˆ |¡� | d¡ ˆ  |¡ W d   ƒ n1 sJw   Y  | d¡ t ˆ |	|d ¡}ˆ  |¡}t|ˆ ||ƒ}ˆdkrs| |¡ n‡ ‡fdd„t|ƒD ƒ}t ˆ |¡}| t ˆ ||g¡¡ tt|ƒƒD ]y}t ˆ ˆ|¡}t ˆ ˆ  |¡¡}|| }|| }ˆ  d	||¡}t ˆ |¡�C ˆ  ||¡ t ˆ |	|¡}ˆ  |¡}t ˆ ||¡}ˆ  ||¡ t|d |ƒD ]}t ˆ |	|¡}ˆ  ||¡ qäˆ  |¡ W d   ƒ n	1 �sw   Y  ˆ  |
|¡ q–ˆ  tj| j¡ ˆ  |¡ ˆ  |¡ d S )
Nr   rà  FTrD   rÚ  c              	      r'  rA   r(  r4  r)  rA   rB   r�   þ  r8  zQ_make_flattening_iter_cls.<locals>.FlatIter.iternext_specific.<locals>.<listcomp>rü   )rf   r	   r°   r\   rœ   r”   rA  r¯   r   r�   r`  r  r=   r  r  rþ   rl  r_   r{   r  r7   ra   r:  r¨  r  rý   rå  r  rî   ræ  rm  )rR   rs   r<   rÜ  rÝ  r  rf   rò   rœ   rA  ré   rê  Úis_exhaustedZlast_ptrrb   rû   r;  r<  r]  rë  r„   r±   r½  rì  rB  Z	inner_dimr7  r)  rB   r#  ã  sn   
ÿ
þ

ýÿÿÿ
þó
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í   )rf   r	   r°   r\   rœ   r¨  r7   r`   ÚuremÚudivÚreverserÔ  r‹   rÕ  )rR   rs   r<   rÜ  rÝ  rã   rf   rò   rœ   r”   r]  rb   rA   rA   rB   Ú_ptr_for_index(  s   þz:_make_flattening_iter_cls.<locals>.FlatIter._ptr_for_indexc                 S   s    |   |||||¡}t||||ƒS r+  )rG  r{   r=  rA   rA   rB   rp  9  s   z3_make_flattening_iter_cls.<locals>.FlatIter.getitemc                 S   s&   |   |||||¡}t|||||ƒ d S r+  )rG  r~   r>  rA   rA   rB   r?  =  s   z3_make_flattening_iter_cls.<locals>.FlatIter.setitemN)	rg   rh   ri   rZ  rø  r#  rG  rp  r?  rA   r7  rA   rB   ÚFlatIterº  s    !ErH  )rZ   rÕ  r	   rn   )rÝ  r£  rZ   r@  rH  rA   r7  rB   rÜ  k  s   
F rÜ  rÚ  c                 C   sh   t t |¡ƒ}|| |ƒ}||_|  |¡}|| || d¡d�}| | |||¡ | ¡ }t| |t |¡|ƒS ©Nr·   )rS   )	rÞ  r   ÚNumpyFlatTyper·   ro   r^   rø  rç   r   )rs   r<   rÜ  rÝ  ÚflatiterclsÚflatiterÚarrclsrê   rA   rA   rB   Úmake_array_flatiterD  s   

rN  c                 C   óZ   |j \}|\}t|ƒ}|| ||d�}|j}|  |¡}	|	| ||jd�}
| | |||
|¡ d S r~  )rß   rÞ  rZ   ro   r·   r#  )rs   r<   rT   rß   r  rÝ  rL  rK  rÜ  rM  rÝ  rA   rA   rB   Úiternext_numpy_flatiterT  ó   
rP  c                 C   sj   |j d }|\}}t|ƒ}|| ||d�}|j}|  |¡}	|	| ||jd�}
| | |||
|¡}t| ||j|ƒS ©Nr   rú   )rß   rÞ  rZ   ro   r·   rp  r   rá   )rs   r<   rT   rß   rÝ  rL  rã   rK  rÜ  rM  rÝ  rê   rA   rA   rB   Úiternext_numpy_getitemd  s   

rS  c                 C   sf   |j d }|\}}}t|ƒ}|| ||d�}|j}	|  |	¡}
|
| ||jd�}| | ||	|||¡ |  ¡ S rR  )rß   rÞ  rZ   ro   r·   r?  rD  )rs   r<   rT   rß   rÝ  rL  rã   rû   rK  rÜ  rM  rÝ  rA   rA   rB   Úiternext_numpy_getitem_anyt  s   


rT  c           	      C   sF   |j d }t|ƒ}|| ||d d�}|  |j¡}|| ||jd�}|jS rR  )rß   rÞ  ro   rZ   r·   r¢   )	rs   r<   rT   rß   rÝ  rK  rL  rM  rÝ  rA   rA   rB   Úiternext_numpy_getitem_flat…  s   
rU  c           
      C   sr   |j \}|\}tt |¡ƒ}|| |ƒ}||_|  |¡}|| || d¡d�}| | |||¡ | ¡ }	t	| ||j
|	ƒS rI  )rß   rã  r   ÚNumpyNdEnumerateTyper·   ro   r^   rø  rç   r   rá   )
rs   r<   rT   rß   rÜ  rÝ  Ú	nditerclsrï  rM  rê   rA   rA   rB   Úmake_array_ndenumerate�  s   

rX  c                 C   rO  r~  )rß   rã  rZ   ro   r·   r#  )rs   r<   rT   rß   r  râ  rï  rW  rÜ  rM  rÝ  rA   rA   rB   Úiternext_numpy_nditer¢  rQ  rY  c                    s^   ‡ ‡fdd„t |j|ƒD ƒ}tt t|ƒ¡ƒ}|ˆˆ ƒ}| ˆˆ |¡ | ¡ }tˆˆ |j	|ƒS )zndindex(*shape)c                    ry  rA   rz  )rŽ   ÚargtyrD  r�   rA   rB   r�   ¶  r{  z&make_array_ndindex.<locals>.<listcomp>)
r’   rß   r6  r   ÚNumpyNdIndexTyper‘   rø  rç   r   rá   )rs   r<   rT   rß   r\   rW  rï  rê   rA   r�   rB   Úmake_array_ndindex²  s   
ÿ
r\  c           
         s�   |j j}|dkr%|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 rA   rz  r  ©r<   rs   rƒ   rA   rB   r�   Ë  ó    ÿz,make_array_ndindex_tuple.<locals>.<listcomp>)rá   rf   rß   rq   r	   r°   r6  r   r[  r‘   rø  rç   r   )
rs   r<   rT   rß   rf   r3  r\   rW  rï  rê   rA   r]  rB   Úmake_array_ndindex_tupleÁ  s   ÿ
r_  c                 C   s6   |j \}|\}t|ƒ}|| ||d�}| | ||¡ d S r~  )rß   r6  r#  )rs   r<   rT   rß   r  râ  rï  rW  rA   rA   rB   Úiternext_numpy_ndindexØ  s
   r`  c           	      C   sn   |j }|j}t|jd tjƒrt ||d ¡}n|d g}t|ƒ| |ƒ}| 	| |||¡ | 
¡ }t| |||ƒS )z
    nditer(...)
    r   )rá   r  rˆ   rß   r   r5  r	   r°   r1  rø  rç   r   )	rs   r<   rT   rß   râ  r  r  rï  rê   rA   rA   rB   Úmake_array_nditerä  s   
ra  c                 C   s2   |j \}|\}t|ƒ| ||d�}| | ||¡ d S r~  )rß   r1  r#  )rs   r<   rT   rß   r  râ  rï  rA   rA   rB   Úiternext_numpy_nditer2ø  s   rb  c                 C   s4   |j \}}t t d¡t||kƒ¡}t| ||j|ƒS rv  )rß   r   r   r˜  r­   r!   rá   )rs   r<   rT   rß   Úarg1Úarg2rê   rA   rA   rB   Údtype_eq_impl  s   
re  c                 C   sb  t |ƒ}|| |ƒ}|  |j¡}|  tjt| |ƒ¡}|  tjd¡}tt 	d¡dƒ}	|D ]}
| 
||
¡}| |d¡}| |	| |d¡¡}	q*|jdkrKd}nN|jdkrp|g}t|dd… ƒD ]}| | |d |¡¡ q[tt|ƒƒ}n)|jdkr‘|g}|dd… D ]}| | |d |¡¡ q~t|ƒ}ntd |j¡ƒ‚| 
||¡}| |d¡}| |	| |d¡¡}	|j|	d	d
�� | j |td¡ W d  ƒ n1 sÉw   Y  |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.
    rD   r   rA   r–   Nr¤  r"  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.r9  rŒ  )+ro   rp   rq   r¯   r   r�   ru   r   r   r˜  Úsmul_with_overflowr:  rº  rf   rÕ  r¨  r`   r²   r«   rK   r´   rÿ   r?  r@  r¨   Úget_preferred_array_alignmentÚuint32rD  ÚMemInfoPointerÚvoidptrÚTypeRefr8   r#   rÎ  Ú_call_allocatorrå   Zmeminfo_datar©   r	   ra   rÀ   r÷  r’  )rs   r<   r  rò   r,  rñ   Údatatyper�   ZarrlenÚoverflowr—   Zarrlen_multrœ   Zdimension_sizeZallocsize_multrÿ  rq   Z	align_valrw   rß   ÚmipZarytypeclassÚargtypesr›   r‹   rº   Zshape_arrayZstrides_arrayrA   rA   rB   rÓ    st   
ÿ



ÿÿþý	
û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ÿ  rw   rA   rA   rB   rÒ   `  r”  z _ol_array_allocate.<locals>.implrA   )rs  rÿ  rw   rÒ   rA   rA   rB   Ú_ol_array_allocate[  s   rt  c                 C   s   |   ||¡S )z9Trampoline to call the intrinsic used for allocation
    )rq  )r  r…   rw   rA   rA   rB   rl  e  s   rl  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)rs   r<   r#   rß   rÿ  rw   r›   rA   rA   rB   r"  o  s   zintrin_alloc.<locals>.codegen)r   ri  rj  r#   )r#  rÿ  rw   r"  ro  rT   rA   rA   rB   rr  k  s   rr  c              	   C   sè   dd„ }t |tjƒrd}|  |||tj¡g}nt |tjƒsJ ‚|j}tj|||d�}g }|D ]}| 	|| ||j
|ƒ¡ q.|  |tjd¡}	t|ƒD ])}
| d||
 |	¡}t ||¡� | j |td¡ W d  ƒ n1 slw   Y  qH|S )	z;
    Parse the shape argument to an array constructor.
    c           
      S   sÄ   |   tj¡}|j}t |¡}t|d|d > d ƒ}|j|k r&| ||¡}|S |j|kr`| d||¡}	|j	|	dd�� | j
 |td¡ W d  ƒ n1 sLw   Y  |j|kr^| ||¡}|S |}|S )z0Cast src to intp only if value can be maintainedrD   ú>Fr=  )z#Cannot safely convert value to intpN)r©   r   r�   rE   r   r˜  r   Úsextrý   rÿ   r?  r@  r¨   Útrunc)
rs   r<   Zsrc_trþ  rº   Z
intp_widthZintp_irÚmaxvalrê   Z	is_largerrA   rA   rB   Úsafecast_intp}  s(   


õþÿ
ÿz#_parse_shape.<locals>.safecast_intprD   rí   r   rü   )znegative dimensions not allowedN)rˆ   r   rŠ   r€   r�   r5  r±   r	   r°   r`   r8   Úget_constant_genericr7   rý   r  r?  r@  r¨   )rs   r<   r-  r}   ry  rf   Zpassed_shapesrò   r—   ré   r]  Úis_negrA   rA   rB   Ú_parse_shapey  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|  )rs   r<   rT   rß   ZarrshapetypeZarrshaper  rA   rA   rB   Ú_parse_empty_args©  s   
r}  c                 C   sT   |j d }t|tjƒr%t|ƒ| ||d d�}tj||j|jd�}|j	|fS |j	dfS )z_
    Parse the arguments of a np.empty_like(), np.zeros_like() or
    np.ones_like() call.
    r   rú   rí   rA   )
rß   rˆ   r   r‰   ro   r	   r°   r\   rf   rá   )rs   r<   rT   rß   Úarytyperñ   rò   rA   rA   rB   r’  ³  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Ó   )Úfnamerq   r¹   rA   rA   rB   Ú_check_const_str_dtypeÁ  s   
þr�  c                 C   ó"   |j }||||ƒ}dd„ }||fS )Nc                 S   ó(   t | |||ƒ\}}t| |||ƒ}| ¡ S r+  )r}  rÓ  rç   ©rQ  r<   rT   rR  r  rò   rñ   rA   rA   rB   r"  Ì  ó   znumpy_empty_nd.<locals>.codegen©Úinstance_type)rT  Zty_shapeÚty_dtypeÚty_retty_refÚty_rettyrT   r"  rA   rA   rB   Únumpy_empty_ndÇ  ó   r‹  c                    s˜   t d|ƒ |tu st|tjƒr|jtu st|ƒrtj}nt|ƒ}t	| ƒ}|d ur>|d ur>tj
||dd�‰ tf‡ fdd„	}|S d| › d|› d�}t |¡‚)	NrB  r–   r‰  c                    ó   t | |ˆ ƒS r+  )r‹  )r\   rq   ©rÑ  rA   rB   rÒ   á  rw  zol_np_empty.<locals>.implz.Cannot parse input types to function np.empty(r\  rb  )r�  Úfloatrˆ   r   ÚFunctionÚ
typing_keyr   ÚdoubleÚty_parse_dtypeÚty_parse_shaper‰   r   rÓ   )r\   rq   Únb_dtyperf   rÒ   r¹   rA   rŽ  rB   Úol_np_emptyÓ  s    

ÿ
ÿ
r–  c                 C   r‚  )Nc                 S   rƒ  r+  )r’  rÓ  rç   r„  rA   rA   rB   r"  î  r…  z$numpy_empty_like_nd.<locals>.codegenr†  )rT  Zty_prototyperˆ  r‰  rŠ  rT   r"  rA   rA   rB   Únumpy_empty_like_ndé  rŒ  r—  c                    s¬   t d|ƒ t|ƒst|ƒ}nt| tjƒr| j}n| }|d ur?t| tjƒr7| jdkr,| jnd}| j||dd�‰ nt |dd¡‰ nd| › d|› d	�}t	 
|¡‚d‡ fd
d„	}|S )Nrù  r  r–   F)rq   rÕ  r  r   z3Cannot parse input types to function np.empty_like(r\  rb  c                    r�  r+  )r—  )rÝ  rq   rŽ  rA   rB   rÒ   	  rw  zol_np_empty_like.<locals>.implr+  )r�  r   r“  rˆ   r   r‰   rq   rÕ  r  r   rÓ   )rÝ  rq   r•  rÕ  r¹   rÒ   rA   rŽ  rB   Úol_np_empty_likeõ  s&   

ÿÿ
r˜  c                 C   rP  )Nc                 S   s<   t |jd ƒ| ||d ƒ}t ||j| |j|j¡d¡ d S rÏ   )ro   rß   r	   r“  r‹   r²   r�   r¢   )rQ  r<   rT   rR  rñ   rA   rA   rB   r"    s   ÿz(_zero_fill_array_method.<locals>.codegen)r   r  )rT  rR   rT   r"  rA   rA   rB   Ú_zero_fill_array_method  s   
r™  Ú
_zero_fillc                 C   r6  )z?Adds a `._zero_fill` method to zero fill an array using memset.c                 S   s   t | ƒ d S r+  )r™  rP  rA   rA   rB   rÒ     rw  z ol_array_zero_fill.<locals>.implrA   )rR   rÒ   rA   rA   rB   Úol_array_zero_fill  r¡  r›  c                 C   s   t d|ƒ tfdd„}|S )NrÝ  c                 S   ó   t j| |d�}| ¡  |S ©Nr@  )rÅ  rB  rš  )r\   rq   rÝ  rA   rA   rB   rÒ   %  ó   zol_np_zeros.<locals>.impl)r�  r�  ©r\   rq   rÒ   rA   rA   rB   Úol_np_zeros!  s   
r   c                 C   ó   t d|ƒ ddd„}|S )NÚ
zeros_likec                 S   rœ  r�  )rÅ  rù  rš  )r�  rq   rÝ  rA   rA   rB   rÒ   1  rž  zol_np_zeros_like.<locals>.implr+  ©r�  rZ  rA   rA   rB   Úol_np_zeros_like,  s   

r¤  c                 C   r¡  )NÚ	ones_likec                 S   ó2   t j| |d�}|j}tt|ƒƒD ]}d||< q|S ©Nr@  rD   ©rÅ  rù  rÚ  r7   r‘   )r�  rq   rÝ  Úarr_flatr„   rA   rA   rB   rÒ   =  ó
   
zol_np_ones_like.<locals>.implr+  r£  rZ  rA   rA   rB   Úol_np_ones_like8  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Å  rB  rÚ  r7   r‘   )r\   Ú
fill_valuerq   rÝ  r©  r„   ©r•  rA   rB   r¬  N  ó
   
zimpl_np_full.<locals>.fullr+  )r�  r   r“  )r\   r®  rq   r¬  rA   r¯  rB   Úimpl_np_fullF  s   

r±  c                 C   s   t d|ƒ ddd„}|S )Nr  c                 S   s0   t  | |¡}|j}tt|ƒƒD ]}|||< q|S r+  r¨  )r�  r®  rq   rÝ  r©  r„   rA   rA   rB   r  [  r°  z$impl_np_full_like.<locals>.full_liker+  r£  )r�  r®  rq   r  rA   rA   rB   Úimpl_np_full_likeW  s   

r²  c                 C   r¡  )NÚonesc                 S   r¦  r§  r­  )r\   rq   rÝ  r©  r„   rA   rA   rB   rÒ   k  rª  zol_np_ones.<locals>.implr+  r£  rŸ  rA   rA   rB   Ú
ol_np_onese  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 rv  )rÅ  rÝ  r7   )rE  rq   rÝ  rd   r¯  rA   rB   rµ  |  s   z"impl_np_identity.<locals>.identityr+  )r�  r   r“  r   r’  )rE  rq   rµ  rA   r¯  rB   Úimpl_np_identityt  s   

r¶  c                 C   rt  r+  rA   ©ÚNÚMrA   rA   rB   Ú_eye_none_handler„  ru  rº  c                 C   s$   t |tjƒrdd„ }|S dd„ }|S )Nc                 S   ó   | S r+  rA   r·  rA   rA   rB   rÒ   ‹  ru  z$_eye_none_handler_impl.<locals>.implc                 S   ó   |S r+  rA   r·  rA   rA   rB   rÒ   Ž  ru  ©rˆ   r   r'  )r¸  r¹  rÒ   rA   rA   rB   Ú_eye_none_handler_implˆ  s
   þr¾  c                    sf   |d u s
t |tjƒrt t¡‰ nt |tjtjfƒr"tt	|d|ƒƒ‰ nt |¡‰ d dtf‡ fdd„	}|S )Nrq   r   c                    s‚   t | |ƒ}t | |fˆ ¡}|dkr)t| || ƒ}t|ƒD ]
}d|||| f< q|S t| | |ƒ}t|ƒD ]
}d||| |f< q4|S re  )rº  rÅ  rÝ  rý  r7   )r¸  r¹  r¾   rq   Ú_MrÝ  Údrd   ©rN  rA   rB   rÒ   ž  s   
ýznumpy_eye.<locals>.impl)
rˆ   r   r'  rÅ  rq   r�  Ú	DTypeSpecrM  r   r  )r¸  r¹  r¾   rq   rÒ   rA   rÁ  rB   Ú	numpy_eye“  s   
rÃ  c                 C   sD   t | ƒs	t d¡‚t| tjƒr | jdvrt d¡‚ddd„}|S d S )Nú#The argument "v" must be array-like)rD   rC  zInput must be 1- or 2-d.r   c                 S   s*  | j dkrG| j}|d t|ƒ }t ||f| j¡}|dkr2t|| ƒD ]}| | |||| f< q#|S t|| ƒD ]}| | ||| |f< q8|S | j\}}|dk rT|| }|dkr\|| }tt||ƒdƒ}t 	|| j¡}|dkr‚t|ƒD ]}| ||| f ||< qs|S t|ƒD ]}| || |f ||< q†|S rŠ  )
rf   r\   r„  rÅ  rÝ  rq   r7   rÌ  rý  rB  )r¿   r¾   r—   rE  r$  rd   ÚrowsÚcolsrA   rA   rB   Ú	diag_impl¶  s2   
þ
þzimpl_np_diag.<locals>.diag_implrÙ   )r   r   rÓ   rˆ   r   r‰   rf   ÚNumbaTypeError)r¿   r¾   rÇ  rA   rA   rB   Úimpl_np_diag­  s   



árÉ  c                    sX   t | tjƒsd}t |¡‚t | jtjƒsd}t |¡‚t| ƒ‰ dˆ  ‰‡ ‡fdd„}|S )Nz5The argument "dimensions" must be a tuple of integersrC  c                    sV   t jˆ f|  t jd�}d}| D ]}t j|t jd� tˆ||ƒ¡}|||< |d7 }q|S )Nr@  r   rD   )rÅ  rB  rh  ÚarangerÖ  r/   )Ú
dimensionsrê   rd   r]  r„   ©r¸  r\   rA   rB   rÒ   á  s   
ÿ
znumpy_indices.<locals>.impl)rˆ   r   rÉ  r   rÓ   rq   rŠ   r‘   )rË  r¹   rÒ   rA   rÌ  rB   Únumpy_indicesÔ  s   

rÍ  c                 C   sB   t | ƒsd}t |¡‚t|ttjfƒsd}t |¡‚ddd„}|S )NrÄ  z#The argument "k" must be an integerr   c           	      S   s€   t  | ¡} |  ¡ } t| ƒ}t|ƒ}|| }t  ||f| j¡}t  d| ¡}t  d|¡}t|ƒD ]}| | ||| || f< q/|S rÏ   )	rÅ  r0  rÜ  r‘   r„  rÝ  rq   Úmaximumr7   )	r¿   r¾   r—   Zabs_krE  rê   rd   Újr
  rA   rA   rB   rÒ   ú  s   
znumpy_diagflat.<locals>.implrÙ   )r   r   rÓ   rˆ   r­   r   rŠ   )r¿   r¾   r¹   rÒ   rA   rA   rB   Únumpy_diagflatð  s   


rÐ  c                 C   s´   |dv sJ ‚|dkr'd}t d| ƒD ]}d| }|d|› dd |¡› d	�7 }qnd
}t d| ƒD ]}d| }|d|› dd |¡› d�7 }q.t |¡}t|tƒ ƒ tƒ d|› � }t|ƒS )N)rp  r?  rp  zv
            def _getitem(a, idx, axis):
                if axis == 0:
                    return a[idx, ...]
        rD   )ú:z
                elif axis == z:
                    return a[r\  z, idx, ...]
            z|
            def _setitem(a, idx, axis, vals):
                if axis == 0:
                    a[idx, ...] = vals
        z:
                    a[z, idx, ...] = vals
            rˆ  )r7   rc  ÚtextwrapÚdedentÚexecÚglobalsr%   )rf   r£  rÉ  rd   ÚlstrA   rA   rB   Ú"generate_getitem_setitem_with_axis  s.   ÿþþÿþ
r×  Útakec                    s8  t  |¡rLt| tjƒrt|tjƒrddd„}|S t| tjƒr2t|tjƒr2|jdk‰ d‡ fdd„	}|S t| tjƒrHt|tjtjfƒrJddd„}|S d S d S t| tjƒrpt|tjƒrpd| j	d  ‰t
‡fdd	„ƒ‰d‡fd
d„	}|S t| tjƒr˜t|tjtjtjfƒrš| j	}t|dƒ‰t|dƒ‰d‡‡fdd„	}|S d S d S )Nc                 S   s.   || j d ks|| j  k rtdƒ‚|  ¡ | S )NrD   úIndex out of bounds)r…   Ú
IndexErrorrÜ  )r�  r”   rÈ   rA   rA   rB   Ú	take_impl4  s   znumpy_take.<locals>.take_implr"  c           	         s†   t j|j| jd�}ˆ r| ¡ }n|}t  |¡}d}|  ¡ }|D ]}|| jd ks.|| j k r2tdƒ‚|| ||< |d }q| |j	¡S )Nr@  r   rD   rÙ  )
rÅ  rB  r…   rq   r  rï  rÜ  rÚ  rÖ  r\   )	r�  r”   rÈ   r$  ÚwalkerÚitrd   rÚ  r  )ÚF_orderrA   rB   rÛ  =  s   


c                 S   s   t  |¡}t  | |¡S r+  )rÅ  r·   rØ  )r�  r”   rÈ   ÚconvertrA   rA   rB   rÛ  P  s   
rÙ   rD   c                    sv   t ˆ ƒ}d}|t| jƒk r| j| dksJ | jƒ‚tt| jƒƒD ]}| j| }||kr5t|||ƒ}|d7 }q |  |¡S re  )r«   r‘   r\   r7   r/   rÖ  )r=  rÈ   r3  rÏ  r„   r—   )r
  rA   rB   Ú_squeeze[  s   &
€
znumpy_take.<locals>._squeezec                    s@   t j| |f|d�}| jdkr|d S |dk r|| j7 }ˆ ||ƒS )Nré  rD   r   )rÅ  rØ  rf   )r�  r”   rÈ   r=  )rà  rA   rB   rÛ  g  s   


rp  r?  c           	         s˜   |}|dk r|| j 7 }|dk s|| j kr!d|› d| j › �}t|ƒ‚t| j|t|ƒƒ}tj|| jd�}tt|ƒƒD ]}ˆ | || |ƒ}ˆ||||ƒ q8|S )Nr   zaxis z) is out of bounds for array of dimension r@  )	rf   r¨   r/   r\   r‘   rÅ  rB  rq   r7   )	r�  r”   rÈ   rÛ   r¹   r\   rë   rd   r  )Ú_getitemÚ_setitemrA   rB   rÛ  ~  s   
ÿr+  )r	   r   rˆ   r   r‰   rŠ   rÕ  rI  r5  rf   r%   r×  )r�  r”   rÈ   rÛ  rf   rA   )rÞ  rá  râ  rà  r
  rB   Ú
numpy_take.  s:   


ÿ
ûÿ

èrã  c                  G   s€   dd„ | D ƒ}t dd„ |D ƒƒrtj}|S t dd„ |D ƒƒr#tj}|S ttddt t¡j  ƒ}dd„ |D ƒ}t	||g ƒ}|S )	Nc                 S   s   g | ]
}t |tjƒs|‘qS rA   r½  r�  rA   rA   rB   r�   ’  r  z!_arange_dtype.<locals>.<listcomp>c                 s   r*  r+  r¬  r�  rA   rA   rB   r.  ”  r/  z _arange_dtype.<locals>.<genexpr>c                 s   r*  r+  )rˆ   r   ÚFloatr�  rA   rA   rB   r.  –  r/  zint%srÊ  c                 S   s   g | ]}t  |¡‘qS rA   )r   Ú	unliteralr`  rA   rA   rB   r�   ¥  r«  )
r0  r   Ú
complex128r¤   r  rÅ  rq   r­   r�   rÌ  )rß   Úboundsrq   ZNPY_TYZunliteral_boundsrA   rA   rB   Ú_arange_dtype‘  s   îúrè  c                   s  t |tjƒr	|j}t |tjƒr|j}t |tjƒr|j}|d u r"tj}|d u r)tj}|d u r0tj}t | tjƒrQt |tjtjfƒrQt |tjtjfƒrQt |tjtjfƒsSd 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   r5  rA   r¬  r`  rA   rA   rB   r�   Ç  ó    ÿznp_arange.<locals>.<listcomp>rÔ   c                   sð   ˆ d urˆ n| }ˆd urˆn|}ˆd urˆn|}|d ur|nd}|d u r*d|}}	n||}}	|dkr7t dƒ‚|	| | }
tt |
j¡ƒ}ˆdu rZtt |
j¡ƒ}tt||ƒdƒ}nt|dƒ}t 	|ˆ¡}|}t
|ƒD ]
}|||  ||< qk|S )NrD   r   zMaximum allowed size exceededT)r¨   r­   ÚmathÚceilr°  r²  rÌ  rý  rÅ  rB  r7   )r  rŸ  rš  rq   Z	lit_startZlit_stopZlit_stepÚ_stepÚ_startÚ_stopÚnitems_cÚnitems_rÚnitems_ir¢   rÝ  r}   rd   ©Zstart_valueZ
step_valueZ
stop_valueZ
true_dtypeZuse_complexrA   rB   rÒ   Î  s(   

znp_arange.<locals>.implr   )rˆ   r   ÚOptionalr8   r  rM  r'  rÂ  rè  rq   r0  r  )r  rŸ  rš  rq   rÒ   rA   rò  rB   Ú	np_arange«  s>   ÿþýÿrô  c                    sn   t dd„ | |fD ƒƒsd S t|ttjfƒsd}t |¡‚tdd„ | |fD ƒƒr+tj‰ ntj	‰ d‡ fdd„	}|S )	Nc                 s   r*  r+  )rˆ   r   rM  r®  rA   rA   rB   r.  ñ  r/  z!numpy_linspace.<locals>.<genexpr>r«  c                 s   r*  r+  r¬  r®  rA   rA   rB   r.  ø  r/  r¥  c                    sŠ   t  |ˆ ¡}| d } |d }|dkr|S |d }|dkr7||  }t  ||¡}td|ƒD ]
}| ||  ||< q+n| |d< |dkrC||d< |S )Ng      ð?r   rD   r¤  )rÅ  rB  Údivider7   )r  rŸ  r¨  rÝ  ÚdivÚdeltarš  rd   r@  rA   rB   r¦  þ  s    ÿz numpy_linspace.<locals>.linspacer©  )
r:  rˆ   r­   r   rŠ   r   rÓ   r0  ræ  r¤   )r  rŸ  r¨  r¹   r¦  rA   r@  rB   Únumpy_linspaceï  s   
rø  c              
   C   s0  |j d }t|ƒ| ||d d�}t ||j¡}|j}t| |||ƒ}|j}	|j}
|jdv s.J ‚|j|jkrBtj	||
|	|j
|jdd� nLt ||j¡}t ||j¡}|  tj¡}t |||¡�)}t | ||	|||j|¡}t | ||
|||j|¡}| | |¡|¡ W d  ƒ n1 s‰w   Y  t| ||j| ¡ ƒS )z
    Array copy.
    r   rú   rÛ  rD   rv   N)rß   ro   r	   r°   r\   rá   rÓ  r‹   rÕ  Ú
raw_memcpyr¢   r�   rœ   r©   r   r�   rý  rÔ  r  r=   r    rç   )rs   r<   rT   rß   r~  rñ   rò   Úrettyper$  rò  rv  ró  ru  rº   r”   rë  r   rA   rA   rB   Ú_array_copy  s6   
ÿ
þ
þù	rû  c                 C   s@   t |tjƒsJ ‚|jdkrdnd}|j|dd�}||ƒ}|tfS )Nr"  r–   F)rÕ  r  )rˆ   r   r‰   rÕ  r  rû  )r#  r�  rÕ  r$  rT   rA   rA   rB   Ú_array_copy_intrinsic<  s
   rü  z
array.copyc                 C   r  r+  )rû  r‚  rA   rA   rB   Ú
array_copyE  rö  rý  c                 C   s6   t | ƒs	t d¡‚t| tjƒrdd„ }|S dd„ }|S )NrÛ  c                 S   ó   t | ƒS r+  )rü  rõ  rA   rA   rB   Ú
numpy_copyQ  rg  z#impl_numpy_copy.<locals>.numpy_copyc                 S   r�  r+  )rÅ  r0  rõ  rA   rA   rB   rÿ  T  r8  )r   r   rÓ   rˆ   r   r‰   )r�  rÿ  rA   rA   rB   Úimpl_numpy_copyJ  s   
ýr   c              	   C   s  |j }|jd }|j|ksJ dƒ‚|jdkr`|jdksJ ‚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sp|jdkry|jdv ryt| |||d ƒS |jdkrû|dv s„J ‚|dkrŠtnt}t|| |||d ƒ}| |¡�D\}}|� t| |||d ƒ}|j}W d	  ƒ n1 s·w   Y  |� t| |||ƒ}|j}W d	  ƒ n1 sÓw   Y  W d	  ƒ n1 sâw   Y  | |j¡}| ||¡ | ||¡ |S t| |||ƒS )
zd
    Common logic for layout conversion function;
    e.g. ascontiguousarray and asfortranarray
    r   z return-type has incorrect layoutrD   rú   rC  rÛ  r  r–   N)rá   rß   rÕ  rf   ro   rz  r   rÉ  r�   rj  r�   rÀ   r‹   r›   rž   r   rç   r   r   r†  rê  Úblockrû  Úphir8   Úadd_incoming)rs   r<   rT   rß   Úoutput_layoutrÑ  rÁ   rñ   r$  r\   rœ   Ú
check_funcrn  ÚthenÚorelseZout_thenZthen_blkZ
out_orelseZ
orelse_blkZret_phirA   rA   rB   Ú_as_layout_arrayZ  s`   

ÿþÿ
üÿýþ€ùr  c                    sJ   t ˆ tjƒst ˆ ¡‚|jˆ jt|jdƒdd�}||ˆ ƒ}|‡ fdd„fS )NrD   F)rÕ  rf   r  c                    s   t | |||ˆ jd�S )N©r  )r  rÔ   )r�  r  r—   r�  r	  rA   rB   rA  §  s    ÿz,_as_layout_array_intrinsic.<locals>.<lambda>)	rˆ   r   r$   r   ÚRequireLiteralValuer  rÔ   rÌ  rf   )r#  r�  r  r$  rT   rA   r	  rB   Ú_as_layout_array_intrinsic›  s   

ý
r  c                 C   sH   t | ƒs	t d¡‚t| tjtjfƒrdd„ }|S t| tjƒr"dd„ }|S )NrÛ  c                 S   ó   t  t  | ¡¡S r+  )rÅ  Úascontiguousarrayr·   rõ  rA   rA   rB   rÒ   ±  rq  z%array_ascontiguousarray.<locals>.implc                 S   rÙ  ©Nr–   ©r  rõ  rA   rA   rB   rÒ   ´  r”  ©r   r   rÓ   rˆ   r   rM  r®  r‰   r2  rA   rA   rB   Úarray_ascontiguousarray«  s   
ýr  c                 C   sL   t | ƒs	t d¡‚t| tjtjfƒrdd„ }|S t| tjƒr$dd„ }|S d S )NrÛ  c                 S   r  r+  )rÅ  Úasfortranarrayr·   rõ  rA   rA   rB   rÒ   ¿  rq  z"array_asfortranarray.<locals>.implc                 S   rÙ  )Nr"  r  rõ  rA   rA   rB   rÒ   Ã  r”  r  r2  rA   rA   rB   Úarray_asfortranarray¹  s   
ýr  zarray.astypec              
   C   s  |j d }t|ƒ| ||d d�}t ||j¡}|j}t| |||ƒ}|j}	|j}
t ||j¡}t ||j¡}|  	t
j¡}t |||¡�9}t | ||	|||j|¡}t | ||
|||j|¡}t| |||ƒ}|  |||j|j¡}t| ||||ƒ W d   ƒ n1 s~w   Y  t| ||j| ¡ ƒS rR  )rß   ro   r	   r°   r\   rá   rÓ  r‹   rœ   r©   r   r�   rý  rÔ  rÕ  r{   r€   rq   r~   r    rç   )rs   r<   rT   rß   r~  rñ   rò   rú  r$  rò  rv  ró  ru  rº   r”   rë  r   ÚitemrA   rA   rB   Úarray_astypeÈ  s0   

þ
þ÷r  c                 C   s(   t |tjƒsJ ‚t|ƒ}dd„ }||fS )Nc              
   S   sR  |j \}t|ƒ}|| ||d ƒ}|j}| ||j¡}t| ||ƒ}	|jr8|jdkr8t 	||	j
|j
|j|¡ |	 ¡ S t ||j¡}
t ||j¡}|j}|  tj¡}tj||ddd�}t ||
|¡�>}t | ||j
|
|||¡}| ||	j
j¡}| |¡}| |	j
|g¡}t ||||¡ | | ||¡|¡ W d   ƒ |	 ¡ S 1 s w   Y  |	 ¡ S )Nr   r–   ZbyteptrT)ÚnamerH   )rß   ro   r�   r²   r¢   r-   rr  rÕ  r	   rù  r‹   r°   r\   rœ   r©   r   r�   rP   rý  rÔ  r÷  r8   r=   rÖ  r¸  r  rz  rç   )rs   r<   rT   rß   r-  rÜ  rÝ  r�   rk  Zbstrr\   rœ   rÕ  rº   Zbyteidxr”   rb   Zsrcptrr„   ZdestptrrA   rA   rB   r"  ì  s>   ÿìÿÿ

öôz)_array_tobytes_intrinsic.<locals>.codegen)rˆ   r   r‰   r.   )r#  r  rT   r"  rA   rA   rB   Ú_array_tobytes_intrinsicç  s   #r  rÌ  c                 C   ó   t | tjƒrdd„ }|S d S )Nc                 S   rþ  r+  )r  rž  rA   rA   rB   rÒ     rg  z impl_array_tobytes.<locals>.implr,  rŸ  rA   rA   rB   Úimpl_array_tobytes  ó   ýr  c           	      C   s&   |j }||||||ƒ}dd„ }||fS )Nc           !   	   S   sæ  |j d }|d }|d }|j}t|ƒ| ||d d�}t|ƒ}	|	| |ƒ}
|
j}t| |ƒ}t|jj|ƒ}| |j	|j¡}| ||¡}| 
||¡}| d|t |jd¡¡}d}|j|dd�� | j |t|f¡ W d   ƒ n1 spw   Y  | d|t |jd¡¡}| ||¡}t ||¡}|j|dd�� d	}| j |t|f¡ W d   ƒ n1 sªw   Y  | |¡�:\}}|� |j}| ||¡}W d   ƒ n1 sÍw   Y  |� |j}W d   ƒ n1 sâw   Y  W d   ƒ n1 sñw   Y  | |j¡}| ||¡ | ||¡ | ||¡}| d
||¡}|j|dd�� d}| j |t|f¡ W d   ƒ n	1 �s3w   Y  t ||g¡}t ||g¡}| |j|g¡}| ||  | d¡¡¡}t |
|||||j!|j"d� |
 #¡ } t$| ||j| ƒS )Nr   rC  rÂ  rú   rü   z=offset must be non-negative and no greater than buffer lengthFr=  z.buffer size must be a multiple of element sizeru  z%buffer is smaller than requested sizer‹   r#  )%rß   rá   ro   r£   ru   r   r�   r8   r²   r¢   rI  rý   r   rÿ   r?  r@  r¨   Úsremr	   Úis_not_nullrê  Úbasic_blockÚsdivr  r  r»  ra   rÖ  r‹   r÷  r©   rª   rÀ   r›   rž   rç   r   )!rs   r<   rT   rß   ZbuftyÚ	arg_countZ
arg_offsetrÁ   rÐ  Z
out_ary_tyÚout_aryZout_datamodelr�   Úll_itemsizerk  Zll_offset_sizeZnbytes_is_negativer¹   Zll_count_is_negativeÚremZis_incompatibleZ
then_blockZ
else_blockZbb_ifZ	num_wholeÚbb_elseZll_itemcountZll_required_sizeZis_too_larger\   rœ   r‹   rê   rA   rA   rB   r"    sˆ   


ýÿýþþÿ€üþÿúznp_frombuffer.<locals>.codegenr†  )	r#  Úbufferrq   r±   ró   rÑ  r-  rT   r"  rA   rA   rB   Únp_frombuffer  s   Pr%  r¤  c                    s¾   t d|ƒ t| tjƒr| jdkrd| › �}t |¡‚|tu s-t|tjƒr)|j	tu s-t
|ƒr1tj}nt|ƒ}|d urEtj|dd| j d�‰ nd| › d|› d�}t |¡‚td	d
f‡ fdd„	}|S )NÚ
frombufferr–   z+Argument "buffer" must be buffer-like. Got rD   )rq   rf   rÕ  r  z3Cannot parse input types to function np.frombuffer(r\  rb  r¤  r   c                    s   t | |||ˆ ƒS r+  )r%  )r$  rq   r±   ró   rŽ  rA   rB   rÒ   ‰  rq  z impl_np_frombuffer.<locals>.impl)r�  rˆ   r   rï   rÕ  r   rÓ   r�  r�  r‘  r   r’  r“  r‰   rw  )r$  rq   r±   ró   r¹   r•  rÒ   rA   rŽ  rB   Úimpl_np_frombufferr  s0   



ÿ
ÿ
ÿÿÿ
r'  c                    óP   t |ƒrtdd ƒ‰ d‡ fdd„	}|S t|tjƒr&td|ƒ‰ d‡ fdd„	}|S d S )Nr–   c                    ó
   ˆ | |ƒS r+  rA   ©rb   r\   rq   ©Úintrinsic_cfarrayrA   rB   rÒ   ”  r”  zimpl_carray.<locals>.implc                    r)  r+  rA   r*  r+  rA   rB   rÒ   š  r”  r+  ©r   Úget_cfarray_intrinsicrˆ   r   rÂ  ©rb   r\   rq   rÒ   rA   r+  rB   Úimpl_carray�  ó   

ûr0  c                    r(  )Nr"  c                    r)  r+  rA   r*  r+  rA   rB   rÒ   ¤  r”  zimpl_farray.<locals>.implc                    r)  r+  rA   r*  r+  rA   rB   rÒ   ª  r”  r+  r-  r/  rA   r+  rB   Úimpl_farrayŸ  r1  r2  c                    s   t ‡ ‡fdd„ƒ}|S )Nc           	         sü   |t ju rd }nt|t jƒr|j}nd|› d�}t |¡‚ˆ d u r/|d u r,d}t |¡‚|}n+tˆ t jƒrOˆ j}|d urN||krNd|› d|› d�}t |¡‚ndˆ › d�}t |¡‚t|ƒ}|d u rmd|› 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   rj  rˆ   ÚCPointerrq   r   rÈ  rÂ  r”  r‰   r#   Ú
np_cfarray)	r#  rb   r\   Ú	ptr_dtyper¹   rq   rf   rÑ  rT   ©Údtype_rÕ  rA   rB   r,  °  s4   



€

z0get_cfarray_intrinsic.<locals>.intrinsic_cfarray©r(   )rÕ  r8  r,  rA   r7  rB   r.  ¯  s   r.  c                    s<  |j dd… \}}|dd… \}}|j}|jdv sJ ‚t|ƒˆˆ ƒ}	tˆ|ƒ}
t |
¡}t|tj	ƒr9t 
ˆ |¡}n|f}|f}‡ ‡fdd„t||ƒD ƒ}|}g }|jdkrf|D ]}| |¡ ˆ  ||¡}qWnt|ƒD ]}| |¡ ˆ  ||¡}qj| ¡  ˆ  |ˆ |j¡ ¡ ¡}t|	||||dd� |	 ¡ }tˆˆ |j|ƒS )zR
    numba.numpy_support.carray(...) and
    numba.numpy_support.farray(...).
    NrC  rÛ  c                    ry  rA   rz  )rŽ   r€  rû   r�   rA   rB   r�   è  r{  znp_cfarray.<locals>.<listcomp>r"  rŒ  )rß   rá   rÕ  ro   ru   r	   rº   rˆ   r   r5  r°   r’   r`   r²   r¨  rF  r÷  rp   rq   r’  rÀ   rç   r    )rs   r<   rT   rß   rñ  r}  rb   r\   rÁ   r   r�   r!  rò   Úoffrœ   r—   r‹   rê   rA   r�   rB   r5  Ó  sJ   

ÿ

þ
ÿú	r5  c                 C   sN   t |tjƒr|  tjt|ƒ¡S t |tjƒr%|  tttj|ƒ¡}|||fƒS J ‚r+  )	rˆ   r   r5  r¯   r�   r‘   rt  rJ   r#   )rs   r<   ÚseqtyÚseqrw  rA   rA   rB   Ú_get_seq_size  s   r=  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)r<   rß   r$  ©rs   rq  rÑ  rA   rB   Úwrap  s   
z$_get_borrowing_getitem.<locals>.wrap)rq   rJ   ro  rp  r#   r   r�   )rs   r;  r@  rA   r?  rB   Ú_get_borrowing_getitem  s   ÿrA  c                    st   ˆ  tj¡}t|dƒ‰‡ ‡‡fdd„}g }||}}	t|ƒD ]}
|
dkr+|||	ƒ\}}	| tˆˆ ||	ƒ¡ qt|ƒS )zF
    Compute the likely shape of a nested sequence (possibly 0d).
    r   c                    sN   t | tjƒrt| ƒdkrdS | d ˆ  |d¡fS tˆ| ƒ}| j|ˆ |ˆfƒfS )Nr   ©NN)rˆ   r   r5  r‘   r:  rA  rq   )r;  r<  rq  ©r<   rs   ré   rA   rB   Úget_first_item)  s   
z.compute_sequence_shape.<locals>.get_first_item)r©   r   r�   r   r7   r`   r=  r«   )rs   r<   rf   r;  r<  rº   rD  rò   ÚinnertyÚinnerrd   rA   rC  rB   Úcompute_sequence_shape"  s   

rG  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¨   rA   r�   rA   rB   Ú_failE  s   
ÿz#check_sequence_shape.<locals>._failc                    s<  t |ƒdkrd S tˆˆ| |ƒ}|d }ˆ d||¡}ˆj|dd�� ˆ ƒ  W d   ƒ n1 s/w   Y  t |ƒdkr<d S t| tjƒrutˆ| ƒ}t 	ˆ|¡�}| j
}|ˆ||jfƒ}	ˆ||	|dd … ƒ W d   ƒ d S 1 snw   Y  d S t| tjƒrštt | ƒƒD ]}
| |
 }ˆ ||
¡}	ˆ||	|dd … ƒ q�d S J | ƒ‚)Nr   r<  Fr=  rD   )r‘   r=  rý   rÿ   rˆ   r   rt  rA  r	   r�  rq   rã   r5  r7   r:  )r;  r<  rò   r…   Úexpectedr  rq  r�  rE  rF  rd   ©rH  r<   Úcheck_seq_sizers   rA   rB   rK  I  s0   ÿ
"ýýz,check_sequence_shape.<locals>.check_seq_sizeNrA   )rs   r<   r;  r<  rò   rA   rJ  rB   Úcheck_sequence_shape@  s   rL  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 r  )r	   rÔ  rÕ  r€   rq   r~   )r”   r8  r}   rb   )rÜ  r<   rs   r‹   rò   rœ   rA   rB   Úassign_itemp  s
   ÿz-assign_sequence_to_array.<locals>.assign_itemc                    s  t |ƒdkrt| tjtjfƒrJ ‚ˆ|| |ƒ d S |d }t| tjƒr[tˆ| ƒ}t ˆ|¡�#}| j}|ˆ||j	fƒ}ˆ |||dd … ||j	f ƒ W d   ƒ d S 1 sTw   Y  d S t| tjƒr‹t
t | ƒƒD ]!}	| |	 }ˆ ||	¡}ˆ tj|	¡}
ˆ |||dd … ||
f ƒ qgd S J | ƒ‚re  )r‘   rˆ   r   rt  r5  rA  r	   r�  rq   rã   r7   r:  r¯   r�   )r;  r<  rò   r”   r…   rq  r�  rE  rF  rd   rã   )ÚassignrM  r<   rs   rA   rB   rN  v  s(   
 "ýüz(assign_sequence_to_array.<locals>.assignrA   NrA   )rs   r<   r‹   rò   rœ   rÜ  r;  r<  rA   )rÜ  rN  rM  r<   rs   r‹   rò   rœ   rB   Úassign_sequence_to_arrayi  s   rO  c                 C   s>   t | |ƒ\}}t|ƒr|}n
t|ƒ}|d u rd S t ||d¡S r  )r4   r   r“  r   r‰   )r#  r0  rq   rf   Z	seq_dtyperA   rA   rB   Únp_array_typer’  s   rP  c                 C   s0   t d|ƒ t| ||ƒ}|||ƒ}dd„ }||fS )Nr·   c           
   	   S   sŠ   |j }|j}|jd }|d }t| ||||ƒ}t|ƒ|ksJ ‚t| ||||ƒ t| |||ƒ}	t| ||	j||	j	|||ƒ t
| ||j |	 ¡ ƒS rÏ   )rá   rf   rß   rG  r‘   rL  rÓ  rO  r‹   rœ   r    rç   )
rs   r<   rT   rß   rÜ  rf   r;  r<  rò   rÝ  rA   rA   rB   r"  £  s   

ÿ
ÿznp_array.<locals>.codegen)r�  rP  )r#  Úobjrq   r$  rT   r"  rA   rA   rB   Únp_array�  s
   

rR  c                 C   sL   t d|ƒ t| ƒst d¡‚t|ƒst|ƒd u 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   ó
   t | |ƒS r+  )rR  )r0  rq   rA   rA   rB   rÒ   Á  r”  zimpl_np_array.<locals>.implr+  )r�  r   r   rÓ   r   r“  )r0  rq   r¹   rÒ   rA   rA   rB   Úimpl_np_array·  s   



rT  c           
      C   s¦   |  d¡}|  |¡}| d||¡}| || ||¡|¡}| | d||¡| d||¡¡}|j|dd�� d| }	| j |t|	f¡ W d   ƒ |S 1 sLw   Y  |S )Nr   rü   rk  Fr=  z%s(): axis out of bounds)	r8   rý   rž  rz  rº  rÿ   r?  r@  rÚ  )
rs   r<   rÆ   rf   rÈ   ré   Zll_ndimZis_neg_axisZaxis_out_of_boundsr¹   rA   rA   rB   Ú_normalize_axisÆ  s   

þ
þürU  c              
   C   sÂ   t |ƒ|d ks
J ‚t tj|¡}t ||¡}t d¡}t|d ƒD ])}t |¡}	| d|	|¡}
|| }| |
| 	|	|¡|	¡}| 
|t ||d|¡¡ q"| 
|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).
    rD   rk  r   ©r‘   r   r‘  r	   rº   rP   r7   rý   rž  rz  r  r_   r°   r=   )rs   r<   Ú
orig_shaperf   rÈ   Úll_shtyrò   r  r]  Úll_dimÚ
after_axisr   r„   rA   rA   rB   Ú_insert_axis_in_shapeÙ  s   


þr[  c              
   C   sÈ   t |ƒ|d ks
J ‚t tj|¡}t ||¡}t d¡}t d¡}t|d ƒD ]'}	t |	¡}
| d|
|¡}| || 	|
|¡|
¡}| 
||	 t ||d|¡¡ q'| 
|t ||d|¡¡ t || |¡¡S )zD
    Same as _insert_axis_in_shape(), but with a strides array.
    rD   r   rk  rV  )rs   r<   Úorig_stridesrf   rÈ   rX  rœ   r  ré   r]  rY  rZ  r„   rA   rA   rB   Ú_insert_axis_in_stridesö  s"   



þ
ÿr]  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á   rf   rß   ro   r	   r°   r\   rœ   r[  r]  rÀ   r‹   r�   r›   rž   rç   )rs   r<   rT   rß   rÈ   rÑ  rf   rÜ  rÝ  r$  rò   rœ   Ú
new_shapesÚnew_stridesrA   rA   rB   Úexpand_dims  s$   
úr`  c                 C   sB   |j dkr|jnd}|j|j d |d�}|||ƒ}dd„ }||fS )NrD   r  r  c                 S   sP   |   ||d |jd tj¡}t| |d|jj|ƒ}t| ||||ƒ}t| ||j|ƒS )NrD   znp.expand_dims)	r€   rß   r   r�   rU  rá   rf   r`  r   )rs   r<   rT   rß   rÈ   r$  rA   rA   rB   r"  5  s   ÿznp_expand_dims.<locals>.codegen)rf   rÕ  r  )r#  r�  rÈ   rÕ  r$  rT   r"  rA   rA   rB   Únp_expand_dims/  s
   
ra  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   rS  r+  )ra  )r�  rÈ   rA   rA   rB   rÒ   J  r”  z!impl_np_expand_dims.<locals>.impl)rˆ   r   r‰   r   rÓ   rŠ   )r�  rÈ   r¹   rÒ   rA   rA   rB   Úimpl_np_expand_dims@  s   



rb  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 )rÄ  )r  rÌ  rf   r®  )ÚminimumrA   rB   r�   S  s     z-_atleast_nd.<locals>.impl.<locals>.<listcomp>c                    sn   t ˆˆƒ‰t ˆ |d ¡}‡ ‡‡fdd„t|ˆˆƒD ƒ}t|ƒdkr+ˆ ˆ |j|¡}n|d }tˆˆ |j|ƒS )Nr   c                    s"   g | ]\}}}ˆˆˆ |||ƒ‘qS rA   rA   )rŽ   rÝ  rÜ  rÑ  ©r<   rs   Ú	transformrA   rB   r�   Y  s    ÿz>_atleast_nd.<locals>.impl.<locals>.codegen.<locals>.<listcomp>rD   )Ú_atleast_nd_transformr	   r°   r’   r‘   rj  rá   r   )rs   r<   rT   rß   ÚarrsÚretsr$  )r  rŸ  rc  r+  rd  rB   r"  U  s   

ÿz*_atleast_nd.<locals>.impl.<locals>.codegenrD   r   )r#   r‘   r   r9  rÍ  Ú
from_types)Ztypingcontextrß   r"  )rŸ  rc  )r  r+  rB   rÒ   P  s   
ÿÿz_atleast_nd.<locals>.implc                     s   ˆ | Ž S r+  rA   rÇ  )rÒ   rA   rB   rA  e  s    z_atleast_nd.<locals>.<lambda>r9  )rc  rŸ  rA   )rŸ  rÒ   rc  rB   Ú_atleast_ndO  s   rj  c                    s"   ˆt ˆ ƒksJ ‚‡ ‡fdd„}|S )z`
    Return a callback successively inserting 1-sized dimensions at the
    following axes.
    c           	         sb   t ˆƒD ]*}|d }|j|k r.t ˆ | ¡}|j|jd d�}t| |t ||¡|f|ƒ}|}q|S )NrD   rÄ  )r7   rf   r	   rº   r  r`  r   r#   )	rs   r<   rÝ  rÜ  rÑ  rd   rf   rÈ   Znewarrty©rŸ  Úmin_ndimrA   rB   re  o  s   
þ€z(_atleast_nd_transform.<locals>.transform)r‘   )rl  rŸ  re  rA   rk  rB   rf  h  s   rf  c                  G   s"   t dd„ | D ƒƒrtddgƒS d S )Nc                 s   r*  r+  r,  r®  rA   rA   rB   r.  �  r/  z np_atleast_1d.<locals>.<genexpr>rD   r   ©r:  rj  rÇ  rA   rA   rB   Únp_atleast_1d  s   ÿrn  c                  G   s$   t dd„ | D ƒƒrtdddgƒS d S )Nc                 s   r*  r+  r,  r®  rA   rA   rB   r.  ‡  r/  z np_atleast_2d.<locals>.<genexpr>rC  r   rm  rÇ  rA   rA   rB   Únp_atleast_2d…  ó   ÿro  c                  G   s$   t dd„ | D ƒƒrtdg d¢ƒS d S )Nc                 s   r*  r+  r,  r®  rA   rA   rB   r.  �  r/  z np_atleast_3d.<locals>.<genexpr>rÂ  )r   r   rC  rm  rÇ  rA   rA   rB   Únp_atleast_3d‹  rp  rq  c	                 C   s¤  t |ƒt |ƒ  krt |ƒ  krt |ƒksJ ‚ J ‚t d¡}	t| |||ƒ}
t ||
j¡}g }|D ]2}|	}tt||ƒƒD ]!\}\}}| d| 	|¡|¡}| 
||¡}| || ||¡|¡}q=| |¡ q2|
j}t|||||ƒD ]_\}}}}}|j}tj||tj|jd�}|�9}t | |||||j|¡}t| |||ƒ}|  |||j|j¡}t | |||||j|¡}t| ||||ƒ W d  ƒ n1 sÃw   Y  t |||¡}qp|
S )z2
    Concatenate arrays along the given axis.
    r   r¸  )ÚorderN)r‘   r	   rº   rÓ  r°   rœ   rÚ   r’   rý   r8   r²   rž  rz  r`   r‹   rý  rÕ  rÔ  r{   r€   rq   r~   rî   )rs   r<   rÈ   r  rg  Ú
arr_shapesÚarr_stridesrÑ  Ú
ret_shapesré   r$  Zret_stridesZcopy_offsetsZarr_shró   r]  r…   r½  Úis_axisÚaddendZret_datarÜ  rÝ  Zarr_stZarr_datarý  r”   rë  r}   r   rA   rA   rB   Ú_do_concatenate‘  sL   6

þÿÿ
þ
þ÷rx  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 ƒ}ˆ  |
¡�v\}}|� t 	ˆ j
||g ¡}ˆ  ||¡ W d   ƒ n1 s€w   Y  |�@ tj}|D ]}ˆ  |ˆ  d||¡¡}q�ˆ jˆ  |¡dd�� ˆj ˆ tdˆ f¡ W d   ƒ n1 s»w   Y  W d   ƒ n1 sÊw   Y  W d   ƒ n1 sÙw   Y  q9‡ fdd„|	D ƒ}	tˆˆ |||||||	ƒ	}tˆˆ || ¡ ƒS )Nc                    ó"   g | ]\}}t |ƒˆˆ |d �‘qS ©rú   rŠ  ©rŽ   rÔ  r�  r�   rA   rB   r�   Ñ  r{  z#_np_concatenate.<locals>.<listcomp>únp.concatenatec                    ó   g | ]	}t  ˆ |j¡‘qS rA   )r	   r°   r\   ©rŽ   rÝ  rƒ  rA   rB   r�   ×  r  c                    r}  rA   ©r	   r°   rœ   r~  rƒ  rA   rB   r�   Ø  r  c                    s   g | ]}t  ˆ |¡‘qS rA   )r	   râ   r  rƒ  rA   rB   r�   Ý  ré  r   r¸  c                    s   g | ]}|ˆ  ‘qS rA   rA   r  )r]  rA   rB   r�   ä  ra  rD   Fr=  z<np.concatenate(): input sizes over dimension %d do not matchc                    r�  rA   r‚  r  rƒ  rA   rB   r�   ø  r«  )rf   r’   rU  r7   rý   r8   r=   rê  r  r  rz  r  r	   r	  rã  rÿ   r•  r?  r@  r¨   rx  r    rç   )rs   r<   r  rg  rÑ  rÈ   rf   rs  rt  ru  rv  Zret_shape_ptrZret_shZother_shapesZon_axisZon_other_dimr   Úis_okr$  rA   )r<   rs   r]  rB   Ú_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 ]A}tj}tt ˆ |j¡|
ƒD ]1\}}ˆ  	|ˆ  
d||¡¡}ˆ jˆ  |¡dd�� ˆj ˆ td	¡ W d   ƒ n1 ssw   Y  qGq8‡ fd
d„|D ƒ}t tj|¡‰t ˆ ˆ¡}t ˆ ˆ¡}t|d ƒD ]5}t |¡}ˆ  
d||¡}|
| }ˆ  |ˆ  ||¡|¡}ˆ  |t ˆ |d|¡¡ ˆ  |t ˆ |d|¡¡ qœˆ  |t ˆ |d|¡¡ ˆ  |	t ˆ |d|¡¡ t ˆ ˆ  |¡¡}|gt|ƒ }t ˆ ˆ  |¡¡}‡ ‡fdd„tt|ƒƒD ƒ}t|d ƒD ]6}t |¡}ˆ  
d||¡}ˆ  |ˆ  ||¡|¡}tt|ƒƒD ]}ˆ  || | t ˆ || d|¡¡ �q6�qtt|ƒƒD ]}ˆ  |t ˆ || d|¡¡ �qT‡ fdd„|D ƒ}tˆˆ |||||||ƒ	}tˆˆ || ¡ ƒS )Nr   rD   c                    ry  rz  rŠ  r{  r�   rA   rB   r�     r{  z_np_stack.<locals>.<listcomp>únp.stackr¸  Fr=  )z5np.stack(): all input arrays must have the same shapec                    r}  rA   r  r~  rƒ  rA   rB   r�     r  rk  c                    r†  rA   r‡  r„  )r<   rX  rA   rB   r�   :  ré  c                    s   g | ]}t  ˆ ˆ  |¡¡‘qS rA   )r	   r°   r=   )rŽ   r!  rƒ  rA   rB   r�   O  r^  )rf   r	   rº   r‘   r’   rU  r°   r\   r	  rã  rý   rÿ   r•  r?  r@  r¨   r   r‘  rP   r7   rž  rz  r  r_   r=   rx  r    rç   )rs   r<   r  rg  rÑ  rÈ   rf   ré   r  Z
ll_narraysrW  rÝ  r€  r   Zorig_shr\  Úinput_shapesru  r]  rY  rZ  r„   Zinput_stridesrd   r$  rA   )r<   rs   rX  rB   Ú	_np_stack   s–   

ÿÿþÿ€ý

þý
ÿ

þÿÿÿ
ÿ
ÿþr„  c                 C   sT   |d urt |tjƒsd S t| d|ƒ\}}|dkrd}t |¡‚t|ƒ}t |||¡S )Nr|  r   z.zero-dimensional arrays cannot be concatenated)rˆ   r   rŠ   r5   r   rÈ  r6   r‰   )r#  r  rÈ   rq   rf   r¹   rÕ  rA   rA   rB   Únp_concatenate_typerY  s   ÿ
r…  c                 C   s6   t | ||ƒ}t|tjƒsJ ‚|||ƒ}dd„ }||fS )Nc              	   S   sF   |   ||d |jd tj¡}t| |t|jd ƒt ||d ¡|j|ƒS rŠ  )	r€   rß   r   r�   r�  r¬   r	   r°   rá   ©rs   r<   rT   rß   rÈ   rA   rA   rB   r"  q  s   üznp_concatenate.<locals>.codegen)r…  rˆ   r   r‰   )r#  r  rÈ   r$  rT   r"  rA   rA   rB   Únp_concatenatek  s
   
r‡  c                 C   ó   t | tjƒrddd„}|S d S )Nr   c                 S   rS  r+  )r‡  ©r  rÈ   rA   rA   rB   rÒ     r”  z!impl_np_concatenate.<locals>.implrÙ   ©rˆ   r   r5  ©r  rÈ   rÒ   rA   rA   rB   Úimpl_np_concatenate|  ó   
ýrŒ  c                 C   s0   |D ]}|j dk s|j dkrd}t |¡‚qdS )NrD   rC  z7np.column_stack() is only defined on 1-d and 2-d arrays)rf   r   rÈ  )rs   rÆ   r  r�  r¹   rA   rA   rB   Ú_column_stack_dims„  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 ]:\}	}
|	jdkr3| 	|	¡ | 	|
¡ q|	jdks:J ‚|	j
dd�}t ||	¡}t| |||
f|ƒ}| 	|¡ | 	|¡ qt| ||||j|ƒS )Nr   rD   rC  rÄ  )r¬   rß   r	   r°   r¯   r   r�   r’   rf   r`   r  r   r#   r`  r�  rá   )rs   r<   rT   rß   Zorig_arrtysZ	orig_arrsr  rg  rÈ   rÜ  rÝ  r+  Ú
expand_sigZnewarrrA   rA   rB   r"  –  s$   



ÿz np_column_stack.<locals>.codegen)r5   rŽ  r6   r   r‰   )r#  r3  rq   rf   rÕ  r$  rT   r"  rA   rA   rB   Únp_column_stack�  s   
þr‘  c                 C   r  )Nc                 S   rþ  r+  )r‘  ©r3  rA   rA   rB   rÒ   ¶  rg  zimpl_column_stack.<locals>.implrŠ  ©r3  rÒ   rA   rA   rB   Úimpl_column_stack³  r  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†  rA   rA   rB   Ú_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 )r"  N)rÕ  r�  rA   rA   rB   r.  Ë  s   € z"np_stack_common.<locals>.<genexpr>r"  r–   rD   c                 S   s,   |   ||d |jd tj¡}t| ||||ƒS rv  )r€   rß   r   r�   r•  r†  rA   rA   rB   r"  Ï  s   z np_stack_common.<locals>.codegen)r5   r:  r   r‰   )	r#  r  rÈ   rq   rf   rÕ  r$  rT   r"  rA   rA   rB   Únp_stack_commonÆ  s   ÿ
r–  c                 C   rˆ  )Nr   c                 S   rS  r+  )r–  r‰  rA   rA   rB   rÒ   Ù  r”  zimpl_np_stack.<locals>.implrÙ   rŠ  r‹  rA   rA   rB   Úimpl_np_stackÖ  r�  r—  c                 C   s4   t | ||ƒ\}}t||ƒ}t|ƒ}t |||¡}|S r+  )r5   rÌ  r6   r   r‰   )r#  rÆ   r  Zndim_minrq   rf   rÕ  r$  rA   rA   rB   ÚNdStack_typerÞ  s
   
r˜  c                 C   ó&   t | d|dƒ}||ƒ}dd„ }||fS )Nz	np.hstackrD   c                    sf   |j d }|d j}|dkr|  tjd¡‰ t| |||ˆ ƒS |dkr#dnd‰ ‡ fdd„}|  ||||¡S )Nr   rD   c                    s   t j| ˆ d�S rè  rê  ©r  ré  rA   rB   Únp_hstack_implú  r4  z3_np_hstack.<locals>.codegen.<locals>.np_hstack_impl©rß   rf   r¯   r   r�   r•  rÎ  )rs   r<   rT   rß   r2  rf   r›  rA   ré  rB   r"  ì  s   

z_np_hstack.<locals>.codegen©r˜  ©r#  r3  r$  rT   r"  rA   rA   rB   Ú
_np_hstackç  ó   rŸ  c                 C   r  )Nc                 S   rþ  r+  )rŸ  r’  rA   rA   rB   rÒ     rg  zimpl_np_hstack.<locals>.implrŠ  r“  rA   rA   rB   Úimpl_np_hstack  r  r¡  c                 C   r™  )Nz	np.vstackrC  c                 S   sd   |j d }|d j}|dkrdd„ }n|dkr&|  tjd¡}t| ||||ƒS dd„ }|  ||||¡S )Nr   c                 S   s   t  t  | ¡d¡S rv  )rÅ  r`  Úhstackrš  rA   rA   rB   Únp_vstack_impl  rë  z3_np_vstack.<locals>.codegen.<locals>.np_vstack_implrD   c                 S   ó   t j| dd�S )Nr   ré  rê  rš  rA   rA   rB   r£    r4  rœ  )rs   r<   rT   rß   r2  rf   r£  rÈ   rA   rA   rB   r"    s   


z_np_vstack.<locals>.codegenr�  rž  rA   rA   rB   Ú
_np_vstack
  r   r¥  c                 C   r  )Nc                 S   rþ  r+  )r¥  r’  rA   rA   rB   rÒ   (  rg  zimpl_np_vstack.<locals>.implrŠ  r“  rA   rA   rB   Úimpl_np_vstack%  r  r¦  )rC  é   c                 C   r™  )Nz	np.dstackrÂ  c                 S   sð   |j d }|j}|d j}|dkrdd„ }|  ||||¡S |dkrY|  tjd¡}|j|jd d�}	tj	|	g|j ¢R Ž }
t
| ||
||ƒ}|  tjd¡}t 	||	¡}t| |||f|ƒS |dkrl|  tjd¡}t
| ||||ƒS dd„ }|  ||||¡S )Nr   c                 S   s   t  | ¡ ddd¡S )NrD   r¤  )rÅ  r¢  rÖ  rš  rA   rA   rB   r£  =  rô  z3_np_dstack.<locals>.codegen.<locals>.np_vstack_implrD   rÄ  rC  c                 S   r¤  )NrC  ré  rê  rš  rA   rA   rB   r£  T  r4  )rß   rá   rf   rÎ  r¯   r   r�   r  r   r#   r•  r`  )rs   r<   rT   rß   r2  rÑ  rf   r£  rÈ   Zstack_rettyZ	stack_sigZ	stack_retr�  rA   rA   rB   r"  7  s*   


ÿz_np_dstack.<locals>.codegenr�  rž  rA   rA   rB   Ú
_np_dstack2  s   "r¨  c                 C   r  )Nc                 S   rþ  r+  )r¨  r’  rA   rA   rB   rÒ   _  rg  zimpl_np_dstack.<locals>.implrŠ  r“  rA   rA   rB   Úimpl_np_dstack\  r  r©  Úfillc                 C   rÔ  )Nc                 S   s   || d d …< d S r+  rA   )rÝ  r}   rA   rA   rB   Ú	fill_implg  s   zarr_fill.<locals>.fill_implrA   )rÝ  r}   r«  rA   rA   rB   Úarr_filld  s   r¬  Údotc                 C   rÔ  )Nc                 S   rL  r+  )rÅ  r­  )rÝ  ÚotherrA   rA   rB   Údot_implp  rw  zarray_dot.<locals>.dot_implrA   )rÝ  r®  r¯  rA   rA   rB   Ú	array_dotn  rO  r°  c                 C   ó"   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 )NrC  r½  r¤  .©rÅ  r0  rf   r¨   ©r>  r  rA   rA   rB   rÒ   |  s   

znp_flip_lr.<locals>.implr1  ©r>  rÒ   rA   rA   rB   Ú
np_flip_lrv  ó   rµ  c                 C   r±  )NzCannot np.flipud on %s typec                 S   s.   t  | ¡}|jdk rtdƒ‚|d d d…df S )NrD   zInput must be >= 1-d.r¤  .r²  r³  rA   rA   rB   rÒ   �  s   

znp_flip_ud.<locals>.implr1  r´  rA   rA   rB   Ú
np_flip_ud‡  r¶  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                    sZ   dd„ }t jˆg}tjˆg|¢R Ž }|  t j¡}|  ˆ¡}|ˆ ƒ|g}	|  ||||	¡}
|
S )Nc                 S   s*   |}t | ƒD ]}t||td d dƒƒ}q|S ©Nr¤  )r7   r/   r  )ÚlengthÚempty_tuplerë   rd   rA   rA   rB   rÒ   £  s   z6_build_flip_slice_tuple.<locals>.codegen.<locals>.impl)r   r�   r   r#   r©   Úget_constant_undefrÎ  )rs   r<   r#   rß   rÒ   Úinner_argtypesÚ	inner_sigÚll_idx_typerº  Ú
inner_argsrê   ©r…   Ú
tuple_typerA   rB   r"  ¢  s   

z(_build_flip_slice_tuple.<locals>.codegen)	rˆ   r   r6  r   r
  r­   rÔ   rÉ  Úslice3_type)rT  ÚszrT   r"  rA   rÀ  rB   Ú_build_flip_slice_tuple˜  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Ä  rf   )r>  ÚslrA   rA   rB   rÒ   ½  s   
znp_flip.<locals>.impl)rˆ   r   r‰   r   rÓ   r´  rA   rA   rB   Únp_flip¶  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ƒr4t |jjtjƒr4d	dd„}|S t |tj	ƒrKt
dd„ |jD ƒƒrMd	dd„}|S d S d S )
Nr   c                 S   ó   t jt  | ¡||d�S rè  )rÅ  Úarray_splitr0  ©rñ   Úindices_or_sectionsrÈ   rA   rA   rB   rÒ   Ç  s
   ýznp_array_split.<locals>.implc                 S   sP   t | j| |ƒ\}}t t |d g| |g|| d   ¡¡}tj| ||d�S )NrD   ré  )Údivmodr\   rÅ  Úcumsumr·   rÈ  )rñ   rÊ  rÈ   r  r"  r”   rA   rA   rB   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   )r0   rf   rÉ   r/   r  r`   ©rñ   rÊ  rÈ   Z	slice_tuprë   ÚprevrØ  r„   rA   rA   rB   rÒ   â  s   
c                 s   r*  r+  ©rˆ   r   rŠ   r	  rA   rA   rB   r.  ò  r/  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Í  )r0   rf   rÉ   r   r/   r  r`   rÎ  rA   rA   rB   rÒ   ô  s   
rÙ   )rˆ   r   rÉ  ÚListTyperI  rŠ   ÚIterableTypeÚiterator_typer   r9  r:  ©rñ   rÊ  rÈ   rÒ   rA   rA   rB   Únp_array_splitÄ  s,   


ÿþþ

ÿþ
ðrÕ  c                 C   sL   t | tjtjtjfƒrddd„}|S t |tjƒrddd„}|S t| ||d�S )Nr   c                 S   rÇ  rè  )rÅ  Úsplitr0  rÉ  rA   rA   rB   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 divisionré  )rË  r\   r¨   rÅ  rÈ  )rñ   rÊ  rÈ   rˆ  r"  rA   rA   rB   rÒ     s   ÿÿré  rÙ   )rˆ   r   rÉ  rÑ  rI  rŠ   rÕ  rÔ  rA   rA   rB   Únp_split  s   


r×  c                 C   óN   t | tjƒsd}t |¡‚t |tjtjtjtjfƒs!d}t |¡‚dd„ }|S )Nú#The argument "ary" must be an arrayú:The argument "indices_or_sections" must be int or 1d-arrayc                 S   ó"   | j dk r	tdƒ‚tj| |dd�S )NrC  z3vsplit only works on arrays of 2 or more dimensionsr   ré  ©rf   r¨   rÅ  rÖ  ©rñ   rÊ  rA   rA   rB   rÒ   )  ó   
znumpy_vsplit.<locals>.impl©rˆ   r   r‰   r   rÓ   rŠ   rI  rÉ  ©rñ   rÊ  r¹   rÒ   rA   rA   rB   Únumpy_vsplit  ó   
ÿ
rá  c                 C   rØ  )NrÙ  rÚ  c                 S   s<   | j dkr	tdƒ‚| j dkrtj| |dd�S tj| |dd�S )Nr   z3hsplit only works on arrays of 1 or more dimensionsrD   ré  rÜ  rÝ  rA   rA   rB   rÒ   =  s
   

znumpy_hsplit.<locals>.implrß  rà  rA   rA   rB   Únumpy_hsplit2  s   
ÿ
rã  c                 C   rØ  )NrÙ  rÚ  c                 S   rÛ  )NrÂ  z3dsplit only works on arrays of 3 or more dimensionsrC  ré  rÜ  rÝ  rA   rA   rB   rÒ   S  rÞ  znumpy_dsplit.<locals>.implrß  rà  rA   rA   rB   Únumpy_dsplitH  râ  rä  c                 C   s   | |k S )z7
    Trivial comparison function between two keys.
    rA   rÒ  rA   rA   rB   Ú
default_ltb  s   rå  Fc                 C   s~   | dkrd} | |j |f}zt| W S  ty>   | dkr(tj||dd�}|j}n| dkr6tj||d�}|j}|t|< | Y S w )z6
    Get a sort implementation of the given kind.
    Ústabler+   r*   T)ÚltÚ
is_argsortZis_np_array)rç  rè  )	rg   Ú_sortsÚKeyErrorr*   Zmake_jit_quicksortZrun_quicksortr+   Zmake_jit_mergesortZrun_mergesort)r£  Últ_implrè  Úkeyr:  rm  rA   rA   rB   Úget_sort_funci  s,   
ýþórí  c                 C   s$   t | tjƒrtS t | tjƒrtS tS r+  )rˆ   r   rä  r   r­  r   rå  r@  rA   rA   rB   Últ_implementation„  s
   rî  z
array.sortc           	         s€   |j \}}|j}t|t|jƒd�‰ |dv r!|jdkr!‡ fdd„}n‡ fdd„}|j|j d d… d�}|d d… }|  ||||¡S )N)r£  rë  )r+   ræ  rD   c                    s*   t  | jd d… ¡D ]}ˆ | | ƒ q
d S r¸  )rÅ  rü  r\   )rÝ  r„   ©Z	sort_funcrA   rB   Úarray_sort_impl–  s   ÿz#array_sort.<locals>.array_sort_implc                    s   ˆ | ƒ d S r+  rA   rž  rï  rA   rB   rð  œ  rï  rÇ  )rß   rÔ   rí  rî  rq   rf   ÚreplacerÎ  )	rs   r<   rT   rß   r~  r£  rð  ÚinnersigÚ	innerargsrA   rï  rB   Ú
array_sort�  s   
ÿÿrô  c                 C   r/  )NzArgument "a" must be array-likec                 S   s   |   ¡ }| ¡  |S r+  )r  r:  )r�  rê   rA   rA   rB   Únp_sort_impl¬  s   z"impl_np_sort.<locals>.np_sort_implr1  )r�  rõ  rA   rA   rB   Úimpl_np_sort¦  s   
rö  zarray.argsortc           	         s^   |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+  rA   rž  rï  rA   rB   Úarray_argsort_impl¼  rg  z)array_argsort.<locals>.array_argsort_implrD   rÇ  )rß   rí  rÔ   rî  rq   rñ  rÎ  )	rs   r<   rT   rß   r~  r£  r÷  rò  ró  rA   rï  rB   Úarray_argsort³  s   
þÿrø  c                 C   s   |j |j ks|jdksJ ‚|S )Nr  )rw  rÕ  )rs   r<   r€  r�  r}   rA   rA   rB   Úarray_to_arrayÈ  s   rù  c                 C   ó4   dd„ }t ||ƒ}|  ||||g¡}t| ||j|ƒS )Nc                 S   s
   |   d¡S rÏ   )rØ  rõ  rA   rA   rB   rÒ   ×  r8  zarray0d_to_scalar.<locals>.impl)r#   rÎ  r!   rá   ©rs   r<   r€  r�  r}   rÒ   rT   rê   rA   rA   rB   Úarray0d_to_scalarÏ  s   
rü  c                 C   rú  )Nc                 S   s   t | d ƒS ry  r^  rõ  rA   rA   rB   rÒ   â  rw  z array_to_unichrseq.<locals>.impl)r#   rÎ  r   rá   rû  rA   rA   rB   Úarray_to_unichrseqà  s   
rý  c                 C   rO  )zR
    An intrinsic returning a derived array with the given shape and strides.
    rÄ   ©r�  r\   rœ   rA   rA   rB   Úreshape_uncheckedí  rT  rÿ  c                    s   dd„ ‰ ‡ fdd„}|S )Nc                 S   s   t | tjƒotdd„ | D ƒƒS )Nc                 s   r*  r+  rÐ  r  rA   rA   rB   r.  ø  r/  z>type_reshape_unchecked.<locals>.check_shape.<locals>.<genexpr>)rˆ   r   r5  r:  rË  rA   rA   rB   r  ö  s   ÿz+type_reshape_unchecked.<locals>.check_shapec                    sJ   t | tjƒsd S ˆ |ƒrˆ |ƒsd S t|ƒt|ƒkrd S | jt|ƒdd�S )Nr  r  )rˆ   r   r‰   r‘   r  rþ  ©r  rA   rB   Útyperú  s   z%type_reshape_unchecked.<locals>.typerrA   )rs   r  rA   r   rB   Útype_reshape_uncheckedô  s   	r  c                 C   s‚   |j d }|j}t|ƒ| ||d ƒ}t|ƒ| |ƒ}t ||d ¡}t ||d ¡}	t||j||	|j|jd� | 	¡ }
t
| |||
ƒS )Nr   rD   rC  rŒ  )rß   rá   ro   r	   r°   rÀ   r‹   r�   r›   rç   r   )rs   r<   rT   rß   rÁ   rÑ  rñ   rë   r\   rœ   rê   rA   rA   rB   Úimpl_shape_unchecked  s   
ûr  c                    s`   |d t jfv rtdd„ ƒ‰ ntdd„ ƒ‰ |d t jfv r t d¡‚tdd„ ƒ‰d	‡ ‡fdd„	}|S )
Nc                 S   rd  r+  rË  ©r  r\   rA   rA   rB   rU    rÊ   zas_strided.<locals>.get_shapec                 S   r¼  r+  rA   r  rA   rA   rB   rU  #  ó   z,as_strided() strides argument cannot be Nonec                 S   r¼  r+  rA   )r  rœ   rA   rA   rB   Úget_strides.  r  zas_strided.<locals>.get_stridesc                    s   t | ˆ | |ƒˆ| |ƒƒ} | S r+  )rÿ  )r  r\   rœ   ©rU  r  rA   rB   Úas_strided_impl2  s   z#as_strided.<locals>.as_strided_implrB  )r   r  r%   r   rÓ   )r  r\   rœ   r  rA   r  rB   Ú
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ƒrIt |jtjƒrItt| jt	|ƒ ƒƒ‰tt| jt	|ƒ ƒƒ‰tdd„ ƒ‰nt
 d¡‚t|ƒrYtdd„ ƒ‰ n&t |tjƒrftdd„ ƒ‰ nt |tjƒrzt |jtjƒrztd	d„ ƒ‰ nt
 d
¡‚d‡ ‡‡‡fdd„	}|S )NrD   c                 S   s   | fS r+  rA   ©Úwindow_shaperA   rA   rB   Úget_window_shapeC  rÊ   z-sliding_window_view.<locals>.get_window_shapec                 S   r»  r+  rA   r
  rA   rA   rB   r  L  r  z4window_shape must be an integer or tuple of integersc                 S   s   t t|ƒƒS r+  )r¬   r7   ©r  rÈ   rf   rA   rA   rB   Úget_axisW  rï  z%sliding_window_view.<locals>.get_axisc                 S   s   t dd||ƒgS )NÚsliding_window_viewrÈ   ©rÉ   r  rA   rA   rB   r  \  s   ÿc                    s   ‡ fdd„|D ƒS )Nc                    s   g | ]	}t d dˆ |ƒ‘qS )r  rÈ   r  r�  rÄ  rA   rB   r�   f  r  z9sliding_window_view.<locals>.get_axis.<locals>.<listcomp>rA   r  rA   rÄ  rB   r  d  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 ]7\}}|dk rItdƒ‚|| |k rStdƒ‚|| | d }t|||ƒ}t|||ƒ}t||| j| ƒ}|d7 }q=t| ||ƒ}	|	S )Nz2Must provide matching length window_shape and axisr   z-`window_shape` cannot contain negative valuesz4window_shape cannot be larger than input array shaperD   )	rf   r‘   r¨   r7   r/   r\   rœ   r’   rÿ  )
r  r  rÈ   Ú	out_shapeÚout_stridesrd   rÛ   r]  Útrimmedr-  ©r  r  Zshape_bufferZstride_bufferrA   rB   Úsliding_window_view_impln  s8   ÿÿÿ
z5sliding_window_view.<locals>.sliding_window_view_implr+  )rˆ   r   rŠ   r«   r7   rf   r%   rÉ  rq   r‘   r   rÓ   r   )r  r  rÈ   r  rA   r  rB   r  9  s>   ÿÿÿÿ'r  c                 C   r  )Nc                 S   s>   | j dkrtdk rdS tdƒ‚| j dkrt|  d¡ƒS tdƒ‚)Nr   )rC  rC  FziThe truth value of an empty array is ambiguous. Use `array.size > 0` to check that an array is not empty.rD   z[The truth value of an array with more than one element is ambiguous. Use a.any() or a.all())r…   r   r¨   r6  rØ  rž  rA   rA   rB   rÒ   ›  s   

zol_bool.<locals>.implr,  rŸ  rA   rA   rB   Úol_bool˜  s   ñr  c                    sn   t |ttjfƒst d¡‚t |ttjfƒst d¡‚t | tjƒs%t d¡‚| j‰tt	ˆƒƒ‰ ‡ ‡fdd„}|S )Nz.The second argument "axis1" must be an integerz-The third argument "axis2" must be an integerú'The first argument "a" must be an arrayc                    s@   t ddˆ|ƒ}t ddˆ|ƒ}tˆ ||ƒ}t|||ƒ}t | |¡S )Nznp.swapaxesÚaxis1Úaxis2)rÉ   r/   rÅ  r�  )r�  r  r  Z
axes_tuple©Ú	axes_listrf   rA   rB   rÒ   »  s
   znumpy_swapaxes.<locals>.impl)
rˆ   r­   r   rŠ   r   rÓ   r‰   rf   r«   r7   )r�  r  r  rÒ   rA   r  rB   Únumpy_swapaxes¬  s   


r  c                    s˜   t | tjƒst d¡‚t |tjƒs#t |tjƒrt |jtjƒs#t d¡‚t |tjƒs;t |tjƒr6t |jtjƒs;t d¡‚| j‰ d| j ‰‡ ‡fdd„}|S )Nr  zGThe second argument "source" must be an integer or sequence of integerszKThe third argument "destination" must be an integer or sequence of integersrC  c           	         sœ   t ddˆˆ ƒ‰ t ddˆ|ƒ}tˆ ƒt|ƒkrtdƒ‚‡ fdd„t| jƒD ƒ}tt|ˆ ƒƒD ]
\}}| ||¡ q-ˆ}t|ƒD ]
\}}t	|||ƒ}q>|  
|¡S )Nznp.moveaxisÚsourceÚdestinationzL`source` and `destination` arguments must have the same number of parametersc                    s   g | ]}|ˆ vr|‘qS rA   rA   )rŽ   rE  ©r  rA   rB   r�   î  r  z0numpy_moveaxis.<locals>.impl.<locals>.<listcomp>)r×   r‘   r¨   r7   rf   r]  r’   rµ  rÚ   r/   r�  )	r�  r  r  Z
order_listr!  rþ  rr  rd   Úo©rf   Z
order_initr  rB   rÒ   ã  s   ÿÿ
znumpy_moveaxis.<locals>.impl)	rˆ   r   r‰   r   rÓ   rŠ   rt  rq   rf   )r�  r  r  rÒ   rA   r!  rB   Únumpy_moveaxisÅ  s0   

ÿ
ýüÿ
ÿ
ýüÿ
r"  c                 C   s¸  t dd| j|ƒ}t| jƒ}d||< tt||jƒƒD ]$\}\}}	|dkr&|	}
n|	dkr-|}
n
||	kr5tdƒ‚|}
t|||
ƒ}qt||| j| ƒ}t 	| |¡} t 	||¡}|}t
|ƒdkrmtt
|ƒƒD ]}t||| j| ƒ}qa|}t
|ƒdkr‹tt
|ƒƒD ]}t||| j|d |  ƒ}q{|j| }t ||f | | j¡}td d d ƒf}t |¡D ]1}t |¡D ])}| || |  }||| |  }||| |  }t|ƒD ]
}|||  ||< qÍq¯q¨|S )Nznp.take_along_axisrÈ   rD   z*`arr` and `indices` dimensions don't matchr   )rÉ   rf   r¬   r\   rÚ   r’   r¨   r/   rÅ  r3  r‘   r7   rB  rq   r  rü  )rÝ  r”   rÈ   ZNi_origZNk_origÚindices_broadcast_shapeÚ	arr_shaperd   Úd1Úd2Únew_valZarr_broadcast_shapeÚNiÚNkÚJrë   Znp_s_ÚiiÚkkZa_1dZ
indices_1dZout_1drÏ  rA   rA   rB   Ú_take_along_axis_implü  sT   
ÿÿÿ
ÿür-  c                    s  t | tjƒst d¡‚t |tjƒst d¡‚t |jtjƒs"t d¡‚t|ƒr)d}n| j}||jkr6t d¡‚t	t
|jƒƒ‰t|ƒrI‡fdd„}|S t|dƒ t |tjƒsYt d	¡‚|j}|d
k re| j| }|d
k sn|| jkrst d¡‚t	t
|ƒƒ‰ t	t
|d | jƒƒ‰‡ ‡‡fdd„}|S )Nz)The first argument "arr" must be an arrayz.The second argument "indices" must be an arrayz'The indices array must contain integersrD   z;`indices` and `arr` must have the same number of dimensionsc                    s   t |  ¡ |dddˆ ƒS )Nr   rA   )r-  rð  ©rÝ  r”   rÈ   )r#  rA   rB   Útake_along_axis_implM  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#  rA   rB   r/  ^  s   ÿ)rˆ   r   r‰   r   rÓ   rq   rŠ   r   rf   r«   r7   r   r6  rÂ  rÔ   )rÝ  r”   rÈ   Úarr_ndimr/  rA   r0  rB   Úarr_take_along_axis8  s>   
ÿ

ÿ
ð


r2  Tç        c                 C   sÔ   t | tjƒr2t | tjƒrddd„}|S t | tjƒr ddd„}|S t | tjƒr-ddd„}|S t d¡‚t| ƒret | j	tjƒrDddd„}|S t | j	tjƒrRdd	d„}|S t | j	tjƒr`dd
d„}|S t d¡‚t d¡‚)NTr3  c                 S   r»  r+  rA   ©r  r  ÚnanÚposinfÚneginfrA   rA   rB   rÒ   i  ru  znan_to_num_impl.<locals>.implc                 S   sf   |d ur|nt  t| ƒ¡j}|d ur|nt  t| ƒ¡j}t  | ¡r#|S t  | ¡r*|S t  | ¡r1|S | S r+  )rÅ  Úfinfor8   rý  rÌ  r7  ÚisneginfÚisposinf)r  r  r5  r6  r7  Úmin_infÚmax_infrA   rA   rB   rÒ   m  s   ÿýÿý


c                 S   s2   t j| j|||d�}t j| j|||d�}t||ƒS )N)r5  r6  r7  )rÅ  Ú
nan_to_numr°  r²  Úcomplex)r  r  r5  r6  r7  r=  r�  rA   rA   rB   rÒ   �  s   
z4Only Integer, Float, and Complex values are acceptedc                 S   r»  r+  rA   r4  rA   rA   rB   rÒ   �  ru  c                 S   s°   |d ur|nt  | j¡j}|d ur|nt  | j¡j}t  | ¡}|r&t  |¡n|}|j}	t|j	ƒD ]%}
t  
|	|
 ¡r>||	|
< q0t  |	|
 ¡rJ||	|
< q0t  |	|
 ¡rU||	|
< q0|S r+  )rÅ  r8  rq   rý  rÌ  r0  r  rÚ  r7   r…   r7  r9  r:  )r  r  r5  r6  r7  r;  r<  Úx_ÚoutputZoutput_flatrd   rA   rA   rB   rÒ   �  s(   ÿýÿý


€c                 S   sL   t  | ¡}|rt  |¡n|}t j|jd|||d� t j|jd|||d� |S )NF)r  r5  r6  r7  )rÅ  r0  r  r=  r°  r²  )r  r  r5  r6  r7  r?  r@  rA   rA   rB   rÒ   ©  s"   
ûûz4The first argument must be a scalar or an array-like©Tr3  NN)
rˆ   r   rM  rŠ   rä  r­  r   rÓ   r   rq   )r  r  r5  r6  r7  rÒ   rA   rA   rB   Únan_to_num_impld  s6   
Z©
V½
BÃÿ
6Ì
3å
úÿ
rB  r+  r©  rC  r   rÙ   )FrB  rA  (Ç  rZ  r  rê  ro  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   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,   Znumba.cpython.charseqr-   r.   Únumba.cpython.unsafe.tupler/   r0   r1   Znumba.core.typing.npydeclr2   r“  r3   r”  r4   r5   r6   Únumba.npÚ	npy_typesrC   rF   ro   ru   r{   r~   r‡   r�   r•   rÀ   rÂ   rÉ   rÖ   r×   rÝ   rï   rì   rø   ÚArrayIteratorÚBORROWEDr  r"  rð   r&  rp  rŠ   r  r'  r)  r5  r4  r?  ÚAnyr9  r‘   r;  r‰   rA  rE  rL  r0  rN  r\  rs  r{  r‰  r—  r¡  r©  rÒ  r1  rÚ  rÞ  rá  râ  ræ  r  r  r  r  r%  r(  r/  r2  r3  r;  r@  rÆ  rJ  rû  rO  rR  rY  rd  r7  r€  rƒ  r…  r–  ÚVarArgr™  r�  r¢  r�  r´  rª  Ú	geomspacer¼  Úrot90rÃ  rË  rÏ  rÒ  rÓ  rÖ  rÙ  Úresizerå  r`   rì  rô  rÜ  r÷  rø  rú  r  r  r  r  r!  r.  r\   r3  r…   r5  Úuniquer?  rK  rJ  rA  rN  rU  rV  r[  rÂ  r_  ra  Ú
MemoryViewrd  rf  rh  ri  rj  rl  ro  rs  rv  rx  r}  rz  r  r4  rj  r‚  r†  r‰  r‡  rŠ  r‹  r‘  r”  r�  r   r¢  ÚDTypeÚNumberClassr¦  r®  r¯  rª  r¶  r¹  r¼  r6  r¾  rÅ  rÆ  rÉ  rÎ  ÚBytesrÑ  Úis_rÖ  rØ  rÞ  rã  rí  rî  r1  r6  rÜ  rN  rJ  rP  rS  rT  rU  rà  rX  rV  rY  rü  r\  r_  r[  r`  rï  ra  ÚNumpyNdIterTyperb  Úeqre  rÓ  rt  rl  rr  r|  r}  r’  r�  r‹  rB  r�  r–  r—  rù  r˜  r™  r›  rÝ  r   r¢  r¤  r¥  r«  r¬  r±  r  r²  r³  r´  rµ  r¶  rº  r¾  ÚeyerÃ  ÚdiagrÉ  r”   rÍ  ÚdiagflatrÐ  r×  rØ  rã  rè  rÊ  rô  r¦  rø  rû  rü  rý  r  r   r  r  r  r  r  r  r  r  r  r%  r&  r'  r0  r2  r.  r5  r=  rA  rG  rL  rO  rP  rR  r·   rT  rU  r[  r]  r`  ra  rb  rj  rf  Ú
atleast_1drn  Ú
atleast_2dro  Ú
atleast_3drq  rx  r�  r„  r…  r‡  rß  rŒ  rŽ  r‘  Úcolumn_stackr”  r•  r–  Ústackr—  r˜  rŸ  r¢  r¡  r¥  Úvstackr¦  Ú	row_stackr¨  Údstackr©  r¬  r°  rÀ  rµ  rÁ  r·  rÄ  ÚfliprÆ  rÈ  rÕ  rÖ  r×  Úvsplitrá  Úhsplitrã  Údspliträ  ré  rå  rí  rî  rô  r:  rö  Úargsortrø  rù  ÚUnicodeCharSeqrä  r­  r®  ÚNPTimedeltaÚ
NPDatetimerü  rý  rÿ  Útype_callabler  r  ÚlibÚstride_tricksr	  r  r6  r  r¿  r  Úmoveaxisr"  r-  Útake_along_axisr2  r=  rB  rA   rA   rA   rB   Ú<module>   s   04<	ÿE


/

ÿD


(





!55"GYPF P4
*L%



*

(
9



 8


6


L$
@



.








 
~
	


,




+

*















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

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