
    J/Ph;^                     r   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%j                  Z8 G d  d!ee%j                  Z9 G d" d#ee%j                  Z: G d$ d%ee%j                  Z;e<d&k    r e%j=                     dS dS )'    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                 l    || v r| |         n't          t          |                               |          S N)superr   __getattr__)sk	__class__s     \/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/numba/tests/test_array_exprs.pyr"   zNamespace.__getattr__   s1    Avvqtt5A#6#6#B#B1#E#EE    )__name__
__module____qualname__r"   __classcell__)r%   s   @r&   r   r      sA        F F F F F F F F Fr'   r   c                     | |z  |z   S r     axys      r&   axyr2           q519r'   c                     | |z  |z   S r    r-   r.   s      r&   ax2r5   #   r3   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.    CR2X"r'B,/C78R"WEEr'   c                 D    d| z  }d|z  |z  }|dz  |z
  }| |dz  z
  |z  S )Nr7   r8   r-   r:   r;   r<   _2As_4AsCs
_Bs2_4AsCss         r&   neg_root_common_subexprrC   )   s=    7D$Y^F(V#JC:$%--r'   c                 J    d| z  }d|z  |z  }|dz  |z
  dz   }| |dz  z
  |z  S )Nr7   y                r8   r-   r?   s         r&   neg_root_complex_subexprrE   /   sB    7D$Y^F(V#r)JC:$%--r'   c                 r    t          j        t          | t          j        |          dz
  d                    S )N      ?)npcosvaxysin)a0a1s     r&   
call_stuffrN   7   s*    6$r26"::?B//000r'   c                 &    |dz  d| z  |z  z
  dk     S )N      r   r-   r9   s      r&   are_roots_imaginaryrR   :   s    !Ga"frk!Q&&r'   c                     | |z  |z   S r    r-   r9   s      r&   div_addrT   =   s    7R<r'   c                     | dz  S )N   r-   )r:   s    r&   cuberW   @   s    7Nr'   c                 X    t          j        | |           t          j        |||          S r    )rH   rI   add)r/   bouts      r&   explicit_outputr\   C   s%    F1cNNN6#q#r'   c                 0    | |z   }|| |z  z
  }||z  |z   }|S r    r-   )r/   rZ   cdus        r&   variable_name_reusera   G   s*    	AA	AE	A	A	AHr'   c                    | j         d         }t          j        ||ft          j                  }t	          |          D ]J}t	          ||          D ]7}t          j        | |         | |         z
  dz            dz  x|||f<   |||f<   8K|S )Nr   dtyperP   r8   )shaperH   emptyfloat64rangesum)vectors	n_vectorsresultijs        r&   distance_matrixro   O   s    a IXy),BJ???F9 7 7q)$$ 	7 	7A(*gaj(Q.)0 )036)7 7F1Q3K&1++	7 Mr'   c                   R    e Zd Zeddi dddfd            Zeddi dfd            ZdS )RewritesTesterNc           	          |st                      }d|_        |t          j        }|t          j        } | |||||||          S NT)r   nrtr   typing_contexttarget_context)clsargsreturn_typeflagslocalslibraryru   rv   s           r&   mk_pipelinezRewritesTester.mk_pipeline\   s[      	GGE	!'6N!'6Ns>>7D+&" " 	"r'   c                 T    |st                      }d|_         | j        |||||fi |S rs   )r   no_rewritesr}   )rw   rx   ry   rz   r{   r|   kwss          r&   mk_no_rw_pipelinez RewritesTester.mk_no_rw_pipelinei   s?      	GGE st[%PPCPPPr'   )r(   r)   r*   classmethodr}   r   r-   r'   r&   rq   rq   [   sp        +/tB d
" 
" 
" [
" 15T""&Q Q Q [Q Q Qr'   rq   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dS )TestArrayExpressionsc                     t                               |          }|                    |          }|j        }t                               |          }|                    |          }|j        }||||fS )zT
        Compile the given function both without and with rewrites enabled.
        )rq   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_functiont   sp     *;;GDD!//33*&227;;,,R00'
zIIr'   c                 j   t          j        ddd          }t          j        ddd          }t          j        ddd          }d |||fD             }|                     t          |          \  }}}}t                              |          }	|	                    t                    }
|
j        } ||||          } ||||          } ||||          }t           j	        
                    ||           t           j	        
                    ||           |j        j        j        }|j        j        j        }|	j        j        j        }|                     t          |          t          |                     |                     t          |          t          |                     |                     t          |d         j                  t          |d         j                             |                     t          |d         j                  t          |d         j                             dS )zv
        Using a simple array expression, verify that rewriting is taking
        place, and is fusing loops.
        r      
   rP   c                 ,    g | ]}t          |          S r-   r   .0args     r&   
<listcomp>z9TestArrayExpressions.test_simple_expr.<locals>.<listcomp>       44436#;;444r'   N)rH   linspacer   r2   rq   r   r   r5   r   testingassert_array_equalstatefunc_irblocksassertEquallenassertGreaterbody)r   AXYr   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!BK!BK!B441a)444 ""300 	<(M8 +<<WEE"0055#8Aq!$$!Q""&Aq//

%%h777

%%gv666$,3!)0%-4S3s88,,,S3s88,,,3s1v{++SQ-=-=>>>SV[))3s1v{+;+;<<<<<r'   c              #      K   |D ]O}t          |t          j                  r3t          |j        t          j                  r|j        j        dk    r|V  Pd S )N	arrayexpr)
isinstancer   AssignvalueExprop)r   blockinstrs      r&   _get_array_exprsz%TestArrayExpressions._get_array_exprs   sb       	$ 	$E%++ $ek2733 ${~44#		$ 	$r'   Nc                    |t                      }t          |t                    s"t          d                    |                    |\  }}g }|D ]E}t          |t                    r|                     ||          \  }}|                    |           F|t          |          f}|                    |           ||fS )zK
        Convert an array expression tree into a set of operators.
        Nz{0} not a tuple)setr   tuple
ValueErrorformat_array_expr_to_setappendrY   )	r   exprr[   	operationoperandsprocessed_operandsoperand_processed_exprs	            r&   r   z'TestArrayExpressions._array_expr_to_set   s     ;%%C$&& 	=.55d;;<<<"	8 	/ 	/G'5)) C!44WcBB
%%g...."E*<$=$==s""r'   c                    t           j                            d          }t           j                            d          dz   }t           j                            d          }d |||fD             }t                              |          }|                    |          }|j        }t                              |          }	|	                    |          }
|
j        } ||||          } ||||          } ||||          }t           j                            ||           t           j                            ||           t          t                                S )Nr   rG   c                 ,    g | ]}t          |          S r-   r   r   s     r&   r   z<TestArrayExpressions._test_root_function.<locals>.<listcomp>   r   r'   )rH   randomrq   r   r   r   r}   r   assert_array_almost_equalr   r{   )r   r   r   BCr   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   s7   IR  IR  2% IR  441a)444);;GDD'55b99*&227;;!//33	'Bq!QKK	gaA&&gaA&&

,,YDDD

,,[+FFF"""r'   c                    t          j        dt           j                  }t          |          f}t                              |          }|                    |          }|j        }t                              |          }|                    |          }|j        }	|dz  }
| 	                    |
 ||                     | 	                    |
 |	|                     t          t                                S )Nr   rc   rV   )rH   arangerg   r   rq   r   r   r   r}   assertPreciseEqualr   r{   )r   r   r   r   r   r   r   r   r   r   r   s              r&   _test_cube_functionz(TestArrayExpressions._test_cube_function   s    Ib
+++!99,);;GDD'55b99*&227;;!//33	'6''!**555''!**555"""r'   c                   	
 t          j        dt           j                  		dz   
t          	          fdz  }|                     ||          \  }}}}	
fd} ||          }|                     | ||                     |                     | ||                     t          t                                S )z
        Test function having a (a, b, out) signature where *out* is
        an output array the function writes into.
        r   rc   r   rV   c                 J    t          j                  } | |           |S r    )rH   
zeros_like)r   r[   r   r   s     r&   run_funczETestArrayExpressions._test_explicit_output_function.<locals>.run_func   s(    -""CBq!SMMMJr'   )rH   r   rg   r   r   r   r   r{   )r   r   r   r   r   r   r   r   r   r   r   s            @@r&   _test_explicit_output_functionz3TestArrayExpressions._test_explicit_output_function   s    
 Ib
+++E!99," ""2w// 	C-
	 	 	 	 	 	
 8B<<((=*A*ABBB((:*>*>???"""r'   c                     t          t          |                     |                              }|                     ||           dS )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   sC    
 D!6!6u!=!=>>??77777r'   Fc                 Z   |                      t          |          t          |                     |d         j        }|d         j        }|                     |d           |                     |d           |s2|                     t          |          t          |                     dS dS )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77"1*QZ_
  222  Q/// 	D s=113z??CCCCC		D 	Dr'   c                 z   |                      t          |          t          |                     |                                D ]u\  }}|j        }||         j        }|                      t          |          t          |                     |                     |d           |                     |d           vdS )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77$$&& 	4 	4DAqFM JS//ZAAA$$]A666$$Z3333	4 	4r'   c                     |                                  }|                     |j        j        j        j        |j        j        j        j        d           dS )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#<#D#K#%#3#9#A#H+/ 	# 	1 	1 	1 	1 	1r'   c                     |                                  }|                     |j        j        j        j        |j        j        j        j                   dS )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_expr.  sY     %%''""2#6#<#D#K#%#3#9#A#H	J 	J 	J 	J 	Jr'   c           
                                |          }|j        j        j        j        }|j        j        j        j        }                     t          |          t          |                                          t          |d         j	                  t          |d         j	                                                  t          t                               |d         j	                                      d           t                               |d         j	                            }                     t          |          d           t           fd|D                       }t          |dd         |dd                   D ]D\  }}|                    |          }	|	r(                     d                    |	                     EdS )zp
        Attempt to verify that rewriting will incorporate user common
        subexpressions properly.
        r   r   c              3   b   K   | ])}                     |j        j                  d          V  *dS )r   N)r   r   r   )r   r   r   s     r&   	<genexpr>zBTestArrayExpressions.test_common_subexpressions.<locals>.<genexpr>K  sO       : :# 11%+2BCCAF : : : : : :r'   Nz9Common 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_subexpressions8  s   
 %%b))!'/6$,3S3s88,,,3s1v{++SQ-=-=>>>T$"7"7A"D"DEEFFJJJ
 !!6!6s1v{!C!CDD30111555  : : : :'8: : : : :
&)*SbS/:abb>&J&J 	E 	E"J
&33J??M E		 ..4f].C.CE E E	E 	Er'   c                 6    |                      t                    S r    )r  rE   )r   s    r&   test_complex_subexpressionz/TestArrayExpressions.test_complex_subexpressionS  s    ../GHHHr'   c                    t           j                            d          }t           j                            d          }d ||fD             }t          j        j        }t
                              ||j        |j                  }|	                    t                    }|j        }t
                              ||j        |j                  }|	                    t                    }	|	j        }
t          ||          } |||          } |
||          }t           j                            ||           t           j                            ||           |                     |j        j        j        |j        j        j                   dS )zn
        Verify that ufunc and DUFunc calls are being properly included in
        array expressions.
        r   c                 ,    g | ]}t          |          S r-   r   r   s     r&   r   zDTestArrayExpressions.test_ufunc_and_dufunc_calls.<locals>.<listcomp>]  s    11136#;;111r'   )ru   rv   N)rH   r   rJ   _dispatchertargetdescrrq   r   ru   rv   r   rN   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_callsV  s}   
 IR  IR  111a&111%1
);;%4%4 < 6 6 "//
;; ,&22%4%4 3 6 6 ,,Z88 ,a##!/!Q'' A&&

,,Xw???

,,Xv>>>""#3#9#A#H#0#6#>#E	G 	G 	G 	G 	Gr'   c                     |                      t                    }|                     |j        j        j        j        |j        j        j        j                   dS )zQ
        Verify that comparison operators are supported by the rewriter.
        N)r   rR   r   r   r   r   r   r   r   s     r&   test_cmp_opz TestArrayExpressions.test_cmp_opw  s\     %%&9::""2#6#<#D#K#%#3#9#A#H	J 	J 	J 	J 	Jr'   c                     |                      t                    }|                     |j        j        j        j        |j        j        j        j                   dS )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  s[     00AA 3 9 A H " 0 6 > E	G 	G 	G 	G 	Gr'   r    )F)r(   r)   r*   r   r   r   r   r=   r   rW   r   r   r   r   r   r   r   rC   r  r  r  r  r  r-   r'   r&   r   r   r   sZ       J J J= = =@$ $ $# # # #$ &. # # # #0 &* # # # #$# # #.8 8 8D D D D$4 4 41 1 1J J J -D E E E E6I I IG G GBJ J JG G G G Gr'   r   c                   8    e Zd Zd Zd Zd Zd Zd Zd Zd Z	dS )	TestRewriteIssuesc                    ddl m} dd l} |d          d              |d          fd            } |j        d          } ||          \  }}|                     ||           |                     ||           d S )Nr   )jitT)nopythonc                     | S r    r-   )arrs    r&   fooz.TestRewriteIssues.test_issue_1184.<locals>.foo  s    Jr'   c                 8     |           } |           }||fS r    r-   )r  r^   r_   r  s      r&   barz.TestRewriteIssues.test_issue_1184.<locals>.bar  s&    CACAa4Kr'   r   )numbar  numpyr   assertIs)r   r  rH   r  r  out_cout_dr  s          @r&   test_issue_1184z!TestRewriteIssues.test_issue_1184  s    	d				 	 
		 
d				 	 	 	 
		
 bimms3xxueU###eS!!!!!r'   c                 8   d}t           j                            |dz                                |df          }t	          |          } t          t                    |          }t           j                            ||           t          j	                     d S )Nd   rV   )size)
rH   r   uniformreshapero   r   r   r   gccollect)r   nr0   r   r   s        r&   test_issue_1264z!TestRewriteIssues.test_issue_1264  s    I1Q3''//166"1%%&o&&q))

,,Xv>>>

r'   c                 (   ddl m} |d             }t          j                            d          }t          j                            d          }|                    ||          } |||          }t          j                            ||           dS )z*Test array expression with duplicated termr   )r   c                 :    t          j        |          }||z   | z   S r    )rH   rK   r/   rZ   s     r&   r  z.TestRewriteIssues.test_issue_1372.<locals>.foo  s    q		Aq519r'   r   N)r  r   rH   r   r'  py_funcr   assert_allclose)r   r   r  r/   rZ   expectgots          r&   test_issue_1372z!TestRewriteIssues.test_issue_1372  s    		 	 
	 Ib!!Ib!!Q""c!Qii

""3/////r'   c                     t           d             }d}t          j        dt          j                  }|                    ||          } |||          }|                     ||           dS )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    q5A2:r'   g      ?r   rc   N)r   rH   r   int32r0  r   )r   r  rZ   r/   r2  r3  s         r&   test_unary_arrayexprz&TestRewriteIssues.test_unary_arrayexpr  sx     
	 	 
	 Ib)))Q""c!QiiV,,,,,r'   c                     t           d             }t          j        g d          }t          j        g d          }|                    ||          } |||          }|                     ||           dS )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   rH   arrayr0  r   )r   r  r/   rZ   r2  r3  s         r&   test_bitwise_arrayexprz(TestRewriteIssues.test_bitwise_arrayexpr  s    
 
	 	 
	 H///00H///00Q""c!QiiV,,,,,r'   c                 <   t          t                    }t          j        ddd          } |||||           t	                      }|                    |           |                                }|                     d|           |                     d|           dS )zo
        Type annotation of array expressions with disambiguated
        variable names (issue #1466).
        r   r   r   z
#   u.1 = z
#   u.2 = N)r   ra   rH   r   r   inspect_typesgetvalueassertIn)r   cfuncr/   bufress        r&   test_annotationsz"TestRewriteIssues.test_annotations  s    
 ())K1b!!aAqjjC   llnnlC(((lC(((((r'   c                     t           d             } |d          }|                    d          }t          j                            ||           d S )Nc                     t          j        |           }t          d          D ]}||z  }|                                }|S )NrP   )rH   onesrh   copy)r0   r  r   vals       r&   fz;TestRewriteIssues.test_issue_5599_name_collision.<locals>.f  sA    '!**C1XX ! !SyhhjjJr'      )r   r0  rH   r   r   )r   rJ  r3  r2  s       r&   test_issue_5599_name_collisionz0TestRewriteIssues.test_issue_5599_name_collision  sW    		 	 
	 add1

%%c622222r'   N)
r(   r)   r*   r#  r,  r4  r8  r<  rD  rL  r-   r'   r&   r  r    s}        " " "&  0 0 0- - -- - - ) ) ) 3 3 3 3 3r'   r  c                       e Zd Zd ZdS )TestSemanticsc                 B   t           }t          |          }t          j        ddt	          d          g          }t          j        g d          }t          j        |          } ||||          } ||||          }t          j                            ||           d S )N        rG   inf)rP  rP  rG   )rT   r   rH   rg   float	ones_liker   r   )r   pyfuncrA  r/   rZ   r^   r2  r3  s           r&   test_division_by_zeroz#TestSemantics.test_division_by_zero  s     VJS%,,/00J''LOO1aeAq!nn

%%fc22222r'   N)r(   r)   r*   rU  r-   r'   r&   rN  rN    s#        3 3 3 3 3r'   rN  c                       e Zd ZdZd Zd ZdS )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        }|d         d         }|                     t          |t          j
                             |                     t          |j        t          j                             d S )Nc                     | |z   S r    r-   r0   r1   s     r&   arr_exprz9TestOptionals.test_optional_scalar_type.<locals>.arr_expr      q5Lr'   c                 2    |dk    rd }n|} | |          S Nr   r-   r0   r1   zr[  s      r&   do_callz8TestOptionals.test_optional_scalar_type.<locals>.do_call  (    1uu8Aq>>!r'   rK  g333333r   r   )r   rH   r   r0  r   r1  
signatures
assertTruer   r	   OptionaltypeFloatr   ra  rx   rC  r   r#   otyr[  s          @r&   test_optional_scalar_typez'TestOptionals.test_optional_scalar_type	  s    		 	 
	 
	" 	" 	" 	" 
	" 	!d# gtn"7?D)

""3111 d1g
377888
38U[99:::::r'   c                 P   t           d             t           fd            }t          j        d          t          j        d          f} || } |j        | }t          j                            ||           j        }|d         d         }|                     t          |t          j
                             |                     t          |j        t          j                             |                     t          |j        j        t          j                             d S )Nc                     | |z   S r    r-   rZ  s     r&   r[  z8TestOptionals.test_optional_array_type.<locals>.arr_expr&  r\  r'   c                 >    |d         dk    rd }n|} | |          S r^  r-   r_  s      r&   ra  z7TestOptionals.test_optional_array_type.<locals>.do_call*  ,    taxx8Aq>>!r'   rK        @r   r   )r   rH   r   r0  r   r1  rc  rd  r   r	   re  rf  Arrayrd   rg  rh  s          @r&   test_optional_array_typez&TestOptionals.test_optional_array_type$  s   		 	 
	 
	" 	" 	" 	" 
	" 	!bimm, gtn"7?D)

""3111 d1g
377888
38U[99:::
38>5;??@@@@@r'   N)r(   r)   r*   __doc__rj  rq  r-   r'   r&   rW  rW    sA           ; ; ;6A A A A Ar'   rW  c                       e Zd Zd Zd ZdS )TestOptionalsExceptionsc                 F   |                                   t          d             t          fd            }t          j        d          df}|                     t
                    5 } ||  d d d            n# 1 swxY w Y   |                     dt          |j                             j	        }|d         d         }| 
                    t          |t          j                             | 
                    t          |j        t          j                             d S )Nc                     | |z   S r    r-   rZ  s     r&   r[  zUTestOptionalsExceptions.test_optional_scalar_type_exception_on_none.<locals>.arr_exprH  r\  r'   c                 2    |dk    rd }n|} | |          S r^  r-   r_  s      r&   ra  zTTestOptionalsExceptions.test_optional_scalar_type_exception_on_none.<locals>.do_callL  rb  r'   rK  rG   zexpected float64, got Noner   r   )disable_leak_checkr   rH   r   assertRaises	TypeErrorr@  str	exceptionrc  rd  r   r	   re  rf  rg  )r   ra  rx   raisesr#   ri  r[  s         @r&   +test_optional_scalar_type_exception_on_nonezCTestOptionalsExceptions.test_optional_scalar_type_exception_on_noneD  sW   !!!		 	 
	 
	" 	" 	" 	" 
	" 	!c" y)) 	VGTNN	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	2C8H4I4IJJJ d1g
377888
38U[99:::::s   (A::A>A>c                 
   |                                   t          d             t          fd            }t          j        d          t          j        dd          f}|                     t
                    5 } ||  d d d            n# 1 swxY w Y   t          |j                  }|                     d|           |                     d|           j	        }|d         d	         }| 
                    t          |t          j                             | 
                    t          |j        t          j                             | 
                    t          |j        j        t          j                             d S )
Nc                     | |z   S r    r-   rZ  s     r&   r[  zTTestOptionalsExceptions.test_optional_array_type_exception_on_none.<locals>.arr_exprf  r\  r'   c                 >    |d         dk    rd }n|} | |          S r^  r-   r_  s      r&   ra  zSTestOptionalsExceptions.test_optional_array_type_exception_on_none.<locals>.do_callj  rn  r'   rK  rG   ro  zexpected array(float64,zgot Noner   r   )rx  r   rH   r   ry  rz  r{  r|  r@  rc  rd  r   r	   re  rf  rp  rd   rg  )r   ra  rx   r}  excstrr#   ri  r[  s          @r&   *test_optional_array_type_exception_on_nonezBTestOptionalsExceptions.test_optional_array_type_exception_on_noneb  s   !!!		 	 
	 
	" 	" 	" 	" 
	" 	!biB//0 y)) 	VGTNN	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 V%&&/888j&))) d1g
377888
38U[99:::
38>5;??@@@@@s   ;BBBN)r(   r)   r*   r~  r  r-   r'   r&   rt  rt  A  s7        ; ; ;<A A A A Ar'   rt  c                   >    e Zd ZdZ ej        d          Zd Zd ZdS )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                 f    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dS ),TestExternalTypes.make_foo_type.<locals>.Fooc                     || _         d S 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dS )1TestExternalTypes.make_foo_type.<locals>.FooModelc                 h    dt           j        fg}t          j                            | |||           d S )Nr   )r	   intpr   StructModelr  )r   dmmfe_typememberss       r&   r  z:TestExternalTypes.make_foo_type.<locals>.FooModel.__init__  s4    #UZ01"++D#wHHHHHr'   Nr  r-   r'   r&   FooModelr    s(        I I I I 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    wyy r'   r-   )contextr  r  s     r&   type_fooz1TestExternalTypes.make_foo_type.<locals>.type_foo  s#    ! ! ! ! ! Lr'   c                     |j         }|\  } t          j        |          | |          }||_        |                                S r    )ry   r   create_struct_proxyr   	_getvalue)r  buildersigrx   typr   r  s          r&   impl_fooz1TestExternalTypes.make_foo_type.<locals>.impl_foo  sA    /CGU2'-c227GDDCCI==??"r'   c                                  S r    r-   )rI  r^   r  s     r&   
typeof_fooz3TestExternalTypes.make_foo_type.<locals>.typeof_foo  s    799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 	I 	I 	I 	Iv) 	I 	I 
!	 	I
 	w999	s			 	 	 	 
		 
sEJ	'	'	# 	# 
(	'	# 
	c	"	"	 	 	 	 
#	"	 G|r'   c                 R   t          | j                  5 }|                     |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
                             |dd          t          j        ddg                     t          j
                             |d	d
          t          j        d	d
g                     t          j
                             |d          t          j        dg                     d d d            d S # 1 swxY w Y   d S )Nc                 j    t          |           rt          |t          j                  rd }|S d S d S )Nc                 D    t          j        | j        |d         g          S r^  rH   r;  r   lhsrhss     r&   impzKTestExternalTypes.test_external_type.<locals>.overload_foo_add.<locals>.imp  s    !xCF(;<<<r'   )r   r	   rp  r  r  r  r  s      r&   overload_foo_addz>TestExternalTypes.test_external_type.<locals>.overload_foo_add  sR    c7++ 
30L0L = = = J	   r'   c                 V    t          |           rt          |          rd }|S d S d S )Nc                 B    t          j        | j        |j        g          S r    r  r  s     r&   r  zKTestExternalTypes.test_external_type.<locals>.overload_foo_add.<locals>.imp  s    !xCI(>???r'   r   r  s      r&   r  z>TestExternalTypes.test_external_type.<locals>.overload_foo_add  sS    c7++ 
30H0H @ @ @ J	   r'   c                 2    t          |           rd }|S d S )Nc                 8    t          j        | j         g          S r    r  )r0   s    r&   r  zKTestExternalTypes.test_external_type.<locals>.overload_foo_neg.<locals>.imp  s    !x!'
333r'   r  )r0   r  r  s     r&   overload_foo_negz>TestExternalTypes.test_external_type.<locals>.overload_foo_neg  s5    a)) 4 4 4 J	 r'   c                 F     |           t          j        |g          z   S r    )rH   r;  r0   r1   r  s     r&   arr_expr_sum1z;TestExternalTypes.test_external_type.<locals>.arr_expr_sum1  s     s1vv!--r'   c                 2     |            |          z   S r    r-   r  s     r&   arr_expr_sum2z;TestExternalTypes.test_external_type.<locals>.arr_expr_sum2  s    s1vvA&r'   c                      |            S r    r-   )r0   r  s    r&   arr_expr_negz:TestExternalTypes.test_external_type.<locals>.arr_expr_neg  s    Awr'   r   r   rP   rV   rQ   )r   source_linesr  r  r   operatorrY   negr   rH   r   r   r;  )	r   test_moduler  r  r  r  r  r  r  s	          @@r&   test_external_typez$TestExternalTypes.test_external_type  s3    122 /	Kk--k.ABBLC hl##    $# hl##    $# hl##    $# . . . . T. ' ' ' ' T'     T J))--1*=*=rxA?O?OPPPJ))--1*=*=rxA?O?OPPPJ)),,q//28RD>>JJJ_/	K /	K /	K /	K /	K /	K /	K /	K /	K /	K /	K /	K /	K /	K /	K /	K /	K /	Ks   E8FF #F N)	r(   r)   r*   rr  textwrapdedentr  r  r  r-   r'   r&   r  r    s\          #8? $  L     D0K 0K 0K 0K 0Kr'   r  __main__)>r)  ior   r  rH   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   r2   r5   r=   rC   rE   rJ   rN   rR   rT   rW   r\   ra   ro   rq   r   r  rN  rW  rt  r  r(   mainr-   r'   r&   <module>r     s   				           ! ! ! ! ! ! ! !       G G G G G G G G G G G G G G G G G G / / / / / / / / * * * * * *5 5 5 5 5 5 5 5 5 5 5 5                    F F F F F F F F    F F F. . .. . . y~~1 1 1' ' '        	 	 	Q Q Q Q QX Q Q Q.SG SG SG SG SG?H SG SG SGli3 i3 i3 i3 i3 i3 i3 i3X3 3 3 3 3OX%6 3 3 3"9A 9A 9A 9A 9AOX%6 9A 9A 9Ax@A @A @A @A @Aox/@ @A @A @AF^K ^K ^K ^K ^K): ^K ^K ^KB zHMOOOOO r'   