U
    Mh?T                     @   sX  d dl Z d dlZd dlZd dlZd dlmZ ddddddd	d
ddddddgZdd Zdd ZG dd dejZ	G dd dejZ
G dd dejZG dd dejZG dd dejZG dd de	ZG dd dejZG d d! d!ejZG d"d dejZG d#d	 d	ejZG d$d
 d
ejZd%d& Zd'd( ZG d)d dejZG d*d dejZG d+d dejZG d,d dejZG d-d dejZG d.d/ d/ejZG d0d1 d1ejZG d2d dejZG d3d dejZG d4d dejZd5d6 Z e d7Z!e d8Z"e d9Z#e d:Z$e d;Z%e d<Z&e d=Z'e d>Z(e d?Z)e d@Z*e dAZ+e dBZ,e dCZ-dS )D    N)SFloorDivModularIndexingCleanDivCeilDiv
IntTrueDivFloatTrueDivLShiftRShift!IsNonOverlappingAndDenseIndicator
RoundToIntRoundDecimalToFloatFloatPowPowByNaturalc                    s   t   fdd}|S )Nc                     s8    |  }t dd | D r4t|tjs4tt|}|S )Nc                 s   s   | ]}t |tjV  qd S N)
isinstancesympyFloat.0a r   N/var/www/html/venv/lib/python3.8/site-packages/torch/utils/_sympy/functions.py	<genexpr>   s     z-_keep_float.<locals>.inner.<locals>.<genexpr>)anyr   r   r   float)argsrfr   r   inner   s     z_keep_float.<locals>.inner)	functoolswraps)r    r!   r   r   r   _keep_float   s    r$   c                 C   s   d | |fkrd S | |kS r   r   )xyr   r   r   fuzzy_eq(   s    r'   c                   @   sH   e Zd ZdZdZdZdZedd Zedd Z	d	d
 Z
edd ZdS )r   a  
    We maintain this so that:
    1. We can use divisibility guards to simplify FloorDiv(a, b) to a / b.
    2. Printing out the expression is nicer (compared to say, representing a//b as (a - a % b) / b)

    NB: This is Python-style floor division, round to -Inf
       2   Tc                 C   s
   | j d S Nr   r   selfr   r   r   baseN   s    zFloorDiv.basec                 C   s
   | j d S N   r,   r-   r   r   r   divisorR   s    zFloorDiv.divisorc                 C   s2   | | j| j}| | j| j}d| d| dS )N(z//))Zparenthesizer/   
precedencer2   )r.   printerr/   r2   r   r   r   	_sympystrV   s    zFloorDiv._sympystrc                 C   s   |j rtd|j rtjjS |jr.|dkr.|S |jrH|dkrHt|dS t|tjrvt|tjrvtt	|t	| S t|t
rt
|jd |jd | S z8t||}|dkrt
t|| t|| W S W n tjk
r   Y nX d S )Ndivision by zeror1   r   )is_zeroZeroDivisionErrorr   r   Zero
is_integerMulr   Integerintr   r   gcdsimplifyPolynomialError)clsr/   r2   rA   r   r   r   eval]   s*    	
 
zFloorDiv.evalN)__name__
__module____qualname____doc__nargsr5   r=   propertyr/   r2   r7   classmethodrE   r   r   r   r   r   @   s   

c                   @   s4   e Zd ZdZdZdZedd Zdd Zdd	 Z	d
S )r   zK
    ModularIndexing(a, b, c) => (a // b) % c where % is the C modulus
       Tc                 C   s  |dks|dkrt dS t|t jrJt|t jrJt|t jrJ|| | S zB|dkrt ||}|dkrtt || t || |W S W n t jk
r   Y nX t|t jrfg }d}|jD ]z}t ||| || krt|t jr|dk s$t|t j	r0t|jd t jr0|jd dk r0d} q<q|
| qt|t|jkrf|rftt|||S t|trt|jd |jd | |S d S )Nr   r1   TF)r   r?   r   rA   r   rB   rC   Addr   r>   appendlensumr   )rD   r/   r2   modulusrA   Z	new_termsZall_positivetermr   r   r   rE      sN    






	zModularIndexing.evalc                 C   s    | j d d \}}t|j|jS Nr)   )r   r'   is_nonnegativer.   pqr   r   r   _eval_is_nonnegative   s    z$ModularIndexing._eval_is_nonnegativec                 C   s    | j d d \}}t|j|jS rU   )r   r'   is_positiverW   r   r   r   _eval_is_positive   s    z!ModularIndexing._eval_is_positiveN)
rF   rG   rH   rI   rJ   r=   rL   rE   rZ   r\   r   r   r   r   r      s   
0c                   @   s8   e Zd ZdZdZdd Zdd Zdd Zed	d
 Z	dS )Wherez#
    Good ol' ternary operator
    rM   c                 C   s    | j d jr| j d jrdS d S Nr1   r)   T)r   r=   r-   r   r   r   _eval_is_integer   s    zWhere._eval_is_integerc                 C   s    | j d jr| j d jrdS d S r^   )r   rV   r-   r   r   r   rZ      s    

zWhere._eval_is_nonnegativec                 C   s    | j d jr| j d jrdS d S r^   r   r[   r-   r   r   r   r\      s    zWhere._eval_is_positivec                 C   s    |t jkr|S |t jkr|S d S r   )r   truefalse)rD   crX   rY   r   r   r   rE      s    

z
Where.evalN)
rF   rG   rH   rI   rJ   r_   rZ   r\   rL   rE   r   r   r   r   r]      s   r]   c                   @   s0   e Zd ZdZdZedd Zdd Zdd Zd	S )
	PythonModr(   Tc                 C   s   |j rtd|tjks.||| fks.|dkr4tjS |jrH|jrH|| S |jrn|dkrn|jrbtjS |jrntjS || }|jrtjS ||k }|j	rt
|r|jr|S t||dkrtjS d S )NModulo by zeror1   r)   r   )r:   r;   r   r<   	is_Numberis_evenis_oddOner=   
is_Booleanboolr[   r   ModrD   rX   rY   r   lessr   r   r   rE      s&     zPythonMod.evalc                 C   s   | j d jrdS d S Nr1   Tr`   r-   r   r   r   rZ     s    zPythonMod._eval_is_nonnegativec                 C   s   | j d jrdS d S ro   )r   Zis_negativer-   r   r   r   _eval_is_nonpositive  s    zPythonMod._eval_is_nonpositiveN)	rF   rG   rH   rJ   r=   rL   rE   rZ   rp   r   r   r   r   rd      s   
+rd   c                   @   s$   e Zd ZdZdZdZedd ZdS )rl   r(   Tc                 C   s   |j rtd|tjks.||| fks.|dkr4tjS |jrh|jrh|dksPt||dks`t||| S |jr|dkr|jrtjS |jrtjS || }|j	rtjS ||k }|j
rt|r|jr|S d S )Nre   r1   r   r)   )r:   r;   r   r<   rf   AssertionErrorrg   rh   ri   r=   rj   rk   r[   rm   r   r   r   rE   &  s&    	 zMod.evalN)rF   rG   rH   rJ   r=   rV   rL   rE   r   r   r   r   rl      s
   rl   c                   @   s   e Zd ZdZdS )r   zZ
    Div where we can assume no rounding.
    This is to enable future optimizations.
    N)rF   rG   rH   rI   r   r   r   r   r   S  s   c                   @   s   e Zd ZdZedd ZdS )	CeilToIntTc                 C   s\   |t jkrt tjd S |t j kr8t tj d S t|t jrXt tt	|S d S r0   )
r   oor?   sysmaxsizer   Numbermathceilr   rD   numberr   r   r   rE   a  s    
zCeilToInt.evalNrF   rG   rH   r=   rL   rE   r   r   r   r   rr   ^  s   rr   c                   @   s   e Zd ZdZedd ZdS )
FloorToIntTc                 C   s\   |t jkrt tjd S |t j kr8t tj d S t|t jrXt tt	|S d S r0   )
r   rs   r?   rt   ru   r   rv   rw   floorr   ry   r   r   r   rE   o  s    
zFloorToInt.evalNr{   r   r   r   r   r|   l  s   r|   c                   @   s   e Zd ZdZdZdd ZdS )r   z.
    Div used in indexing that rounds up.
    Tc                 C   sD   t |}t |}t |||kr.t||S t||d  |S d S r0   )r   ZsympifyrA   r   r   rD   r/   r2   r   r   r   __new__  s
    


zCeilDiv.__new__N)rF   rG   rH   rI   r=   r   r   r   r   r   r   z  s   c                   @   s   e Zd ZdZedd ZdS )r	   Tc                 C   s   |dk rt d|d|  S Nr   znegative shift countr)   
ValueErrorrD   r/   shiftr   r   r   rE     s    zLShift.evalNr{   r   r   r   r   r	     s   c                   @   s   e Zd ZdZedd ZdS )r
   Tc                 C   s   |dk rt d|d|  S r   r   r   r   r   r   rE     s    zRShift.evalNr{   r   r   r   r   r
     s   c                 C   s4   d}| dk r&|  } |d dkr"dnd}|t | | S )Nr1   r   r)   r9   )	_safe_pow)r/   expsignr   r   r   safe_pow  s
    r   c                 C   s   |dk rt d|dkrdS t| |d }|tjd krBtjd S || }|tjd krbtjd S |d dkr|| 9 }|tjd krtjd S |S )Nr   zExponent must be non-negative.r1   r)   )r   r   rt   ru   )r/   exponentZhalf_expresultr   r   r   r     s    


r   c                   @   s   e Zd ZdZedd ZdS )r   Tc                 C   s`   t |tjr(t |tjr(tt||S t |tjr\td}tt|D ]}||9 }qJ|S d S r0   )r   r   rv   r?   r   ranger@   )rD   r/   r   r   _r   r   r   rE     s    

zPowByNatural.evalNr{   r   r   r   r   r     s   c                   @   s    e Zd ZdZdZedd ZdS )r   FTc                 C   s2   t |tjr.t |tjr.tt|t| S d S r   )r   r   rv   r   r   )rD   r/   r   r   r   r   rE     s    zFloatPow.evalNrF   rG   rH   r=   Zis_realrL   rE   r   r   r   r   r     s   c                   @   s    e Zd ZdZdZedd ZdS )r   FTc                 C   s@   |j rtdt|tjr<t|tjr<tt|t| S d S Nr8   )r:   r;   r   r   rv   r   r   r~   r   r   r   rE     s    zFloatTrueDiv.evalNr   r   r   r   r   r     s   c                   @   s    e Zd ZdZdZedd ZdS )r   FTc                 C   s@   |j rtdt|tjr<t|tjr<tt|t| S d S r   )r:   r;   r   r   rv   r   r@   r~   r   r   r   rE     s    zIntTrueDiv.evalNr   r   r   r   r   r     s   c                   @   s   e Zd ZdZedd ZdS )r   Tc                 G   sx   t |d dkstt |d }tdd |D rtddlm} |d| }||d  }|dd |D dd |D S d S )Nr)   r   c                 s   s   | ]}t |tjV  qd S r   )r   r   r?   r   r   r   r   r     s     z9IsNonOverlappingAndDenseIndicator.eval.<locals>.<genexpr>)!eval_is_non_overlapping_and_densec                 S   s   g | ]}t |qS r   )r@   r   r   r   r   
<listcomp>   s     z:IsNonOverlappingAndDenseIndicator.eval.<locals>.<listcomp>)rQ   rq   allZ%torch.fx.experimental.symbolic_shapesr   )rD   r   dimr   Z	size_argsZstride_argsr   r   r   rE     s     z&IsNonOverlappingAndDenseIndicator.evalNr{   r   r   r   r   r     s   c                   @   s    e Zd ZdZdZedd ZdS )TruncToFloatFTc                 C   s$   t |tjr ttt|S d S r   )r   r   rv   r   rw   truncr   ry   r   r   r   rE   *  s    zTruncToFloat.evalNr   r   r   r   r   r   &  s   r   c                   @   s   e Zd ZdZedd ZdS )
TruncToIntTc                 C   s\   |t jkrt tjd S |t j kr8t tj d S t|t jrXt tt	|S d S r0   )
r   rs   r?   rt   ru   r   rv   rw   r   r   ry   r   r   r   rE   7  s    
zTruncToInt.evalNr{   r   r   r   r   r   4  s   r   c                   @   s   e Zd ZdZedd ZdS )r   Tc                 C   s$   t |tjr ttt|dS d S r+   )r   r   r   r?   roundr   ry   r   r   r   rE   F  s    zRoundToInt.evalNr{   r   r   r   r   r   C  s   c                   @   s    e Zd ZdZdZedd ZdS )r   FTc                 C   s4   t |tjr0t |tjr0ttt|t|S d S r   )r   r   r   r?   r   r   r@   )rD   rz   ndigitsr   r   r   rE   a  s    zRoundDecimal.evalNr   r   r   r   r   r   ]  s   c                   @   s    e Zd ZdZdZedd ZdS )r   FTc                 C   s4   |t jt j fkr|S t|t jr0t t|S d S r   )r   rs   r   r?   r   r@   ry   r   r   r   rE   m  s    zToFloat.evalNr   r   r   r   r   r   i  s   c                    s$   G  fdddt j}d  |_|S )Nc                       s$   e Zd ZdZ Ze fddZdS )z+make_opaque_unary_fn.<locals>.OpaqueUnaryFna  
        Unlike the builtin sympy functions on real numbers like sympy.sqrt,
        these equivalents do not do any nontrivial reasoning besides
        constant propagation.  This helps avoid performing transformations
        that are valid for real numbers but are invalid for floating point;
        in particular, while we are willing to make optimizations that change
        numerics for Tensor compute, we are NOT willing to make optimziations
        that change numerics for size compute.
        c                    s   t |tjtjfrRzttt t|W S  tk
rN   tt | Y S X n*|tjtj tj	tj	 fkr|tt |S d S r   )
r   r   r?   r   getattrrw   r   OverflowErrorrs   Zzoo)rD   r   namer   r   rE     s    z0make_opaque_unary_fn.<locals>.OpaqueUnaryFn.evalN)rF   rG   rH   rI   Z_torch_handler_namerL   rE   r   r   r   r   OpaqueUnaryFnw  s   
r   ZOpaqueUnaryFn_)r   FunctionrF   )r   r   r   r   r   make_opaque_unary_fnv  s    
r   sqrtcoscoshsinsinhtantanhasinacosatanr   logasinh).r"   rw   rt   r   r   __all__r$   r'   r   r   r   r]   rd   rl   r   rr   r|   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   ZOpaqueUnaryFn_sqrtZOpaqueUnaryFn_cosZOpaqueUnaryFn_coshZOpaqueUnaryFn_sinZOpaqueUnaryFn_sinhZOpaqueUnaryFn_tanZOpaqueUnaryFn_tanhZOpaqueUnaryFn_asinZOpaqueUnaryFn_acosZOpaqueUnaryFn_atanZOpaqueUnaryFn_expZOpaqueUnaryFn_logZOpaqueUnaryFn_asinhr   r   r   r   <module>   st   HB93

&