U ,d@sddlZddlZddlZddlZddlZddlZddlm Z ddl m Z ddl Z ddl m Z mZddlmZddlmZmZddlmZmZddlmZdd lmZmZmZdd lmZmZmZddl Z eZ!ed d Z"ed dddZ#eddddZ$eddZ%eddZ&eddZ'eddddZ(edddd Z)e d!d"Z*eshe d#d$d%d&Z+e ,ed'kd(Gd)d*d*e j-Z.Gd+d,d,e.Z/Gd-d.d.Z0d5d0d1Z1e!Gd2d3d3e.Z2e3d4kre 4dS)6N)contextmanager)deepcopy)njitstencil) PYVERSION)typesregistry) compile_extraFlags)ParallelOptions)tagskip_parfors_unsupported_32bit) LoweringError TypingErrorNumbaValueErrorcCs$d|d|d|d|dSN?rrrrrrarr=/tmp/pip-unpacked-wheel-eu7e0c37/numba/tests/test_stencils.pystencil1_kernelsr)r neighborhoodcCs,|d}tddD]}|||7}qd|S)Nr r333333?range)rcumirrrstencil2_kernel#sr)?cvalcCs d|dS)Nrrrrrrstencil3_kernel+sr0cCsDd|d|d|d|d|d|d|d|dSrrrbrrrstencil_multiple_input_kernel0s r3cCsD||d|d|d|d|d|d|d|dSNrrrrr)rr2wrrr!stencil_multiple_input_kernel_var6s r6cCs|dr|dS|dSNrrr)rr2frrr%stencil_multiple_input_mixed_types_2d<sr:)r2)standard_indexingcCs |d|d|d|dS)Nrrrrr1rrr!stencil_with_standard_indexing_1dAsr<cCs@|d|d|d|d|d|d|d|dSr4rr1rrr!stencil_with_standard_indexing_2dFs r=cCs|dSNrrrrrr addone_njitLsr?TparallelcCs|dSr>rrrrr addone_pjitRsrB)z Run under 3.7 only, AST unstablecsHeZdZdZfddZddZddZdd Zd d Zd d Z Z S)TestStencilBaseFcs$t|_d|j_tt|j|dSNT)r cflagsnrtsuperrE__init__)selfargs __class__rrrJ\szTestStencilBase.__init__cCsttjjtjj||d|iSN)r rZ cpu_targetZtyping_contextZtarget_context)rKfuncsigflagsrrr _compile_thiscszTestStencilBase._compile_thiscKs0t}d|_|sdn|}t||_||||SrF)r rHr Z auto_parallelrS)rKrPrQkwsrRoptionsrrrcompile_parallelhs   z TestStencilBase.compile_parallelcCs|j|||jdS)N)rR)rSrG)rKrPrQrrr compile_njitoszTestStencilBase.compile_njitcOs2tdd|D}|||}|||}||fS)NcSsg|]}t|qSrnumbaZtypeof.0xrrr ssz/TestStencilBase.compile_all..)tuplerVrW)rKpyfuncrLkwargsrQcpfunccfuncrrr compile_allrs  zTestStencilBase.compile_allc Gs|j|f|\}}||}||}|j|}|j|} tjj||ddtjj||ddtjj| |dd|d|jdS)NrCdecimal@do_scheduling)rc entry_pointnptestingassert_almost_equalassertInlibrary get_llvm_str) rKZno_stencil_funcr_rLrbraexpectedZ py_output njit_output parfor_outputrrrcheckzs  zTestStencilBase.check) __name__ __module__ __qualname__Z_numba_parallel_test_rJrSrVrWrcrq __classcell__rrrMrrEWs rEcseZdZfddZeddZeddZeddZed d Zed d Z ed dZ eddZ eddZ eddZ eddZeddZeddZeddZeddZZS) TestStencilcstt|j||dSrO)rIrvrJrKrLr`rMrrrJszTestStencil.__init__cCs<dd}dd}dd}d}||||||||dS) zHTests whether the optional out argument to stencil calls works. cSs@t|d||f}t|d||f}t||d}|S)Nr/out)rharangereshapezerosrnABrrr test_with_outs z0TestStencil.test_stencil1..test_with_outcSs$t|d||f}t|}|SNr/)rhrzr{rr}rrrtest_without_outsz3TestStencil.test_stencil1..test_without_outcSst|d||f}t|d||f}td|dD]d}td|dD]P}d|||df||d|f|||df||d|f|||f<qPq>|SNr/rrrhrzr{r|r&r~rrr(jrrr test_impl_seqsz0TestStencil.test_stencil1..test_impl_seqdNrq)rKrrrr~rrr test_stencil1s  zTestStencil.test_stencil1c Cs8dd}dd}d}||||dd}dd}d}d}||tjtjf}|||}|||}tjj||d d |d |j d d}d }||tjtjtjf}||||}tjj||d d |d |j dd}d }||tjtjtjf}||||}tjj||d d |d |j dS)z`Tests whether the optional neighborhood argument to the stencil decorate works. cSst|}t|}|SrO)rhrzr)r}rrrtest_seqs z+TestStencil.test_stencil2..test_seqcSsLt|}t|}tdt|D]$}dt||d|d||<q"|S)Nr$rrhrzr|r&lensumr~rrr(rrrrs   "z0TestStencil.test_stencil2..test_impl_seqrcSs2t|}dd}tj|| |ffd||}|S)NcSs8|| }t| d|dD]}|||7}qd|SNrr$r%rr5r'r(rrrr)s DTestStencil.test_stencil2..test_seq..stencil2_kernelr!rhrzrYr)r~r5rr)rrrrrs cSsTt|}t|}t|t||D](}dt|||||d||<q&|S)Nr$rr)r~r5rrr(rrrrs   &rrCrdrfcSs8t|}dd}tj|| |ff| fd||}|S)NcSs@|| d}t| d|dD]}|||d7}q"d|Srr%rrrrr)srr"Z index_offsetsrr~r5offsetrr)rrrrrs rcSs8t|}dd}tj|| |ff| fd||}|S)NcSs dt|| d|dS)Nr$rr/)rhr)rr5rrrr)srrrrrrrrs N) rqrVrintprgrhrirjrkrlrm) rKrrr~r5rarnrprrrr test_stencil2s:     zTestStencil.test_stencil2cCsdd}t|}t|dd}d}||}||}||}||ddkoR|ddk||ddkop|ddk||ddko|ddkd S) zTests whether a non-zero optional cval argument to the stencil decorator works. Also tests integer result type. cSs$t|d||f}t|}|Sr)rhrzr{r0r}rrrr sz+TestStencil.test_stencil3..test_seqTr@rr8r*)rN)r assertTrue)rKrZ test_njitZtest_parr~Zseq_resZnjit_resZpar_resrrr test_stencil3s zTestStencil.test_stencil3cCs&dd}dd}d}||||dS)z1Tests standard indexing with a 1d array. cSs t|}ddg}t||}|S)N@@)rhrzr<r~rrCrrrrs  z?TestStencil.test_stencil_standard_indexing_1d..test_seqcSsXt|}ddg}t|}td|D],}||d|d|||d||<q&|S)Nrrrrrhrzr|r&)r~rrrr(rrrr%s   *zDTestStencil.test_stencil_standard_indexing_1d..test_impl_seqrNrrKrrr~rrr!test_stencil_standard_indexing_1ds z-TestStencil.test_stencil_standard_indexing_1dcCs&dd}dd}d}||||dS)zLTests standard indexing with a 2d array and multiple stencil calls. cSs:t|d||f}td}t||}t||}|S)Nr/rCrC)rhrzr{onesr=)r~rrrDrrrr5s    z?TestStencil.test_stencil_standard_indexing_2d..test_seqcSsxt|d||f}td}t|d||f}t|d||f}td|dD]}td|dD]l}|||df|d||d|f|d|||df|d||d|f|d|||f<qrq`td|dD]}td|dD]n}|||df|d||d|f|d|||df|d||d|f|d|||f<qq|S)Nr/rrrrrr)rhrzr{rr|r&)r~rrrrr(rrrrr<s& ..zDTestStencil.test_stencil_standard_indexing_2d..test_impl_seqrNrrrrr!test_stencil_standard_indexing_2d1sz-TestStencil.test_stencil_standard_indexing_2dcCs<dd}dd}d}||||dd}||||dS)z=Tests whether multiple inputs of the same size work. cSs>t|d||f}t|d||f}t||}|Sr)rhrzr{r3rrrrrSs z:TestStencil.test_stencil_multiple_inputs..test_seqcSst|d||f}t|d||f}t|d||f}td|dD]}td|dD]}d|||df||d|f|||df||d|f|||df||d|f|||df||d|f|||f<qhqV|Srr)r~rrrr(rrrrrYs*z?TestStencil.test_stencil_multiple_inputs..test_impl_seqrCcSsDt|d||f}t|d||f}d}t|||}|S)Nr/r)rhrzr{r6)r~rrr5rrrrrjs  Nrrrrrtest_stencil_multiple_inputsOs  z(TestStencil.test_stencil_multiple_inputscCs&dd}dd}d}||||dS)NcSst|d||f}|dt|d||f}tj|tjd}tj||f|jd}td|D]@}td|D]0}|||fr|||fn |||f|||f<qtqf|S)Nr/dtyper)rhrzr{eyebool_r|rr&)r~rrSOr(rrrrrts 0z;TestStencil.test_stencil_mixed_types..test_impl_seqcSsXt|d||f}|dt|d||f}tj|tjd}t|||}|S)Nr/r)rhrzr{rrr:)r~rrrrrrrr~s   z6TestStencil.test_stencil_mixed_types..test_seqrCr)rKrrr~rrrtest_stencil_mixed_typesrs z$TestStencil.test_stencil_mixed_typescCs<dd}dd}dd}d}||||||||dS) z&Tests 2D numba.stencil calls. cSsJt|d||f}t|d||f}tdd||d|S)Nr/cSs$d|d|d|d|dSrrrrrrszCTestStencil.test_stencil_call..test_impl1..rxrhrzr{r|rYrr}rrr test_impl1s z1TestStencil.test_stencil_call..test_impl1cSsJt|d||f}t|d||f}dd}t||}|S)Nr/cSs$d|d|d|d|dSrrrrrrsfsz=TestStencil.test_stencil_call..test_impl2..sfr)r~rrrrrr test_impl2s z1TestStencil.test_stencil_call..test_impl2cSst|d||f}t|d||f}td|dD]d}td|dD]P}d|||df||d|f|||df||d|f|||f<qPq>|Srrrrrrrs z4TestStencil.test_stencil_call..test_impl_seqrNr)rKrrrr~rrrtest_stencil_calls   zTestStencil.test_stencil_callcCs&dd}dd}d}||||dS)z&Tests 1D numba.stencil calls. cSs.t|}t|}tdd||d|S)NcSsd|d|d|dSNr$rrrrrrrrrzETestStencil.test_stencil_call_1D..test_impl..rxrhrzr|rYrr}rrr test_impls  z3TestStencil.test_stencil_call_1D..test_implcSsTt|}t|}td|dD],}d||d||||d||<q"|Srrrrrrrs   *z7TestStencil.test_stencil_call_1D..test_impl_seqrNrrKrrr~rrrtest_stencil_call_1Dsz TestStencil.test_stencil_call_1Dc CsPdd}dd}dd}dd}d d }d }||tjf}||tjf}||tjf} ||tjf} ||} ||} ||} | |}| |}tjj| | d d tjj| | d d tjj|| d d tjj|| d d |t}|dW5QRX| dt |j |t tf}t |dW5QRX| dt |j dS)zTests numba.stencil call that has an index that can be inferred as constant from a unary expr. Otherwise, this would raise an error since neighborhood length is not specified. cSs4t|}t|}d}tdd|||d|S)NrcSsd|| |d||SNr$rrrcrrrrrzITestStencil.test_stencil_call_const..test_impl1..rxrr~rrrrrrrs   z7TestStencil.test_stencil_call_const..test_impl1cSs4t|}t|}d}tdd|||d|S)Nr/cSs$d|d||d||dSNr$rrrrrrrrrzITestStencil.test_stencil_call_const..test_impl2..rxrrrrrrs   z7TestStencil.test_stencil_call_const..test_impl2cSs4t|}t|}d}tdd|||d|S)Nr/cSs&d|| d|d||dSrrrrrrrrzITestStencil.test_stencil_call_const..test_impl3..rxrrrrr test_impl3s   z7TestStencil.test_stencil_call_const..test_impl3cSs:t|}t|}d}d}tdd||||d|S)Nrr/cSs&d|| ||d|||Srr)rrdrrrrrzITestStencil.test_stencil_call_const..test_impl4..rxr)r~rrrrrrr test_impl4s   z7TestStencil.test_stencil_call_const..test_impl4cSsXt|}t|}d}td|dD],}d||||||||||<q&|Srr)r~rrrr(rrrrs   *z:TestStencil.test_stencil_call_const..test_impl_seqrrCrdrzDstencil kernel index is not constant, 'neighborhood' option requiredN)rVrrrgrhrirj assertRaisesrrkstr exceptionrr)rKrrrrrr~Zcpfunc1Zcpfunc2Zcpfunc3Zcpfunc4rnZparfor_output1Zparfor_output2Zparfor_output3Zparfor_output4errrtest_stencil_call_consts:        z#TestStencil.test_stencil_call_constcCs:dd}|j|tjddfdd}|d|jdS)zYTests 1D numba.stencil calls without parallel translation turned off. cSstdd|S)NcSsd|d|d|dSrrrrrrrrzJTestStencil.test_stencil_parallel_off..test_impl..)rYr)rrrrrsz8TestStencil.test_stencil_parallel_off..test_implNFrrf)rVrYfloat64Z assertNotInrlrm)rKrrarrrtest_stencil_parallel_off sz%TestStencil.test_stencil_parallel_offcCs>tdddd}dd}td}tj||||dS) z6Tests whether nested stencil decorator works. Tr@cSstdd}||}|S)NcSsd}|| dS)Nr/rrrrrrfunsz@TestStencil.test_stencil_nested1..test_impl..funr)r~rrrrrrs z3TestStencil.test_stencil_nested1..test_implcSs:tjt|td}tdt|D]}||d||<q |S)Nrr)rhr|rintr&)r~rr(rrrr%sz7TestStencil.test_stencil_nested1..test_impl_seq N)rrhrzriZ assert_equalrrrrtest_stencil_nested1s   z TestStencil.test_stencil_nested1c sddg}dd}|D]}tj||dfdd}tdd }t|d }||d d d f<t|}||d tj||| |}|D]} | } tj| |qqtj|ddfdd}tdd }t|}| t } ||d W5QRXd} | | t| j|j|jfD]V} z| |dWn8t tfk rp} z| | t| W5d } ~ XYn Xtdq&d S)z/ Issue #3518, out kwarg did not work with cval.rDrcSs|d|dSNr8rrrrrrkernel4sz1TestStencil.test_out_kwarg_w_cval..kernelr+cs*tdd}t|}||d|SN rCrrxrhrzr{ ones_likerretZ stencil_fnrrwrapped:s  z2TestStencil.test_out_kwarg_w_cval..wrappedrrr#rNrx?cs*tdd}t|}||d|SrrrrrrrQs  z-cval type does not match stencil return type.rzExpected error was not raised)rYrrhrzr{ full_likerrirjrcrgrrrkrrrWrVrAssertionError)rKZ const_valsrZ const_valrrrnrimplsimplgotrmsgcompilerrrrtest_out_kwarg_w_cval.s:        "z!TestStencil.test_out_kwarg_w_cvalc stjtjtj tdtd fD]}dd}tj||dfdd}tdd}t|d }||d d d f<t |}||d tj ||| |}|D]}| } tj | |qq d S) U Test issue #7286 where the cval is a np attr/string-based numerical constantinfcSs|d|dSrrrrrrrksz9TestStencil.test_out_kwarg_w_cval_np_attr..kernelr+cs*tdd}t|}||d|S)N(@rrxrrrrrrps  z:TestStencil.test_out_kwarg_w_cval_np_attr..wrappedrrr#rNrx)rhnanrfloatrYrrzr{rrrirjrcrg) rKr,rrrrnrrrrrrrtest_out_kwarg_w_cval_np_attrfs$     z)TestStencil.test_out_kwarg_w_cval_np_attr)rrrsrtrJskip_unsupportedrrrrrrrrrrrrrrrurrrMrrvs:   T    "    O   7rvc@seZdZdZGdddZGdddejeZGdddejeZGdd d ejeZ Gd d d ejeZ Gd d d ej eZ GdddejZ ddZdS)pyStencilGeneratorz Holds the classes and methods needed to generate a python stencil implementation from a kernel purely using AST transforms. c@s~eZdZdZddZdddDZddZdd d Zd d ZdddZ ddZ ddZ ddZ dddZ ddZd ddZdS)!zpyStencilGenerator.Builderz Provides code generation for the AST manipulation pipeline. The class methods largely produce AST nodes/trees. cCs d|_dSNrZ_Builder__staterKrrrrJsz#pyStencilGenerator.Builder.__init__cCs*g|]"}tdD]}tt||qqS))r&chrord)r[vr\rrrr]s z%pyStencilGenerator.Builder.)rrcCs|j}|jd|_|S)zZ a monotonically increasing index for use in labelling variables. rr)rKtmprrrvaridxs z!pyStencilGenerator.Builder.varidxrc Cstjtj|tdgtjtjtjdtddtdtjtj|tddtd||gtjd| d|j gj dgd d d d }|S) z Generates an AST equivalent to: `var = np.full(orig.shape, init_val, dtype = dtype_var)` idctxrhfullvalueattrrshapertypeargrNrPrLkeywordsZstarargsr`targetsr) astAssignNameStoreCall AttributeLoadgen_numkeywordgen_callrr)rKorigvarZ dtype_varZinit_valnewrrrgen_alloc_returnsBz+pyStencilGenerator.Builder.gen_alloc_returncCsVdd|D}tjtjtj|tdtjtj|tddtdg|d}|S)z Generates an AST equivalent to: `retvar[(*index_names,)] = value[]` cSsg|]}tj|tdqS)rrrr rZrrrr]sz9pyStencilGenerator.Builder.gen_assign..reltsrrrslicerr)rr Subscriptrr IndexTupler)rKrrZ index_namesZ elts_inforrrr gen_assigns&  z%pyStencilGenerator.Builder.gen_assignNc Cszt|trtj|d}n|}t|tr4tj|d}n|}tjtj|tdtjtjdtd||ggddd|gdS)z} Generates an AST equivalent to a loop in `var` from `start` to `stop` with body `body`. r~rr&Nr)targetiterbodyZorelse) isinstancerrNumZForrrr r )rKrstartstopr Z start_valZstop_valrrrgen_loops$  z#pyStencilGenerator.Builder.gen_loopcCstjtj|tddS)zE Generates an AST equivalent to `return var` rr)rZReturnrr )rKrrrr gen_returnsz%pyStencilGenerator.Builder.gen_returncCstjtj|ddS)z'Generates an Index with the given valuerr)rrr"rKrrrr gen_slicesz$pyStencilGenerator.Builder.gen_slicecCs"tjtj|td|tdS)zA Generates AST equivalent to `name.attr` rr)rr rr )rKnamerrrrgen_attrs z#pyStencilGenerator.Builder.gen_attrc Csf|||}||}tj||td}|rb|dkr>tnt}tj||tjt |dd}|S)z Generates an AST equivalent to a subscript, something like: name.attr[slice(index) +/- offset] rrr)leftopright) r*r(rrr AddSubBinOpr"abs) rKr)rindexr attributeZslisessZpmrrr gen_subscripts  z(pyStencilGenerator.Builder.gen_subscriptcCsJt|trtt|St|dkr.t|Sttt| SdS)z? Generates an ast.Num of value `value` rN)r!boolrr"rr1UnaryOpZUSubr'rrrr s    z"pyStencilGenerator.Builder.gen_numcCs^dd|D}|dk r&dd|D}ng}tj|td}tjtj|||dddtdS)z| Generates an AST equivalent to a call, something like: `call_name(*args, **kwargs) cSs"g|]}tjd|tdqS)%srrrZrrrr]sz7pyStencilGenerator.Builder.gen_call..NcSs0g|](}tjd|tt|jdjdqS)r8rr)rr parserr rrZrrrr]srrrr)rrr ZExprr )rKZ call_namerLr`Z fixed_argsrrPrrrrs z#pyStencilGenerator.Builder.gen_call)r)rrN)N)N)rrrsrt__doc__rJidsrrrr%r&r(r*r5r rrrrrBuilders    r=c@s4eZdZdZejejejej ej ej iZ ddZ dS)zpyStencilGenerator.FoldConstzn Folds const expr, this is so const expressions in the relidx are more easily handled cCsz||}|j|jj}t|dd}t|dd}|r>|r>|sB|St|tjrrt|tjrrt||j j |j j S|SdS)Nr+r-) generic_visit supported_opsgetr,rNgetattrr!rr"r+r~r-)rKnoder,lhsrhsrrr visit_BinOp5s      z(pyStencilGenerator.FoldConst.visit_BinOpN)rrrsrtr;rr.operatoraddr/subZMultmulr?rErrrr FoldConst(srJc@sXeZdZdZddZddZddZedd Zed d Z ed d Z eddZ dS)zpyStencilGenerator.FixRelIndexza Fixes the relative indexes to be written in as induction index + relative index cOstjj|f||tjj|f||||_||_d|_d|_d|_ t t j |_t t j|_|rj|ng|_||_|r~dnd|_dS)Nrz__%sn__%s)rNodeTransformerrJrr= _argnames_const_assigns_idx_len_mins_maxesrhZiinformin_iminmax_imax_standard_indexing _neighborhood_id_pat)rKargnames const_assignsr;r"rLr`rrrrJKsz'pyStencilGenerator.FixRelIndex.__init__cCs4t|tjr|jSt|tjr(|jj StddS)zF Gets the literal value from a Num or UnaryOp z,get_val_from_num: Unknown indexing operationN)r!rr"r~r7Zoperand ValueError)rKrBrrrget_val_from_num[s   z/pyStencilGenerator.FixRelIndex.get_val_from_numcsfdd}fdd}fddfddfd d }fd d }|}|jjjkr|jjjkrt|jtjr||St|jtj r||St|jjtj r||St|jtj r||St d n|SdS)z Transforms subscripts of the form `a[x]` and `a[x, y, z, ...]` where `x, y, z` are relative indexes, to forms such as: `a[x + i]` and `a[x + i, y + j, z + k]` for use in loop induced indexing. c s g}t|jjjD]P\}}j||}|tjtj j j |t dt |t dqjdkrzt|_njt|krtdt|jtjrd}t|t }tj|jtjtj|t dt d|d}t||t|jdkr.jdkr.jgj_jgj_jst|jjjD]\}}t|tjsht|tjrt |} n0t!|d r|j"jkrj|j"} ntd | j|kr| j|<| j|krD| j|<qDn>tjD]2\}}j|d j|<j|d j|<q|S) Nrr+r,r-rr#Relative indexing mismatch detected=Assignments to array passed to stencil kernels is not allowedrr:rrCannot interpret indexing valuerr)# enumeraterrrrNr@appendrr0rrXr<r r.rOrr[r!rrrrr copy_locationfix_missing_locationsrPrQrUrSrWr"r7r\hasattrr) rBidxr\valusevalrcontextnewnodelnoderelvaluerrr handle2dindexosz         zEpyStencilGenerator.FixRelIndex.visit_Subscript..handle2dindexcsj|jj|jj}tjtjjjdt dt |t d}j dkr\d_ nj dkrnt dt |jtjrd}t |t }tj|jtj|t d|d }t||t|jdkrjdkrjg_jg_jst |jjtjst |jjtjr*|jj}n.handle1dindexcsHfdd}t|j||j|j}t|t||S)Ncsfj||}|}tjtjjj|tdt |td}t |t ||S)Nrr]) rNr@r\rr0rrXr<r r.rcrd)rgr\rhrr)rBrKrrgen_idxs   zUpyStencilGenerator.FixRelIndex.visit_Subscript..computeSlice..gen_idx)rSliceloweruppersteprcrd)r(rBrorjr)rBr computeSlices    zDpyStencilGenerator.FixRelIndex.visit_Subscript..computeSlicecsrj|j|j}tjtjjj|tdt |td}tj |td}t ||t ||S)Nrr]r:) rNr@rrr0rrXr<r r.rrcrd)r(rBrhrfrjrrr computeIndexs  zDpyStencilGenerator.FixRelIndex.visit_Subscript..computeIndexc sg}t|jjD]@\}}t|tjr4|||t|tjr|||qjdkrlt |jj_njt |jjkrt dt|j tj rd}t |t }tj|jtj|t d|d}jdkrjdkrjgj_jgj_jsbt|jjD]L\}}t|tjr|j|jfD]} t| tjsTt| tjr`| } n0t| dr| jjkrj| j} nt d| j|kr| j|<| j|kr4| j|<q4n|j}t|tjst|tjr|} n0t|dr |jjkr j|j} nt d| j|krB| j|<| j|kr| j|<qn>tjD]2\}} j|dj|<j|d j|<qlt||t||S) Nrr^r_)dimsrrrr`rr) rarrvr!rrprbrrOrr[rrr rrExtSlicerPrQrUrSrWrqrrr"r7r\rerrNrcrd) rBrfr(rgrrirjr\ZanoderkrlrurtrKrrhandleExtSlices                zFpyStencilGenerator.FixRelIndex.visit_Subscript..handleExtSlicecsd|j}t|_t|jtjr0d}t|t}tj|j||d}t ||t |j dkrrd_ nj dkrtdj dkrj dkrjg_ jg_ jsVt|jjtjst|jjtjr|jj}n.handleSlicezUnhandled subscriptN) r>rrrMrVr!rrrwrprrr[)rKrBrmrnryrzrrxrvisit_Subscriptgs( > 7  K0   z.pyStencilGenerator.FixRelIndex.visit_SubscriptcCs|jdkrtdn|jSdS)Nrz+Transform has not been run/no indexes found)rOr[rrrridx_lens  z&pyStencilGenerator.FixRelIndex.idx_lencCs|jSrO)rQrrrrmaxessz$pyStencilGenerator.FixRelIndex.maxescCs|jSrO)rPrrrrminssz#pyStencilGenerator.FixRelIndex.minscCs|jSrO)rXrrrr id_patternsz)pyStencilGenerator.FixRelIndex.id_patternN) rrrsrtr;rJr\r{propertyr|r}r~rrrrr FixRelIndexFs 1   rc@s,eZdZdZddZddZeddZdS) z#pyStencilGenerator.TransformReturnsz; Transforms return nodes into assignments. cOsLtjj|f||tjj|f||||_||_d|j}||_dS)Nz__b%s) rrLrJrr= _relidx_inforZ _ret_var_idx _retvarname)rK relidx_inforLr`retvarrrrrJs   z,pyStencilGenerator.TransformReturns.__init__cs@|jj}jjj|jfddt|DS)Ncsg|]}j|qSr)r<)r[lrK var_patternrrr]szDpyStencilGenerator.TransformReturns.visit_Return..)r>rr|rrrrr&)rKrBnloopsrrr visit_Returns z0pyStencilGenerator.TransformReturns.visit_ReturncCs|jSrO)rrrrr ret_var_namesz0pyStencilGenerator.TransformReturns.ret_var_nameN)rrrsrtr;rJrrrrrrrTransformReturnss rc@s eZdZdZddZddZdS)zpyStencilGenerator.FixFuncz The main function rewriter, takes the body of the kernel and generates: * checking function calls * return value allocation * loop nests * return site * Function definition as an entry point c stjjf||tjjf|||j_|j_|j _ |_ |_ |rT|ng_ |rb|nt_fddjD_t|dr|_n|_jd_dS)Ncsg|]}|jkr|qSr)rVrZrrrr]s z7pyStencilGenerator.FixFunc.__init__..rr)rrLrJrr=original_kernel_original_kernelrYrMretty_rettyr _ret_inforVr^rW _relidx_argsretolistr, stencil_arr) rKZkpropsrZret_infor,r;r"rLr`rrrrJs&   z#pyStencilGenerator.FixFunc.__init__c Cs||dd}t|}t|jd}t||jd|j dgd}|j j }dd}|j j }|j} d} t |D]b} ||j j| |j j| \} } | }||jd | | }|j||j| ||| d }|g} | d 7} qxt|||jjd}|jj}||j|||j}t||||}t||tdd g}g}tj|jj||d d gggd }tjd|j ||||j!|j|||ggd}t|||S)z Transforms the kernel function into a function that will perform the stencil like behaviour on the kernel. c_sf|d}|dj}|dk r4t|t|kr4td|ddD] }t|dr@||jkr@tdq@dS)Nr"rzInvalid neighborhood suppliedrrz#Input stencil arrays do not commute)r@rrr[re)rLr`r"Z init_shaper\rrrcheck_stencil_arrayss    zJpyStencilGenerator.FixFunc.visit_FunctionDef..check_stencil_arraysrrr")r`cSs,|dkr dn| }|dkr | nd}||fSrr)r~Zmaxsminlimmaxlimrrr computeboundszBpyStencilGenerator.FixFunc.visit_FunctionDef..computeboundr)r rN)rLdefaultsvarargkwarg kwonlyargs kw_defaults posonlyargsrK)r)rLr Zdecorator_list)"r>inspect getsourcerr9stripr rdrrrr|rr&r~r}r5rr%r<rcrrrrrr,r&r argumentsrLZ FunctionDefr)r)rKrBrZchecksrcZ check_implZ checker_callrrrZ loop_bodyZ loop_countrrrZminboundZmaxboundZloopsZ _rettynamerallocateZreturnerZ add_kwargrZnewargsrrrrvisit_FunctionDefs               z,pyStencilGenerator.FixFunc.visit_FunctionDefN)rrrsrtr;rJrrrrrFixFuncsrc@sXeZdZdZddZddZddZedd Zed d Z ed d Z eddZ dS)z!pyStencilGenerator.GetKernelPropszV Gets the argument names and other properties of the original kernel. cOsJtjj|f||tjj|f||d|_d|_d|_d|_i|_ dSrO) r NodeVisitorrJrr=rM _kwargnamesrrrNrwrrrrJJsz*pyStencilGenerator.GetKernelProps.__init__cs|jdk s|jdk rtddfdd|jjD|_|jjrTdd|jjD|_||j|j}tjtj dt dg|j d|_ t t||_||dS) Nz%multiple definition of function/args?rcsg|]}t|qSr)rArZrrrr]XszGpyStencilGenerator.GetKernelProps.visit_FunctionDef..cSsg|] }|jqSr)rrZrrrr]ZsZ __retdtyperr)rMr RuntimeErrorrLrrr)rrrrrrrdrrr>)rKrBZcompute_retdtyperrrrSsz3pyStencilGenerator.GetKernelProps.visit_FunctionDefcCs|||j}t|dkr|d}t|tjrt|jtjrP|jj|j |j <n@t|jtj rt|jtj r~|jj|j |j <n|jj |j |j <dSNrr) r>rrr!rrrr"r~rNrr7ZUAdd)rKrBZtgtrrrr visit_Assignbs   z.pyStencilGenerator.GetKernelProps.visit_AssigncCs|jS)zD The names of the arguments to the function )rMrrrrrYpsz*pyStencilGenerator.GetKernelProps.argnamescCs|jS)z{ A map of variable name to constant for variables that are simple constant assignments )rNrrrrrZwsz/pyStencilGenerator.GetKernelProps.const_assignscCs|jS)z) The return type )rrrrrrsz'pyStencilGenerator.GetKernelProps.rettycCs|jS)z7 The original unmutated kernel )rrrrrrsz1pyStencilGenerator.GetKernelProps.original_kernelN) rrrsrtr;rJrrrrYrZrrrrrrGetKernelPropsEs    rc@seZdZdZddZdS)zpyStencilGenerator.FixCallsz3 Fixes call sites for astor (in case it is in use) cCs(||tj|j|j|jddd}|S)Nr)r>rr rPrLr)rKrBrrrr visit_Calls z&pyStencilGenerator.FixCalls.visit_CallN)rrrsrtr;rrrrrFixCallssrc st|}t|}d}|r6tdtt|fdd}|||rtdttj|ddzdd l} t| |Wnt k rYnX|S) z Generates the AST tree for a stencil from: func - a python stencil kernel cval, standard_indexing and neighborhood as per the @stencil decorator FZORIGINALc s}|||j}|j}r@D]}||kr&d}t|q&}||||}|||}|||||} | | } | |t |j ddS)z the pipeline of manipulations z4Non-existent variable specified in standard_indexingrN) rvisitrYrZr[rJrrrrrrdr ) treeZ kernel_propsZargnmZ const_asgnr\rZ fold_constZ relidx_fixerZreturn_transformerfixerZ callFixerr,r"rKr;rrpipelines@        z:pyStencilGenerator.generate_stencil_tree..pipelinez NEWT)Zinclude_attributesrN) rrrr9rprintdumpastorZ to_source ImportError) rKrPr,r;r"srcrDEBUGrrrrrgenerate_stencil_trees" -z(pyStencilGenerator.generate_stencil_treeN)rrrsrtr;r=rrLrJrrrrrrrrrrrrsfHrconstantc Kst|tsd}|}nt|ts&td|}d}|D]}|dkr2td|q2|dkr`td||dd}|d d}|d d}t}|||||} t| d d d } | jd} t | t } | S)zs A pure python implementation of (a large subset of) stencil functionality, equivalent to StencilFunc. rzWstencil mode should be a stringN)r,r;r"zUnknown stencil option zUnsupported mode style r,rr;r"zexec)filenamemode) r!rrr[r@rrcompile co_constspytypes FunctionTypeglobals) func_or_moderUrrPoptionr,r;r"genrZmod_code func_codeZ full_funcrrr pyStencils,       rcseZdZfddZddZddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Z d=d>Z!d?d@Z"dAdBZ#dCdDZ$dEdFZ%dGdHZ&dIdJZ'e()dKdLdMZ*dNdOZ+dPdQZ,dRdSZ-dTdUZ.dVdWZ/dXdYZ0dZd[Z1d\d]Z2d^d_Z3d`daZ4dbdcZ5dddeZ6dfdgZ7dhdiZ8djdkZ9dldmZ:dndoZ;dpdqZdwdxZ?dydzZ@d{d|ZAd}d~ZBddZCddZDddZEddZFddZGddZHddZIddZJddZKddZLddZMddZNddZOddZPddZQddZRddZSddZTddZUddZVddZWddZXddZYddZZddZ[ddZ\ddZ]ddZ^ddZ_ddZ`ddZaddZbddZcdd„ZdddĄZeddƄZfddȄZgddʄZhdd̄Zidd΄ZjddЄZkdd҄ZlddԄZme()dաddׄZnddلZoe()dաddۄZpdd݄ZqZrS)TestManyStencilscstt|j||dSrO)rIrrJrwrMrrrJszTestManyStencils.__init__c s|dt}|d}d}ggtd.fdd }t|trd|d}|d} |d } |d } n|}|} |} |} d |i} | |d } z8tfd |i|}||d |d i}|rtd|WnFtk r}z&||d |W5QRX|}d} W5d}~XYnXd}|| dtf| |}W5QRXt |dkrRfdd}nHt |dkrnfdd}n,t |dkrfdd}nt dt |t dd|D}d}|| d | ||}|j |}W5QRXd}|| d|||}|j |}W5QRX|r0td|td|td|| rz,| s`tjj||dd||j|jWnRtk r}z2ddt|t|fftd t|W5d}~XYnXz,| stjj||dd||j|jWnRtk r4}z2d dt|t|fftd!t|W5d}~XYnXzf| stjj||dd||j|jz|d"|jWn"tk rd#}t|YnXWnRtk r}z2ddt|t|fftd$t|W5d}~XYnX|rtd%rd&dD}td'|rbd(dD}d)d*dD}d+|}d,|}t||| s||dkr|td-|dS)/a For a given kernel: The expected result is computed from a pyStencil version of the stencil. The following results are then computed: * from a pure @stencil decoration of the kernel. * from the njit of a trivial wrapper function around the pure @stencil decorated function. * from the njit(parallel=True) of a trivial wrapper function around the pure @stencil decorated function. The results are then compared. rUexpected_exceptionFNc 3sz dVWntk r}zb|dk r\t|dr2|n|g}d}|D]}|t||O}q@|szn|dt|t|ffW5d}~XYnX|dk r|dS)N__iter__F%s: %s) Exceptionrer!rbrr)ZextyZusecaserZlextyfoundex) should_failshould_not_failrr errorhandler0s" z,TestManyStencils.check..errorhandlerrrrparforrTr"z Expected: z@stencilrcs|SrOr)arg0stencil_func_implrr wrap_stencilisz,TestManyStencils.check..wrap_stencilr/cs ||SrOr)rarg1rrrrlsrCcs |||SrOr)rrZarg2rrrrosz+Up to 3 arguments can be provided, found %scSsg|]}t|qSrrXrZrrrr]vsz*TestManyStencils.check..Zparforsz @stencil_output: z njit_output: z parfor_output: rdrz@stencil failed: %sz@njit failed: %srfz*Could not find `@do_scheduling` in LLVM IRz@njit(parallel=True) failed: %sz cSsg|] }d|qS)r8rrZrrrr]szMThe following implementations should have raised an exception but did not: %scSsg|]}d|dqS)r8rrrZrrrr]scSsg|] }d|qS)z%s: Message: %s rrZrrrr]szNThe following implementations should not have raised an exception but did: %s zErrors were: %sz)pyStencil failed, was not caught/expected)NN)r@dictrr!updaterrrrrr[r^rWrgrVrhrirj assertEqualrrbrrrkrlrmrrjoin)rKr_rLr`rUrZ DEBUG_OUTPUTrZ pystencil_exZ stencil_exZnjit_exZ parfor_exZ stencil_argsZexpected_presentZast_implrnrZpyStencil_unhandled_exZstencilfunc_outputrrQroZ wrapped_cfuncrpZwrapped_cpfuncrrrZerrsZstr1Zstr2r)rrrrrqs               """   zTestManyStencils.checkcKsDt}d|d<d|d<d|d<d|d<|D]\}}|||<q.|S)Nrrrr)ritems)rKr`rkrrrrexception_dicts zTestManyStencils.exception_dictcCs*dd}tddd}|||dS)z rel indexcSs|dSr7rrrrrrsz-TestManyStencils.test_basic00..kernelrrCrNrhrzr{rqrKrrrrr test_basic00szTestManyStencils.test_basic00cCs*dd}tddd}|||dS)rel index add constcSs|dSNrrrrrrrsz-TestManyStencils.test_basic01..kernelrrCrNrrrrr test_basic01szTestManyStencils.test_basic01cCs*tddd}dd}|||dS)rrrCrcSs|dS)Nrrrrrrrsz-TestManyStencils.test_basic02..kernelNrrKrrrrr test_basic02szTestManyStencils.test_basic02cCs*tddd}dd}|||dS)rrrCrcSs|dS)Nrrrrrrrsz-TestManyStencils.test_basic03..kernelNrrrrr test_basic03szTestManyStencils.test_basic03cCs*tddd}dd}|||dS)rrrCrcSs|dS)Nrrrrrrrsz-TestManyStencils.test_basic04..kernelNrrrrr test_basic04szTestManyStencils.test_basic04cCs*tddd}dd}|||dS)rrrCrcSs|dS)Nrrrrrrrrsz-TestManyStencils.test_basic05..kernelNrrrrr test_basic05szTestManyStencils.test_basic05cCs*tddd}dd}|||dS)rrrCrcSs|dS)Nrrrrrrrrsz-TestManyStencils.test_basic06..kernelNrrrrr test_basic06szTestManyStencils.test_basic06cCs*tddd}dd}|||dS)rrrCrcSs|dS)Nrrrrrrrr sz-TestManyStencils.test_basic07..kernelNrrrrr test_basic07szTestManyStencils.test_basic07cCs*tddd}dd}|||dS)rrrCrcSs|dS)Nrrrrrrrrsz-TestManyStencils.test_basic08..kernelNrrrrr test_basic08szTestManyStencils.test_basic08cCs*tddd}dd}|||dS)rrrCrcSs|dS)Nr-rrrrrrsz-TestManyStencils.test_basic09..kernelNrrrrr test_basic09szTestManyStencils.test_basic09cCs*tddd}dd}|||dS)rrrCrcSs|d|dSrrrrrrr#sz-TestManyStencils.test_basic10..kernelNrrrrr test_basic10szTestManyStencils.test_basic10cCs*tddd}dd}|||dS)rrrCrcSs|d|dS)Nrrrrrrrr+sz-TestManyStencils.test_basic11..kernelNrrrrr test_basic11'szTestManyStencils.test_basic11cCs*tddd}dd}|||dS)rrrCrcSs|d|dS)Nrrrrrrrr3sz-TestManyStencils.test_basic12..kernelNrrrrr test_basic12/szTestManyStencils.test_basic12cCs*tddd}dd}|||dS)rrrCrcSs|d|dS)Nrrrrrrrr;sz-TestManyStencils.test_basic13..kernelNrrrrr test_basic137szTestManyStencils.test_basic13cCs*tddd}dd}|||dS)!rel index add domain change constrrCrcSs |ddS)Nr8rrrrrrrCsz-TestManyStencils.test_basic14..kernelNrrrrr test_basic14?szTestManyStencils.test_basic14cCs*tddd}dd}|||dS)rrrCrcSsd}|d|S)Nrr8rrtrrrrKsz.TestManyStencils.test_basic14b..kernelNrrrrr test_basic14bGszTestManyStencils.test_basic14bcCs*tddd}dd}|||dS)ztwo rel index, add constrrCrcSs|d|ddS)Nr8rr*rrrrrrTsz-TestManyStencils.test_basic15..kernelNrrrrr test_basic15PszTestManyStencils.test_basic15cCs:tddd}dd}|jtd}|j|||ddS) ztwo rel index OOB, add constrrCrcSs|d|ddS)Nr8)rrr*rrrrrr\sz-TestManyStencils.test_basic16..kernel)rrN)rhrzr{r IndexErrorrq)rKrrrrrr test_basic16Xs zTestManyStencils.test_basic16cCs*tddd}dd}|||dS)&two rel index boundary test, add constrrCrcSs|d|ddS)Nr8)r/rr*rrrrrrgsz-TestManyStencils.test_basic17..kernelNrrrrr test_basic17cszTestManyStencils.test_basic17cCs*tddd}dd}|||dS)rrrCrcSs|d|ddS)Nr8r.rr*rrrrrrosz-TestManyStencils.test_basic18..kernelNrrrrr test_basic18kszTestManyStencils.test_basic18cCs*tddd}dd}|||dS)rrrCrcSs|d|ddS)Nr8rrCr*rrrrrrwsz-TestManyStencils.test_basic19..kernelNrrrrr test_basic19sszTestManyStencils.test_basic19cCs*tddd}dd}|||dS)rrrCrcSs|d|ddS)Nr8)rr*rrrrrrsz-TestManyStencils.test_basic20..kernelNrrrrr test_basic20{szTestManyStencils.test_basic20cCs*tddd}dd}|||dS)zsame rel, add constrrCrcSs|d|ddS)Nr8r*rrrrrrsz-TestManyStencils.test_basic21..kernelNrrrrr test_basic21szTestManyStencils.test_basic21cCs*tddd}dd}|||dS)z%rel idx const expr folding, add constrrCrcSs|d|ddS)Nrr8r*rrrrrrsz-TestManyStencils.test_basic22..kernelNrrrrr test_basic22szTestManyStencils.test_basic22cCs*tddd}dd}|||dS)zrel idx, work in bodyrrCrcSs&td|d}|d|d|SNr)r/rrr8rhsinrr\rrrrsz-TestManyStencils.test_basic23..kernelNrrrrr test_basic23szTestManyStencils.test_basic23cCs*tddd}dd}|||dS)z,rel idx, dead code should not impact rel idxrrCrcSs"td|d}|d|dSr r rrrrrsz.TestManyStencils.test_basic23a..kernelNrrrrr test_basic23aszTestManyStencils.test_basic23acCs2tddd}dd}|j||ttgddS)z1d idx on 2d arrrrCrcSs |ddS)Nrr*rrrrrrsz-TestManyStencils.test_basic24..kernelrNrhrzr{rqr[rrrrr test_basic24szTestManyStencils.test_basic24cCs2tddd}dd}|j||ttgddS)zno idx on 2d arrrrCrcSsdS)Nr*rrrrrrsz-TestManyStencils.test_basic25..kernelrNrhrzr{rqr[rrrrr test_basic25szTestManyStencils.test_basic25cCs,tdddd}dd}|||dS)z3d arr@rr/cSs|d|ddS)N)rrr)rrrr*rrrrrrsz-TestManyStencils.test_basic26..kernelNrrrrr test_basic26szTestManyStencils.test_basic26cCs.tddddd}dd}|||dS)z4d arrrrr/cSs|d|ddS)N)rrrr)rrrrr*rrrrrrsz-TestManyStencils.test_basic27..kernelNrrrrr test_basic27szTestManyStencils.test_basic27cCs2tdddtj}dd}|||dS)z type widen rrCrcSs|dtdS)Nr8$@)rhrrrrrrsz-TestManyStencils.test_basic28..kernelN)rhrzr{astypeZfloat32rqrrrr test_basic28szTestManyStencils.test_basic28cCs4tddd}dd}|j||tttgddS)zconst index from func rrCrcSs|dttdfSr)rrhcosrrrrrsz-TestManyStencils.test_basic29..kernelrNrhrzr{rqr[rrrrrr test_basic29s  zTestManyStencils.test_basic29cCs*tddd}dd}|||dS)z signed zerosrrCrcSs|dSr7rrrrrrsz-TestManyStencils.test_basic30..kernelNrrrrr test_basic30szTestManyStencils.test_basic30cCs*tddd}dd}|||dS)zdoes a const propagate? 2DrrCrcSsd}||dfSrrrrrrrsz-TestManyStencils.test_basic31..kernelNrrrrr test_basic31szTestManyStencils.test_basic31z constant folding not implementedcCs*tddd}dd}|||dS)zdoes a const propagate?rrCrcSsd}d|}||dfSrr)rsrrrrrsz.TestManyStencils.test_basic31b..kernelNrrrrr test_basic31bszTestManyStencils.test_basic31bcCs"td}dd}|||dS)zdoes a const propagate? 1DrcSs d}||Sr>rrrrrrsz.TestManyStencils.test_basic31c..kernelNrhrzrqrrrr test_basic31cs zTestManyStencils.test_basic31ccCs4tddd}dd}|j||tttgddS)ztyped int indexrrCrcSs|tddfSr)rhZint8rrrrrsz-TestManyStencils.test_basic32..kernelrNrrrrr test_basic32s  zTestManyStencils.test_basic32cCs*tddd}dd}|||dS)z add 0d arrayrrCrcSs|dtdS)Nr8r)rharrayrrrrrsz-TestManyStencils.test_basic33..kernelNrrrrr test_basic33szTestManyStencils.test_basic33cCs*dd}tddd}|||dS)z.kernelrNrrrrr test_basic34 szTestManyStencils.test_basic34cCs2dd}tddd}|j||ddidd S) z.kernelrrCrr,rrUNrrrrr test_basic35szTestManyStencils.test_basic35cCs2dd}tddd}|j||ddidd S) zmore complex with cvalcSs |d|d|d|dSNrrrrrrrrrsz-TestManyStencils.test_basic36..kernelrrCrr,g@r-Nrrrrr test_basic36szTestManyStencils.test_basic36cCs2dd}tddd}|j||ddidd S) z cval is exprcSs |d|d|d|dSr/rrrrrr$sz-TestManyStencils.test_basic37..kernelrrCrr,gQ@r-Nrrrrr test_basic37"szTestManyStencils.test_basic37cCsDdd}tddd}|jtttd}|j||ddi|d d S) zcval is complexcSs |d|d|d|dSr/rrrrrr+sz-TestManyStencils.test_basic38..kernelrrCr)rrrr,rrUrN)rhrzr{rrr[rqrKrrrrrr test_basic38)szTestManyStencils.test_basic38cCsBdd}tddd}|j||dtdtdid d S) zcval is func exprcSs |d|d|d|dSr/rrrrrr6sz-TestManyStencils.test_basic39..kernelrrCrr,rr/r-N)rhrzr{rqr rrrrr test_basic394szTestManyStencils.test_basic39cCs>dd}tddd}tddd}||||dS)z2 args!cSs|d|dSNr)rr.rr1rrrr=sz-TestManyStencils.test_basic40..kernelrrCrNrrKrrr2rrr test_basic40;szTestManyStencils.test_basic40cCsFdd}tddd}tddd}|j|||ttgdd S) z(2 args! rel arrays wildly not same size!cSs|d|dSr6rr1rrrrEsz-TestManyStencils.test_basic41..kernelrrCrr*rrNrhrzr{rqr[rr7rrr test_basic41CszTestManyStencils.test_basic41cCsFdd}tddd}tddd}|j|||ttgddS) z%2 args! rel arrays very close in sizecSs|d|dSr6rr1rrrrOsz-TestManyStencils.test_basic42..kernelrrCr"@rNr9r7rrr test_basic42MszTestManyStencils.test_basic42cCs>dd}tddd}tddd}||||dS)z2 args more complexitycSs |d|d|d|dS)Nrrr/rrrr1rrrrYsz-TestManyStencils.test_basic43..kernelg>@rNrr7rrr test_basic43WszTestManyStencils.test_basic43cCsFdd}tddd}tddd}|j|||ttgddS)z!2 args, has assignment before usecSsd|d<|dS)Nrrrr1rrrrasz-TestManyStencils.test_basic44..kernelrrCrrNrhrzr{rqr[rr7rrr test_basic44_szTestManyStencils.test_basic44cCsFdd}tddd}tddd}|j|||ttgddS)z02 args, has assignment and then cross dependencycSsd|d<|d|dS)Nrrrrr1rrrrlsz-TestManyStencils.test_basic45..kernelrrCrrNr@r7rrr test_basic45jszTestManyStencils.test_basic45cCsFdd}tddd}tddd}|j|||ttgddS)z#2 args, has cross relidx assignmentcSs|d|d<|d|dS)Nr=rrrr1rrrrws z-TestManyStencils.test_basic46..kernelrrCrrNr@r7rrr test_basic46uszTestManyStencils.test_basic46cCsRdd}tddd}tddd}tddd}|||||dS)z3 argscSs|d|d|dS)Nrrrrrr2rrrrrsz-TestManyStencils.test_basic47..kernelrrCrNrrKrrr2rrrr test_basic47s zTestManyStencils.test_basic47cCs*dd}tddd}|||dS)z22 args, has assignment before use via memory aliascSs"|j}d|ddddf<|dS)Nrr)Trrrrrsz-TestManyStencils.test_basic48..kernelrrCrNrrrrr test_basic48szTestManyStencils.test_basic48cCsFdd}tddd}tddd}|j|||ddidd S) z#2 args, standard_indexing on secondcSs|d|dS)Nrrrr1rrrrsz-TestManyStencils.test_basic49..kernelrrCrr;r2r-Nrr7rrr test_basic49szTestManyStencils.test_basic49z&dynamic range checking not implementedcCsHdd}tddd}tddd}|j|||dditdd S) z2 args, standard_indexing OOBcSs|d|dS)Nr)rrr1rrrrsz-TestManyStencils.test_basic50..kernelrrCrr;r2r2N)rhrzr{rqrr7rrr test_basic50szTestManyStencils.test_basic50cCsPdd}tddd}tddd}|j|||dddgittgd d S) z$2 args, standard_indexing, no relidxcSs|d|dSNr)rr/rr1rrrrsz-TestManyStencils.test_basic51..kernelrrCrr;rr2r2Nrr7rrr test_basic51s zTestManyStencils.test_basic51cCsZdd}tddd}tddd}tddd}|j||||dd id d S) z(3 args, standard_indexing on middle arg cSs|d|d|dS)Nrr=rrDrrrrsz-TestManyStencils.test_basic52..kernelrrCrr)r/r;r2r-NrrErrr test_basic52s zTestManyStencils.test_basic52cCsZdd}tddd}tddd}|jttttd}|j|||ddi|d d S) z92 args, standard_indexing on variable that does not existcSs|d|dSrLrr1rrrrsz-TestManyStencils.test_basic53..kernelrrCrrrrrr;rr2N)rhrzr{rr[rrqrKrrr2rrrr test_basic53s$zTestManyStencils.test_basic53cCsFdd}tddd}tddd}|j|||ddidd S) z)2 args, standard_indexing, index from varcSsd}|d|d|fS)Nr/rrr)rr2rrrrrsz-TestManyStencils.test_basic54..kernelrrCrr;r2r-Nrr7rrr test_basic54szTestManyStencils.test_basic54cCsFdd}tddd}tddd}|j|||ddidd S) z62 args, standard_indexing, index from more complex varcSs d}d|}|d|d|fS)Nrr/rrr)rr2r"rrrrrsz-TestManyStencils.test_basic55..kernelrrCrr;r2r-Nrr7rrr test_basic55szTestManyStencils.test_basic55cCsFdd}tddd}tddd}|j|||ddidd S) z,2 args, standard_indexing, added complexity cSsJd}d}|dddfD] }||7}qd|d}|d|d|f|S)Nrrr/rr)rr2r"accrrrrrrs   z-TestManyStencils.test_basic56..kernelrrCrr;r2r-Nrr7rrr test_basic56szTestManyStencils.test_basic56cCsFdd}tddd}tddd}|j|||ddidd S) z12 args, standard_indexing, split index operation cSs|d}|d|dS)NrrrrrDrrrrsz-TestManyStencils.test_basic57..kernelrrCrr;r2r-Nrr7rrr test_basic57szTestManyStencils.test_basic57cCsFdd}tddd}tddd}|j|||ddidd S) z?2 args, standard_indexing, split index with broadcast mutation cSs|dd}|d|dS)NrrrrrDrrrrs z-TestManyStencils.test_basic58..kernelrrCrr;r2r-Nrr7rrr test_basic58szTestManyStencils.test_basic58cCsPdd}tddd}tddd}d}|j||||ddd gid d S) z>3 args, mix of array, relative and standard indexing and constcSs|d|d|SNrrrrDrrrr sz-TestManyStencils.test_basic59..kernelrrCrrr;r2rr-NrrErrr test_basic59 s zTestManyStencils.test_basic59cCs^dd}tddd}tddd}d}|jtd}|j||||dd d gi|d d S) zP3 args, mix of array, relative and standard indexing, tuple pass throughcSs|d|d|dS)NrrrrrDrrrr sz-TestManyStencils.test_basic60..kernelrrCr)r)rr;r2rr2N)rhrzr{rr[rq)rKrrr2rrrrr test_basic60 s" zTestManyStencils.test_basic60cCsHdd}tddd}tddd}|j|||dditdd S) z"2 args, standard_indexing on firstcSs|d|dSrXrr1rrrr sz-TestManyStencils.test_basic61..kernelrrCrr;rr2N)rhrzr{rqrr7rrr test_basic61 szTestManyStencils.test_basic61cCsHdd}tddd}tddd}|j|||dddd d S) z"2 args, standard_indexing and cvalcSs|d|dSrXrr1rrrr- sz-TestManyStencils.test_basic62..kernelrrCrr2r)r;r,r-Nrr7rrr test_basic62+ szTestManyStencils.test_basic62cCsZdd}tddd}tddd}|jttttd}|j|||dd i|d d S) zQ2 args, standard_indexing applied to relative, should fail, non-const idxcSs|d|dfS)Nrrrr1rrrr< sz-TestManyStencils.test_basic63..kernelrrCrrrOr;r2r2Nrhrzr{rr[rrqrPrrr test_basic639 s$zTestManyStencils.test_basic63cCs8dd}tddd}|j||ddittgdd S) z!1 arg that uses standard_indexingcSs|dSr7rrrrrrP sz-TestManyStencils.test_basic64..kernelrrCrr;rr2Nrrrrr test_basic64N szTestManyStencils.test_basic64cCs*dd}td}|j||ddiddS)zbasic induced neighborhood testcSs(d}tddD]}|||7}q|dSNrrr%rcumulr(rrrr^ sz-TestManyStencils.test_basic65..kernelN@r")rarr-Nr$rrrr test_basic65\ s zTestManyStencils.test_basic65cCs*dd}td}|j||ddiddS)zbasic const neighborhood testcSs(d}tddD]}||d7}q|dSr`r%rcrrrri sz-TestManyStencils.test_basic66..kernelrer"rfr-Nr$rrrr test_basic66g s zTestManyStencils.test_basic66cCs2dd}tddd}|j||ddidd S) z"basic 2d induced neighborhood testcSs<d}tddD]$}tddD]}||||f7}qq|dSNrr r2r%rrdr(rrrrrs s z-TestManyStencils.test_basic67..kerneli@rr"rrjrr-Nrrrrr test_basic67q szTestManyStencils.test_basic67cCs8dd}tddd}|j||ddittgdd S) z basic 2d induced 1D neighborhoodcSs,d}tddD]}||d|f7}q|dS)Nrrjrrkr%)rrdrrrrr~ sz.TestManyStencils.test_basic67b..kernelrmrrnr")rpr2N)rhrzr{rqrr[rrrr test_basic67b| szTestManyStencils.test_basic67bcCs2dd}tddd}|j||ddidd S) z0basic 2d one induced, one cost neighborhood testcSs<d}tddD]$}tddD]}|||df7}qq|dSrir%rlrrrr s z-TestManyStencils.test_basic68..kernelrmrrnr"ror-Nrrrrr test_basic68 szTestManyStencils.test_basic68cCs2dd}tddd}|j||ddidd S) z#basic 2d two cost neighborhood testcSs8d}tddD] }tddD]}||d7}qq|dS)Nrr rrjr8rkr%rlrrrr s z-TestManyStencils.test_basic69..kernelrmrrnr"ror-Nrrrrr test_basic69 szTestManyStencils.test_basic69cCs2dd}tddd}|j||ddidd S) zneighborhood adding complexitycSsLd}d}tddD]0}||}tddD]}||||f|7}q(q|dS)Nrrr rrjrkr%rrdzzr(rrrrrr sz-TestManyStencils.test_basic70..kernelrmrrnr"ror-Nrrrrr test_basic70 szTestManyStencils.test_basic70cCs*dd}td}|j||ddiddS)zneighborhood, type changecSs<d}tddD]$}d}|dkr"d}||||7}q|dS)Nrrargirrbr%)rrdr(rrrrr sz-TestManyStencils.test_basic71..kernelrer"rfr-Nr$rrrr test_basic71 s zTestManyStencils.test_basic71cCs*dd}td}|j||ddiddS)z+neighborhood, narrower range than specifiedcSs(d}tddD]}|||7}q|dS)Nrirrbr%rcrrrr sz-TestManyStencils.test_basic72..kernelrer"rfr-Nr$rrrr test_basic72 s zTestManyStencils.test_basic72cCs*dd}td}|j||ddiddS)zneighborhood, +ve rangecSs(d}tddD]}|||7}q|dS)Nrr rbr%rcrrrr sz-TestManyStencils.test_basic73..kernelrer"))rrr-Nr$rrrr test_basic73 s zTestManyStencils.test_basic73cCs*dd}td}|j||ddiddS)zneighborhood, -ve rangecSs(d}tddD]}|||7}q|dS)Nrrjr#rbr%rcrrrr sz.TestManyStencils.test_basic73b..kernelrer"))rjr r-Nr$rrrr test_basic73b s zTestManyStencils.test_basic73bcCs*dd}td}|j||ddiddS)z!neighborhood, -ve->+ve range spancSs(d}tddD]}|||7}q|dS)Nrr rzrbr%rcrrrr sz-TestManyStencils.test_basic74..kernelrer"))r rr-Nr$rrrr test_basic74 s zTestManyStencils.test_basic74cCs*dd}td}|j||ddiddS)z!neighborhood, -ve->-ve range spancSs(d}tddD]}|||7}q|dS)Nrrjrrbr%rcrrrr sz-TestManyStencils.test_basic75..kernelrer"))rjr.r-Nr$rrrr test_basic75 s zTestManyStencils.test_basic75cCs2dd}tddd}|j||ddidd S) zneighborhood, mixed range spancSsLd}d}tddD]0}||}tddD]}||||f|7}q(q|dS)Nrrrrrkr%rurrrr sz-TestManyStencils.test_basic76..kernelrmrrnr"))rr)rrCr-Nrrrrr test_basic76 szTestManyStencils.test_basic76cCsFdd}tddd}tddd}|j|||ddidd S) z neighborhood, two args cSsHd}tddD]0}tddD] }||||f|||f7}qq|dSNrrrr;r%rr2rdr(rrrrr s  z-TestManyStencils.test_basic77..kernelrmrrnr"rrrr-Nrr7rrr test_basic77 szTestManyStencils.test_basic77cCsFdd}tddd}tddd}|j|||ddidd S) z. neighborhood, two args, -ve range, -ve range cSsHd}tddD]0}tddD] }||||f|||f7}qq|dS)Nrr.rr;r%rrrrr s  z-TestManyStencils.test_basic78..kernelr@rJrnr")rr)rr.r-Nrr7rrr test_basic78 szTestManyStencils.test_basic78cCsFdd}tddd}tddd}|j|||ddidd S) z. neighborhood, two args, -ve range, +ve range cSsHd}tddD]0}tddD] }||||f|||f7}qq|dS)Nrrr.r/rr;r%rrrrr s  z.TestManyStencils.test_basic78b..kernelrrJrnr")r)r/ r-Nrr7rrr test_basic78b szTestManyStencils.test_basic78bcCs\dd}tddd}tdddd}|jttttd}|j|||dd i|d d S) z% neighborhood, two incompatible args cSsHd}tddD]0}tddD] }||||f|||f7}qq|dSrr%rrrrr* s  z-TestManyStencils.test_basic79..kernelrmrrnr/rOr"rr2N)rhrzr{rr[rrqrPrrr test_basic79( s$zTestManyStencils.test_basic79cCs8dd}tddd}d}|j|||ddid d S) z neighborhood, type change cSs@d}tddD](}tddD]}||||f|7}qq|dSrr%rrrrr> s z-TestManyStencils.test_basic80..kernelrmrrny(@r"rr-Nrr7rrr test_basic80< szTestManyStencils.test_basic80cCsTdd}tddd}|d}|jttttd}|j|||dd i|d d S) z1 neighborhood, dimensionally incompatible arrays cSsDd}tddD],}tddD]}||||f||7}qq|dSrr%rrrrrJ s z-TestManyStencils.test_basic81..kernelrmrrnrrOr"rr2N) rhrzr{copyrr[rrrqrPrrr test_basic81H s$ zTestManyStencils.test_basic81cCs>dd}tddd}|}|j|||dddd d S) z% neighborhood, with standard_indexingcSsDd}tddD],}tddD]}||||f|d7}qq|dSNrrrrrCr;r%rrrrr^ s z-TestManyStencils.test_basic82..kernelrmrrnrr2)r"r;r-Nrhrzr{rrqr7rrr test_basic82\ szTestManyStencils.test_basic82cCs@dd}tddd}|}|j|||dddd d d S) z. neighborhood, with standard_indexing and cvalcSsDd}tddD],}tddD]}||||f|d7}qq|dSrr%rrrrrm s z-TestManyStencils.test_basic83..kernelrmrrnrr2?r"r;r,r-Nrr7rrr test_basic83k szTestManyStencils.test_basic83cCs*dd}tddd}|||dS)z kernel calls njit cSs|dt|dSNr8r)r?rrrrr| sz-TestManyStencils.test_basic84..kernelrmrrnNrrrrr test_basic84z szTestManyStencils.test_basic84cCs*dd}tddd}|||dS)z! kernel calls njit(parallel=True)cSs|dt|dSr)rBrrrrr sz-TestManyStencils.test_basic85..kernelrmrrnNrrrrr test_basic85 szTestManyStencils.test_basic85cCs8dd}tddd}|j||ddittgddS) z bad kwarg cSs|dSr7rrrrrr sz-TestManyStencils.test_basic86..kernelrmrrnbadr2Nrrrrr test_basic86 s zTestManyStencils.test_basic86cCs*dd}tddd}|||dS)z reserved arg name in use cSs|dSr7r)Z __sentinel__rrrr sz-TestManyStencils.test_basic87..kernelrmrrnNrrrrr test_basic87 szTestManyStencils.test_basic87cCsDdd}tddd}|jttttd}|j||di|dd S) z use of reserved word cSs ||dSrr)rryrrrr sz-TestManyStencils.test_basic88..kernelrrCrrOr*r2Nr]r3rrr test_basic88 szTestManyStencils.test_basic88cCs*dd}tddd}|||dS)z basic multiple returncSs,|ddkrdS|ddkr$|dSdSdS)Nrrrrrr8rrrrrrr s   z-TestManyStencils.test_basic89..kernelrmrrnNrrrrr test_basic89 szTestManyStencils.test_basic89cCs@dd}tddd}|}|j|||dddd d d S) z@ neighborhood, with standard_indexing and cval, multiple returnscSs\d}tddD],}tddD]}||||f|d7}qq|d}|dkrT|dS|SdS)Nrrrrr;rmr*r%)rr2rdr(rresrrrr sz-TestManyStencils.test_basic90..kernelrmrrnrr2rrr-Nrr7rrr test_basic90 s zTestManyStencils.test_basic90cCs*dd}tddd}|||dS)z? Issue #3454, const(int) == const(int) evaluating incorrectly. cSsd}ddkrd}|d|S)Nrr/r8rr1rrrr sz-TestManyStencils.test_basic91..kernelrmrrnNrrrrr test_basic91 szTestManyStencils.test_basic91cCs<dd}ttddddtj}|||dS)7 Issue #3497, bool return type evaluating incorrectly. cSsH|d|dA|dA|dA|dA|dA|dA|dA|d AS Nrrrrr8rrrrrrrrrr sz-TestManyStencils.test_basic92..kernelrnr/rrNrhr'rzr{rrrqrKrrrrr test_basic92 s$zTestManyStencils.test_basic92cCsDdd}ttddddtj}|j||ddid d S) rcSsH|d|dA|dA|dA|dA|dA|dA|dA|d ASrrrrrrr sz-TestManyStencils.test_basic93..kernelrnr/rrr,Tr-Nrrrrr test_basic93 s$zTestManyStencils.test_basic93cCs8dd}tjdtjddd}|j||ddid d S) z" Issue #3528. Support for slices. cSst|ddddfSNrr/rhZmedianrrrrr sz-TestManyStencils.test_basic94..kernelrnrrrr"rrr-Nrhrzuint32r{rqrrrr test_basic94 szTestManyStencils.test_basic94znot yet supportedcCs0dd}tjdtjddd}|||dS)z Slice, calculate neighborhood. cSst|ddddfS)Nrr/rrrrrrrr sz-TestManyStencils.test_basic95..kernelrnrrrNrrrrr test_basic95 szTestManyStencils.test_basic95cCs0dd}tjdtjd}|j||ddiddS) z 1D slice. cSst|ddSrrrrrrr sz-TestManyStencils.test_basic96..kernelrnrr")rr-N)rhrzrrqrrrr test_basic96 szTestManyStencils.test_basic96cCs0dd}tjdtjddd}|||dS)z 2D slice and index. cSst|dddfS)Nrr/rCrrrrrr sz-TestManyStencils.test_basic97..kernelrnrrrNrrrrr test_basic97 szTestManyStencils.test_basic97cCsXtjtjtj tdtd fD]2}dd}tdd}|j||d|ddq d S) rrcSs|dSr7rrrrrr sz-TestManyStencils.test_basic98..kernelg@)r/rCr)r"r,r-N)rhrrrrzr{rq)rKr,rrrrr test_basic98 s $ zTestManyStencils.test_basic98)srrrsrtrJrqrrrrrrrrrrrrrrrrrrrrrrrr r rrrrrrrrr r!unittestskipr#r%r&r(r,r.r0r1r4r5r8r:r<r?rArBrCrFrHrIrKrMrNrQrRrSrUrVrWrYrZr[r\r^r_rgrhrqrrrsrtrwrxryr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrurrrMrrs 4                                                   r__main__)r)5sysZnumpyrhrrrFrr contextlibrrrrYrrZnumba.core.utilsrZ numba.corerZnumba.core.compilerr r Znumba.core.cpur Znumba.tests.supportr r rZnumba.core.errorsrrrrrrr)r0r3r6r:r<r=r?rBZskipIfZTestCaserErvrrrrrmainrrrrs              7yh '