o
    "ôjª.  ã                	   @  sÚ   U d dl 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 d dlmZ d dlmZmZ d 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eeeeeeeedœZded< dS )!é    )Úannotations)ÚCallable)ÚSÚAddÚExprÚBasicÚMulÚPowÚRational)Ú	fuzzy_not)ÚBoolean)ÚaskÚQTc                   s¨   t | tƒs| S | js‡ fdd„| jD ƒ}| j|Ž } t| dƒr)|  ˆ ¡}|dur)|S | jj}t	 
|d¡}|du r9| S || ˆ ƒ}|du sF| |krH| S t |tƒsO|S t|ˆ ƒS )a  
    Simplify an expression using assumptions.

    Explanation
    ===========

    Unlike :func:`~.simplify` which performs structural simplification
    without any assumption, this function transforms the expression into
    the form which is only valid under certain assumptions. Note that
    ``simplify()`` is generally not done in refining process.

    Refining boolean expression involves reducing it to ``S.true`` or
    ``S.false``. Unlike :func:`~.ask`, the expression will not be reduced
    if the truth value cannot be determined.

    Examples
    ========

    >>> from sympy import refine, sqrt, Q
    >>> from sympy.abc import x
    >>> refine(sqrt(x**2), Q.real(x))
    Abs(x)
    >>> refine(sqrt(x**2), Q.positive(x))
    x

    >>> refine(Q.real(x), Q.positive(x))
    True
    >>> refine(Q.positive(x), Q.real(x))
    Q.positive(x)

    See Also
    ========

    sympy.simplify.simplify.simplify : Structural simplification without assumptions.
    sympy.assumptions.ask.ask : Query for boolean expressions using assumptions.
    c                   s   g | ]}t |ˆ ƒ‘qS © )Úrefine)Ú.0Úarg©Úassumptionsr   úk/var/www/html/academy/tools/voices/clone/cosy-venv/lib/python3.10/site-packages/sympy/assumptions/refine.pyÚ
<listcomp>4   s    zrefine.<locals>.<listcomp>Ú_eval_refineN)Ú
isinstancer   Úis_AtomÚargsÚfuncÚhasattrr   Ú	__class__Ú__name__Úhandlers_dictÚgetr   r   )Úexprr   r   Zref_exprÚnameÚhandlerÚnew_exprr   r   r   r      s&   
%





r   c                   sÂ   ddl m} | jd }tt |¡ˆ ƒrttt |¡ˆ ƒƒr|S tt |¡ˆ ƒr*| S t|t	ƒr_‡ fdd„|jD ƒ}g }g }|D ]}t||ƒrO| 
|jd ¡ q?| 
|¡ q?t	|Ž |t	|Ž ƒ S dS )aF  
    Handler for the absolute value.

    Examples
    ========

    >>> from sympy import Q, Abs
    >>> from sympy.assumptions.refine import refine_abs
    >>> from sympy.abc import x
    >>> refine_abs(Abs(x), Q.real(x))
    >>> refine_abs(Abs(x), Q.positive(x))
    x
    >>> refine_abs(Abs(x), Q.negative(x))
    -x

    r   ©ÚAbsc                   s   g | ]	}t t|ƒˆ ƒ‘qS r   )r   Úabs)r   Úar   r   r   r   b   s    zrefine_abs.<locals>.<listcomp>N)Ú$sympy.functions.elementary.complexesr&   r   r   r   Úrealr   Únegativer   r   Úappend)r!   r   r&   r   ÚrZnon_absZin_absÚir   r   r   Ú
refine_absG   s$   
ÿ

÷r/   c                 C  sÒ  ddl m} ddlm} t| j|ƒr0tt | jj	d ¡|ƒr0tt 
| j¡|ƒr0| jj	d | j S tt | j¡|ƒ�ra| jjrett 
| j¡|ƒrOt| jƒ| j S tt | j¡|ƒre|| jƒt| jƒ| j  S t| jtƒr~t| jtƒr~t| jjƒ| jj| j  S | jtju �rc| jj�re| }| j ¡ \}}t|ƒ}tƒ }tƒ }t|ƒ}	|D ]}
tt 
|
¡|ƒr³| |
¡ q£tt |
¡|ƒrÀ| |
¡ q£||8 }t|ƒd r×||8 }|tj d }n||8 }|d }||ksét|ƒ|	k rõ| |¡ | jt|Ž  } d| j }tt 
|¡|ƒ�r| ¡ �r|| j9 }|j�rZ| ¡ \}}|j�rZ|jtju �rZtt |j¡|ƒ�rZ|d d }tt 
|¡|ƒ�rA| j|j S tt |¡|ƒ�rR| j|jd  S | j|j|  S || k�rg| S dS dS dS dS )as  
    Handler for instances of Pow.

    Examples
    ========

    >>> from sympy import Q
    >>> from sympy.assumptions.refine import refine_Pow
    >>> from sympy.abc import x,y,z
    >>> refine_Pow((-1)**x, Q.real(x))
    >>> refine_Pow((-1)**x, Q.even(x))
    1
    >>> refine_Pow((-1)**x, Q.odd(x))
    -1

    For powers of -1, even parts of the exponent can be simplified:

    >>> refine_Pow((-1)**(x+y), Q.even(x))
    (-1)**y
    >>> refine_Pow((-1)**(x+y+z), Q.odd(x) & Q.odd(z))
    (-1)**y
    >>> refine_Pow((-1)**(x+y+2), Q.odd(x))
    (-1)**(y + 1)
    >>> refine_Pow((-1)**(x+3), True)
    (-1)**(x + 1)

    r   r%   )Úsigné   é   N)r)   r&   Zsympy.functionsr0   r   Úbaser   r   r*   r   ÚevenÚexpÚ	is_numberr'   Úoddr
   r	   r   ÚNegativeOneÚis_AddÚas_coeff_addÚsetÚlenÚaddÚOner   Úcould_extract_minus_signÚas_two_termsÚis_PowÚinteger)r!   r   r&   r0   ÚoldÚcoeffÚtermsZ
even_termsZ	odd_termsZinitial_number_of_termsÚtZ	new_coeffÚe2r.   Úpr   r   r   Ú
refine_Powm   sv   ÿ

€




Á
3rI   c                 C  s"  ddl m} | j\}}tt |¡t |¡@ |ƒr||| ƒS tt |¡t |¡@ |ƒr4||| ƒtj	 S tt |¡t |¡@ |ƒrJ||| ƒtj	 S tt 
|¡t |¡@ |ƒrZtj	S tt |¡t 
|¡@ |ƒrltj	d S tt |¡t 
|¡@ |ƒrtj	 d S tt 
|¡t 
|¡@ |ƒr�tjS | S )aÃ  
    Handler for the atan2 function.

    Examples
    ========

    >>> from sympy import Q, atan2
    >>> from sympy.assumptions.refine import refine_atan2
    >>> from sympy.abc import x, y
    >>> refine_atan2(atan2(y,x), Q.real(y) & Q.positive(x))
    atan(y/x)
    >>> refine_atan2(atan2(y,x), Q.negative(y) & Q.negative(x))
    atan(y/x) - pi
    >>> refine_atan2(atan2(y,x), Q.positive(y) & Q.negative(x))
    atan(y/x) + pi
    >>> refine_atan2(atan2(y,x), Q.zero(y) & Q.negative(x))
    pi
    >>> refine_atan2(atan2(y,x), Q.positive(y) & Q.zero(x))
    pi/2
    >>> refine_atan2(atan2(y,x), Q.negative(y) & Q.zero(x))
    -pi/2
    >>> refine_atan2(atan2(y,x), Q.zero(y) & Q.zero(x))
    nan
    r   )Úatanr1   )Ú(sympy.functions.elementary.trigonometricrJ   r   r   r   r*   Úpositiver+   r   ÚPiÚzeroÚNaN)r!   r   rJ   ÚyÚxr   r   r   Úrefine_atan2Ñ   s"   

rR   c                 C  s>   | j d }tt |¡|ƒr|S tt |¡|ƒrtjS t| |ƒS )a  
    Handler for real part.

    Examples
    ========

    >>> from sympy.assumptions.refine import refine_re
    >>> from sympy import Q, re
    >>> from sympy.abc import x
    >>> refine_re(re(x), Q.real(x))
    x
    >>> refine_re(re(x), Q.imaginary(x))
    0
    r   )r   r   r   r*   Ú	imaginaryr   ÚZeroÚ_refine_reim©r!   r   r   r   r   r   Ú	refine_reþ   s   

rW   c                 C  sF   | j d }tt |¡|ƒrtjS tt |¡|ƒrtj | S t| |ƒS )a  
    Handler for imaginary part.

    Explanation
    ===========

    >>> from sympy.assumptions.refine import refine_im
    >>> from sympy import Q, im
    >>> from sympy.abc import x
    >>> refine_im(im(x), Q.real(x))
    0
    >>> refine_im(im(x), Q.imaginary(x))
    -I*x
    r   )	r   r   r   r*   r   rT   rS   ÚImaginaryUnitrU   rV   r   r   r   Ú	refine_im  s   

rY   c                 C  s:   | j d }tt |¡|ƒrtjS tt |¡|ƒrtjS dS )a"  
    Handler for complex argument

    Explanation
    ===========

    >>> from sympy.assumptions.refine import refine_arg
    >>> from sympy import Q, arg
    >>> from sympy.abc import x
    >>> refine_arg(arg(x), Q.positive(x))
    0
    >>> refine_arg(arg(x), Q.negative(x))
    pi
    r   N)r   r   r   rL   r   rT   r+   rM   )r!   r   Úrgr   r   r   Ú
refine_arg+  s   
r[   c                 C  s.   | j dd�}|| krt||ƒ}||kr|S d S )NT)Úcomplex)Úexpandr   )r!   r   ÚexpandedZrefinedr   r   r   rU   B  s   
rU   c                 C  s¦   | j d }tt |¡|ƒrtjS tt |¡ƒr-tt |¡|ƒr"tjS tt 	|¡|ƒr-tj
S tt |¡ƒrQ| ¡ \}}tt |¡|ƒrEtjS tt 	|¡|ƒrQtj S | S )a*  
    Handler for sign.

    Examples
    ========

    >>> from sympy.assumptions.refine import refine_sign
    >>> from sympy import Symbol, Q, sign, im
    >>> x = Symbol('x', real = True)
    >>> expr = sign(x)
    >>> refine_sign(expr, Q.positive(x) & Q.nonzero(x))
    1
    >>> refine_sign(expr, Q.negative(x) & Q.nonzero(x))
    -1
    >>> refine_sign(expr, Q.zero(x))
    0
    >>> y = Symbol('y', imaginary = True)
    >>> expr = sign(y)
    >>> refine_sign(expr, Q.positive(im(y)))
    I
    >>> refine_sign(expr, Q.negative(im(y)))
    -I
    r   )r   r   r   rN   r   rT   r*   rL   r>   r+   r8   rS   Úas_real_imagrX   )r!   r   r   Zarg_reZarg_imr   r   r   Úrefine_signM  s   
r`   c                 C  sH   ddl m} | j\}}}tt |¡|ƒr"||  ¡ r| S ||||ƒS dS )aU  
    Handler for symmetric part.

    Examples
    ========

    >>> from sympy.assumptions.refine import refine_matrixelement
    >>> from sympy import MatrixSymbol, Q
    >>> X = MatrixSymbol('X', 3, 3)
    >>> refine_matrixelement(X[0, 1], Q.symmetric(X))
    X[0, 1]
    >>> refine_matrixelement(X[1, 0], Q.symmetric(X))
    X[0, 1]
    r   )ÚMatrixElementN)Ú"sympy.matrices.expressions.matexprra   r   r   r   Ú	symmetricr?   )r!   r   ra   Úmatrixr.   Újr   r   r   Úrefine_matrixelementv  s   ýrf   )r&   r	   Úatan2ÚreÚimr   r0   ra   z*dict[str, Callable[[Expr, Boolean], Expr]]r   N)T)Ú
__future__r   Útypingr   Ú
sympy.corer   r   r   r   r   r	   r
   Úsympy.core.logicr   Úsympy.logic.boolalgr   Úsympy.assumptionsr   r   r   r/   rI   rR   rW   rY   r[   rU   r`   rf   r   Ú__annotations__r   r   r   r   Ú<module>   s2    $
<&d-)ø