Ë
    èÿæi¥^  ã                   ób  — d dl Z d dlmZ d dlZd dlmZmZ d dlmZ d dl	m
Z
mZmZmZmZmZmZ d dlmZmZ d dlmZ d dlmZmZmZmZ d d	lmZmZmZmZm Z m!Z!m"Z" d dl#Z#d dl$Z$d dl%Z% G d
„ de&«      Z'd„ Z(d„ Z)d„ Z*d„ Z+d„ Z, ee(«      Z-d„ Z.d„ Z/d„ Z0d„ Z1d„ Z2d„ Z3d„ Z4 G d„ de«      Z5 G d„ dee«      Z6 G d„ dee«      Z7 G d„ dee%j0                  «      Z8 G d „ d!ee%j0                  «      Z9 G d"„ d#ee%j0                  «      Z: G d$„ d%ee%j0                  «      Z;e<d&k(  r e%jz                  «        yy)'é    N)ÚStringIO)ÚnjitÚ	vectorize)Útypeof)ÚutilsÚtypesÚtypingÚirÚcompilerÚcpuÚcgutils)ÚCompilerÚFlags)Ú
cpu_target)ÚMemoryLeakMixinÚTestCaseÚtemp_directoryÚcreate_temp_module)ÚoverloadÚmodelsÚlower_builtinÚregister_modelÚmake_attribute_wrapperÚtype_callableÚtypeof_implc                   ó   ‡ — e Zd Zˆ fd„Zˆ xZS )Ú	Namespacec                 ó<   •— || v r| |   S t         t        | �  |«      S ©N)Úsuperr   Ú__getattr__)ÚsÚkÚ	__class__s     €úq/Volumes/fast/ai/experiments/voice-extract-mac/.venv/lib/python3.12/site-packages/numba/tests/test_array_exprs.pyr!   zNamespace.__getattr__   s$   ø€ Ø˜A‘vˆq�‰tÐE¤5¬°AÑ#BÀ1Ó#EÐEó    )Ú__name__Ú
__module__Ú__qualname__r!   Ú__classcell__)r$   s   @r%   r   r      s   ø„ ÷Fð Fr&   r   c                 ó   — | |z  |z   S r   © ©ÚaÚxÚys      r%   Úaxyr1       ó   € Øˆq‰5�1‰9Ðr&   c                 ó   — | |z  |z   S r   r,   r-   s      r%   Úax2r4   #   r2   r&   c                 ó8   — | |dz  d| z  |z  z
  dz  z   d| z  z  S )Nç       @g      @ç      à?r,   ©ÚAsÚBsÚCss      r%   Úpos_rootr<   &   s.   € ØˆC�R˜2‘X " r¡'¨B¡,Ñ/°CÑ7Ñ8¸RÀ"¹WÑEÐEr&   c                 óD   — d| z  }d|z  |z  }|dz  |z
  }| |dz  z
  |z  S )Nr6   r7   r,   ©r9   r:   r;   Ú_2AsÚ_4AsCsÚ
_Bs2_4AsCss         r%   Úneg_root_common_subexprrB   )   s=   € Ø�‰7€DØ�$‰Y˜‰^€FØ˜‘(˜VÑ#€JØˆC�: Ñ$Ñ%¨Ñ-Ð-r&   c                 óJ   — d| z  }d|z  |z  }|dz  |z
  dz   }| |dz  z
  |z  S )Nr6   y                r7   r,   r>   s         r%   Úneg_root_complex_subexprrD   /   sB   € Ø�‰7€DØ�$‰Y˜‰^€FØ˜‘(˜VÑ# rÑ)€JØˆC�: Ñ$Ñ%¨Ñ-Ð-r&   c                 ón   — t        j                  t        | t        j                  |«      dz
  d«      «      S )Nç      ð?)ÚnpÚcosÚvaxyÚsin)Úa0Úa1s     r%   Ú
call_stuffrM   7   s&   € Ü�6‰6”$�rœ2Ÿ6™6 "›:¨™?¨BÓ/Ó0Ð0r&   c                 ó$   — |dz  d| z  |z  z
  dk  S )Né   é   r   r,   r8   s      r%   Úare_roots_imaginaryrQ   :   s   € Ø�!‰G�a˜"‘f˜r‘kÑ! QÑ&Ð&r&   c                 ó   — | |z  |z   S r   r,   r8   s      r%   Údiv_addrS   =   s   € Ø�‰7�R‰<Ðr&   c                 ó   — | dz  S )Né   r,   )r9   s    r%   ÚcuberV   @   s   € Ø�‰7€Nr&   c                 ó\   — t        j                  | |«       t        j                  |||«      S r   )rG   rH   Úadd)r.   ÚbÚouts      r%   Úexplicit_outputr[   C   s"   € Ü‡F�Fˆ1ˆc„NÜ�6‰6�#�q˜#ÓÐr&   c                 ó0   — | |z   }|| |z  z
  }||z  |z   }|S r   r,   )r.   rY   ÚcÚdÚus        r%   Úvariable_name_reuser`   G   s*   € Ø	ˆA‰€AØ	ˆA�‰E‰	€AØ	ˆA‰�‰	€AØ€Hr&   c                 ó  — | j                   d   }t        j                  ||ft        j                  ¬«      }t	        |«      D ]C  }t	        ||«      D ]2  }t        j
                  | |   | |   z
  dz  «      dz  x|||f<   |||f<   Œ4 ŒE |S )Nr   ©ÚdtyperO   r7   )ÚshaperG   ÚemptyÚfloat64ÚrangeÚsum)ÚvectorsÚ	n_vectorsÚresultÚiÚjs        r%   Údistance_matrixrn   O   s’   € Ø—‘˜aÑ €IÜ�X‰X�y )Ð,´B·J±JÔ?€Fä�9ÖˆÜ�q˜)Ö$ˆAÜ(*¯©Ø˜‘˜g a™jÑ(¨QÑ.ó)0Ø36ñ)7ð 7ˆF�1�Q�3‰K˜&  1 š+ñ %ð ð
 €Mr&   c                   ó8   — e Zd Ze	 	 dd„«       Ze	 	 dd„«       Zy)ÚRewritesTesterNc           	      ó”   — |€i }|s
t        «       }d|_        |€t        j                  }|€t        j                  } | |||||||«      S ©NT)r   Únrtr   Útyping_contextÚtarget_context)ÚclsÚargsÚreturn_typeÚflagsÚlocalsÚlibraryrt   ru   s           r%   Úmk_pipelinezRewritesTester.mk_pipeline\   s]   € ð ˆ>ØˆFÙÜ“GˆEØˆŒ	ØÐ!Ü'×6Ñ6ˆNØÐ!Ü'×6Ñ6ˆNÙ�> >°7¸DÀ+Ø˜&ó"ð 	"r&   c                 ó^   — |€i }|s
t        «       }d|_         | j                  |||||fi |¤ŽS rr   )r   Úno_rewritesr|   )rv   rw   rx   ry   rz   r{   Úkwss          r%   Úmk_no_rw_pipelinez RewritesTester.mk_no_rw_pipelinek   s>   € ð ˆ>ØˆFÙÜ“GˆEØ ˆÔØˆs�‰˜t [°%¸ÀÑPÈCÑPÐPr&   )NNNNNN)NNNN)r'   r(   r)   Úclassmethodr|   r€   r,   r&   r%   rp   rp   [   s6   „ ØØDHØFJò"ó ð"ð ØJNØ"&òQó ñQr&   rp   c                   ó‚   — e Zd Zd„ Zd„ Zd„ Zdd„Zefd„Ze	fd„Z
d„ Zd	„ Zdd
„Zd„ Zd„ Zd„ Zefd„Zd„ Zd„ Zd„ Zd„ Zy)ÚTestArrayExpressionsc                 óÖ   — t         j                  |«      }|j                  |«      }|j                  }t         j	                  |«      }|j                  |«      }|j                  }||||fS )zT
        Compile the given function both without and with rewrites enabled.
        )rp   r€   Úcompile_extraÚentry_pointr|   )	ÚselfÚfnÚarg_tysÚcontrol_pipelineÚcres_0Úcontrol_cfuncÚtest_pipelineÚcres_1Ú
test_cfuncs	            r%   Ú_compile_functionz&TestArrayExpressions._compile_functionx   sj   € ô *×;Ñ;¸GÓDÐØ!×/Ñ/°Ó3ˆØ×*Ñ*ˆä&×2Ñ2°7Ó;ˆØ×,Ñ,¨RÓ0ˆØ×'Ñ'ˆ
à °¸zÐIÐIr&   c                 ót  — t        j                  ddd«      }t        j                  ddd«      }t        j                  ddd«      }|||fD �cg c]  }t        |«      ‘Œ }}| j                  t        |«      \  }}}}	t
        j                  |«      }
|
j                  t        «      }|j                  } ||||«      } |	|||«      } ||||«      }t         j                  j                  ||«       t         j                  j                  ||«       |j                  j                  j                  }|j                  j                  j                  }|
j                  j                  j                  }| j                  t!        |«      t!        |«      «       | j                  t!        |«      t!        |«      «       | j#                  t!        |d   j$                  «      t!        |d   j$                  «      «       | j                  t!        |d   j$                  «      t!        |d   j$                  «      «       yc c}w )zv
        Using a simple array expression, verify that rewriting is taking
        place, and is fusing loops.
        r   é   é
   rO   N)rG   Úlinspacer   r�   r1   rp   r€   r…   r4   r†   ÚtestingÚassert_array_equalÚstateÚfunc_irÚblocksÚassertEqualÚlenÚassertGreaterÚbody)r‡   ÚAÚXÚYÚargr‰   rŠ   Únb_axy_0r�   Únb_axy_1Úcontrol_pipeline2Úcres_2Únb_ctlÚexpectedÚactualÚcontrolÚir0Úir1Úir2s                      r%   Útest_simple_exprz%TestArrayExpressions.test_simple_expr†   sÅ  € ô
 �K‰K˜˜!˜BÓˆÜ�K‰K˜˜!˜BÓˆÜ�K‰K˜˜!˜BÓˆØ+,¨a°©)Ó4©) 3”6˜#•;¨)ˆÐ4ð ×"Ñ"¤3¨Ó0ñ 	<Ð˜( M°8ô +×<Ñ<¸WÓEÐØ"×0Ñ0´Ó5ˆØ×#Ñ#ˆá˜A˜q !Ó$ˆÙ˜!˜Q Ó"ˆÙ˜˜A˜q“/ˆÜ
�
‰
×%Ñ% h°Ô7Ü
�
‰
×%Ñ% g¨vÔ6à×$Ñ$×,Ñ,×3Ñ3ˆØ×!Ñ!×)Ñ)×0Ñ0ˆØ×%Ñ%×-Ñ-×4Ñ4ˆØ×Ñœ˜S›¤3 s£8Ô,Ø×Ñœ˜S›¤3 s£8Ô,à×Ñœ3˜s 1™vŸ{™{Ó+¬S°°Q±·±Ó-=Ô>Ø×Ñœ˜S ™VŸ[™[Ó)¬3¨s°1©v¯{©{Ó+;Õ<ùò- 5s   ÁH5c              #   óÖ   K  — |D ]`  }t        |t        j                  «      sŒt        |j                  t        j                  «      sŒC|j                  j
                  dk(  sŒ]|–— Œb y ­w)NÚ	arrayexpr)Ú
isinstancer
   ÚAssignÚvalueÚExprÚop)r‡   ÚblockÚinstrs      r%   Ú_get_array_exprsz%TestArrayExpressions._get_array_exprs¦   sE   è ø€ ÛˆEÜ˜%¤§¡Õ+Ü˜eŸk™k¬2¯7©7Õ3Ø—{‘{—~‘~¨Ó4Ø#›ñ	 ùs   ‚ A)£$A)ÁA)Á"A)Nc                 ó:  — |€
t        «       }t        |t        «      st        dj	                  |«      «      ‚|\  }}g }|D ]8  }t        |t        «      r| j                  ||«      \  }}|j                  |«       Œ: |t        |«      f}|j                  |«       ||fS )zK
        Convert an array expression tree into a set of operators.
        z{0} not a tuple)Úsetr°   ÚtupleÚ
ValueErrorÚformatÚ_array_expr_to_setÚappendrX   )	r‡   ÚexprrZ   Ú	operationÚoperandsÚprocessed_operandsÚoperandÚ_Úprocessed_exprs	            r%   r½   z'TestArrayExpressions._array_expr_to_set­   s¢   € ð ˆ;Ü“%ˆCÜ˜$¤Ô&ÜÐ.×5Ñ5°dÓ;Ó<Ð<Ø"Ñˆ	�8ØÐÛˆGÜ˜'¤5Ô)Ø!×4Ñ4°W¸cÓB‘
�˜Ø×%Ñ% gÕ.ð  ð #¤EÐ*<Ó$=Ð=ˆØ�‰�ÔØ˜sÐ"Ð"r&   c                 ó¬  — t         j                  j                  d«      }t         j                  j                  d«      dz   }t         j                  j                  d«      }|||fD �cg c]  }t        |«      ‘Œ }}t        j	                  |«      }|j                  |«      }|j                  }	t        j                  |«      }
|
j                  |«      }|j                  } ||||«      } |	|||«      } ||||«      }t         j                  j                  ||«       t         j                  j                  ||«       t        t        «       «      S c c}w )Nr“   rF   )rG   Úrandomr   rp   r€   r…   r†   r|   r•   Úassert_array_almost_equalr   rz   )r‡   rˆ   rž   ÚBÚCr¡   r‰   rŠ   Úcontrol_cresÚnb_fn_0r�   Ú	test_cresÚnb_fn_1Ú	np_resultÚnb_result_0Únb_result_1s                   r%   Ú_test_root_functionz(TestArrayExpressions._test_root_function¿   s  € Ü�I‰I×Ñ˜RÓ ˆÜ�I‰I×Ñ˜RÓ  2Ñ%ˆô �I‰I×Ñ˜RÓ ˆØ+,¨a°©)Ó4©) 3”6˜#•;¨)ˆÐ4ä)×;Ñ;¸GÓDÐØ'×5Ñ5°bÓ9ˆØ×*Ñ*ˆä&×2Ñ2°7Ó;ˆØ!×/Ñ/°Ó3ˆ	Ø×'Ñ'ˆá�q˜!˜Q“Kˆ	Ù˜a  AÓ&ˆÙ˜a  AÓ&ˆÜ
�
‰
×,Ñ,¨Y¸ÔDÜ
�
‰
×,Ñ,¨[¸+ÔFäœ›Ó"Ð"ùò! 5s   Á(Ec                 ó¼  — t        j                  dt         j                  ¬«      }t        |«      f}t        j                  |«      }|j                  |«      }|j                  }t        j                  |«      }|j                  |«      }|j                  }	|dz  }
| j                  |
 ||«      «       | j                  |
 |	|«      «       t        t        «       «      S )Nr“   rb   rU   )rG   Úarangerf   r   rp   r€   r…   r†   r|   ÚassertPreciseEqualr   rz   )r‡   rˆ   rž   r‰   rŠ   rË   rÌ   r�   rÍ   rÎ   r§   s              r%   Ú_test_cube_functionz(TestArrayExpressions._test_cube_function×   s¶   € Ü�I‰I�b¤§
¡
Ô+ˆÜ˜!“9�,ˆä)×;Ñ;¸GÓDÐØ'×5Ñ5°bÓ9ˆØ×*Ñ*ˆä&×2Ñ2°7Ó;ˆØ!×/Ñ/°Ó3ˆ	Ø×'Ñ'ˆà˜‘6ˆØ×Ñ ©'°!«*Ô5Ø×Ñ ©'°!«*Ô5äœ›Ó"Ð"r&   c                 óH  ‡	‡
— t        j                  dt         j                  ¬«      Š	‰	dz   Š
t        ‰	«      fdz  }| j	                  ||«      \  }}}}ˆ	ˆ
fd„} ||«      }| j                  | ||«      «       | j                  | ||«      «       t        t        «       «      S )z
        Test function having a (a, b, out) signature where *out* is
        an output array the function writes into.
        r“   rb   r’   rU   c                 óF   •— t        j                  ‰«      } | ‰‰|«       |S r   )rG   Ú
zeros_like)rˆ   rZ   rž   rÉ   s     €€r%   Úrun_funczETestArrayExpressions._test_explicit_output_function.<locals>.run_funcõ   s!   ø€ Ü—-‘- Ó"ˆCÙˆq�!�SŒMØˆJr&   )rG   rÔ   rf   r   r�   rÕ   r   rz   )r‡   rˆ   r‰   rŠ   rŒ   r�   r�   rÚ   r§   rž   rÉ   s            @@r%   Ú_test_explicit_output_functionz3TestArrayExpressions._test_explicit_output_functioné   sš   ù€ ô
 �I‰I�b¤§
¡
Ô+ˆØ�‰EˆÜ˜!“9�, Ñ"ˆð ×"Ñ" 2 wÓ/ñ 	CÐ˜-¨¸
õ	ñ
 ˜B“<ˆØ×Ñ ©(°=Ó*AÔBØ×Ñ ©(°:Ó*>Ô?äœ›Ó"Ð"r&   c                 ón   — t        t        | j                  |«      «      «      }| j                  ||«       y)z`
        Assert the *block* has the expected number of array expressions
        in it.
        N)r›   Úlistr·   rš   )r‡   rµ   Úexpected_countÚrewrite_counts       r%   Ú_assert_array_exprsz(TestArrayExpressions._assert_array_exprs   s.   € ô
 œD ×!6Ñ!6°uÓ!=Ó>Ó?ˆØ×Ñ˜¨Õ7r&   c                 ó  — | j                  t        |«      t        |«      «       |d   j                  }|d   j                  }| j                  |d«       | j                  |d«       |s%| j	                  t        |«      t        |«      «       yy)zµ
        Given two dictionaries of Numba IR blocks, check to make sure the
        control IR has no array expressions, while the test IR
        contains one and only one.
        r   r’   N)rš   r›   r�   rà   rœ   )r‡   Ú
control_irÚtest_irÚtrivialÚcontrol_blockÚ
test_blocks         r%   Ú_assert_total_rewritez*TestArrayExpressions._assert_total_rewrite  s{   € ð 	×Ñœ˜Z›¬#¨g«,Ô7Ø" 1™×*Ñ*ˆØ˜Q‘Z—_‘_ˆ
Ø× Ñ  °Ô2Ø× Ñ  ¨QÔ/Ùð ×Ñœs =Ó1´3°z³?ÕCð	 r&   c                 óB  — | j                  t        |«      t        |«      «       |j                  «       D ]h  \  }}|j                  }||   j                  }| j                  t        |«      t        |«      «       | j	                  |d«       | j	                  |d«       Œj y)z–
        Given two dictionaries of Numba IR blocks, check to make sure
        the control IR and the test IR both have no array expressions.
        r   N)rš   r›   Úitemsr�   rà   )r‡   râ   rã   r#   Úvrå   ræ   s          r%   Ú_assert_no_rewritez'TestArrayExpressions._assert_no_rewrite  s‚   € ð
 	×Ñœ˜Z›¬#¨g«,Ô7à×$Ñ$Ö&‰DˆAˆqØŸF™FˆMØ  ™Ÿ™ˆJØ×ÑœS Ó/´°Z³ÔAØ×$Ñ$ ]°AÔ6Ø×$Ñ$ Z°Õ3ñ 'r&   c                 óì   — | j                  «       }| j                  |j                  j                  j                  j
                  |j                  j                  j                  j
                  d¬«       y)z�
        Ensure even a non-nested expression is rewritten, as it can enable
        scalar optimizations such as rewriting `x ** 2`.
        T)rä   N)rÖ   rç   rŠ   r—   r˜   r™   r�   ©r‡   Únss     r%   Útest_trivial_exprz&TestArrayExpressions.test_trivial_expr(  s]   € ð
 ×%Ñ%Ó'ˆØ×"Ñ" 2×#6Ñ#6×#<Ñ#<×#DÑ#D×#KÑ#KØ#%×#3Ñ#3×#9Ñ#9×#AÑ#A×#HÑ#HØ+/ð 	#õ 	1r&   c                 óè   — | j                  «       }| j                  |j                  j                  j                  j
                  |j                  j                  j                  j
                  «       y)z´
        Using the polynomial root function, ensure the full expression is
        being put in the same kernel with no remnants of intermediate
        array expressions.
        N)rÒ   rç   rŠ   r—   r˜   r™   r�   rí   s     r%   Útest_complicated_exprz*TestArrayExpressions.test_complicated_expr2  sV   € ð ×%Ñ%Ó'ˆØ×"Ñ" 2×#6Ñ#6×#<Ñ#<×#DÑ#D×#KÑ#KØ#%×#3Ñ#3×#9Ñ#9×#AÑ#A×#HÑ#Hõ	Jr&   c           
      ó\  ‡ — ‰ j                  |«      }|j                  j                  j                  j                  }|j
                  j                  j                  j                  }‰ j                  t        |«      t        |«      «       ‰ j                  t        |d   j                  «      t        |d   j                  «      «       ‰ j                  t        t        ‰ j                  |d   j                  «      «      «      d«       t        ‰ j                  |d   j                  «      «      }‰ j                  t        |«      d«       t        ˆ fd„|D «       «      }t        |dd |dd «      D ]9  \  }}|j                  |«      }	|	sŒ‰ j                  dj                  |	«      «       Œ; y)zp
        Attempt to verify that rewriting will incorporate user common
        subexpressions properly.
        r   r’   c              3   ón   •K  — | ],  }‰j                  |j                  j                  «      d    –— Œ. y­w)r’   N)r½   r²   r¿   )Ú.0r¶   r‡   s     €r%   Ú	<genexpr>zBTestArrayExpressions.test_common_subexpressions.<locals>.<genexpr>O  s3   øè ø€ ð :Ù'8˜eð ×1Ñ1°%·+±+×2BÑ2BÓCÀAÕFÙ'8ùs   ƒ25Néÿÿÿÿz9Common subexpressions detected in array expressions ({0}))rÒ   rŠ   r—   r˜   r™   r�   rš   r›   rœ   r�   rÝ   r·   ÚzipÚintersectionÚfailr¼   )
r‡   rˆ   rî   rª   r«   Úarray_expr_instrsÚ
array_setsÚ
expr_set_0Ú
expr_set_1Úintersectionss
   `         r%   Útest_common_subexpressionsz/TestArrayExpressions.test_common_subexpressions<  s_  ø€ ð
 ×%Ñ% bÓ)ˆØ×!Ñ!×'Ñ'×/Ñ/×6Ñ6ˆØ×Ñ×$Ñ$×,Ñ,×3Ñ3ˆØ×Ñœ˜S›¤3 s£8Ô,Ø×Ñœ3˜s 1™vŸ{™{Ó+¬S°°Q±·±Ó-=Ô>Ø×ÑœœT $×"7Ñ"7¸¸A¹¿¹Ó"DÓEÓFÈÔJô
 ! ×!6Ñ!6°s¸1±v·{±{Ó!CÓDÐØ×Ñœ3Ð0Ó1°1Ô5ô ó :Ù'8ó:ó :ˆ
ä&)¨*°S°b¨/¸:ÀaÀb¸>Ö&JÑ"ˆJ˜
Ø&×3Ñ3°JÓ?ˆMÚØ—	‘	ð .ß.4©f°]Ó.CõEñ 'Kr&   c                 ó,   — | j                  t        «      S r   )rÿ   rD   )r‡   s    r%   Útest_complex_subexpressionz/TestArrayExpressions.test_complex_subexpressionW  s   € Ø×.Ñ.Ô/GÓHÐHr&   c                 ó~  — t         j                  j                  d«      }t         j                  j                  d«      }||fD �cg c]  }t        |«      ‘Œ }}t        j                  j
                  }t        j                  ||j                  |j                  ¬«      }|j                  t        «      }|j                  }t        j                  ||j                  |j                  ¬«      }	|	j                  t        «      }
|
j                  }t        ||«      } |||«      } |||«      }t         j                  j                  ||«       t         j                  j                  ||«       | j!                  |j"                  j$                  j&                  |	j"                  j$                  j&                  «       yc c}w )zn
        Verify that ufunc and DUFunc calls are being properly included in
        array expressions.
        r“   )rt   ru   N)rG   rÇ   r   rI   Ú_dispatcherÚtargetdescrrp   r€   rt   ru   r…   rM   r†   r|   r•   rÈ   rç   r—   r˜   r™   )r‡   rž   rÉ   r¡   r‰   Ú
vaxy_descrrŠ   r‹   Únb_call_stuff_0r�   rŽ   Únb_call_stuff_1r§   r©   r¨   s                  r%   Útest_ufunc_and_dufunc_callsz0TestArrayExpressions.test_ufunc_and_dufunc_callsZ  sr  € ô
 �I‰I×Ñ˜RÓ ˆÜ�I‰I×Ñ˜RÓ ˆØ+,¨a©&Ó1©& 3”6˜#•;¨&ˆÐ1ä×%Ñ%×1Ñ1ˆ
Ü)×;Ñ;ØØ%×4Ñ4Ø%×4Ñ4ð <ó 6Ðð "×/Ñ/´
Ó;ˆØ ×,Ñ,ˆä&×2Ñ2ØØ%×4Ñ4Ø%×4Ñ4ð 3ó 6ˆð ×,Ñ,¬ZÓ8ˆØ ×,Ñ,ˆä˜a Ó#ˆÙ! ! QÓ'ˆÙ   AÓ&ˆÜ
�
‰
×,Ñ,¨X°wÔ?Ü
�
‰
×,Ñ,¨X°vÔ>à×"Ñ"Ð#3×#9Ñ#9×#AÑ#A×#HÑ#HØ#0×#6Ñ#6×#>Ñ#>×#EÑ#Eõ	Gùò/ 2s   ÁF:c                 óò   — | j                  t        «      }| j                  |j                  j                  j
                  j                  |j                  j                  j
                  j                  «       y)zQ
        Verify that comparison operators are supported by the rewriter.
        N)rÒ   rQ   rç   rŠ   r—   r˜   r™   r�   rí   s     r%   Útest_cmp_opz TestArrayExpressions.test_cmp_op{  sY   € ð ×%Ñ%Ô&9Ó:ˆØ×"Ñ" 2×#6Ñ#6×#<Ñ#<×#DÑ#D×#KÑ#KØ#%×#3Ñ#3×#9Ñ#9×#AÑ#A×#HÑ#Hõ	Jr&   c                 óò   — | j                  t        «      }| j                  |j                  j                  j
                  j                  |j                  j                  j
                  j                  «       y)zQ
        Check that ufunc calls with explicit outputs are not rewritten.
        N)rÛ   r[   rë   rŠ   r—   r˜   r™   r�   rí   s     r%   Útest_explicit_outputz)TestArrayExpressions.test_explicit_outputƒ  sX   € ð ×0Ñ0´ÓAˆØ×Ñ × 3Ñ 3× 9Ñ 9× AÑ A× HÑ HØ "× 0Ñ 0× 6Ñ 6× >Ñ >× EÑ Eõ	Gr&   r   )F)r'   r(   r)   r�   r­   r·   r½   r<   rÒ   rV   rÖ   rÛ   rà   rç   rë   rï   rñ   rB   rÿ   r  r  r
  r  r,   r&   r%   rƒ   rƒ   v   sq   „ òJò=ò@$ó#ð$ &.ó #ð0 &*ó #ò$#ò.8óDò$4ò1òJð -Dó Eò6IòGòBJóGr&   rƒ   c                   ó6   — e Zd Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	y)	ÚTestRewriteIssuesc                 óÜ   ‡— ddl m} dd l} |d¬«      d„ «       Š |d¬«      ˆfd„«       } |j                  d«      } ||«      \  }}| j	                  ||«       | j	                  ||«       y )Nr   )ÚjitT)Únopythonc                 ó   — | S r   r,   )Úarrs    r%   Úfooz.TestRewriteIssues.test_issue_1184.<locals>.foo’  s   € àˆJr&   c                 ó,   •—  ‰| «      } ‰| «      }||fS r   r,   )r  r]   r^   r  s      €r%   Úbarz.TestRewriteIssues.test_issue_1184.<locals>.bar–  s   ø€ á�C“ˆAÙ�C“ˆAØ�a�4ˆKr&   r“   )Únumbar  ÚnumpyrÔ   ÚassertIs)r‡   r  rG   r  r  Úout_cÚout_dr  s          @r%   Útest_issue_1184z!TestRewriteIssues.test_issue_1184Ž  ss   ø€ ÝÛá	�dÔ	ñ	ó 
ð	ñ 
�dÔ	ó	ó 
ð	ð
 ˆb�i‰i˜‹mˆÙ˜3“x‰ˆˆuØ�‰�e˜UÔ#Ø�‰�e˜SÕ!r&   c                 ó  — d}t         j                  j                  |dz  ¬«      j                  |df«      }t	        |«      } t        t        «      |«      }t         j                  j                  ||«       t        j                  «        y )Néd   rU   )Úsize)
rG   rÇ   ÚuniformÚreshapern   r   r•   rÈ   ÚgcÚcollect)r‡   Únr/   r§   r¨   s        r%   Útest_issue_1264z!TestRewriteIssues.test_issue_1264¡  si   € ØˆÜ�I‰I×Ñ 1 Q¡3ÐÓ'×/Ñ/°°1°Ó6ˆÜ" 1Ó%ˆØ&””oÓ& qÓ)ˆÜ
�
‰
×,Ñ,¨X°vÔ>ä
�
‰
�r&   c                 ó  — ddl m} |d„ «       }t        j                  j	                  d«      }t        j                  j	                  d«      }|j                  ||«      } |||«      }t        j                  j                  ||«       y)z*Test array expression with duplicated termr   )r   c                 ó<   — t        j                  |«      }||z   | z   S r   )rG   rJ   ©r.   rY   s     r%   r  z.TestRewriteIssues.test_issue_1372.<locals>.foo®  s   € ä—‘�q“	ˆAØ�q‘5˜1‘9Ðr&   r“   N)r  r   rG   rÇ   r   Úpy_funcr•   Úassert_allclose)r‡   r   r  r.   rY   ÚexpectÚgots          r%   Útest_issue_1372z!TestRewriteIssues.test_issue_1372ª  sp   € åà	ñ	ó 
ð	ô �I‰I×Ñ˜bÓ!ˆÜ�I‰I×Ñ˜bÓ!ˆØ—‘˜Q Ó"ˆÙ�!�Q‹iˆÜ
�
‰
×"Ñ" 3¨Õ/r&   c                 óÄ   — t         d„ «       }d}t        j                  dt        j                  ¬«      }|j	                  ||«      } |||«      }| j                  ||«       y)zP
        Typing of unary array expression (np.negate) can be incorrect.
        c                 ó   — || z
  |  z   S r   r,   r(  s     r%   r  z3TestRewriteIssues.test_unary_arrayexpr.<locals>.foo½  s   € à�q‘5˜A˜2‘:Ðr&   g      ø?r“   rb   N)r   rG   rÔ   Úint32r)  rÕ   )r‡   r  rY   r.   r+  r,  s         r%   Útest_unary_arrayexprz&TestRewriteIssues.test_unary_arrayexpr¹  s\   € ô 
ñ	ó 
ð	ð ˆÜ�I‰I�b¤§¡Ô)ˆà—‘˜Q Ó"ˆÙ�!�Q‹iˆØ×Ñ  VÕ,r&   c                 óÒ   — t         d„ «       }t        j                  g d¢«      }t        j                  g d¢«      }|j                  ||«      } |||«      }| j	                  ||«       y)zd
        Typing of bitwise boolean array expression can be incorrect
        (issue #1813).
        c                 ó   — | | z   S r   r,   r(  s     r%   r  z5TestRewriteIssues.test_bitwise_arrayexpr.<locals>.fooÍ  s   € à˜1˜"‘X�;Ðr&   )TTFF)FTFTN)r   rG   Úarrayr)  rÕ   )r‡   r  r.   rY   r+  r,  s         r%   Útest_bitwise_arrayexprz(TestRewriteIssues.test_bitwise_arrayexprÈ  sa   € ô
 
ñ	ó 
ð	ô �H‰HÒ/Ó0ˆÜ�H‰HÒ/Ó0ˆà—‘˜Q Ó"ˆÙ�!�Q‹iˆØ×Ñ  VÕ,r&   c                 ó  — t        t        «      }t        j                  ddd«      } |||||«       t	        «       }|j                  |«       |j                  «       }| j                  d|«       | j                  d|«       y)zo
        Type annotation of array expressions with disambiguated
        variable names (issue #1466).
        r   r’   r“   z
#   u.1 = z
#   u.2 = N)r   r`   rG   r”   r   Úinspect_typesÚgetvalueÚassertIn)r‡   Úcfuncr.   ÚbufÚress        r%   Útest_annotationsz"TestRewriteIssues.test_annotationsØ  sk   € ô
 Ô(Ó)ˆä�K‰K˜˜1˜bÓ!ˆÙˆa��A�qÔä‹jˆØ×Ñ˜CÔ Ø�l‰l‹nˆØ�‰�l CÔ(Ø�‰�l CÕ(r&   c                 óŽ   — t         d„ «       } |d«      }|j                  d«      }t        j                  j	                  ||«       y )Nc                 óz   — t        j                  | «      }t        d«      D ]  }||z  }|j                  «       }Œ |S )NrO   )rG   Úonesrg   Úcopy)r/   r  rÄ   Úvals       r%   Úfz;TestRewriteIssues.test_issue_5599_name_collision.<locals>.fê  s8   € ä—'‘'˜!“*ˆCä˜1–X�Ø˜S‘y�Ø—h‘h“j‘ð ð ˆJr&   é   )r   r)  rG   r•   r–   )r‡   rC  r,  r+  s       r%   Útest_issue_5599_name_collisionz0TestRewriteIssues.test_issue_5599_name_collisionè  s@   € ä	ñ	ó 
ð	ñ �‹dˆØ—‘˜1“ˆÜ
�
‰
×%Ñ% c¨6Õ2r&   N)
r'   r(   r)   r  r%  r-  r1  r5  r=  rE  r,   r&   r%   r  r  Œ  s%   „ ò"ò&ò0ò-ò-ò )ó 3r&   r  c                   ó   — e Zd Zd„ Zy)ÚTestSemanticsc                 ó(  — t         }t        |«      }t        j                  ddt	        d«      g«      }t        j                  g d¢«      }t        j
                  |«      } ||||«      } ||||«      }t        j                  j                  ||«       y )Nç        rF   Úinf)rI  rI  rF   )rS   r   rG   rf   ÚfloatÚ	ones_liker•   r–   )r‡   Úpyfuncr:  r.   rY   r]   r+  r,  s           r%   Útest_division_by_zeroz#TestSemantics.test_division_by_zeroú  st   € ô ˆÜ�V“ˆä�J‰J˜˜S¤%¨£,Ð/Ó0ˆÜ�J‰J’Ó'ˆÜ�L‰L˜‹Oˆá˜˜1˜a“ˆÙ�A�q˜!‹nˆÜ
�
‰
×%Ñ% f¨cÕ2r&   N)r'   r(   r)   rN  r,   r&   r%   rG  rG  ø  s   „ ó3r&   rG  c                   ó   — e Zd ZdZd„ Zd„ Zy)ÚTestOptionalsze Tests the arrival and correct lowering of Optional types at a arrayexpr
    derived ufunc, see #3972c                 ó°  ‡— t         d„ «       Št         ˆfd„«       }t        j                  d«      df} ||Ž } |j                  |Ž }t        j                  j                  ||«       ‰j                  }|d   d   }| j                  t        |t        j                  «      «       | j                  t        |j                  t        j                  «      «       y )Nc                 ó   — | |z   S r   r,   ©r/   r0   s     r%   Úarr_exprz9TestOptionals.test_optional_scalar_type.<locals>.arr_expr  ó   € à�q‘5ˆLr&   c                 ó*   •— |dkD  rd }n|} ‰| |«      S ©Nr   r,   ©r/   r0   ÚzrT  s      €r%   Údo_callz8TestOptionals.test_optional_scalar_type.<locals>.do_call  ó    ø€ à�1ŠuØ‘à�Ù˜A˜q“>Ð!r&   rD  g333333ó¿r   r’   )r   rG   rÔ   r)  r•   r*  Ú
signaturesÚ
assertTruer°   r   ÚOptionalÚtypeÚFloat©r‡   rZ  rw   r<  r§   r"   ÚotyrT  s          @r%   Útest_optional_scalar_typez'TestOptionals.test_optional_scalar_type  s¸   ø€ ä	ñ	ó 
ð	ô 
ó	"ó 
ð	"ô —	‘	˜!“˜dÐ#ˆñ �tˆnˆØ"�7—?‘? DÐ)ˆÜ
�
‰
×"Ñ" 3¨Ô1ð ×ÑˆØ�‰d�1‰gˆØ�‰œ
 3¬¯©Ó7Ô8Ø�‰œ
 3§8¡8¬U¯[©[Ó9Õ:r&   c                 óP  ‡— t         d„ «       Št         ˆfd„«       }t        j                  d«      t        j                  d«      f} ||Ž } |j                  |Ž }t        j                  j                  ||«       ‰j                  }|d   d   }| j                  t        |t        j                  «      «       | j                  t        |j                  t        j                  «      «       | j                  t        |j                  j                  t        j                  «      «       y )Nc                 ó   — | |z   S r   r,   rS  s     r%   rT  z8TestOptionals.test_optional_array_type.<locals>.arr_expr*  rU  r&   c                 ó0   •— |d   dkD  rd }n|} ‰| |«      S rW  r,   rX  s      €r%   rZ  z7TestOptionals.test_optional_array_type.<locals>.do_call.  ó$   ø€ à�‰t�aŠxØ‘à�Ù˜A˜q“>Ð!r&   rD  ç      @r   r’   )r   rG   rÔ   r)  r•   r*  r\  r]  r°   r   r^  r_  ÚArrayrc   r`  ra  s          @r%   Útest_optional_array_typez&TestOptionals.test_optional_array_type(  sß   ø€ ä	ñ	ó 
ð	ô 
ó	"ó 
ð	"ô —	‘	˜!“œbŸi™i¨›mÐ,ˆñ �tˆnˆØ"�7—?‘? DÐ)ˆÜ
�
‰
×"Ñ" 3¨Ô1ð ×ÑˆØ�‰d�1‰gˆØ�‰œ
 3¬¯©Ó7Ô8Ø�‰œ
 3§8¡8¬U¯[©[Ó9Ô:Ø�‰œ
 3§8¡8§>¡>´5·;±;Ó?Õ@r&   N)r'   r(   r)   Ú__doc__rc  rj  r,   r&   r%   rP  rP  	  s   „ ñ ò;ó6Ar&   rP  c                   ó   — e Zd Zd„ Zd„ Zy)ÚTestOptionalsExceptionsc                 ó  ‡— | j                  «        t        d„ «       Št        ˆfd„«       }t        j                  d«      df}| j	                  t
        «      5 } ||Ž  d d d «       | j                  dt        j                  «      «       ‰j                  }|d   d   }| j                  t        |t        j                  «      «       | j                  t        |j                  t        j                  «      «       y # 1 sw Y   ŒŸxY w)Nc                 ó   — | |z   S r   r,   rS  s     r%   rT  zUTestOptionalsExceptions.test_optional_scalar_type_exception_on_none.<locals>.arr_exprL  rU  r&   c                 ó*   •— |dkD  rd }n|} ‰| |«      S rW  r,   rX  s      €r%   rZ  zTTestOptionalsExceptions.test_optional_scalar_type_exception_on_none.<locals>.do_callP  r[  r&   rD  rF   zexpected float64, got Noner   r’   )Údisable_leak_checkr   rG   rÔ   ÚassertRaisesÚ	TypeErrorr9  ÚstrÚ	exceptionr\  r]  r°   r   r^  r_  r`  )r‡   rZ  rw   Úraisesr"   rb  rT  s         @r%   Ú+test_optional_scalar_type_exception_on_nonezCTestOptionalsExceptions.test_optional_scalar_type_exception_on_noneH  sØ   ø€ à×ÑÔ!ä	ñ	ó 
ð	ô 
ó	"ó 
ð	"ô —	‘	˜!“˜cÐ"ˆð ×ÑœyÔ)¨VÙ�T‰N÷ *ð 	�‰Ð2´C¸×8HÑ8HÓ4IÔJð ×ÑˆØ�‰d�1‰gˆØ�‰œ
 3¬¯©Ó7Ô8Ø�‰œ
 3§8¡8¬U¯[©[Ó9Õ:÷ *Ð)ús   ÁC<Ã<Dc                 óÚ  ‡— | j                  «        t        d„ «       Št        ˆfd„«       }t        j                  d«      t        j                  dd«      f}| j	                  t
        «      5 } ||Ž  d d d «       t        j                  «      }| j                  d|«       | j                  d|«       ‰j                  }|d   d	   }| j                  t        |t        j                  «      «       | j                  t        |j                  t        j                  «      «       | j                  t        |j                  j                   t        j"                  «      «       y # 1 sw Y   ŒðxY w)
Nc                 ó   — | |z   S r   r,   rS  s     r%   rT  zTTestOptionalsExceptions.test_optional_array_type_exception_on_none.<locals>.arr_exprj  rU  r&   c                 ó0   •— |d   dkD  rd }n|} ‰| |«      S rW  r,   rX  s      €r%   rZ  zSTestOptionalsExceptions.test_optional_array_type_exception_on_none.<locals>.do_calln  rg  r&   rD  rF   rh  zexpected array(float64,zgot Noner   r’   )rq  r   rG   rÔ   rr  rs  rt  ru  r9  r\  r]  r°   r   r^  r_  ri  rc   r`  )r‡   rZ  rw   rv  Úexcstrr"   rb  rT  s          @r%   Ú*test_optional_array_type_exception_on_nonezBTestOptionalsExceptions.test_optional_array_type_exception_on_nonef  s  ø€ à×ÑÔ!ä	ñ	ó 
ð	ô 
ó	"ó 
ð	"ô —	‘	˜!“œbŸi™i¨¨BÓ/Ð0ˆð ×ÑœyÔ)¨VÙ�T‰N÷ *ô �V×%Ñ%Ó&ˆØ�‰Ð/°Ô8Ø�‰�j &Ô)ð ×ÑˆØ�‰d�1‰gˆØ�‰œ
 3¬¯©Ó7Ô8Ø�‰œ
 3§8¡8¬U¯[©[Ó9Ô:Ø�‰œ
 3§8¡8§>¡>´5·;±;Ó?Õ@÷ *Ð)ús   Á,E!Å!E*N)r'   r(   r)   rw  r|  r,   r&   r%   rm  rm  E  s   „ ò;ó<Ar&   rm  c                   ó@   — e Zd ZdZ ej
                  d«      Zd„ Zd„ Zy)ÚTestExternalTypeszJ Tests RewriteArrayExprs with external (user defined) types,
    see #5157z¬
        from numba.core import types

        class FooType(types.Type):
            def __init__(self):
                super(FooType, self).__init__(name='Foo')
        c                 ó2  ‡—  G d„ dt         «      }t        ‰«       G d„ dt        j                  «      «       }t	        ‰dd«       t        |«      ˆfd„«       }t        |t        j                  «      d„ «       }t        j                  |«      ˆfd„«       }|‰fS )	Nc                   ó   — e Zd Zd„ Zy)ú,TestExternalTypes.make_foo_type.<locals>.Fooc                 ó   — || _         y r   )r²   )r‡   r²   s     r%   Ú__init__z5TestExternalTypes.make_foo_type.<locals>.Foo.__init__–  s	   € Ø"�•
r&   N©r'   r(   r)   rƒ  r,   r&   r%   ÚFoor�  •  s   „ ó#r&   r…  c                   ó   — e Zd Zd„ Zy)ú1TestExternalTypes.make_foo_type.<locals>.FooModelc                 ón   — dt         j                  fg}t        j                  j	                  | |||«       y )Nr²   )r   Úintpr   ÚStructModelrƒ  )r‡   ÚdmmÚfe_typeÚmemberss       r%   rƒ  z:TestExternalTypes.make_foo_type.<locals>.FooModel.__init__›  s-   € Ø#¤U§Z¡ZÐ0Ð1�Ü×"Ñ"×+Ñ+¨D°#°wÀÕHr&   Nr„  r,   r&   r%   ÚFooModelr‡  ™  s   „ óIr&   rŽ  r²   c                 ó   •— ˆfd„}|S )Nc                 ó   •—  ‰«       S r   r,   )r²   ÚFooTypes    €r%   Útyperz@TestExternalTypes.make_foo_type.<locals>.type_foo.<locals>.typer£  s   ø€ Ù“yÐ r&   r,   )Úcontextr’  r‘  s     €r%   Útype_fooz1TestExternalTypes.make_foo_type.<locals>.type_foo¡  s   ø€ ô!ð ˆLr&   c                 óˆ   — |j                   }|\  } t        j                  |«      | |«      }||_        |j	                  «       S r   )rx   r   Úcreate_struct_proxyr²   Ú	_getvalue)r“  ÚbuilderÚsigrw   Útypr²   r  s          r%   Úimpl_fooz1TestExternalTypes.make_foo_type.<locals>.impl_foo¨  s>   € à—/‘/ˆCØ‰GˆUØ2”'×-Ñ-¨cÓ2°7¸GÓDˆCØˆCŒIØ—=‘=“?Ð"r&   c                 ó   •—  ‰«       S r   r,   )rB  r]   r‘  s     €r%   Ú
typeof_fooz3TestExternalTypes.make_foo_type.<locals>.typeof_foo°  s   ø€ á“9Ðr&   )Úobjectr   r   rŠ  r   r   r   r   r‰  r   Úregister)r‡   r‘  r…  rŽ  r”  r›  r�  s    `     r%   Úmake_foo_typezTestExternalTypes.make_foo_type”  s§   ø€ ô	#”&ô 	#ô 
˜Ó	 ô	I”v×)Ñ)ó 	Ió 
!ð	Iô
 	˜w¨°Ô9ä	�sÓ	ó	ó 
ð	ô 
�sœEŸJ™JÓ	'ñ	#ó 
(ð	#ô 
×	Ñ	˜cÓ	"ó	ó 
#ð	ð �Gˆ|Ðr&   c                 ó  ‡‡— t        | j                  «      5 }| j                  |j                  «      \  ŠŠt	        t
        j                  «      ˆfd„«       }t	        t
        j                  «      ˆfd„«       }t	        t
        j                  «      ˆfd„«       }t        ˆfd„«       }t        ˆfd„«       }t        ˆfd„«       }t        j                  j                   |dd«      t        j                  ddg«      «       t        j                  j                   |d	d
«      t        j                  d	d
g«      «       t        j                  j                   |d«      t        j                  dg«      «       d d d «       y # 1 sw Y   y xY w)Nc                 ó^   •— t        | ‰«      r t        |t        j                  «      rd„ }|S y y )Nc                 óJ   — t        j                  | j                  |d   g«      S rW  ©rG   r4  r²   ©ÚlhsÚrhss     r%   ÚimpzKTestExternalTypes.test_external_type.<locals>.overload_foo_add.<locals>.imp¿  s   € Ü!Ÿx™x¨¯©°C¸±FÐ(;Ó<Ð<r&   )r°   r   ri  ©r¦  r§  r¨  r‘  s      €r%   Úoverload_foo_addz>TestExternalTypes.test_external_type.<locals>.overload_foo_add¼  s/   ø€ ä˜c 7Ô+´
¸3ÄÇÁÔ0Lò=ð �Jð	 1MÐ+r&   c                 óB   •— t        | ‰«      rt        |‰«      rd„ }|S y y )Nc                 óX   — t        j                  | j                  |j                  g«      S r   r¤  r¥  s     r%   r¨  zKTestExternalTypes.test_external_type.<locals>.overload_foo_add.<locals>.impÉ  s   € Ü!Ÿx™x¨¯©°C·I±IÐ(>Ó?Ð?r&   ©r°   r©  s      €r%   rª  z>TestExternalTypes.test_external_type.<locals>.overload_foo_addÆ  s,   ø€ ä˜c 7Ô+´
¸3ÀÔ0Hò@ð �Jð	 1IÐ+r&   c                 ó(   •— t        | ‰«      rd„ }|S y )Nc                 óD   — t        j                  | j                   g«      S r   r¤  )r/   s    r%   r¨  zKTestExternalTypes.test_external_type.<locals>.overload_foo_neg.<locals>.impÓ  s   € Ü!Ÿx™x¨!¯'©'¨¨
Ó3Ð3r&   r­  )r/   r¨  r‘  s     €r%   Úoverload_foo_negz>TestExternalTypes.test_external_type.<locals>.overload_foo_negÐ  s   ø€ ä˜a Ô)ò4ð �Jð	 *r&   c                 óB   •—  ‰| «      t        j                  |g«      z   S r   )rG   r4  ©r/   r0   r…  s     €r%   Úarr_expr_sum1z;TestExternalTypes.test_external_type.<locals>.arr_expr_sum1Ø  s   ø€ á˜1“v¤§¡¨!¨£Ñ-Ð-r&   c                 ó&   •—  ‰| «       ‰|«      z   S r   r,   r²  s     €r%   Úarr_expr_sum2z;TestExternalTypes.test_external_type.<locals>.arr_expr_sum2Ü  s   ø€ á˜1“v¡ A£‘Ð&r&   c                 ó   •—  ‰| «       S r   r,   )r/   r…  s    €r%   Úarr_expr_negz:TestExternalTypes.test_external_type.<locals>.arr_expr_negà  s   ø€ á˜A›�w�r&   r   r’   rO   rU   rP   éüÿÿÿ)r   Úsource_linesr   r‘  r   ÚoperatorrX   Únegr   rG   r•   r–   r4  )	r‡   Útest_modulerª  r°  r³  rµ  r·  r…  r‘  s	          @@r%   Útest_external_typez$TestExternalTypes.test_external_type¶  sA  ù€ Ü × 1Ñ 1Ô2°kØ×-Ñ-¨k×.AÑ.AÓB‰LˆC�ô ”h—l‘lÓ#óó $ðô ”h—l‘lÓ#óó $ðô ”h—l‘lÓ#óó $ðô ó.ó ð.ô ó'ó ð'ô óó ðô �J‰J×)Ñ)©-¸¸1Ó*=¼r¿x¹xÈÈAÈÓ?OÔPÜ�J‰J×)Ñ)©-¸¸1Ó*=¼r¿x¹xÈÈAÈÓ?OÔPÜ�J‰J×)Ñ)©,°q«/¼2¿8¹8ÀRÀD»>ÔJ÷_ 3×2Ñ2ús   ˜EE?Å?FN)	r'   r(   r)   rk  ÚtextwrapÚdedentr¹  r   r½  r,   r&   r%   r~  r~  ˆ  s*   „ ñð #�8—?‘?ð $ó €Lò óD0Kr&   r~  Ú__main__)>r"  Úior   r  rG   r  r   r   r   Ú
numba.corer   r   r	   r
   r   r   r   Únumba.core.compilerr   r   Únumba.core.registryr   Únumba.tests.supportr   r   r   r   Únumba.extendingr   r   r   r   r   r   r   rº  r¾  ÚunittestÚdictr   r1   r4   r<   rB   rD   rI   rM   rQ   rS   rV   r[   r`   rn   rp   rƒ   r  rG  rP  rm  r~  r'   Úmainr,   r&   r%   Ú<module>rÊ     sF  ðÛ 	Ý ã ç !Ý ß G× GÑ Gß /Ý *÷5ó 5÷÷ ñ ó Û ã ôF�ô FòòòFò.ò.ñ �ƒ~€ò1ò'òòòòò	ôQ�Xô Qô6SG˜?¨Hô SGôli3˜¨ô i3ôX3�O X×%6Ñ%6ô 3ô"9A�O X×%6Ñ%6ô 9Aôx@A˜o¨x×/@Ñ/@ô @AôF^K˜¨×):Ñ):ô ^KðB ˆzÒØ€H‡M�M…Oð r&   