o
    iA                     @   s  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d Zed	G d
d dejZe
je je
je je
je jiZe
je j e
j!e j"e
j#e j$e
j%e j&e
j'e j(e
j)e j*e
j+e j,e
j-e j.e
j/e j0e
j1e j2e
j3e j4e
j5e j6iZ7e
j8e j9e
j:e j;e
j<e j=e
j>e j?e
j@e jAe
jBe jCiZDdd ZEejFdd ZGG dd de jHZIde jJfddZKdd ZLdS )    N)defaultdictOrderedDict)SimpleNamespace)typestargetconfigirrewritescompiler)npydecl)DUFuncc                 C   s   t | tjtfS N)
isinstancenpufuncr   )func r   i/var/www/html/eduruby.in/lip-sync/lip-sync-env/lib/python3.10/site-packages/numba/np/ufunc/array_exprs.py	_is_ufunc   s   r   zafter-inferencec                       sh   e Zd ZdZ fddZdd Zdd Zdd	 Zd
d Zdd Z	dd Z
dd Zdd Zdd Z  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                    s>   t t| j|g|R i | |jj}d|vrt|d< d S d S )N	arrayexpr)superr   __init__Z	targetctxspecial_ops_lower_array_expr)selfstateargskwsr   	__class__r   r   r      s
   zRewriteArrayExprs.__init__c           	      C   s   t |dkrdS || _|| _t | _i | _|tj}|D ],}|j	j
}|j}t|tjr>t||dtjr>| ||| qt|tjrI|| j|< qt | jdk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_assignsZ
find_instsr   Assigntargetnamevaluer   Exprgetr   Array_match_array_exprConst)	r   Zfunc_irblockr"   Z	calltypesZassignmentsinstrtarget_nameexprr   r   r   match!   s$   
zRewriteArrayExprs.matchc                    s   |j } j}|dv r%|jtjv r%t fdd| D r#|||< dS dS |dkrP|jj j	v rR j	|jj }t
|tjrT|j}t|rV ||sX|||< dS dS dS dS dS dS )z
        Find whether the given assignment (*instr*) of an expression (*expr*)
        to variable *target_name* is an array expression.
        unarybinopc                 3   s    | ]
} j |j jV  qd S r   )r"   r'   Zis_internal.0varr   r   r   	<genexpr>Q   s    z6RewriteArrayExprs._match_array_expr.<locals>.<genexpr>callN)opr#   fnr
   supported_array_operatorsall	list_varsr   r'   r"   r   r   Function
typing_keyr   _has_explicit_output)r   r/   r1   r0   Zexpr_opr#   	func_typeZfunc_keyr   r9   r   r,   B   s(   z#RewriteArrayExprs._match_array_exprc                 C   s,   t |jt |j }|jdurdS ||jkS )zr
        Return whether the *expr* call to *func* (a ufunc) features an
        explicit output argument.
        NT)r    r   r   varargnin)r   r1   r   nargsr   r   r   rC   `   s   

z&RewriteArrayExprs._has_explicit_outputc                 C   s:   |j }|dv r
|jS |dkr| j|jj jS td|)Nr3   r;   z:Don't know how to find the operator for '{0}' expressions.)r<   r=   r"   r   r'   rB   NotImplementedErrorformatr   ir_exprir_opr   r   r   _get_array_operatorl   s   z%RewriteArrayExprs._get_array_operatorc                 C   sF   |j }|dkr|j|jfS |dkr| S |dkr|jS td|)z{Given a Numba IR expression, return the operands to the expression
        in order they appear in the expression.
        r5   r4   r;   z:Don't know how to find the operands for '{0}' expressions.)r<   lhsrhsr@   r   rH   rI   rJ   r   r   r   _get_operandsv   s   zRewriteArrayExprs._get_operandsc                    s:   |j }|dkr
|jS  fdd |D } ||fS )zZTranslate the given expression from Numba IR to an array expression
        tree.
        r   c                    s   g | ]
} j |j|qS r   )r$   r*   r'   )r7   Zop_varr9   r   r   
<listcomp>   s    z5RewriteArrayExprs._translate_expr.<locals>.<listcomp>)r<   r1   rP   rM   )r   rK   rL   Zoperands_or_argsr   r9   r   _translate_expr   s   
z!RewriteArrayExprs._translate_exprc                 C   sL  i }t  }tt}| j D ]}|j}g }| ||f}tjd|j	|| j
|jj d}t||j|j	}	|	||< |	| j|jj< | |D ][}
|
j}|
jr|| jv r| j| }|j}| }|D ]}
||
j  d7  < q_|| | |jjr||jj d||< qD|| jv r|| j|  qD||
j  d7  < ||
 qDq|||fS )ztIterate over the matches, trying to find which instructions should
        be rewritten, deleted, or moved.
        r   )r<   locr1   ty   N)setr   intr#   valuesr(   rM   r   r)   rS   r"   r&   r'   r%   rP   Zis_tempr@   appendrR   addr$   )r   replace_map	dead_vars	used_varsr/   r1   Zarr_inpsZarr_exprZnew_exprZ	new_instroperandZoperand_nameZchild_assignZ
child_exprZchild_operandsr   r   r   _handle_matches   sD   


z!RewriteArrayExprs._handle_matchesc                 C   s$   || }||v r|| }||v s|S )zFind the final replacement instruction for a given initial
        instruction by chasing instructions in a map from instructions
        to replacement instructions.
        r   )r   Zreplacement_mapr/   replacementr   r   r   _get_final_replacement   s
   z(RewriteArrayExprs._get_final_replacementc                 C   s.  |   \}}}| j }|  i }| jjD ]p}t|tjr[||v rU| ||}|rT|	| |j
 D ]}|j}	|	|v rE|	||	 ||	 dkrS||	  d8  < q4q|	| qt|tjr|j
}
||
 dkrw||
  d8  < |||
< q|
|vr|	| q|	| q|r| D ]}|| q|S )z}When we've found array expressions in a basic block, rewrite that
        block, returning a new, transformed block.
        r   rU   )r_   r!   copyclearbodyr   r   r%   ra   rY   r(   r@   r'   popDelrX   Zinsert_before_terminator)r   r[   r\   r]   resultZ
delete_mapr/   r`   r8   var_nameZinstr_valuer   r   r   apply   sB   



zRewriteArrayExprs.apply)__name__
__module____qualname____doc__r   r2   r,   rC   rM   rP   rR   r_   ra   ri   __classcell__r   r   r   r   r      s    !
%
r   c                 C   s  t | tr| \}}g }i }|D ]}t|\}}|| || q|tjv rkt|dkrX|tv rAt	
|d t|  |d |fS |tv rWt	|d t|  g|d g|fS nh|tv s^J t	t|  |d |fS t|rdtt|dd}t	|t	 }	|||< t	|	|g }
|
|fS n,t | tjrt	j| jt	 | jj| jjr| jjnddi fS t | tjrt	| ji fS t d| f )	z[Build a Python expression AST from an array expression built by
    RewriteArrayExprs.
       r   rU   z__ufunc_or_dufunc_{0}-_)lineno
col_offsetz1Don't know how to translate array expression '%r')!r   tuple_arr_expr_to_astrY   updater
   r>   r    _binopsastBinOp_cmpopsCompare	_unaryopsUnaryOpr   rI   hexhashreplaceNameLoadCallr   ZVarr'   rS   linecolr-   Numr(   rH   )r1   r<   Zarr_expr_argsast_argsenvargZast_argZ	child_envfn_nameZfn_ast_nameZast_callr   r   r   ru   
  s\   


ru   c              	   c   s    t  }| D ]-}|j}|jj||jdj}|dddd}||v r*t|d||f||< ||_qt|}z|V  W | D ]\}}||_qAdS | D ]\}}||_qOw )za
    Legalize names in the variable list for use as a Python function's
    parameter names.
    )rS   $rq   .z not uniqueN)	r   r'   scopeZredefinerS   r   AssertionErrorlistrX   )Zvar_listZvar_mapr8   Zold_namenew_nameZparam_namesr   r   r   _legalize_parameter_names2  s$   r   c                       s*   e Zd Zdejdejf fddZ  ZS )_EraseInvalidLineRangesnodereturnc                    s>   t  |}t|drt|dd d ur|j|jkr|`|`|S )Nrr   
end_lineno)r   generic_visithasattrgetattrrr   r   )r   r   r   r   r   r   M  s   
z%_EraseInvalidLineRanges.generic_visit)rj   rk   rl   rx   ASTr   rn   r   r   r   r   r   L  s    "r   astreec                 C   s$   t |  t |  t |  dS )z)Inplace fixes invalid lineno ranges.
    N)rx   fix_missing_locationsr   visit)r   r   r   r   _fix_invalid_lineno_rangesW  s   
r   c                    s  dt t|dd }|jj}| }tt|dd d}dd |D }t|?}d	d |D }t	
d
||d}	t|	drGt|	jdksIJ |	jd }
||
j_t|j\|
jd _}t|	 W d   n1 skw   Y  t|	|d}t|| || }j}j |jfdd|D  }g }|jD ]}t|tjr|j}t|tjr||j q|| q|j j| t!" # }|du rt$% n|& }d|_'|j( ||ddddl)m*} G  fddd|j+}t,t|d|d}|j-|j. |_/fdd|D }|0| ||||S )z:Lower an array expression built by RewriteArrayExprs.
    z__numba_array_expr_%srp   rq   c                 S   s   | j S r   r'   )r8   r   r   r   <lambda>j  s    z#_lower_array_expr.<locals>.<lambda>)keyc                 S   s   g | ]}|j qS r   r   r6   r   r   r   rQ   m  s    z%_lower_array_expr.<locals>.<listcomp>c                 S   s   g | ]}t |d qS r   )rx   r   )r7   
param_namer   r   r   rQ   q  s    zdef {0}(): returnexecrd   rU   r   Nc                 3   s    | ]}  |V  qd S r   )Ztypeofr7   r'   lowererr   r   r:     s    z$_lower_array_expr.<locals>.<genexpr>numpyF)flagsZcaching)npyimplc                       s   e Zd Z fddZdS )z%_lower_array_expr.<locals>.ExprKernelc                    sL   t | jjj} fdd|D } jj|} |j jjS )Nc                    s    g | ]\}}}  |||qS r   )cast)r7   valZintyZouttyr9   r   r   rQ     s    zB_lower_array_expr.<locals>.ExprKernel.generate.<locals>.<listcomp>)zip	outer_sigr   contextZcall_internalZfndescr   return_type)r   r   Zarg_zipZ	cast_argsrg   buildercres	inner_sigr9   r   generate  s   


z._lower_array_expr.<locals>.ExprKernel.generateN)rj   rk   rl   r   r   r   r   r   
ExprKernel  s    r   )rF   noutrj   c                    s   g | ]}  |qS r   )Zloadvarr   r   r   r   rQ     s    )1r~   r   r   rS   filenamer@   sortedrV   r   rx   parserI   r   r    rd   r   ru   r1   r(   r   compiler   r   r   rT   r   r   Optionaltyper+   rY   Zdtyper   r   ZConfigStackZtop_or_noner	   Flagsrb   Zerror_modelZcompile_subroutineZnumba.npr   Z_Kernelr   rF   r   rG   Znumpy_ufunc_kernel)r   r1   Z	expr_nameZexpr_filenameZexpr_var_listZexpr_var_uniqueZ	expr_argsZexpr_paramsr   Z
ast_moduleZast_fn	namespaceZcode_objimplr   r   Zinner_sig_argsZargtyr   r   r   r   r   r   )r   r   r   r   r   r   b  s\   




r   )Mrx   collectionsr   r   
contextlibsysr   r   r   r   operatorZ
numba.corer   r   r   r	   Znumba.core.typingr
   Znumba.np.ufunc.dufuncr   r   Zregister_rewriteZRewriter   posUAddnegUSubinvertInvertr|   rZ   AddsubSubmulMulttruedivDivmodModor_BitOrrshiftRShiftxorBitXorlshiftLShiftand_BitAndpowPowfloordivFloorDivrw   eqEqneNotEqltLtleLtEgtGtgeGtErz   ru   contextmanagerr   NodeTransformerr   r   r   r   r   r   r   r   <module>   sX     X
(
