ó
    „ñ:iŸ�  ã                   óz  • S r SSKrSSKrSSKrSSKJr  SSKJr  SSKr	SSK
r
SSKJrJrJr  SSKJr  SSKJrJrJrJr  SSKJrJrJrJrJrJr  SSKJrJrJ r J!r!  SS	K"J#r#  SS
K$J%r%  SSK&J'r'J(r(  SSKJ)r)  \" S5      r* " S S\+5      r, " S S\+5      r- " S S\" SS5      5      r. " S S\" SS5      5      r/ " S S\" SS5      5      r0S-S jr1\Rd                  (       a^  \Rf                  " \Rf                  \Rh                  " \Rf                  5      \Rf                  \Rh                  " \Rf                  5      5      r5O]\Rl                  " \Rl                  \Rh                  " \Rl                  5      \Rl                  \Rh                  " \Rl                  5      5      r5S r7S r8S r9S r:S  r;S! r<S" r= " S# S$\+5      r>S% r?S& r@ S.S' jrAS.S( jrB\*R‡                  \
Rˆ                  \RŠ                  5      S) 5       rFS* rG\G" \R�                  " 5       \*R†                  5        \(S+ 5       rI\'" \	R”                  5      S, 5       rKg)/z3
Implementation of functions in the Numpy package.
é    N)Ú
namedtuple)ÚarrayobjÚufunc_dbÚnumpy_support)Úparse_signature)ÚRegistryÚimpl_ret_new_refÚforce_error_modelÚimpl_ret_borrowed)ÚtypingÚtypesÚutilsÚcgutilsÚcallconvÚconfig)Úufunc_find_matching_loopÚselect_array_wrapperÚ
from_dtypeÚ_ufunc_loop_sig)Ú_getitem_array_generic)Únpydecl)ÚoverloadÚ	intrinsic)ÚerrorsÚnpyimplc                   ó    • \ rS rSrS rS rSrg)Ú_ScalarIndexingHelperé,   c                 ó   • g ©N© )ÚselfÚloop_indicesÚnames      ÚS/srv/projetos/modelo_ml_acdoc/venv/lib/python3.13/site-packages/numba/np/npyimpl.pyÚupdate_indicesÚ$_ScalarIndexingHelper.update_indices-   ó   € Øó    c                 ó   • g r    r!   ©r"   s    r%   Ú	as_valuesÚ_ScalarIndexingHelper.as_values0   r(   r)   r!   N©Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__r&   r,   Ú__static_attributes__r!   r)   r%   r   r   ,   s   † òõr)   r   c                   ó@   • \ rS rSrSrS rS rS rS r\	S 5       r
Srg	)
Ú_ScalarHelperé4   a0  Helper class to handle scalar arguments (and result).
Note that store_data is only used when generating code for
a scalar ufunc and to write the output value.

For loading, the value is directly used without having any
kind of indexing nor memory backing it up. This is the use
for input arguments.

For storing, a variable is created in the stack where the
value will be written.

Note that it is not supported (as it is unneeded for our
current use-cases) reading back a stored value. This class
will always "load" the original value it got at its creation.
c                 óX  • Xl         X l        X0l        X@l        UR	                  [
        R                  5      n[        R                  " US5      /U l	        U[
        R                  :w  a  UR                  U5      O[        R                  " S5      n[        R                  " X&5      U l        g ©Né   )ÚcontextÚbuilderÚvalÚ	base_typeÚget_value_typer   ÚintpÚirÚConstantÚshapeÚbooleanÚget_data_typeÚIntTyper   Úalloca_onceÚ_ptr)r"   ÚctxtÚbldr<   ÚtyÚintptyÚltys          r%   Ú__init__Ú_ScalarHelper.__init__D   sv   € ØŒØŒØŒØŒØ×$Ñ$¤U§Z¡ZÓ0ˆÜ—k’k &¨!Ó,Ð-ˆŒ
à(*¬e¯m©mÓ(;ˆd× Ñ  Ô$ÄÇÂÈAÃˆÜ×'Ò'¨Ó1ˆ�	r)   c                 ó   • [        5       $ r    )r   r+   s    r%   Úcreate_iter_indicesÚ!_ScalarHelper.create_iter_indicesO   s   € Ü$Ó&Ð&r)   c                 ó   • U R                   $ r    )r<   ©r"   Úindicess     r%   Ú	load_dataÚ_ScalarHelper.load_dataR   s   € Ø�x‰xˆr)   c                 óN   • U R                   R                  X R                  5        g r    )r;   ÚstorerG   )r"   rT   r<   s      r%   Ú
store_dataÚ_ScalarHelper.store_dataU   s   € Ø�‰×Ñ˜3§	¡	Õ*r)   c                 óL   • U R                   R                  U R                  5      $ r    )r;   ÚloadrG   r+   s    r%   Ú
return_valÚ_ScalarHelper.return_valX   s   € à�|‰|× Ñ  §¡Ó+Ð+r)   )rG   r=   r;   r:   rB   r<   N)r/   r0   r1   r2   Ú__doc__rM   rP   rU   rY   Úpropertyr]   r3   r!   r)   r%   r5   r5   4   s/   † ñò	2ò'òò+ð ñ,ó ó,r)   r5   c                   ó    • \ rS rSrS rS rSrg)Ú_ArrayIndexingHelperé]   c                 óN  • U R                   R                  nU R                   R                  R                  [        R
                  5      n[        R                  " [        R                  " UR                  5      S5      nU[        U5      [        U R                  5      -
  S  n[        X`R                  U R                   R                  5       HC  u  pxn	UR                  SX•5      n
UR                  U
5         UR!                  Xx5        S S S 5        ME     g ! , (       d  f       MW  = f)Nr9   Ú>)Úarrayr;   r:   r>   r   r?   r@   rA   rE   ÚwidthÚlenrT   ÚziprB   Úicmp_unsignedÚif_thenrX   )r"   r#   r$   rI   rK   ÚONErT   ÚsrcÚdstÚdimÚconds              r%   r&   Ú#_ArrayIndexingHelper.update_indices_   sË   € Ø�j‰j× Ñ ˆØ—‘×#Ñ#×2Ñ2´5·:±:Ó>ˆÜ�kŠkœ"Ÿ*š* V§\¡\Ó2°AÓ6ˆð
 œs <Ó0´3°t·|±|Ó3DÑDÐEÐFˆÜ  ¯,©,¸¿
¹
×8HÑ8HÖI‰MˆC�cØ×$Ñ$ S¨#Ó3ˆDØ—‘˜TÕ"Ø—	‘	˜#Ô#÷ #Ñ"ò Jç"Ö"ús   Ã6DÄ
D$	c                 óŽ   • U R                   R                  nU R                   Vs/ s H  o!R                  U5      PM     sn$ s  snf )zÐ
The indexing helper is built using alloca for each value, so it
actually contains pointers to the actual indices to load. Note
that update_indices assumes the same. This method returns the
indices as values
)rf   r;   rT   r\   )r"   rI   Úindexs      r%   r,   Ú_ArrayIndexingHelper.as_valuesm   s5   € ð �j‰j× Ñ ˆØ-1¯\ª\Ó:ª\ E—‘˜–©\Ñ:Ð:ùÒ:s   ¥Ar!   Nr.   r!   r)   r%   rb   rb   ]   s   † ò$õ;r)   rb   )rf   rT   c                   ó0   • \ rS rSrSrS rS rS rS rSr	g)	Ú_ArrayHelperéx   z¡Helper class to handle array arguments/result.
It provides methods to generate code loading/storing specific
items as well as support code for handling indices.
c                 óæ  • U R                   R                  [        R                  5      n[        R
                  " [        R                  " UR                  5      S5      n/ n[        U R                  5       Hn  n[        R                  " U R                  [        R                  " UR                  5      5      nU R                  R                  X%5        UR                  U5        Mp     [        X5      $ ©Nr   )r:   r>   r   r?   r@   rA   rE   rg   ÚrangeÚndimr   rF   r;   rX   Úappendrb   ©r"   rK   ÚZEROrT   ÚiÚxs         r%   rP   Ú _ArrayHelper.create_iter_indices€   s�   € Ø—‘×,Ñ,¬U¯Z©ZÓ8ˆÜ�{Š{œ2Ÿ:š: f§l¡lÓ3°QÓ7ˆàˆÜ�t—y‘yÖ!ˆAÜ×#Ò# D§L¡L´"·*²*¸V¿\¹\Ó2JÓKˆAØ�L‰L×Ñ˜tÔ'Ø�N‰N˜1Öñ "ô $ DÓ2Ð2r)   c           
      ó®   • [         R                  " U R                  U R                  U R                  U R
                  U R                  U R                  US9$ ©N)ÚdatarB   ÚstridesÚlayoutÚinds)r   Úget_item_pointer2r:   r;   r„   rB   r…   r†   rS   s     r%   Ú_load_effective_addressÚ$_ArrayHelper._load_effective_address‹   sA   € Ü×(Ò(¨¯©Ø)-¯©Ø.2¯i©iØ/3¯z©zØ15·±Ø04·±Ø.5ñ7ð 	7r)   c                 ó¢   • U R                   R                  U R                     nU R                  U5      nUR	                  U R
                  U5      $ r    )r:   Údata_model_managerr=   r‰   Úload_from_data_pointerr;   )r"   rT   ÚmodelÚptrs       r%   rU   Ú_ArrayHelper.load_data”   sA   € Ø—‘×/Ñ/°·±Ñ?ˆØ×*Ñ*¨7Ó3ˆØ×+Ñ+¨D¯L©L¸#Ó>Ð>r)   c                 ó  • U R                   nU R                  nUR                  X@R                  U5      nUR	                  U R                  5      UR
                  :X  d   eUR                  XPR                  U5      5        g r    )r:   r;   Úget_value_as_datar=   rD   ÚtyperX   r‰   )r"   rT   ÚvalueÚctxrI   Ústore_values         r%   rY   Ú_ArrayHelper.store_data™   sd   € Ø�l‰lˆØ�l‰lˆØ×+Ñ+¨C·±ÀÓGˆØ× Ñ  §¡Ó0°K×4DÑ4DÓDÐDÐDØ�	‰	�+×;Ñ;¸GÓDÕEr)   r!   N)
r/   r0   r1   r2   r_   rP   r‰   rU   rY   r3   r!   r)   r%   rv   rv   x   s   † ñò	3ò7ò?õ
Fr)   rv   )	r:   r;   rB   r…   r„   r†   r=   r{   r]   c                   óB   • \ rS rSrSrS rS rS rS rSS S\	4S	 jr
S
rg)Ú_ArrayGUHelperé¡   zçHelper class to handle array arguments/result.
It provides methods to generate code loading/storing specific
items as well as support code for handling indices.

Contrary to _ArrayHelper, this class can create a view to a subarray
c                 ó  • U R                   R                  [        R                  5      n[        R
                  " [        R                  " UR                  5      S5      n/ n[        U R                  U R                  R                  -
  5       Hn  n[        R                  " U R                  [        R                  " UR                  5      5      nU R                  R                  X%5        UR                  U5        Mp     [!        X5      $ ry   )r:   r>   r   r?   r@   rA   rE   rg   rz   r{   Úinner_arr_tyr   rF   r;   rX   r|   rb   r}   s         r%   rP   Ú"_ArrayGUHelper.create_iter_indices«   s®   € Ø—‘×,Ñ,¬U¯Z©ZÓ8ˆÜ�{Š{œ2Ÿ:š: f§l¡lÓ3°QÓ7ˆàˆÜ�t—y‘y 4×#4Ñ#4×#9Ñ#9Ñ9Ö:ˆAÜ×#Ò# D§L¡L´"·*²*¸V¿\¹\Ó2JÓKˆAØ�L‰L×Ñ˜tÔ'Ø�N‰N˜1Öñ ;ô $ DÓ2Ð2r)   c           
      óf  • U R                   nU R                  n[        R                  " U R                  U R
                  U R                  5      nUR                  U5      " X#U R                  5      n[        R                  " UUUR                  U R                  U R                  U R                  US9$ rƒ   )r:   r;   r   ÚArrayr=   r{   r†   Ú
make_arrayr„   r   rˆ   rB   r…   )r"   rT   r:   r;   Úarr_tyÚarrs         r%   r‰   Ú&_ArrayGUHelper._load_effective_address¶   s„   € Ø—,‘,ˆØ—,‘,ˆÜ—’˜TŸ^™^¨T¯Y©Y¸¿¹ÓDˆØ× Ñ  Ô(¨¸4¿9¹9ÓEˆä×(Ò(¨Ø)0Ø.1¯h©hØ/3¯z©zØ15·±Ø04·±Ø.5ñ7ð 	7r)   c           
      ó   • U R                   U R                  p2U R                  R                  S:X  aL  U R                  (       a;  UR
                  U R                     nU R                  U5      nUR                  X55      $ U R                  R                  S:X  Ga†  U R                  (       Gdt  UR                  [        R                  5      nU" S5      n[        R                  " U R                  U R                  U R                  5      n[        R                  " U R                  SU R                  5      n	U" [        R                  " X(5      5      n
U R                   R!                  U5      " UUU R"                  5      nU R                   R!                  U	5      " X#5      n[        R$                  " UU R                  U5      [&        R(                  " X7/5      [&        R(                  " X:/5      UR*                  UR,                  UR.                  S9  UR1                  5       $ [        R2                  4U R                  U R                  R                  -
  -  n[        R                  " U R                  U R                  U R                  5      nU R                   R!                  U5      " X#U R"                  5      n[5        X#U R                  XïXÑ5      nU$ )Nr   r9   )r„   rB   r…   ÚitemsizeÚmeminfoÚparent)r:   r;   rœ   r{   Úis_input_argrŒ   r=   r‰   r�   r>   r   r?   rŸ   r†   r   Úget_itemsizer    r„   Úpopulate_arrayr   Ú
pack_arrayr¥   r¦   r§   Ú	_getvalueÚint64r   )r"   rT   r:   r;   rŽ   r�   rK   ÚoneÚfromtyÚtotyr¥   Úarr_fromÚarr_toÚindex_typesÚarrtyr¢   Úress                    r%   rU   Ú_ArrayGUHelper.load_dataÄ   s  € ØŸ<™<¨¯©�à×Ñ×!Ñ! QÓ&¨4×+<×+<à×.Ñ.¨t¯~©~Ñ>ˆEØ×.Ñ.¨wÓ7ˆCØ×/Ñ/°Ó=Ð=Ø×Ñ×#Ñ# qÔ(°×1B×1BÐ1Bð ×+Ñ+¬E¯J©JÓ7ˆFÙ˜“)ˆCä—[’[ §¡°·±¸D¿K¹KÓHˆFÜ—;’;˜tŸ~™~¨q°$·+±+Ó>ˆDÙœh×3Ò3°GÓDÓEˆHð —|‘|×.Ñ.¨vÔ6°wØ7>Ø7;·y±yóBˆHð —\‘\×,Ñ,¨TÔ2°7ÓDˆFÜ×#Ò#ØØ×1Ñ1°'Ó:Ü×(Ò(¨°%Ó8Ü×*Ò*¨7°JÓ?Ø!×*Ñ*Ø ×(Ñ(Ø—‘ò(ð ×#Ñ#Ó%Ð%ô !Ÿ;™;˜.¨D¯I©I¸×8IÑ8I×8NÑ8NÑ,NÑOˆKÜ—K’K §¡°·	±	¸4¿;¹;ÓGˆEØ—,‘,×)Ñ)¨%Ô0°À4Ç9Á9ÓMˆCÜ(¨Ø)-×):Ñ):¸EØ)4ó?ˆCð
 ˆJr)   c           	      ó  ^• U R                   R                  mU4S jnU R                  U R                  pC[        R
                  " [        R                  " [        R                  [        U5      5      [        R                  " [        R                  [        U R                  5      5      5      nUR                  XER                  S   U5      UR                  XER                  S   U R                  5      4nUR                  XBXV5        g )Nc                 ó¬   >• [        U5      T-
  nU[        U 5      :„  nU(       d  [        U5       H  nX1U   X   :g  -  nM     U(       a  [        S5      eg )Nz&Loop and array shapes are incompatible©rh   rz   Ú
ValueError)Ú
loop_shapeÚarray_shapeÚ	remainingÚ_raiser   Ú
inner_ndims        €r%   Ú
raise_implÚ._ArrayGUHelper.guard_shape.<locals>.raise_impló   s]   ø€ ô
 ˜KÓ(¨:Ñ5ˆIØ¤# j£/Ñ1ˆFÞÜ˜yÖ)�AØ¨1™~°±Ñ>Ñ?’Fñ *æô
 !Ð!IÓJÐJð r)   r   r9   )rœ   r{   r:   r;   r   ÚnoneÚUniTupler?   rh   rB   Ú
make_tupleÚargsÚcompile_internal)r"   Ú	loopshaperÀ   r:   r;   ÚsigÚtupr¿   s          @r%   Úguard_shapeÚ_ArrayGUHelper.guard_shapeñ   s·   ø€ Ø×&Ñ&×+Ñ+ˆ
õ	Kð"  Ÿ<™<¨¯©�Ü�jŠjÜ�NŠNœ5Ÿ:™:¤s¨9£~Ó6Ü�NŠNœ5Ÿ:™:¤s¨4¯:©:£Ó7ó
ˆð ×!Ñ! '¯8©8°A©;¸	ÓBØ×!Ñ! '¯8©8°A©;¸¿
¹
ÓCðEˆà× Ñ  °cÕ?r)   ÚotherÚndimsc           	      ó  ^• U4S jnU R                   U R                  pT[        R                  " [        R                  " [        R
                  [        U R                  5      5      [        R                  " [        R
                  [        UR                  5      5      5      nUR                  XVR                  S   U R                  5      UR                  XVR                  S   UR                  5      4nUR                  XSXg5        g )Nc                 ó®   >• Sn[        U 5      T-
  [        U5      T-
  pC[        T5       H  nX X5-      XU-      :H  -  nM     U(       d  Sn[        U5      eg )NTzŽOperand has a mismatch in one of its core dimensions. Please, check if all arguments to a @guvectorize function have the same core dimensions.r¹   )Ú
self_shapeÚother_shapeÚsameÚaÚbr   ÚmsgrÍ   s          €r%   rÀ   Ú8_ArrayGUHelper.guard_match_core_dims.<locals>.raise_impl  sg   ø€ ØˆDÜ�z“? UÑ*¬C°Ó,<¸uÑ,DˆqÜ˜5–\�Ø 1¡5Ñ)¨[¸Q¹Ñ-?Ñ?Ñ?’ñ "æðA�ô ! “oÐ%ð r)   r   r9   )r:   r;   r   rÂ   rÃ   r?   rh   rB   rÄ   rÅ   rÆ   )r"   rÌ   rÍ   rÀ   r:   r;   rÈ   rÉ   s     `     r%   Úguard_match_core_dimsÚ$_ArrayGUHelper.guard_match_core_dims  s®   ø€ õ	&ð"  Ÿ<™<¨¯©�Ü�jŠjÜ�NŠNœ5Ÿ:™:¤s¨4¯:©:£Ó7Ü�NŠNœ5Ÿ:™:¤s¨5¯;©;Ó'7Ó8ó
ˆð ×!Ñ! '¯8©8°A©;¸¿
¹
ÓCØ×!Ñ! '¯8©8°A©;¸¿¹ÓDðGˆà× Ñ  °cÕ?r)   r!   N)r/   r0   r1   r2   r_   rP   r‰   rU   rÊ   Úintr×   r3   r!   r)   r%   r™   r™   ¡   s4   † ñò	3ò7ò+òZ@ð8 @Ð+;ð  @ÀC÷  @r)   r™   )
r:   r;   rB   r…   r„   r†   r=   r{   rœ   r¨   c                 ó2  • [        U[        R                  5      (       a   UnUR                  nU R	                  XXS5      n[        U[        R
                  5      (       a§  U R                  U5      " XU5      n[        R                  " XR                  UR                  5      n[        R                  " XR                  UR                  5      n[        XXxUR                  UR                  UR                  UR                  U5	      $ [        R                   " U5      [        R"                  [        R$                  1-  ;   d)  [        U[        R&                  R(                  5      (       a  [+        XX#5      $ [-        SR/                  U[1        U5      5      5      e)zâreturns an instance of the appropriate Helper (either
_ScalarHelper or _ArrayHelper) class to handle the argument.
using the polymorphic interface of the Helper classes, scalar
and array cases can be handled with the same codezunsupported type for {0}: {1})Ú
isinstancer   ÚOptionalr“   ÚcastÚArrayCompatibler    r   Úunpack_tuplerB   r{   r…   rv   r„   r†   ÚdtypeÚ	unliteralÚnumber_domainrC   ÚscalarsÚ_NPDatetimeBaser5   ÚNotImplementedErrorÚformatÚstr)	rH   rI   ÚinpÚtyinpÚwhereÚotyÚaryrB   r…   s	            r%   Ú_prepare_argumentrí   0  s)  € ô �%œŸ™×(Ñ(ØˆØ—
‘
ˆØ�i‰i˜ #Ó-ˆô �%œ×.Ñ.×/Ñ/Ø—/‘/ %Ô(¨°CÓ8ˆÜ×&Ò& s¯I©I°u·z±zÓBˆÜ×&Ò& s¯K©K¸¿¹ÓDˆÜ˜D u°s·x±xØ!ŸL™L¨%¯+©+°u·z±zÀ3óHð 	Hä
�/Š/˜%Ó
 ¤E×$7Ñ$7¼5¿=¹=¸/Ñ$IÓ
IÜ˜œuŸ}™}×<Ñ<×=Ñ=Ü˜T¨Ó3Ð3ä!Ð"A×"HÑ"HÈÜ"% e£*ó#.ó /ð 	/r)   c                 óž   • X:”  a  gSnX -
  nX@:  a;  X   nX5   nUS:w  a  Xg:w  a  US:w  a  US-   * $ O
US:w  a  XcU'   US-  nUS-  nX@:  a  M;  U$ )aq  Low-level utility function used in calculating a shape for
an implicit output array.  This function assumes that the
destination shape is an LLVM pointer to a C-style array that was
already initialized to a size of one along all axes.

Returns an integer value:
>= 1  :  Succeeded.  Return value should equal the number of dimensions in
         the destination shape.
0     :  Failed to broadcast because source shape is larger than the
         destination shape (this case should be weeded out at type
         checking).
< 0   :  Failed to broadcast onto destination axis, at axis number ==
         -(return_value + 1).
r   r9   r!   )Úsrc_ndimÚ	src_shapeÚ	dest_ndimÚ
dest_shapeÚ	src_indexÚ
dest_indexÚsrc_dim_sizeÚdest_dim_sizes           r%   Ú_broadcast_ontor÷   R  s‹   € ð Óð àˆ	ØÑ)ˆ
ØÓ"Ø$Ñ/ˆLØ&Ñ2ˆMð  Ó!ð  Ó0°\ÀQÓ5FØ'¨!™^Ð,Ð,øØ Ó"à)5˜:Ñ&Ø˜‰NˆIØ˜!‰OˆJð Õ"ð  Ðr)   c                 ó„  ^ ^^ • U Vs/ s H0  n[        U[        R                  5      (       a  UR                  OUPM2     nnT R	                  [        R
                  5      nU 4S jnU" S5      nU" S5      n	[        R                  " TXbR                  S5      n
U" UR                  5      n[        R                  " TXbR                  S5      m [        UU 4S j[        UR                  5       5       5      nU H  nTR                  X�5        M     [        U5       GH5  u  pï[        US5      (       d  M  U" UR                  5      n[        UR                  5       H8  nTR                  UR                  U   [        R                  " TU
U5      5        M:     T R!                  T["        [$        UX«T /5      n[        R&                  " TTR)                  SUU	5      5         S	U4-  n[*        R,                  R/                  S
S5      nUb  USUR0                  UR2                  4-  -  nT R4                  R7                  T[8        U45        SSS5        GM8     UR:                  n[        U4S jU 5       5      n[<        R>                  " T TUU5      n[A        U5      nUU   n T RC                  SU" UU5      5      nUU   RD                  URG                  5       4nU" TU5      nUR                  n[        RN                  " TUR                  U5      n[        RN                  " TURP                  U5      n[S        T TUUURT                  URV                  URX                  UU5	      $ s  snf ! , (       d  f       GM\  = f! [H         a<    URJ                  [        RL                  RJ                  :w  a  e URG                  5       n NÞf = f)zžUtility function to handle allocation of an implicit output array
given the target context, builder, output array type, and a list of
_ArrayHelper instances.
c                 óD   >• TR                  [        R                  U 5      $ r    )Úget_constantr   r?   )r<   r:   s    €r%   Úmake_intp_constÚ%_build_array.<locals>.make_intp_const„  s   ø€ Ø×#Ñ#¤E§J¡J°Ó4Ð4r)   r   r9   rð   rò   c              3   óT   >#   • U  H  n[         R                  " TTU5      v •  M     g 7fr    )r   Úgep_inbounds)Ú.0rs   r;   rò   s     €€r%   Ú	<genexpr>Ú_build_array.<locals>.<genexpr>�  s+   øé € ð @Ú*> ô %×1Ò1°'¸:Àu×MÐMÚ*>ùs   ƒ%(r{   Ú<z/unable to broadcast argument %d to output arrayÚlocNz
File "%s", line %d, c              3   óF   >#   • U  H  nTR                  U5      v •  M     g 7fr    )r\   )rÿ   Údest_shape_addrr;   s     €r%   r   r  °  s%   øé € ð DÚ2B˜ð #Ÿ<™<¨×8Ð8Ú2Bùs   ƒ!Ú__array_wrap__)-rÛ   r   rÜ   r“   r>   r?   r   rF   r{   Útuplerz   rX   Ú	enumerateÚhasattrrB   rþ   rÆ   r÷   Ú_broadcast_onto_sigÚif_unlikelyÚicmp_signedr   Úloc_infoÚgetÚfilenameÚlineÚ	call_convÚreturn_user_excrº   Úas_arrayr   Ú_empty_nd_implr   Úget_functionr]   r¬   rå   Úarray_priorityrŸ   rß   r…   rv   r„   r†   rà   )!r:   r;   Úarray_tyÚinput_typesÚinputsr€   Úintp_tyrû   r~   rl   rð   rñ   Údest_shape_addrsr  Ú
arg_numberÚargÚarg_ndimrs   Ú
arg_resultrÕ   r  Úreal_array_tyÚdest_shape_tupÚ	array_valÚarray_wrapper_indexÚarray_wrapper_tyÚ
array_wrapÚ	wrap_argsÚout_valr{   rB   r…   rò   s!   ``                              @r%   Ú_build_arrayr(  z  sy  ú€ ñ (ó)Ú'�qô (¨¬5¯>©>×:Ñ:�1—6’6ÀÒAÙ'ð ð )ð ×$Ñ$¤U§Z¡ZÓ0€Gõ5ñ ˜1Ó€DÙ
˜!Ó
€Cä×#Ò# G¨W·m±mØ$/ó1€Iá §¡Ó.€IÜ×$Ò$ W¨g·}±}Ø%1ó3€Jäõ @Ü*/°·±Ô*>ó@ó @Ðó ,ˆØ�‰�cÖ+ñ ,ô % V×,‰ˆ
Ü�s˜F×#Ñ#ÙÙ" 3§8¡8Ó,ˆÜ˜3Ÿ8™8–_ˆEØ�M‰M˜#Ÿ)™) EÑ*Ü!×.Ò.¨w¸	À5ÓIöKñ %ð ×-Ñ-Ø”_Ô&9Ø�y¨ZÐ8ó:ˆ
ô × Ò  Ø!(×!4Ñ!4°S¸*ÀcÓ!JõLàCØðGñ ˆCô —/‘/×%Ñ% e¨TÓ2ˆCØ‰ØÐ/°3·<±<ÀÇÁÐ2JÑJÑJ�à×Ñ×-Ñ-¨g´zÀCÀ6ÔJ÷Lò Lñ -ð* ×%Ñ%€Mäô DÙ2BóDó D€Nä×'Ò'¨°¸-Ø(6ó8€Iô /¨{Ó;ÐØ"Ð#6Ñ7Ðð1à×)Ñ)Ð*:Ù*2Ð3CÀ]Ó*SóUˆ
ð Ð/Ñ0×;Ñ;¸Y×=PÑ=PÓ=RÐSˆ	Ù˜W iÓ0ˆà�=‰=€DÜ×"Ò" 7¨I¯O©O¸TÓB€EÜ×"Ò" 7¨I×,=Ñ,=¸tÓD€GÜ˜ ¨%°¸)¿.¹.Ø Ÿ™¨¯©¸Øó!ð !ùòS)÷FL÷ Lûô2 ó (ð ×*Ñ*¬e¯k©k×.HÑ.HÓHØØ×%Ñ%Ó'Šð(ús%   ˆ7M!ÇA*M&ÊM9 Í&
M6	Í9AN?Î>N?c                 óf   • U R                   S:X  a  UR                  /$ [        UR                  5      $ r8   )ÚnoutÚreturn_typeÚlist)ÚufuncrÈ   s     r%   Ú_unpack_output_typesr.  Ï  s)   € Ø‡z�z�QƒØ—‘Ð Ð ä�C—O‘OÓ$Ð$r)   c                 óT   • U R                   S:X  a  U/$ [        R                  " X5      $ r8   )r*  r   rß   )r-  r;   Úvaluess      r%   Ú_unpack_output_valuesr1  Ö  s%   € Ø‡z�z�QƒØˆxˆä×#Ò# GÓ4Ð4r)   c                 óP   • U R                   S:X  a  US   $ UR                  X#U5      $ )Nr9   r   )r*  rÄ   )r-  r:   r;   Útypr0  s        r%   Ú_pack_output_valuesr4  Ý  s*   € Ø‡z�z�QƒØ�a‰yÐà×!Ñ! '°Ó7Ð7r)   c           
      ó*  • [        X2R                  5       VVs/ s H  u  pg[        XXg5      PM     nnn[        U5      UR                  :  a9  [        SR                  UR                  UR                  [        U5      5      5      e[        [        XB5      5       HÚ  u  pšUR                  U	-   [        U5      :¼  a{  [        U
[        R                  5      (       a  [        XX¢R                  U5      nO1[        X[        R                  " U R!                  U
5      S 5      U
5      nUR#                  U5        Mœ  U R$                  (       d  M¯  U R&                  R)                  XX4R                  U	-      5        MÜ     US UR                   nX„R                  S  n[        U5      UR*                  :X  d   e[-        U Vs/ s H  oîR.                  PM     snU Vs/ s H  oîR.                  PM     sn5      nU" XU5      nU R!                  [        R0                  5      nU Vs/ s H  nUR3                  5       PM     nnUS   R4                  nU Vs/ s H&  n[        U[6        5      (       d  M  UR8                  PM(     nn[        U Vs/ s H  nUS:X  d  M  UPM     sn5      n[        U Vs/ s H  nUS:X  d  M  UPM     sn5      nUU:”  a  SnOSn[:        R<                  " UUUUS9 n/ n[        [        UU5      5       HI  u  nu  nnUR?                  UU5        UR#                  URA                  URC                  5       5      5        MK     [E        XAURF                  " U6 5      n[        UU5       H  u  nnURI                  UU5        M     S S S 5        [K        X@XRL                  U V s/ s H  n U RN                  PM     sn 5      n![Q        XURL                  U!5      $ s  snnf s  snf s  snf s  snf s  snf s  snf s  snf ! , (       d  f       N{= fs  sn f )Nz+Not enough inputs to {}, expected {} got {}r   ÚCÚF©r?   Úorder))ri   rÅ   rí   rh   ÚninÚRuntimeErrorræ   r/   r  r.  rÛ   r   rÞ   r(  r@   rA   r>   r|   Ú
enable_nrtÚnrtÚincrefr*  r   r=   r?   rP   rB   rv   r†   r   Ú	loop_nestr&   rU   r,   r1  ÚgeneraterY   r4  r+  r]   r	   )"r:   r;   rÈ   rÅ   r-  Úkernel_classr  ÚtyargÚ	argumentsÚout_iÚret_tyÚoutputr  ÚoutputsrÓ   Ú	outer_sigÚkernelrK   rè   rT   rÇ   Úinput_layoutsr€   Únum_c_layoutÚnum_f_layoutr9  r#   Úvals_inr   rs   Úvals_outÚval_outÚoÚouts"                                     r%   Únumpy_ufunc_kernelrR  ä  sw  € ô $' t¯X©XÔ#6ô8Ú#6‘Z�Sô # 7°SÖ@Ù#6ð ñ 8ô ˆ9ƒ~˜Ÿ	™	Ó!ÜØ9ß‰V�E—N‘N E§I¡I¬s°9«~Ó>ó@ð 	@ô #Ô#7¸Ó#CÖD‰ˆØ�9‰9�uÑ¤ I£Ó.ä˜&¤%×"7Ñ"7×8Ñ8Ü% g¸ÇÁÈ)ÓT‘ä*ØÜ—K’K × 6Ñ 6°vÓ >ÀÓEÀvóO�ð ×Ñ˜VÖ$Ø××Ñà�K‰K×Ñ˜w°·Y±YÀÑ5FÑ0GÖHñ Eð �z˜Ÿ	™	Ð"€FØŸ	™	˜
Ð#€GÜˆw‹<˜5Ÿ:™:Ó%Ð%Ð%äÙ%Ó&šg˜�Œ™gÑ&Ù$Ó%šf˜�Œ™fÑ%ó€Iñ ˜'¨IÓ6€FØ×#Ñ#¤E§J¡JÓ/€Fá4:Ó;²F¨Sˆs×&Ñ&Ö(±F€GÐ;ð ˜‘
× Ñ €Iñ ,2ó 7ª6 CÜ" 3¬×5ó  �S—Z”Z©6€Mð 7ä¡=Ó=¢=˜a°A¸±HŸ¡=Ñ=Ó>€LÜ¡=Ó=¢=˜a°A¸±HŸ¡=Ñ=Ó>€Lð �lÓ"Ø‰àˆä	×	Ò	˜7 I°FÀ%Ò	HÈLØˆÜ(¬¨W°fÓ)=Ö>‰OˆA‰|��sØ× Ñ  ¨qÔ1Ø�N‰N˜3Ÿ=™=¨¯©Ó):Ó;Ö<ñ  ?ô )¨¸¿ºÈ'Ð9RÓSˆÜ" 8¨WÖ5‰OˆG�VØ×Ñ˜l¨GÖ4ñ  6÷ 
Iô ˜e¨g·±Ñ_fÓHgÒ_fÐZ[ÈÏÌÑ_fÑHgÓ
h€CÜ˜G¨c¯o©o¸sÓCÐCùóC8ùò6 	'ùÚ%ùò
 <ùò7ùâ=ùÚ=÷ 
IÕ	Hüò IhsN   ™OÆ9O!ÇO&
ÈO+ÉO0É(O0Ê
O5ÊO5Ê'
O:Ê5O:Ë$B&O?Î'PÏ?
Pc                 ól  • / nUR                   R                  5       nUS   US   -   nS/UR                  -  S/UR                  -  -   n[	        X2R
                  Xx5       GH	  u  pšp¼[        U
[        R                  5      (       aÆ  U R                  U
5      " XU	5      n[        R                  " XR                  U
R                  5      n[        R                  " XR                  U
R                  5      nU
R                  US9nU
R                  nU
R                   nU
R"                  n[%        XXïU	UUUUU5
      nUR'                  U5        Mì  [)        XXš5      nUR'                  U5        GM     U" XU5      nU V	s/ s H&  n	[        U	[$        5      (       d  M  U	R                   PM(     nn	[+        U Vs/ s H  nUS:X  d  M  UPM     sn5      n[+        U Vs/ s H  nUS:X  d  M  UPM     sn5      nUU:”  a  SnOSnXdR                  S  nU R-                  [        R.                  5      nU Vs/ s H  nUR1                  5       PM     nnUS   R                  US   R2                  R                  -
  n US   R                  S U  n![5        UR6                  R8                  5      n"[:        R<                  " [	        [?        [+        U5      5      U"S   U"S   -   5      SS	9 H^  u  u  n#n$u  n%n&UU#   UU%   n(n'U$U&:X  d  M  [A        S
 U'U(4 5       5      (       d  M9  UU#   UU%   n(n'U'RC                  U([+        U$5      5        M`     US UR                    H+  n	[        U	[$        5      (       d  M  U	RE                  U!5        M-     [        RF                  " UU!UUS9 n)/ n*[I        [	        UU5      5       HI  u  n+u  n,n	U,RK                  U)U+5        U*R'                  U	RM                  U,RO                  5       5      5        MK     URP                  " U*6   S S S 5        g s  sn	f s  snf s  snf s  snf ! , (       d  f       g = f)Nr   r9   TF)r{   r6  r7  é   )Úrc              3   óB   #   • U  H  n[        U[        5      v •  M     g 7fr    )rÛ   r™   )rÿ   r€   s     r%   r   Ú&numpy_gufunc_kernel.<locals>.<genexpr>l  s   é € ÐJº>°a”J˜q¤.×1Ð1º>ùs   ‚r8  ))ÚdufuncÚexpected_ndimsr:  r*  ri   rÅ   rÛ   r   rÞ   r    r   rß   rB   r{   r…   Úcopyr†   rà   r™   r|   r5   rh   r>   r?   rP   rœ   r   Úgufunc_builderÚ	signatureÚ	itertoolsÚcombinationsrz   Úallr×   rÊ   r?  r  r&   rU   r,   r@  )-r:   r;   rÈ   rÅ   r-  rA  rC  rY  Úis_inputr  rJ   Úexp_ndimÚis_inpr¢   rB   r…   rœ   r{   r†   r=   Úarray_helperÚscalar_helperrI  Úlayoutsr€   rK  rL  r9  rG  rK   rè   rT   Úloopshape_ndimrÇ   Ú_sigÚidx_aÚsig_aÚidx_bÚsig_bÚarg_aÚarg_br#   rM  r   rs   s-                                                r%   Únumpy_gufunc_kernelrn  4  sÊ  € Ø€IØ!×(Ñ(×7Ñ7Ó9€NØ# AÑ&¨¸Ñ):Ñ:€NØˆv˜Ÿ	™	Ñ! U G¨e¯j©jÑ$8Ñ8€HÜ%(¨¯x©x¸×%RÑ!ˆ�Ü�bœ%×/Ñ/×0Ñ0ð ×$Ñ$ RÔ(¨¸3Ó?ˆCÜ×(Ò(¨·)±)¸R¿W¹WÓEˆEÜ×*Ò*¨7·K±KÀÇÁÓIˆGØŸ7™7¨˜7Ð1ˆLØ—7‘7ˆDØ—Y‘YˆFØŸ™ˆIÜ)¨'Ø*/¸#Ø*0°)¸TØ*6¸ó@ˆLð ×Ñ˜\Ö*ä)¨'¸CÓDˆMØ×Ñ˜]×+ñ% &Sñ& ˜'¨CÓ0€Fá%.ó 3¢Y˜cÜ˜S¤.×1ó ˆs�zŒz¡Y€Gð 3ä¡7Ó7¢7˜a¨a°3©hŸ¡7Ñ7Ó8€LÜ¡7Ó7¢7˜a¨a°3©hŸ¡7Ñ7Ó8€Lð �lÓ"Ø‰àˆàŸ	™	˜
Ð#€GØ×#Ñ#¤E§J¡JÓ/€FÙ4=Ó>²I¨Sˆs×&Ñ&Ö(±I€GÐ>Ø˜Q‘Z—_‘_ w¨q¡z×'>Ñ'>×'CÑ'CÑC€NØ˜‘
× Ñ Ð"2 NÐ3€Iä˜5×/Ñ/×9Ñ9Ó:€DÜ*3×*@Ò*@Ü””c˜)“nÓ%Ø�‰G�d˜1‘gÑóàô+Ñ&‰ˆ�™˜ ð ! Ñ'¨°5Ñ)9ˆuˆØ�E�>ÜÑJ¸EÀ5¹>ÓJ×JÓJØ$ UÑ+¨Y°uÑ-=�5ˆEØ×'Ñ'¨¬s°5«zÖ:ñ+ð ˜˜%Ÿ)™)Ó$ˆÜ�cœ>×*Ó*Ø�O‰O˜IÖ&ñ %ô 
×	Ò	˜7Ø$Ø &Ø!&ò
(ð ,8ØˆÜ(¬¨W°iÓ)@ÖA‰OˆA‰|��sØ× Ñ  ¨qÔ1Ø�N‰N˜3Ÿ=™=¨¯©Ó):Ó;Ö<ñ  Bð 	�Š˜Ñ!÷
(ð 
(ùòM3ùâ7ùÚ7ùò ?÷,
(õ 
(ús7   Å:PÆPÆ2
PÇ PÇ
PÇ$PÈ-P ÎA4P%Ð%
P3c                   ó&   • \ rS rSrS rS rS rSrg)Ú_Kerneli�  c                 ó(   • Xl         X l        X0l        g r    )r:   r;   rH  )r"   r:   r;   rH  s       r%   rM   Ú_Kernel.__init__‚  s   € ØŒØŒØ"�r)   c                 ó^  • [        U[        R                  5      (       ah  [        U[        R                  5      (       dI  UR                  nU R                  R                  US5      nU" U R                  U R                  X!S5      nUnU R                  R                  U R                  XU5      $ )zÙNumpy uses cast semantics that are different from standard Python
(for example, it does allow casting from complex to float).

This method acts as a patch to context.cast so that it allows
complex to real/int casts.

Úreal)rÛ   r   ÚComplexÚunderlying_floatr:   Úget_getattrr;   rÝ   )r"   r<   r¯   r°   ÚnewtyÚattrs         r%   rÝ   Ú_Kernel.cast‡  s…   € ô �vœuŸ}™}×-Ñ-Ü˜4¤§¡×/Ñ/ð ×+Ñ+ˆEØ—<‘<×+Ñ+¨F°FÓ;ˆDÙ�t—|‘| T§\¡\°6ÀÓGˆCØˆFð �|‰|× Ñ  §¡¨s¸DÓAÐAr)   c           
      óü  • U R                   nU R                  n[        XR                  UR                  5       VVVs/ s H  u  pEnU R	                  XEU5      PM     nnnnU R
                  R                  (       aZ  U R                  R                  R                  [        R                  [        R                  /[        UR                  5      -  5      nO:U R                  R                  R                  UR                  UR                  5      nU R                  R                  R                   R"                  n	[$        R&                  " X˜U R
                  R(                  R*                  5      n
U
R,                  R/                  S5        U R                  R                  R1                  U R                  X¢R                  UR                  U5      u  p¼U R	                  XÂR                  UR                  5      $ s  snnnf )NÚalwaysinline)Ú	inner_sigrH  ri   rÅ   rÝ   ÚcresÚ
objectmoder:   r  Úget_function_typer   Úpyobjectrh   r+  r;   ÚblockÚfunctionÚmoduler   Úget_or_insert_functionÚfndescÚllvm_func_nameÚ
attributesÚaddÚcall_function)r"   rÅ   ÚisigÚosigr<   ÚintyÚouttyÚ	cast_argsÚ	func_typer„  Úentry_pointÚ_rµ   s                r%   r@  Ú_Kernel.generate›  sx  € Ø�~‰~ˆØ�~‰~ˆô ˜Ÿy™y¨$¯)©)Ô4õ6â4ñ *˜ Eð —Y‘Y˜s¨%Ö0á4ð 	ò 6ð �9‰9××ØŸ™×.Ñ.×@Ñ@Ü—‘¤§¡Ð 0´3°t·y±y³>Ñ AóC‰Ið Ÿ™×.Ñ.×@Ñ@Ø× Ñ  $§)¡)ó-ˆIà—‘×#Ñ#×,Ñ,×3Ñ3ˆÜ×4Ò4ØØ�I‰I×Ñ×+Ñ+ó-ˆð 	×Ñ×"Ñ" >Ô2à—‘×'Ñ'×5Ñ5Ø�L‰L˜+×'7Ñ'7¸¿¹Øó‰ˆð �y‰y˜×.Ñ.°×0@Ñ0@ÓAÐAùô%6s   ½G7)r;   r:   rH  N)r/   r0   r1   r2   rM   rÝ   r@  r3   r!   r)   r%   rp  rp  �  s   † ò#ò
Bõ(Br)   rp  c                 ó0   ^ ^•  " UU 4S jS[         5      mT$ )aÂ  Use the ufunc loop type information to select the code generation
function from the table provided by the dict_of_kernels. The dict
of kernels maps the loop identifier to a function with the
following signature: (context, builder, signature, args).

The loop type information has the form 'AB->C'. The letters to the
left of '->' are the input types (specified as NumPy letter
types).  The letters to the right of '->' are the output
types. There must be 'ufunc.nin' letters to the left of '->', and
'ufunc.nout' letters to the right.

For example, a binary float loop resulting in a float, will have
the following signature: 'ff->f'.

A given ufunc implements many loops. The list of loops implemented
for a given ufunc can be accessed using the 'types' attribute in
the ufunc object. The NumPy machinery selects the first loop that
fits a given calling signature (in our case, what we call the
outer_sig). This logic is mimicked by 'ufunc_find_matching_loop'.
c                   ó4   >^ • \ rS rSrUU U4S jrS rSrU =r$ )Ú'_ufunc_db_function.<locals>._KernelImpliÉ  c           
      óŽ  >• [         TU ]  XU5        [        TUR                  [	        [        TU5      5      -   5      nUR                  T5      R                  UR                  5      U l	        [        UR                  UR                  5      U l        U R                  c'  Sn[        UR                  TR                   U5      5      eg )Nz2Don't know how to lower ufunc '{0}' for loop '{1}')ÚsuperrM   r   rÅ   r  r.  Úget_ufunc_infor  Ú	ufunc_sigÚfnr   rG  r  r}  rå   ræ   r/   )	r"   r:   r;   rH  ÚlooprÕ   Ú_KernelImplÚ	__class__r-  s	         €€€r%   rM   Ú0_ufunc_db_function.<locals>._KernelImpl.__init__Ê  sž   ø€ Ü�+˜tÑ-¨gÀ	ÔJÜ+Ø�y—~‘~¬Ô.BÀ5È)Ó.TÓ(UÑUóWˆDà×,Ñ,¨UÓ3×7Ñ7¸¿¹ÓGˆDŒGÜ,¨T¯\©\¸4¿;¹;ÓGˆDŒNà�w‰w‰ØJ�Ü)¨#¯*©*°U·^±^ÀTÓ*JÓKÐKð r)   c           
      óD  • U R                   nU R                  n[        XR                  UR                  5       VVVs/ s H  u  pEnU R	                  XEU5      PM     nnnn[        U R                  S5         U R                  U R                  U R                  X'5      nS S S 5        U R                  R                  n	X’R                     R                  U R                  W5      nU R	                  X‚R                  UR                  5      $ s  snnnf ! , (       d  f       Ny= f)NÚnumpy)r}  rH  ri   rÅ   rÝ   r
   r:   r›  r;   rŒ   r+  Úfrom_return)
r"   rÅ   r‹  rŒ  r<   r�  rŽ  r�  rµ   Údmms
             r%   r@  Ú0_ufunc_db_function.<locals>._KernelImpl.generateÕ  sê   € Ø—>‘>ˆDØ—>‘>ˆDô 25°T¿9¹9Ø59·Y±Yô2@õAò2@Ñ-˜S¨ð Ÿ™ 3¨eÖ4ñ2@ð ò Aô # 4§<¡<°Õ9Ø—g‘g˜dŸl™l¨D¯L©L¸$ÓJ�÷ :à—,‘,×1Ñ1ˆCØ×&Ñ&Ñ'×3Ñ3°D·L±LÀ#ÓFˆCØ—9‘9˜S×"2Ñ"2°D×4DÑ4DÓEÐEùôA÷ :Õ9ús   ½D
Á6(DÄ
D)r›  r}  )r/   r0   r1   r2   rM   r@  r3   Ú__classcell__)rž  r�  r-  s   @€€r%   r�  r–  É  s   ù† ÷		L÷	Fð 	Fr)   r�  )rp  )r-  r�  s   `@r%   Ú_ufunc_db_functionr¦  ³  s   ù€ ÷,Fð F”gô Fð2 Ðr)   c                 óà   ^ ^• UU 4S jn[         R                  nU4T R                  -  n[        T R                  S-   5       H(  n[         R
                  4U-  nU" T /UQUQ76 " U5        M*     T$ )Nc                 ó    >• [        XX#TT5      $ r    ©rR  ©r:   r;   rÈ   rÅ   rI  r-  s       €€r%   Údo_ufuncÚ'register_ufunc_kernel.<locals>.do_ufuncé  ó   ø€ Ü! '°C¸uÀfÓMÐMr)   r9   )r   ÚAnyr:  rz   r*  rŸ   )r-  rI  Úlowerr«  Ú_anyÚin_argsÚn_explicit_outÚout_argss   ``      r%   Úregister_ufunc_kernelr´  è  sk   ù€ öNô �9‰9€DØˆg˜Ÿ	™	Ñ!€Gô   §
¡
¨Q¡Ö/ˆÜ—K‘K�> NÑ2ˆÙˆeÐ)�gÐ) Ó)¨(Ö3ñ 0ð €Mr)   c                 ód   ^^• U(       a   eUU4S jn[         R                  nU" X5      " U5        g )Nc                 ó    >• [        XX#TT5      $ r    r©  rª  s       €€r%   Úlower_unary_operatorÚ<register_unary_operator_kernel.<locals>.lower_unary_operatorú  r­  r)   )r   rŸ   )Úoperatorr-  rI  r¯  Úinplacer·  Ú	_arr_kinds    ``    r%   Úregister_unary_operator_kernelr¼  ÷  s(   ù€ æÐˆ;öNä—‘€IÙ	ˆ(ÔÐ3Õ4r)   c                 óÔ   ^^• UU4S jnUU4S jn[         R                  n[         R                  nXˆ4Xx4X‡4/n	U	 H*  n
U(       d  U" U /U
Q76 " U5        M  U" U /U
Q76 " U5        M,     g )Nc                 ó    >• [        XX#TT5      $ r    r©  rª  s       €€r%   Úlower_binary_operatorÚ>register_binary_operator_kernel.<locals>.lower_binary_operator  r­  r)   c                 ó¼   >• [        U5      US   4-   n[        R                  " UR                  /UR                  UR                  S   4-   Q76 n[        XX#TT5      $ ry   )r  r   r\  r+  rÅ   rR  rª  s       €€r%   Úlower_inplace_operatorÚ?register_binary_operator_kernel.<locals>.lower_inplace_operator  sV   ø€ ô �T‹{˜d 1™g˜ZÑ'ˆÜ×Ò˜sŸ™ÐK°·±¸S¿X¹XÀa¹[¸NÑ1JÒKˆÜ! '°C¸uÀfÓMÐMr)   )r   r®  rŸ   )Úopr-  rI  r¯  rº  r¿  rÂ  r°  r»  Úformal_sigsrÈ   s    ``        r%   Úregister_binary_operator_kernelrÆ     sg   ù€ öNöNô �9‰9€DÜ—‘€IØÐ)¨DÐ+<¸yÐ>OÐP€KÛˆÞÙ�"ˆO�s‹OÐ1Ö2á�"ˆO�s‹OÐ2Ö3ò	 r)   c                 óX   •  " S S[         5      n[        XX#[        R                  U5      $ )z¬Lowering function for +(array) expressions.  Defined here
(numba.targets.npyimpl) since the remaining array-operator
lowering functions are also registered in this module.
c                   ó   • \ rS rSrS rSrg)Ú1array_positive_impl.<locals>._UnaryPositiveKerneli  c                 ó   • Uu  nU$ r    r!   )r"   rÅ   r<   s      r%   r@  Ú:array_positive_impl.<locals>._UnaryPositiveKernel.generate   s   € Ø‰EˆSØˆJr)   r!   N)r/   r0   r1   r2   r@  r3   r!   r)   r%   Ú_UnaryPositiveKernelrÉ    s   † õ	r)   rÌ  )rp  rR  ÚnpÚpositive)r:   r;   rÈ   rÅ   rÌ  s        r%   Úarray_positive_implrÏ    s*   € ôœwô ô
 ˜g°¼2¿;¹;Ø2ó4ð 4r)   c           
      óÊ  • 0 nU  H  n[        U5      n[        X4U5      X#'   M     [        R                  R                  [        R
                  R                  4 Hu  nUR                  5        H^  u  pg[        [        U5      nX#   nUR                  S:X  a  [        XcX�5        M7  UR                  S:X  a  [        XcX�5        MU  [        S5      e   Mw     [        R                  R                  4 Hs  nUR                  5        H\  u  pg[        [        U5      nX#   nUR                  S:X  a  [        XcX�SS9  M6  UR                  S:X  a  [        XcX�SS9  MS  [        S5      e   Mu     g )Nr9   rT  z4There shouldn't be any non-unary or binary operatorsT)rº  )r¦  r´  r   ÚNumpyRulesUnaryArrayOperatorÚ_op_mapÚNumpyRulesArrayOperatorÚitemsÚgetattrrÍ  r:  r¼  rÆ  r;  ÚNumpyRulesInplaceArrayOperator)	Úufuncsr¯  Úkernelsr-  Údb_funcrÒ  r¹  Ú
ufunc_namerI  s	            r%   Úregister_ufuncsrÛ  (  s8  € Ø€GÛˆÜ$ UÓ+ˆÜ.¨u¸uÓEˆ‹ñ ô ×8Ñ8×@Ñ@Ü×3Ñ3×;Ñ;óˆð %,§M¡M¦OÑ ˆHÜœB 
Ó+ˆEØ‘^ˆFØ�y‰y˜A‹~Ü.¨xÀÖNØ—‘˜a“Ü/°ÀÖOä"Ð#YÓZÐZó %4ñô ×:Ñ:×BÑBó ˆà$+§M¡M¦OÑ ˆHÜœB 
Ó+ˆEØ‘^ˆFØ�y‰y˜A‹~Ü.¨xÀØ7;ô=à—‘˜a“Ü/°ÀØ8<ô>ô #Ð#YÓZÐZó %4òr)   c                 ó|  ^• U4S jn[        T[        R                  5      (       a1  [        [        R
                  " TR                  5      5      nU" U5      $ [        T[        R                  R                  5      (       a<  [        TR
                  5      n[        [        R
                  " U5      5      nU" U5      $ g)zPGiven a string or NumberClass description *desc*, returns the dtype object.
    c                 óL   >• [         R                  " U 5      nU" T5      nS nX#4$ )Nc                 ó"   • U R                  5       $ r    )Úget_dummy_value)r:   r;   r\  rÅ   s       r%   ÚcodegenÚ9_make_dtype_object.<locals>.from_nb_type.<locals>.codegenU  s   € ð ×*Ñ*Ó,Ð,r)   )r   ÚDType)Únb_typer+  rÈ   rà  Údescs       €r%   Úfrom_nb_typeÚ(_make_dtype_object.<locals>.from_nb_typeQ  s*   ø€ Ü—k’k 'Ó*ˆÙ˜$Óˆò	-ð
 ˆ|Ðr)   N)
rÛ   r   ÚLiteralr   rÍ  rà   Úliteral_valueÚ	functionsÚNumberClassrç   )Ú	typingctxrä  rå  rã  Úthestrs    `   r%   Ú_make_dtype_objectrí  M  s†   ø€ õ	ô �$œŸ™×&Ñ&äœRŸXšX d×&8Ñ&8Ó9Ó:ˆÙ˜GÓ$Ð$Ü	�Dœ%Ÿ/™/×5Ñ5×	6Ñ	6Ü�T—Z‘Z“ˆäœRŸXšX fÓ-Ó.ˆÙ˜GÓ$Ð$ð	 
7r)   c                 óÈ   • [        U [        R                  [        R                  R                  45      (       a  S nU$ [
        R                  " SR                  U 5      5      e)zKProvide an implementation so that numpy.dtype function can be lowered.
    c                 ó   • [        U 5      $ r    )rí  )rä  s    r%   ÚimpÚnumpy_dtype.<locals>.impk  s   € Ü% dÓ+Ð+r)   zunknown dtype descriptor: {})rÛ   r   rç  ré  rê  r   ÚNumbaTypeErrorræ   )rä  rð  s     r%   Únumpy_dtyperó  f  sK   € ô �$œŸ™¬¯©×(CÑ(CÐD×EÑEò	,àˆ
ä×#Ò#Ð$B×$IÑ$IÈ$Ó$OÓPÐPr)   )zinput operand)F)Lr_   ÚmathÚsysr]  Úcollectionsr   Úllvmlite.irr@   r¡  rÍ  r¹  Únumba.npr   r   r   Únumba.np.ufunc.sigparser   Únumba.core.imputilsr   r	   r
   r   Ú
numba.corer   r   r   r   r   r   Únumba.np.numpy_supportr   r   r   r   Únumba.np.arrayobjr   Únumba.core.typingr   Únumba.core.extendingr   r   r   ÚregistryÚobjectr   r5   rb   rv   r™   rí   ÚUSE_LEGACY_TYPE_SYSTEMr?   ÚCPointerr
  Únp_intpr÷   r(  r.  r1  r4  rR  rn  rp  r¦  r´  r¼  rÆ  r¯  ÚposrŸ   rÏ  rÛ  Ú
get_ufuncsrí  rà   ró  r!   r)   r%   Ú<module>r     s  ðñó
 Û 
Û Ý "å ã Û ç 6Ñ 6Ý 3ß bÓ bß F× F÷ó õ 5Ý %ß 4å á�IÓ€ô˜Fô ô&,�Fô &,ôR;™:Ð&<Ø&:ó<ô ;ô6&F‘:˜nð /=ó >ô &FôRL@‘Z ð 1Qó Rô L@ô^/ð6 
× × ØŸ*š* U§Z¡Z°·²ÀÇ
Á
Ó1KØ$)§J¡J°·²¸u¿z¹zÓ0JóLÑð  Ÿ-š-¨¯©°u·~²~ÀeÇmÁmÓ7TØ$)§M¡M°5·>²>À%Ç-Á-Ó3PóRÐò&òPQ!òj%ò5ò8òMDò`I"ôZ/Bˆfô /Bòd/òjð  ,1ô5ô4ð2 
‡��—‘˜eŸk™kÓ*ñ4ó +ð4ò[ñD �×#Ò#Ó% x§~¡~Ô 6ð ñ%ó ð%ñ0 
ˆ"�(‰(ÓñQó ñQr)   