
    xKgA                        d dl Z d dlmZmZ d dlZd dlZd dlmZ d dlZ	d dl
Z
d dlmZmZmZmZmZ d dlmZ d dlmZ d Z ej*                  d       G d	 d
ej,                               Ze
j0                  e j2                  e
j4                  e j6                  e
j8                  e j:                  iZe
j>                  e j@                  e
jB                  e jD                  e
jF                  e jH                  e
jJ                  e jL                  e
jN                  e jP                  e
jR                  e jT                  e
jV                  e jX                  e
jZ                  e j\                  e
j^                  e j`                  e
jb                  e jd                  e
jf                  e jh                  e
jj                  e jl                  iZ7e
jp                  e jr                  e
jt                  e jv                  e
jx                  e jz                  e
j|                  e j~                  e
j                  e j                  e
j                  e j                  iZDd ZEej                  d        ZG G d de j                        ZIde j                  fdZKd ZLy)    N)defaultdictOrderedDict)SimpleNamespace)typestargetconfigirrewritescompiler)npydecl)DUFuncc                 B    t        | t        j                  t        f      S N)
isinstancenpufuncr   )funcs    ^/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/numba/np/ufunc/array_exprs.py	_is_ufuncr      s    dRXXv.//    zafter-inferencec                   X     e Zd ZdZ fdZd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd Z xZS )RewriteArrayExprszThe RewriteArrayExprs class is responsible for finding array
    expressions in Numba intermediate representation code, and
    rewriting those expressions to a single operation that will expand
    into something similar to a ufunc call.
    c                 |    t        t        | 
  |g|i | |j                  j                  }d|vr
t
        |d<   y y )N	arrayexpr)superr   __init__	targetctxspecial_ops_lower_array_expr)selfstateargskwsr   	__class__s        r   r   zRewriteArrayExprs.__init__   sC    /DDDoo11k)'8K$ *r   c                 ,   t        |      dk(  ry|| _        || _        t               | _        i | _        |j                  t        j                        }|D ]  }|j                  j                  }|j                  }t        |t        j                        r>t        |j                  |d      t        j                         r| j#                  |||       }t        |t        j$                        s|| j
                  |<    t        | j                        dkD  S )z
        Using typing and a basic block, search the basic block for array
        expressions.
        Return True when one or more matches were found, False otherwise.
        r   FN)len
crnt_blocktypemapr   array_assignsconst_assigns
find_instsr   Assigntargetnamevaluer   Exprgetr   Array_match_array_exprConst)	r   func_irblockr'   	calltypesassignmentsinstrtarget_nameexprs	            r   matchzRewriteArrayExprs.match!   s     y>Q(]&&ryy1 E,,++K;;D4)7;;{D95;;G&&udK@D"((+ 37"";/ ! 4%%&**r   c                     |j                   } j                  }|dv rE|j                  t        j                  v r)t         fd|j                         D              r|||<   yy|dk(  r|j                  j                   j                  v ro j                  |j                  j                     }t        |t        j                        r1|j                  }t        |      r j                  ||      s|||<   yyyyyy)z
        Find whether the given assignment (*instr*) of an expression (*expr*)
        to variable *target_name* is an array expression.
        unarybinopc              3   d   K   | ]'  }j                   |j                     j                   ) y wr   )r'   r-   is_internal).0varr   s     r   	<genexpr>z6RewriteArrayExprs._match_array_expr.<locals>.<genexpr>Q   s,      0.s <<)55.s   -0callN)opr(   fnr   supported_array_operatorsall	list_varsr   r-   r'   r   r   Function
typing_keyr   _has_explicit_output)r   r8   r:   r9   expr_opr(   	func_typefunc_keys   `       r   r2   z#RewriteArrayExprs._match_array_exprB   s     ''****7<<<  0"nn.0 0-2k*0 & tyy~~'ETYY^^4I)U^^4$//X&44T8D5:k2 E ' 5 (F r   c                     t        |j                        t        |j                        z   }|j                  y||j                  kD  S )zr
        Return whether the *expr* call to *func* (a ufunc) features an
        explicit output argument.
        T)r%   r!   r"   varargnin)r   r:   r   nargss       r   rM   z&RewriteArrayExprs._has_explicit_output`   s<    
 DIITXX.;;" txxr   c                     |j                   }|dv r|j                  S |dk(  r-| j                  |j                  j                     j
                  S t        dj                  |            )Nr=   rE   z:Don't know how to find the operator for '{0}' expressions.)rF   rG   r'   r   r-   rL   NotImplementedErrorformatr   ir_exprir_ops      r   _get_array_operatorz%RewriteArrayExprs._get_array_operatorl   sb    

&&::f_<< 1 12===!HOO 	r   c                     |j                   }|dk(  r|j                  |j                  fS |dk(  r|j                         S |dk(  r|j                  S t        dj                  |            )z{Given a Numba IR expression, return the operands to the expression
        in order they appear in the expression.
        r?   r>   rE   z:Don't know how to find the operands for '{0}' expressions.)rF   lhsrhsrJ   r!   rV   rW   rX   s      r   _get_operandszRewriteArrayExprs._get_operandsv   sn     

G;;++g$$&&f_<<!HOO 	r   c                     |j                   }|dk(  r|j                  S | j                  |      D cg c](  }| j                  j	                  |j
                  |      * }}| j                  |      |fS c c}w )zZTranslate the given expression from Numba IR to an array expression
        tree.
        r   )rF   r:   r_   r)   r0   r-   r[   )r   rY   rZ   op_varoperands_or_argss        r   _translate_exprz!RewriteArrayExprs._translate_expr   s     

K<<*.*<*<W*EG*E !..226;;G*E 	 G''02BBBGs   -A3c                 r   i }t               }t        t              }| j                  j	                         D ]  }|j
                  }g }| j                  |      |f}t        j                  d|j                  || j                  |j                  j                           }t        j                  ||j                  |j                        }	|	||<   |	| j                  |j                  j                  <   | j                  |      D ]*  }
|
j                  }|
j                  r|| j                  v r| j                  |   }|j
                  }|j!                         }|D ]  }
||
j                  xx   dz  cc<    |j#                  | j%                  |             |j                  j                  s|j'                  |j                  j                         d||<   || j(                  v r |j#                  | j(                  |          ||
j                  xx   dz  cc<   |j#                  |
       -  |||fS )ztIterate over the matches, trying to find which instructions should
        be rewritten, deleted, or moved.
        r   )rF   locr:   ty   N)setr   intr(   valuesr.   r[   r   r/   re   r'   r,   r-   r+   r_   is_temprJ   appendrc   addr)   )r   replace_map	dead_vars	used_varsr8   r:   arr_inpsarr_exprnew_expr	new_instroperandoperand_namechild_assign
child_exprchild_operandss                  r   _handle_matchesz!RewriteArrayExprs._handle_matches   s    E	$	''..0E;;DH//5x?Hww+#'88$,"&,,u||/@/@"ACH 		(ELL%))DI!*K4=Du||001--d3&||??|t7I7I'I#'#5#5l#CL!-!3!3J%/%9%9%;N#1!',,/14/ $2OOD$8$8$DE#**22!l&9&9&>&>?48L1!T%7%77OOD$6$6|$DEgll+q0+OOG,! 4 18 Iy00r   c                 ,    ||   }||v r
||   }||v r
|S )zFind the final replacement instruction for a given initial
        instruction by chasing instructions in a map from instructions
        to replacement instructions.
         )r   replacement_mapr8   replacements       r   _get_final_replacementz(RewriteArrayExprs._get_final_replacement   s0    
 &e,_,)+6K _,r   c                 `   | j                         \  }}}| j                  j                         }|j                          i }| j                  j                  D ]+  }t        |t        j                        r||v r| j                  ||      }|s7|j                  |       |j                  j                         D ]H  }|j                  }	|	|v r |j                  |j                  |	             ||	   dkD  s<||	xx   dz  cc<   J |j                  |       t        |t        j                        rA|j                  }
||
   dkD  r||
xx   dz  cc<   |||
<   |
|vs|j                  |       |j                  |       . |r&|j                         D ]  }|j!                  |        |S )z}When we've found array expressions in a basic block, rewrite that
        block, returning a new, transformed block.
        r   rg   )rz   r&   copyclearbodyr   r   r+   r   rl   r.   rJ   r-   popDelrj   insert_before_terminator)r   rn   ro   rp   result
delete_mapr8   r~   rC   var_nameinstr_values              r   applyzRewriteArrayExprs.apply   s}    -1,@,@,B)Y	 %%'
__))E%+K'"&"="=#U#,K"k2#.#4#4#>#>#@C'*xxH':5 &jnnX.F G(2Q6 )( 3q 8 3 $A MM%(E266*#kk[)A-k*a/*.3J{+ 	1MM%(e$1 *2 #**,//6 -r   )__name__
__module____qualname____doc__r   r;   r2   rM   r[   r_   rc   rz   r   r   __classcell__r#   s   @r   r   r      s=    
9+B;<
 	C#1J(r   r   c                    t        | t              r~| \  }}g }i }|D ]2  }t        |      \  }}|j                  |       |j	                  |       4 |t
        j                  v rt        |      dk(  rg|t        v r*t        j                  |d   t        |          |d         |fS |t        v rt        j                  |d   t        |          g|d   g      |fS |t        v sJ t        j                  t        |          |d         |fS t        |      rGdj!                  t#        t%        |            j'                  dd            }t        j(                  |t        j*                               }	|||<   t        j,                  |	|g       }
|
|fS t        | t.        j0                        rwt        j(                  | j2                  t        j*                         | j4                  j6                  | j4                  j8                  r| j4                  j8                  nd      i fS t        | t.        j:                        r!t        j<                  | j>                        i fS tA        d| d	      )
z[Build a Python expression AST from an array expression built by
    RewriteArrayExprs.
       r   rg   z__ufunc_or_dufunc_{0}-_)lineno
col_offsetz.Don't know how to translate array expression '')!r   tuple_arr_expr_to_astrl   updater   rH   r%   _binopsastBinOp_cmpopsCompare	_unaryopsUnaryOpr   rW   hexhashreplaceNameLoadCallr   Varr-   re   linecolr3   Constantr.   rV   )r:   rF   arr_expr_argsast_argsenvargast_arg	child_envfn_namefn_ast_nameast_calls              r   r   r   
  s    $ M C!1#!6GYOOG$JJy! ! 2228}!=99 WR[]HQKABEF F=;; gbkm_x{mEFIJ J Y&{{9R=?HQK@#EEr]-44DH%%c3/1G((7CHHJ7KCLxxXr:HS= 	D"&&	!xx		388:#xx}}3788<<488<<QHIKL 	L 
D"((	#||DJJ'++
?CEG Gr   c              #     K   t               }| D ]  }|j                  }|j                  j                  ||j                        j                  }|j                  dd      j                  dd      }||v rt        |d      ||f||<   ||_         t        |      }	 | |j                         D ]  \  }}||_         y# |j                         D ]  \  }}||_         w xY ww)za
    Legalize names in the variable list for use as a Python function's
    parameter names.
    )re   $r   .z not uniqueN)	r   r-   scoperedefinere   r   AssertionErrorlistrj   )var_listvar_maprC   old_namenew_nameparam_namess         r   _legalize_parameter_namesr   2  s      mG8899%%hCGG%<AA##C-55c3?w H<{!;<<M  w-K  %^^-MCCH .W^^-MCCH .s   BC'C # C'!C$$C'c                   P     e Zd Zdej                  dej                  f fdZ xZS )_EraseInvalidLineRangesnodereturnc                     t         |   |      }t        |d      r*t        |dd       |j                  |j
                  kD  r|`|`|S )Nr   
end_lineno)r   generic_visithasattrgetattrr   r   )r   r   r#   s     r   r   z%_EraseInvalidLineRanges.generic_visitM  sJ    w$T*4"t\40<;;0r   )r   r   r   r   ASTr   r   r   s   @r   r   r   L  s#    #'' cgg  r   r   astreec                     t        j                  |        t               j                  |        t        j                  |        y)z)Inplace fixes invalid lineno ranges.
    N)r   fix_missing_locationsr   visit)r   s    r   _fix_invalid_lineno_rangesr   W  s1     f%##F+f%r   c                     dt        t        |            j                  dd      z  }|j                  j                  }|j                         }t        t        |      d       }|D cg c]  }|j                   }}t        |      5 }|D 	cg c]  }	t        j                  |	d       }
}	t        j                  dj                  |      |d      }t        |d	      rt        |j                         d
k(  sJ |j                   d   }|
|j"                  _        t%        |j&                        \  |j                   d   _        }t+        |       ddd       t-        |d      }t/        |       ||   } j0                  } j2                   |j4                   fd|D         }g }|j"                  D ]o  }t7        |t8        j:                        r|j<                  }t7        |t8        j>                        r|jA                  |jB                         _|jA                  |       q  |jD                  jB                  | tG        jH                         jK                         }|tM        jN                         n|jQ                         }d|_)        |jU                  ||d      ddl+m,}  G fdd|jZ                        }t]        t        |      d
|      }|j^                  |j`                  z   |_1        |D cg c]  } je                  |       }}|jg                  |||||      S c c}w c c}	w # 1 sw Y   xY wc c}w )z:Lower an array expression built by RewriteArrayExprs.
    z__numba_array_expr_%sr   r   c                     | j                   S r   )r-   )rC   s    r   <lambda>z#_lower_array_expr.<locals>.<lambda>j  s    r   )keyNzdef {0}(): returnexecr   rg   r   c              3   @   K   | ]  }j                  |        y wr   )typeof)rB   r-   lowerers     r   rD   z$_lower_array_expr.<locals>.<genexpr>  s     E94'...9s   numpyF)flagscaching)npyimplc                       e Zd Z fdZy)%_lower_array_expr.<locals>.ExprKernelc           
      j   t        || j                  j                  
j                        }|D cg c]  \  }}}| j                  |||       }}}}| j                  j                  	j                  
|      }| j                  |
j                  | j                  j                        S c c}}}w r   )zip	outer_sigr!   castcontextcall_internalfndescreturn_type)r   r!   arg_zipvalintyoutty	cast_argsr   buildercres	inner_sigs           r   generatez._lower_array_expr.<locals>.ExprKernel.generate  s    $ 3 3Y^^DG18:18-S$ 3e418  :\\//i<F99VY%:%:!^^779 9	:s   B.N)r   r   r   r   )r   r   r   s   r   
ExprKernelr     s    	9r   r   )rS   noutr   )4r   r   r   re   filenamerJ   sortedrh   r-   r   r   r   parserW   r   r%   r   r!   r   r:   r.   r   compiler   r   r   rf   r   r   Optionaltyper1   rl   dtyper   r   ConfigStacktop_or_noner
   Flagsr   error_modelcompile_subroutinenumba.npr   _Kernelr   rS   r   rT   loadvarnumpy_ufunc_kernel)r   r:   	expr_nameexpr_filenameexpr_var_listexpr_var_uniquerC   	expr_argsexpr_params
param_namer   
ast_moduleast_fn	namespacecode_objimplr   r   inner_sig_argsargtyr   r   r   r   r-   r!   r   r   r   s   `                         @@@r   r   r   b  s    (3tDz?+B+B3+LMIHH%%MNN$M S/5IJO &55_c_I5 
#?	3{&13&1
 GGJ-&1 	 3 YY299)D,f6
z6*s:??/Cq/HHH##*:499*E'Ai":. 
4 z=&9H9YD ooGooGE9EFINeU^^,JJEeU[[)!!%++.!!%(   ,	%%++^<I$$&224E %HNN5::<E  E%%gtYe.3 & 5D !9 9W__ 9 IQKE))ejj(EK.78idGOOD!iD8%%)T5*> >} 63 
4	3t 9s+   -L.L8L3/B#L8>M3L88M)Mr   collectionsr   r   
contextlibsysr   r   r   r   operator
numba.corer   r   r	   r
   numba.core.typingr   numba.np.ufunc.dufuncr   r   register_rewriteRewriter   posUAddnegUSubinvertInvertr   rm   AddsubSubmulMulttruedivDivmodModor_BitOrrshiftRShiftxorBitXorlshiftLShiftand_BitAndpowPowfloordivFloorDivr   eqEqneNotEqltLtleLtEgtGtgeGtEr   r   contextmanagerr   NodeTransformerr   r   r   r   r|   r   r   <module>rE     s   
 0  
 !   B B % (0 ,-S(( S .Sn LL#((LL#((OOSZZ	 LL#''LL#''LL#((cggLL#''LL#))OOSZZLL#**OOSZZMM3::LL#''s||" KKKKKKKKKKKK%GP    2c11 &sww &J>r   