o
    0ôjˆ¬  ã                   @  s   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mZmZmZmZ d dlmZmZ d dlmZmZmZ d dlmZ d d	lmZ d d
l m!Z! d dl"m#Z# G dd„ deƒZ$G dd„ deƒZ%G dd„ deƒZ&G dd„ deƒZ'G dd„ deƒZ(G dd„ deƒZ)G dd„ deƒZ*G dd„ deƒZ+G dd„ deƒZ,G dd„ deƒZ-d d!„ Z.G d"d#„ d#eƒZ/d/d%d&„Z0d0d(d)„Z1d/d*d+„Z2d1d-d.„Z3d,S )2é    )Úannotations)ÚSÚAddÚMulÚsympifyÚSymbolÚDummyÚBasic)ÚExpr)Úfactor_terms)ÚDefinedFunctionÚ
DerivativeÚArgumentIndexErrorÚAppliedUndefÚ
expand_mulÚ	PoleError)Ú	fuzzy_notÚfuzzy_or)ÚpiÚIÚoo)ÚPow)ÚEq)Úsqrt)Ú	Piecewisec                   @  ól   e Zd ZU dZded< dZdZdZedd„ ƒZ	ddd„Z
d	d
„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ ZdS )Úrea÷  
    Returns real part of expression. This function performs only
    elementary analysis and so it will fail to decompose properly
    more complicated expressions. If completely simplified result
    is needed then use ``Basic.as_real_imag()`` or perform complex
    expansion on instance of this function.

    Examples
    ========

    >>> from sympy import re, im, I, E, symbols
    >>> x, y = symbols('x y', real=True)
    >>> re(2*E)
    2*E
    >>> re(2*I + 17)
    17
    >>> re(2*I)
    0
    >>> re(im(x) + x*I + 2)
    2
    >>> re(5 + I + 2)
    7

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    Returns
    =======

    expr : Expr
        Real part of expression.

    See Also
    ========

    im
    útuple[Expr]ÚargsTc                 C  s@  |t ju rt jS |t ju rt jS |jr|S |jst| jr t jS |jr)| ¡ d S |j	r8t
|tƒr8t|jd ƒS g g g }}}t |¡}|D ]7}| t¡}|d ur[|jsZ| |¡ qG| t¡si|jri| |¡ qG|j|d�}|ry| |d ¡ qG| |¡ qGt|ƒt|ƒkrždd„ |||fD ƒ\}	}
}| |	ƒt|
ƒ | S d S )Nr   ©Úignorec                 s  ó   � | ]}t |Ž V  qd S ©N©r   ©Ú.0Úxs© r'   úu/var/www/html/academy/tools/voices/clone/sv-venv/lib/python3.10/site-packages/sympy/functions/elementary/complexes.pyÚ	<genexpr>i   ó   € zre.eval.<locals>.<genexpr>)r   ÚNaNÚComplexInfinityÚis_extended_realÚis_imaginaryr   ÚZeroÚ	is_MatrixÚas_real_imagÚis_FunctionÚ
isinstanceÚ	conjugater   r   r   Ú	make_argsÚas_coefficientÚappendÚhasÚlenÚim©ÚclsÚargÚincludedZrevertedÚexcludedr   ÚtermÚcoeffÚ	real_imagÚaÚbÚcr'   r'   r(   ÚevalD   s<   




€ýzre.evalc                 K  ó
   | t jfS )zF
        Returns the real number with a zero imaginary part.

        ©r   r/   ©ÚselfÚdeepÚhintsr'   r'   r(   r1   m   ó   
zre.as_real_imagc                 C  ó^   |j s	| jd j rtt| jd |dd�ƒS |js| jd jr-t tt| jd |dd�ƒ S d S ©Nr   T©Úevaluate)r-   r   r   r   r.   r   r:   ©rJ   Úxr'   r'   r(   Ú_eval_derivativet   ó   ÿÿzre._eval_derivativec                 K  s   | j d tt| j d ƒ  S ©Nr   )r   r   r:   ©rJ   r=   Úkwargsr'   r'   r(   Ú_eval_rewrite_as_im{   s   zre._eval_rewrite_as_imc                 C  ó   | j d jS rV   ©r   Úis_algebraic©rJ   r'   r'   r(   Ú_eval_is_algebraic~   ó   zre._eval_is_algebraicc                 C  s   t | jd j| jd jgƒS rV   )r   r   r.   Úis_zeror]   r'   r'   r(   Ú_eval_is_zero�   s   zre._eval_is_zeroc                 C  ó   | j d jrdS d S ©Nr   T©r   Ú	is_finiter]   r'   r'   r(   Ú_eval_is_finite…   ó   ÿzre._eval_is_finitec                 C  rb   rc   rd   r]   r'   r'   r(   Ú_eval_is_complex‰   rg   zre._eval_is_complexN©T)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__r-   Ú
unbranchedÚ_singularitiesÚclassmethodrF   r1   rT   rY   r^   ra   rf   rh   r'   r'   r'   r(   r      s   
 )

(r   c                   @  r   )r:   aï  
    Returns imaginary part of expression. This function performs only
    elementary analysis and so it will fail to decompose properly more
    complicated expressions. If completely simplified result is needed then
    use ``Basic.as_real_imag()`` or perform complex expansion on instance of
    this function.

    Examples
    ========

    >>> from sympy import re, im, E, I
    >>> from sympy.abc import x, y
    >>> im(2*E)
    0
    >>> im(2*I + 17)
    2
    >>> im(x*I)
    re(x)
    >>> im(re(x) + y)
    im(y)
    >>> im(2 + 3*I)
    3

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    Returns
    =======

    expr : Expr
        Imaginary part of expression.

    See Also
    ========

    re
    r   r   Tc                 C  sH  |t ju rt jS |t ju rt jS |jrt jS |jst| jr#t | S |jr,| ¡ d S |j	r<t
|tƒr<t|jd ƒ S g g g }}}t |¡}|D ]7}| t¡}|d ure|js_| |¡ qK| |¡ qK| t¡sm|js‚|j|d�}|r}| |d ¡ qK| |¡ qKt|ƒt|ƒkr¢dd„ |||fD ƒ\}	}
}| |	ƒt|
ƒ | S d S )Né   r   r   c                 s  r!   r"   r#   r$   r'   r'   r(   r)   â   r*   zim.eval.<locals>.<genexpr>)r   r+   r,   r-   r/   r.   r   r0   r1   r2   r3   r4   r:   r   r   r5   r6   r7   r8   r9   r   r;   r'   r'   r(   rF   ¾   s<   





€ýzim.evalc                 K  rG   )zC
        Return the imaginary part with a zero real part.

        rH   rI   r'   r'   r(   r1   æ   rM   zim.as_real_imagc                 C  rN   rO   )r-   r   r:   r   r.   r   r   rR   r'   r'   r(   rT   í   rU   zim._eval_derivativec                 K  s   t  | jd t| jd ƒ  S rV   )r   r   r   rW   r'   r'   r(   Ú_eval_rewrite_as_reô   s   zim._eval_rewrite_as_rec                 C  rZ   rV   r[   r]   r'   r'   r(   r^   ÷   r_   zim._eval_is_algebraicc                 C  rZ   rV   ©r   r-   r]   r'   r'   r(   ra   ú   r_   zim._eval_is_zeroc                 C  rb   rc   rd   r]   r'   r'   r(   rf   ý   rg   zim._eval_is_finitec                 C  rb   rc   rd   r]   r'   r'   r(   rh     rg   zim._eval_is_complexNri   )rj   rk   rl   rm   rn   r-   ro   rp   rq   rF   r1   rT   rs   r^   ra   rf   rh   r'   r'   r'   r(   r:   Ž   s   
 )

'r:   c                      s¦   e Zd ZdZdZdZ‡ fdd„Ze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d$dd„Zdd„ Zdd„ Zd d!„ Zd"d#„ Z‡  ZS )%Úsignaæ  
    Returns the complex sign of an expression:

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

    If the expression is real the sign will be:

        * $1$ if expression is positive
        * $0$ if expression is equal to zero
        * $-1$ if expression is negative

    If the expression is imaginary the sign will be:

        * $I$ if im(expression) is positive
        * $-I$ if im(expression) is negative

    Otherwise an unevaluated expression will be returned. When evaluated, the
    result (in general) will be ``cos(arg(expr)) + I*sin(arg(expr))``.

    Examples
    ========

    >>> from sympy import sign, I

    >>> sign(-1)
    -1
    >>> sign(0)
    0
    >>> sign(-3*I)
    -I
    >>> sign(1 + I)
    sign(1 + I)
    >>> _.evalf()
    0.707106781186548 + 0.707106781186548*I

    Parameters
    ==========

    arg : Expr
        Real or imaginary expression.

    Returns
    =======

    expr : Expr
        Complex sign of expression.

    See Also
    ========

    Abs, conjugate
    Tc                   s>   t ƒ  ¡ }|| kr| jd jdu r| jd t| jd ƒ S |S )Nr   F)ÚsuperÚdoitr   r`   ÚAbs)rJ   rL   Ús©Ú	__class__r'   r(   rw   C  s   
z	sign.doitc           	      C  s:  |j rW| ¡ \}}g }t|ƒ}|D ]-}|jr| }q|jrq|jr9t|ƒ}|jr3|t9 }|jr2| }q| 	|¡ q| 	|¡ q|t
ju rNt|ƒt|ƒkrNd S || |j|Ž ƒ S |t
ju r_t
jS |jret
jS |jrkt
jS |jrqt
jS |jr{t|tƒr{|S |jr™|jr‰|jt
ju r‰tS t | }|jr“tS |jr›t S d S d S r"   )Úis_MulÚas_coeff_mulru   Úis_extended_negativeÚis_extended_positiver.   r:   Úis_comparabler   r7   r   ÚOner9   Ú_new_rawargsr+   r`   r/   ÚNegativeOner2   r3   Úis_PowÚexpÚHalf)	r<   r=   rE   r   Úunkry   rC   ÚaiÚarg2r'   r'   r(   rF   I  sT   €


÷z	sign.evalc                 C  s   t | jd jƒrtjS d S rV   )r   r   r`   r   r�   r]   r'   r'   r(   Ú	_eval_Abs{  s   ÿzsign._eval_Absc                 C  s   t t| jd ƒƒS rV   )ru   r4   r   r]   r'   r'   r(   Ú_eval_conjugate  ó   zsign._eval_conjugatec                 C  s†   | j d jrddlm} dt| j d |dd� || j d ƒ S | j d jrAddlm} dt| j d |dd� |t | j d  ƒ S d S )Nr   )Ú
DiracDeltaé   TrP   )r   r-   Ú'sympy.functions.special.delta_functionsr�   r   r.   r   )rJ   rS   r�   r'   r'   r(   rT   ‚  s   ÿÿþzsign._eval_derivativec                 C  rb   rc   )r   Úis_nonnegativer]   r'   r'   r(   Ú_eval_is_nonnegativeŒ  rg   zsign._eval_is_nonnegativec                 C  rb   rc   )r   Úis_nonpositiver]   r'   r'   r(   Ú_eval_is_nonpositive�  rg   zsign._eval_is_nonpositivec                 C  rZ   rV   )r   r.   r]   r'   r'   r(   Ú_eval_is_imaginary”  r_   zsign._eval_is_imaginaryc                 C  rZ   rV   rt   r]   r'   r'   r(   Ú_eval_is_integer—  r_   zsign._eval_is_integerc                 C  rZ   rV   )r   r`   r]   r'   r'   r(   ra   š  r_   zsign._eval_is_zeroc                 C  s.   t | jd jƒr|jr|jrtjS d S d S d S rV   )r   r   r`   Ú
is_integerÚis_evenr   r�   )rJ   Úotherr'   r'   r(   Ú_eval_power�  s   ÿþýûzsign._eval_powerr   c                 C  sV   | j d }| |d¡}|dkr|  |¡S |dkr| ||¡}t|ƒdk r(tj S tjS rV   )r   ÚsubsÚfuncÚdirr   r   r�   )rJ   rS   ÚnÚlogxÚcdirÚarg0Úx0r'   r'   r(   Ú_eval_nseries¥  s   

zsign._eval_nseriesc                 K  s&   |j rtd|dkfd|dk fdƒS d S )Nrr   r   éÿÿÿÿ)r   T)r-   r   rW   r'   r'   r(   Ú_eval_rewrite_as_Piecewise®  s   ÿzsign._eval_rewrite_as_Piecewisec                 K  s&   ddl m} |jr||ƒd d S d S )Nr   ©Ú	HeavisiderŽ   rr   ©r�   r¦   r-   ©rJ   r=   rX   r¦   r'   r'   r(   Ú_eval_rewrite_as_Heaviside²  s   ÿzsign._eval_rewrite_as_Heavisidec                 K  s    t dt|dƒf|t|ƒ dfƒS rc   )r   r   rx   rW   r'   r'   r(   Ú_eval_rewrite_as_Abs·  s    zsign._eval_rewrite_as_Absc                 K  s   |   t| jd ƒ¡S rV   )r›   r   r   )rJ   rX   r'   r'   r(   Ú_eval_simplifyº  s   zsign._eval_simplify©r   )rj   rk   rl   rm   Ú
is_complexrp   rw   rq   rF   rŠ   r‹   rT   r‘   r“   r”   r•   ra   r™   r¢   r¤   r©   rª   r«   Ú__classcell__r'   r'   rz   r(   ru   	  s*    6
1

	ru   c                   @  sÆ   e Zd ZU dZded< dZdZdZdZdZ	d-dd„Z
e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dd„ Zd.d d!„Zd"d#„ Zd$d%„ Zd&d'„ Zd(d)„ Zd*d+„ Zd,S )/rx   ab  
    Return the absolute value of the argument.

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

    This is an extension of the built-in function ``abs()`` to accept symbolic
    values.  If you pass a SymPy expression to the built-in ``abs()``, it will
    pass it automatically to ``Abs()``.

    Examples
    ========

    >>> from sympy import Abs, Symbol, S, I
    >>> Abs(-1)
    1
    >>> x = Symbol('x', real=True)
    >>> Abs(-x)
    Abs(x)
    >>> Abs(x**2)
    x**2
    >>> abs(-x) # The Python built-in
    Abs(x)
    >>> Abs(3*x + 2*I)
    sqrt(9*x**2 + 4)
    >>> Abs(8*I)
    8

    Note that the Python built-in will return either an Expr or int depending on
    the argument::

        >>> type(abs(-1))
        <... 'int'>
        >>> type(abs(S.NegativeOne))
        <class 'sympy.core.numbers.One'>

    Abs will always return a SymPy object.

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    Returns
    =======

    expr : Expr
        Absolute value returned can be an expression or integer depending on
        input arg.

    See Also
    ========

    sign, conjugate
    r   r   TFrr   c                 C  s    |dkrt | jd ƒS t| |ƒ‚)zE
        Get the first derivative of the argument to Abs().

        rr   r   )ru   r   r   )rJ   Úargindexr'   r'   r(   Úfdiff   s   
z	Abs.fdiffc                   s¨  ddl m} tˆ dƒrˆ  ¡ }|d ur|S tˆ tƒs"tdtˆ ƒ ƒ‚|ˆ dd�‰ ˆ  ¡ \}}|j	r<|j	s<| |ƒ| |ƒ S ˆ j
r—g }g }ˆ jD ];}|jrm|jjrm|jjrm| |jƒ}	t|	| ƒrc| |¡ qF| t|	|jƒ¡ qF| |ƒ}
t|
| ƒr|| |¡ qF| |
¡ qFt|Ž }|r�| t|Ž dd�ntj}|| S ˆ tju rŸtjS ˆ tju r¦tS ddlm}m} ˆ j�rˆ  ¡ \}}|jrï|jrÑ|jrÃˆ S |tju rËtjS t|ƒ| S |j rÚ|t!|ƒ S |j"rí| t!|ƒ |t# t$|ƒ ƒ S d S | %t&¡�s||ƒ '¡ \}}|t(|  }|t!|| ƒƒS tˆ |ƒ�r|t!ˆ jd ƒƒS tˆ t)ƒ�r/ˆ j*�r&ˆ S ˆ j�r-ˆ  S d S ˆ j+�rIˆ  %ttj,¡�rIt-dd	„ ˆ  '¡ D ƒƒ�rItS ˆ j.�rPtj/S ˆ j �rVˆ S ˆ j0�r]ˆ  S ˆ j1�rlt( ˆ  }|j �rl|S ˆ j�rrd S |ˆ  2¡ dd�‰ˆ 3t2¡ˆ  3t2¡ }|�r•t4‡ fd
d	„|D ƒƒ�r•d S ˆ ˆk�rÎˆ ˆ k�rÐˆ  3t¡}ˆ  5dd„ |D ƒ¡}dd„ |j	D ƒ}|�rÆt4‡fdd	„|D ƒƒ�sÒt6t7ˆ ˆ ƒƒS d S d S d S )Nr   )ÚsignsimprŠ   zBad argument type for Abs(): %sFrP   )r…   Úlogc                 s  s   � | ]}|j V  qd S r"   )Úis_infinite©r%   rC   r'   r'   r(   r)   P  s   € zAbs.eval.<locals>.<genexpr>c                 3  s    � | ]}ˆ   |jd  ¡V  qdS )r   N)r8   r   ©r%   Úi©r=   r'   r(   r)   b  s   € c                 S  s   i | ]}|t d d�“qS )T)Úreal)r   rµ   r'   r'   r(   Ú
<dictcomp>f  ó    zAbs.eval.<locals>.<dictcomp>c                 S  s   g | ]	}|j d u r|‘qS r"   )r-   r´   r'   r'   r(   Ú
<listcomp>g  ó    zAbs.eval.<locals>.<listcomp>c                 3  s   � | ]
}ˆ   t|ƒ¡V  qd S r"   )r8   r4   )r%   Úu)Úconjr'   r(   r)   h  s   € )8Úsympy.simplify.simplifyr±   ÚhasattrrŠ   r3   r
   Ú	TypeErrorÚtypeÚas_numer_denomÚfree_symbolsr|   r   r„   r…   r–   Úis_negativeÚbaser7   r   r   r   r�   r+   r,   r   Ú&sympy.functions.elementary.exponentialr²   Úas_base_expr-   r—   rƒ   rx   Úis_extended_nonnegativer   r~   r   r:   r8   r   r1   r   r   Úis_positiveÚis_AddÚNegativeInfinityÚanyr`   r/   Úis_extended_nonpositiver.   r4   ÚatomsÚallÚxreplacer   r   )r<   r=   r±   Úobjr�   ÚdÚknownr‡   ÚtZbnewÚtnewr…   r²   rÆ   ÚexponentrC   rD   Úzr‰   Znew_conjr    Zabs_free_argr'   )r=   r¾   r(   rF   
  sª   








 

ûzAbs.evalc                 C  rb   rc   rd   r]   r'   r'   r(   Ú_eval_is_realk  rg   zAbs._eval_is_realc                 C  ó   | j d jr| j d jS d S rV   )r   r-   r–   r]   r'   r'   r(   r•   o  ó   ÿzAbs._eval_is_integerc                 C  ó   t | jd jƒS rV   ©r   Ú_argsr`   r]   r'   r'   r(   Ú_eval_is_extended_nonzeros  ó   zAbs._eval_is_extended_nonzeroc                 C  rZ   rV   )rÞ   r`   r]   r'   r'   r(   ra   v  r_   zAbs._eval_is_zeroc                 C  rÜ   rV   rÝ   r]   r'   r'   r(   Ú_eval_is_extended_positivey  rà   zAbs._eval_is_extended_positivec                 C  rÚ   rV   )r   r-   Úis_rationalr]   r'   r'   r(   Ú_eval_is_rational|  rÛ   zAbs._eval_is_rationalc                 C  rÚ   rV   )r   r-   r—   r]   r'   r'   r(   Ú_eval_is_even€  rÛ   zAbs._eval_is_evenc                 C  rÚ   rV   )r   r-   Úis_oddr]   r'   r'   r(   Ú_eval_is_odd„  rÛ   zAbs._eval_is_oddc                 C  rZ   rV   r[   r]   r'   r'   r(   r^   ˆ  r_   zAbs._eval_is_algebraicc                 C  sP   | j d jr&|jr&|jr| j d | S |tjur&|jr&| j d |d  |  S d S )Nr   rr   )r   r-   r–   r—   r   rƒ   Ú
is_Integer)rJ   r×   r'   r'   r(   r™   ‹  s   zAbs._eval_powerr   c                 C  sd   ddl m} | jd  |¡d }| ||ƒ¡r| ||ƒ|¡}| jd j|||d�}t|ƒ|  ¡ S )Nr   )r²   )r�   rž   )	rÇ   r²   r   Úleadtermr8   rš   r¢   ru   Úexpand)rJ   rS   r�   rž   rŸ   r²   Ú	directionry   r'   r'   r(   r¢   “  s   zAbs._eval_nseriesc                 C  s¢   | j d js| j d jrt| j d |dd�tt| j d ƒƒ S t| j d ƒtt| j d ƒ|dd� t| j d ƒtt| j d ƒ|dd�  t| j d ƒ }| 	t¡S rO   )
r   r-   r.   r   ru   r4   r   r:   rx   Úrewrite)rJ   rS   Úrvr'   r'   r(   rT   ›  s   ÿÿÿÿþ
zAbs._eval_derivativec                 K  s,   ddl m} |jr|||ƒ|| ƒ  S d S )Nr   r¥   r§   r¨   r'   r'   r(   r©   ¤  s   ÿzAbs._eval_rewrite_as_Heavisidec                 K  sL   |j rt||dkf| dfƒS |jr$tt| t| dkft | dfƒS d S rc   )r-   r   r.   r   rW   r'   r'   r(   r¤   «  s
   $ÿzAbs._eval_rewrite_as_Piecewisec                 K  s   |t |ƒ S r"   ©ru   rW   r'   r'   r(   Ú_eval_rewrite_as_sign±  r_   zAbs._eval_rewrite_as_signc                 K  s   t |t|ƒ ƒS r"   )r   r4   rW   r'   r'   r(   Ú_eval_rewrite_as_conjugate´  rà   zAbs._eval_rewrite_as_conjugateN)rr   r¬   )rj   rk   rl   rm   rn   r-   r~   rÉ   ro   rp   r°   rq   rF   rÙ   r•   rß   ra   rá   rã   rä   ræ   r^   r™   r¢   rT   r©   r¤   rî   rï   r'   r'   r'   r(   rx   ¾  s6   
 9


`
	rx   c                   @  sN   e Zd ZdZdZdZdZdZedd„ ƒZ	dd„ Z
dd„ Zd	d
„ Zddd„ZdS )r=   a©  
    Returns the argument (in radians) of a complex number. The argument is
    evaluated in consistent convention with ``atan2`` where the branch-cut is
    taken along the negative real axis and ``arg(z)`` is in the interval
    $(-\pi,\pi]$. For a positive number, the argument is always 0; the
    argument of a negative number is $\pi$; and the argument of 0
    is undefined and returns ``nan``. So the ``arg`` function will never nest
    greater than 3 levels since at the 4th application, the result must be
    nan; for a real number, nan is returned on the 3rd application.

    Examples
    ========

    >>> from sympy import arg, I, sqrt, Dummy
    >>> from sympy.abc import x
    >>> arg(2.0)
    0
    >>> arg(I)
    pi/2
    >>> arg(sqrt(2) + I*sqrt(2))
    pi/4
    >>> arg(sqrt(3)/2 + I/2)
    pi/6
    >>> arg(4 + 3*I)
    atan(3/4)
    >>> arg(0.8 + 0.6*I)
    0.643501108793284
    >>> arg(arg(arg(arg(x))))
    nan
    >>> real = Dummy(real=True)
    >>> arg(arg(arg(real)))
    nan

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    Returns
    =======

    value : Expr
        Returns arc tangent of arg measured in radians.

    Tc                 C  sV  |}t dƒD ]}t|| ƒr|jd }q|dkr|jrtj  S  ntjS ddlm}m} t||ƒr6t	|t
ƒS t||ƒrZt|jd ƒ}|jrZ|dtj ; }|tjkrX|dtj 8 }|S |jsyt|ƒ ¡ \}}|jrrtdd„ |jD ƒŽ }t|ƒ| }n|}tdd„ | t¡D ƒƒr‰d S dd	lm}	 | ¡ \}
}|	||
ƒ}|jrŸ|S ||kr©| |d
d�S d S )Né   r   rŽ   ©r…   Ú	exp_polarc                 S  s$   g | ]}t |ƒd vr|nt |ƒ‘qS ))r£   rr   rí   r´   r'   r'   r(   r»     s
    ÿÿzarg.eval.<locals>.<listcomp>c                 s  s   � | ]}|j d u V  qd S r"   )r   rµ   r'   r'   r(   r)     s   € zarg.eval.<locals>.<genexpr>©Úatan2FrP   )Úranger3   r   r-   r   r+   rÇ   r…   rò   Úperiodic_argumentr   r:   r€   ÚPiÚis_Atomr   Úas_coeff_Mulr|   r   ru   rÍ   rÏ   r   Ú(sympy.functions.elementary.trigonometricrô   r1   Ú	is_number)r<   r=   rC   r¶   r…   rò   Úi_rE   Úarg_rô   rS   Úyrì   r'   r'   r(   rF   í  sH   





ÿ
ÿzarg.evalc                 C  sF   | j d  ¡ \}}|t||dd� |t||dd�  |d |d   S )Nr   TrP   rŽ   )r   r1   r   )rJ   rÕ   rS   rþ   r'   r'   r(   rT     s   ÿÿzarg._eval_derivativec                 K  s(   ddl m} | jd  ¡ \}}|||ƒS )Nr   ró   )rú   rô   r   r1   )rJ   r=   rX   rô   rS   rþ   r'   r'   r(   Ú_eval_rewrite_as_atan2  s   
zarg._eval_rewrite_as_atan2c                 C  sV   | j d }tddd�}|dkrd}| ||| ¡}|jrtjS |jr%tjS td|  ƒ‚)Nr   rÕ   T)Úpositiverr   zCannot expand %s around 0)	r   r   rš   rÊ   r   r/   rÅ   r÷   r   )rJ   rS   rž   rŸ   r    rÕ   rØ   r'   r'   r(   Ú_eval_as_leading_term   s   
zarg._eval_as_leading_termr   c                 C  s,   ddl m} |dkr|dƒS | j|||d�S )Nr   )ÚOrderrr   )rž   rŸ   )Úsympy.series.orderr  r  )rJ   rS   r�   rž   rŸ   r  r'   r'   r(   r¢   -  s   zarg._eval_nseriesNr¬   )rj   rk   rl   rm   r-   Úis_realre   rp   rq   rF   rT   rÿ   r  r¢   r'   r'   r'   r(   r=   ¸  s    /
(r=   c                   @  sX   e Zd ZdZdZe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S )r4   a>  
    Returns the *complex conjugate* [1]_ of an argument.
    In mathematics, the complex conjugate of a complex number
    is given by changing the sign of the imaginary part.

    Thus, the conjugate of the complex number
    :math:`a + ib` (where $a$ and $b$ are real numbers) is :math:`a - ib`

    Examples
    ========

    >>> from sympy import conjugate, I
    >>> conjugate(2)
    2
    >>> conjugate(I)
    -I
    >>> conjugate(3 + 2*I)
    3 - 2*I
    >>> conjugate(5 - I)
    5 + I

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    Returns
    =======

    arg : Expr
        Complex conjugate of arg as real, imaginary or mixed expression.

    See Also
    ========

    sign, Abs

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Complex_conjugation
    Tc                 C  ó   |  ¡ }|d ur
|S d S r"   )r‹   ©r<   r=   rÒ   r'   r'   r(   rF   b  ó   ÿzconjugate.evalc                 C  s   t S r"   )r4   r]   r'   r'   r(   Úinverseh  s   zconjugate.inversec                 C  ó   t | jd dd�S rO   ©rx   r   r]   r'   r'   r(   rŠ   k  rŒ   zconjugate._eval_Absc                 C  ó   t | jd ƒS rV   ©Ú	transposer   r]   r'   r'   r(   Ú_eval_adjointn  ó   zconjugate._eval_adjointc                 C  ó
   | j d S rV   ©r   r]   r'   r'   r(   r‹   q  ó   
zconjugate._eval_conjugatec                 C  sB   |j rtt| jd |dd�ƒS |jrtt| jd |dd�ƒ S d S rO   )r  r4   r   r   r.   rR   r'   r'   r(   rT   t  s
   ÿzconjugate._eval_derivativec                 C  r  rV   ©Úadjointr   r]   r'   r'   r(   Ú_eval_transposez  r  zconjugate._eval_transposec                 C  rZ   rV   r[   r]   r'   r'   r(   r^   }  r_   zconjugate._eval_is_algebraicN)rj   rk   rl   rm   rp   rq   rF   r  rŠ   r  r‹   rT   r  r^   r'   r'   r'   r(   r4   4  s    +
r4   c                   @  s4   e Zd ZdZedd„ ƒZdd„ Zdd„ Zdd	„ Zd
S )r  aŒ  
    Linear map transposition.

    Examples
    ========

    >>> from sympy import transpose, Matrix, MatrixSymbol
    >>> A = MatrixSymbol('A', 25, 9)
    >>> transpose(A)
    A.T
    >>> B = MatrixSymbol('B', 9, 22)
    >>> transpose(B)
    B.T
    >>> transpose(A*B)
    B.T*A.T
    >>> M = Matrix([[4, 5], [2, 1], [90, 12]])
    >>> M
    Matrix([
    [ 4,  5],
    [ 2,  1],
    [90, 12]])
    >>> transpose(M)
    Matrix([
    [4, 2, 90],
    [5, 1, 12]])

    Parameters
    ==========

    arg : Matrix
         Matrix or matrix expression to take the transpose of.

    Returns
    =======

    value : Matrix
        Transpose of arg.

    c                 C  r  r"   )r  r  r'   r'   r(   rF   ª  r  ztranspose.evalc                 C  r  rV   ©r4   r   r]   r'   r'   r(   r  °  r  ztranspose._eval_adjointc                 C  r  rV   r  r]   r'   r'   r(   r‹   ³  r  ztranspose._eval_conjugatec                 C  r  rV   r  r]   r'   r'   r(   r  ¶  r  ztranspose._eval_transposeN)	rj   rk   rl   rm   rq   rF   r  r‹   r  r'   r'   r'   r(   r  �  s    (
r  c                   @  sF   e Zd ZdZedd„ ƒZdd„ Zdd„ Zdd	„ Zddd„Z	dd„ Z
d
S )r  aµ  
    Conjugate transpose or Hermite conjugation.

    Examples
    ========

    >>> from sympy import adjoint, MatrixSymbol
    >>> A = MatrixSymbol('A', 10, 5)
    >>> adjoint(A)
    Adjoint(A)

    Parameters
    ==========

    arg : Matrix
        Matrix or matrix expression to take the adjoint of.

    Returns
    =======

    value : Matrix
        Represents the conjugate transpose or Hermite
        conjugation of arg.

    c                 C  s0   |  ¡ }|d ur
|S | ¡ }|d urt|ƒS d S r"   )r  r  r4   r  r'   r'   r(   rF   Õ  s   ÿzadjoint.evalc                 C  r  rV   r  r]   r'   r'   r(   r  Þ  r  zadjoint._eval_adjointc                 C  r  rV   r  r]   r'   r'   r(   r‹   á  r  zadjoint._eval_conjugatec                 C  r  rV   r  r]   r'   r'   r(   r  ä  r  zadjoint._eval_transposeNc                 G  s,   |  | jd ¡}d| }|rd||f }|S )Nr   z%s^{\dagger}z\left(%s\right)^{%s})Ú_printr   )rJ   Úprinterr…   r   r=   Útexr'   r'   r(   Ú_latexç  s
   zadjoint._latexc                 G  sJ   ddl m} |j| jd g|¢R Ž }|jr||dƒ }|S ||dƒ }|S )Nr   )Ú
prettyFormu   â€ ú+)Ú sympy.printing.pretty.stringpictr  r  r   Ú_use_unicode)rJ   r  r   r  Úpformr'   r'   r(   Ú_prettyî  s   ÿzadjoint._prettyr"   )rj   rk   rl   rm   rq   rF   r  r‹   r  r  r   r'   r'   r'   r(   r  º  s    

r  c                   @  s4   e Zd ZdZdZdZedd„ ƒZdd„ Zdd	„ Z	d
S )Ú
polar_lifta¢  
    Lift argument to the Riemann surface of the logarithm, using the
    standard branch.

    Examples
    ========

    >>> from sympy import Symbol, polar_lift, I
    >>> p = Symbol('p', polar=True)
    >>> x = Symbol('x')
    >>> polar_lift(4)
    4*exp_polar(0)
    >>> polar_lift(-4)
    4*exp_polar(I*pi)
    >>> polar_lift(-I)
    exp_polar(-I*pi/2)
    >>> polar_lift(I + 2)
    polar_lift(2 + I)

    >>> polar_lift(4*x)
    4*polar_lift(x)
    >>> polar_lift(4*p)
    4*p

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    See Also
    ========

    sympy.functions.elementary.exponential.exp_polar
    periodic_argument
    TFc           	      C  s  ddl m} |jr*||ƒ}|dtd t d tfv r*ddlm} |t| ƒt|ƒ S |jr1|j	}n|g}g }g }g }|D ]}|j
rG||g7 }q<|jrP||g7 }q<||g7 }q<t|ƒt|ƒk r‚|rlt|| Ž tt|Ž ƒ S |rtt|| Ž S ddlm} t|Ž |dƒ S d S )Nr   r·   rŽ   ©rò   )Ú$sympy.functions.elementary.complexesr=   rû   r   rÇ   rò   r   Úabsr|   r   Úis_polarrÊ   r9   r   r!  )	r<   r=   ÚargumentÚarrò   r   r>   r?   r   r'   r'   r(   rF   %  s4   ùzpolar_lift.evalc                 C  s   | j d  |¡S )z. Careful! any evalf of polar numbers is flaky r   )r   Ú_eval_evalf)rJ   Úprecr'   r'   r(   r(  I  s   zpolar_lift._eval_evalfc                 C  r	  rO   r
  r]   r'   r'   r(   rŠ   M  rŒ   zpolar_lift._eval_AbsN)
rj   rk   rl   rm   r%  r€   rq   rF   r(  rŠ   r'   r'   r'   r(   r!  ü  s    %
#r!  c                   @  s0   e Zd ZdZedd„ ƒZedd„ ƒZdd„ ZdS )	rö   aÅ  
    Represent the argument on a quotient of the Riemann surface of the
    logarithm. That is, given a period $P$, always return a value in
    $(-P/2, P/2]$, by using $\exp(PI) = 1$.

    Examples
    ========

    >>> from sympy import exp_polar, periodic_argument
    >>> from sympy import I, pi
    >>> periodic_argument(exp_polar(10*I*pi), 2*pi)
    0
    >>> periodic_argument(exp_polar(5*I*pi), 4*pi)
    pi
    >>> from sympy import exp_polar, periodic_argument
    >>> from sympy import I, pi
    >>> periodic_argument(exp_polar(5*I*pi), 2*pi)
    pi
    >>> periodic_argument(exp_polar(5*I*pi), 3*pi)
    -pi
    >>> periodic_argument(exp_polar(5*I*pi), pi)
    0

    Parameters
    ==========

    ar : Expr
        A polar number.

    period : Expr
        The period $P$.

    See Also
    ========

    sympy.functions.elementary.exponential.exp_polar
    polar_lift : Lift argument to the Riemann surface of the logarithm
    principal_branch
    c           	      C  sÄ   ddl m}m} |jr|j}n|g}d}|D ]I}|js"|t|ƒ7 }qt||ƒr1||j 	¡ d 7 }q|j
rN|j 	¡ \}}||t|jƒ ||t|jƒƒ  7 }qt|tƒr]|t|jd ƒ7 }q d S |S )Nr   )rò   r²   rr   )rÇ   rò   r²   r|   r   r%  r=   r3   r…   r1   r„   Úunbranched_argumentrÆ   r$  r!  )	r<   r'  rò   r²   r   ro   rC   r   r:   r'   r'   r(   Ú_getunbranchedz  s*   
ÿÿ
z periodic_argument._getunbranchedc           	      C  s
  |j sd S |tkrt|tƒrt|jŽ S t|tƒr&|dt kr&t|jd |ƒS |jrAdd„ |jD ƒ}t	|ƒt	|jƒkrAtt
|Ž |ƒS |  |¡}|d u rLd S ddlm}m} | t||¡r]d S |tkrc|S |tkr�ddlm} ||| tj ƒ| }| |¡sƒ|| S d S d S )NrŽ   r   c                 S  s   g | ]}|j s|‘qS r'   )rÊ   ©r%   rS   r'   r'   r(   r»   ž  ó    z*periodic_argument.eval.<locals>.<listcomp>)Úatanrô   ©Úceiling)r   r   r3   Úprincipal_branchrö   r   r!  r   r|   r9   r   r+  rú   r.  rô   r8   Ú#sympy.functions.elementary.integersr0  r   r†   )	r<   r'  ÚperiodÚnewargsro   r.  rô   r0  r�   r'   r'   r(   rF   ‘  s2   


üzperiodic_argument.evalc                 C  sn   | j \}}|tkrt |¡}|d u r| S | |¡S t|tƒ |¡}ddlm} |||| tj ƒ|   |¡S )Nr   r/  )	r   r   rö   r+  r(  r2  r0  r   r†   )rJ   r)  rØ   r3  ro   Úubr0  r'   r'   r(   r(  ¯  s   


 zperiodic_argument._eval_evalfN)rj   rk   rl   rm   rq   r+  rF   r(  r'   r'   r'   r(   rö   Q  s    (

rö   c                 C  s
   t | tƒS )a\  
    Returns periodic argument of arg with period as infinity.

    Examples
    ========

    >>> from sympy import exp_polar, unbranched_argument
    >>> from sympy import I, pi
    >>> unbranched_argument(exp_polar(15*I*pi))
    15*pi
    >>> unbranched_argument(exp_polar(7*I*pi))
    7*pi

    See also
    ========

    periodic_argument
    )rö   r   r·   r'   r'   r(   r*  »  s   
r*  c                   @  s,   e Zd ZdZdZdZedd„ ƒZdd„ ZdS )	r1  aÎ  
    Represent a polar number reduced to its principal branch on a quotient
    of the Riemann surface of the logarithm.

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

    This is a function of two arguments. The first argument is a polar
    number `z`, and the second one a positive real number or infinity, `p`.
    The result is ``z mod exp_polar(I*p)``.

    Examples
    ========

    >>> from sympy import exp_polar, principal_branch, oo, I, pi
    >>> from sympy.abc import z
    >>> principal_branch(z, oo)
    z
    >>> principal_branch(exp_polar(2*pi*I)*3, 2*pi)
    3*exp_polar(0)
    >>> principal_branch(exp_polar(2*pi*I)*3*z, 2*pi)
    3*principal_branch(z, 2*pi)

    Parameters
    ==========

    x : Expr
        A polar number.

    period : Expr
        Positive real number or infinity.

    See Also
    ========

    sympy.functions.elementary.exponential.exp_polar
    polar_lift : Lift argument to the Riemann surface of the logarithm
    periodic_argument
    TFc                 C  sö  ddl m} t|tƒrt|jd |ƒS |tkr|S t|tƒ}t||ƒ}||krj| t¡sj| t¡sjt|ƒ}dd„ }| 	t|¡}t|tƒ}| t¡sj||krX|t
||  ƒ| }n|}|jsh| |¡sh||dƒ9 }|S |jss|d}	}
n|j|jŽ \}	}
g }|
D ]}|jr‰|	|9 }	q||g7 }qt|ƒ}
t|	|ƒ}| t¡rŸd S |jrÔt|	ƒ|ks´|dkrÔ|
dkrÔ|	dkrÔ|dkrÃt|	ƒtt|
Ž |ƒ S t|t
| ƒt|
Ž  |ƒt|	ƒ S |jrõt|ƒ|d k dksç||d krù|
dkr÷||t
 ƒt|	ƒ S d S d S d S )	Nr   r"  c                 S  s   t | tƒs	t| ƒS | S r"   )r3   r   r!  )Úexprr'   r'   r(   Úmr
  s   
z!principal_branch.eval.<locals>.mrr'   rr   rŽ   T)rÇ   rò   r3   r!  r1  r   r   rö   r8   Úreplacer   r%  rÄ   r}   rÊ   Útuplerû   r*  r$  r   )rJ   rS   r3  rò   r5  ÚbargÚplr7  ÚresrE   ÚmÚothersrþ   r=   r'   r'   r(   rF   ý  sX   


ÿ




"&þÿzprincipal_branch.evalc                 C  sZ   | j \}}t||ƒ |¡}t|ƒtks|t kr| S ddlm} t|ƒ|t| ƒ  |¡S )Nr   )r…   )r   rö   r(  r$  r   rÇ   r…   r   )rJ   r)  rØ   r3  Úpr…   r'   r'   r(   r(  1  s   
zprincipal_branch._eval_evalfN)	rj   rk   rl   rm   r%  r€   rq   rF   r(  r'   r'   r'   r(   r1  Ñ  s    (
3r1  Fc           
        s`  ddl m} | jr| S | jrˆst| ƒS t| tƒr!ˆs!ˆ r!t| ƒS | jr&| S | jr>| j	‡ fdd„| j
D ƒŽ }ˆ r<t|ƒS |S | jrT| jtjkrT|  	tjt| jˆ dd�¡S | jrd| j	‡ fdd„| j
D ƒŽ S t| |ƒr¢t| jˆ ˆd�}g }| j
dd … D ]}t|d dˆd	�}t|dd … ˆ ˆd	�}	| |f|	 ¡ qz||ft|ƒ Ž S | j	‡ ‡fd
d„| j
D ƒŽ S )Nr   )ÚIntegralc                   ó   g | ]	}t |ˆ d d�‘qS )T©Úpause©Ú	_polarify©r%   r=   ©Úliftr'   r(   r»   E  r¼   z_polarify.<locals>.<listcomp>FrB  c                   rA  )FrB  rD  rF  rG  r'   r(   r»   L  r¼   rr   ©rH  rC  c                   s(   g | ]}t |tƒrt|ˆ ˆd �n|‘qS )rB  )r3   r
   rE  rF  rI  r'   r(   r»   W  s
    
ÿÿ)Úsympy.integrals.integralsr@  r%  rû   r!  r3   r   rø   rË   r›   r   r„   rÆ   r   ÚExp1rE  r…   r2   Úfunctionr7   r9  )
ÚeqrH  rC  r@  Úrr›   ÚlimitsÚlimitÚvarÚrestr'   rI  r(   rE  :  s:   

ÿrE  Tc                 C  sN   |rd}t t| ƒ|ƒ} |s| S dd„ | jD ƒ}|  |¡} | dd„ | ¡ D ƒfS )aÓ  
    Turn all numbers in eq into their polar equivalents (under the standard
    choice of argument).

    Note that no attempt is made to guess a formal convention of adding
    polar numbers, expressions like $1 + x$ will generally not be altered.

    Note also that this function does not promote ``exp(x)`` to ``exp_polar(x)``.

    If ``subs`` is ``True``, all symbols which are not already polar will be
    substituted for polar dummies; in this case the function behaves much
    like :func:`~.posify`.

    If ``lift`` is ``True``, both addition statements and non-polar symbols are
    changed to their ``polar_lift()``ed versions.
    Note that ``lift=True`` implies ``subs=False``.

    Examples
    ========

    >>> from sympy import polarify, sin, I
    >>> from sympy.abc import x, y
    >>> expr = (-x)**y
    >>> expr.expand()
    (-x)**y
    >>> polarify(expr)
    ((_x*exp_polar(I*pi))**_y, {_x: x, _y: y})
    >>> polarify(expr)[0].expand()
    _x**_y*exp_polar(_y*I*pi)
    >>> polarify(x, lift=True)
    polar_lift(x)
    >>> polarify(x*(1+y), lift=True)
    polar_lift(x)*polar_lift(y + 1)

    Adds are treated carefully:

    >>> polarify(1 + sin((1 + I)*x))
    (sin(_x*polar_lift(1 + I)) + 1, {_x: x})
    Fc                 S  s   i | ]
}|t |jd d�“qS )T)Úpolar)r   Úname)r%   ry   r'   r'   r(   r¹   ˆ  s    zpolarify.<locals>.<dictcomp>c                 S  s   i | ]\}}||“qS r'   r'   )r%   ry   rN  r'   r'   r(   r¹   Š  r-  )rE  r   rÄ   rš   Úitems)rM  rš   rH  Úrepsr'   r'   r(   Úpolarify[  s   (
rW  c                   sR  t | tƒr| jr
| S |slddlm}m} t | |ƒr!|t| jˆ ƒƒS t | tƒr7| jd dt	 kr7t| jd ˆ ƒS | j
sR| jsR| jsR| jr_| jdv rMd| jv sR| jdvr_| j‡ fdd„| jD ƒŽ S t | tƒrlt| jd ˆ ƒS | jr…t| jˆ ƒ}t| jˆ |jo~|  ƒ}|| S | jrœt| jdd	ƒrœ| j‡ fd
d„| jD ƒŽ S | j‡ fdd„| jD ƒŽ S )Nr   rñ   rr   rŽ   )z==z!=c                   s   g | ]}t |ˆ ƒ‘qS r'   ©Ú_unpolarifyr,  ©Úexponents_onlyr'   r(   r»   �  r-  z_unpolarify.<locals>.<listcomp>ro   Fc                   s   g | ]}t |ˆ ˆ ƒ‘qS r'   rX  r,  rZ  r'   r(   r»   ¨  s    ÿc                   s   g | ]}t |ˆ d ƒ‘qS ri   rX  r,  rZ  r'   r(   r»   «  rº   )r3   r	   rø   rÇ   r…   rò   rY  r1  r   r   rË   r|   Ú
is_BooleanÚis_RelationalÚrel_opr›   r!  r„   rÆ   r–   r2   Úgetattr)rM  r[  rC  r…   rò   ÚexporÆ   r'   rZ  r(   rY  �  s@   
ÿÿÿþ

ÿÿrY  Nc                 C  s˜   t | tƒr| S t| ƒ} |durt|  |¡ƒS d}d}|rd}|r9d}t| ||ƒ}|| kr0d}|} t |tƒr7|S |s ddlm} | |dƒdtdƒdi¡S )a  
    If `p` denotes the projection from the Riemann surface of the logarithm to
    the complex line, return a simplified version `eq'` of `eq` such that
    `p(eq') = p(eq)`.
    Also apply the substitution subs in the end. (This is a convenience, since
    ``unpolarify``, in a certain sense, undoes :func:`polarify`.)

    Examples
    ========

    >>> from sympy import unpolarify, polar_lift, sin, I
    >>> unpolarify(polar_lift(I + 2))
    2 + I
    >>> unpolarify(sin(polar_lift(I + 7)))
    sin(7 + I)
    NTFr   r"  rr   )	r3   Úboolr   Ú
unpolarifyrš   rY  rÇ   rò   r!  )rM  rš   r[  ÚchangedrC  r<  rò   r'   r'   r(   rb  ®  s(   

ù
rb  )F)TF)NF)4Ú
__future__r   Ú
sympy.corer   r   r   r   r   r   r	   Úsympy.core.exprr
   Zsympy.core.exprtoolsr   Úsympy.core.functionr   r   r   r   r   r   Úsympy.core.logicr   r   Úsympy.core.numbersr   r   r   Úsympy.core.powerr   Úsympy.core.relationalr   Ú(sympy.functions.elementary.miscellaneousr   Ú$sympy.functions.elementary.piecewiser   r   r:   ru   rx   r=   r4   r  r  r!  rö   r*  r1  rE  rW  rY  rb  r'   r'   r'   r(   Ú<module>   s:    $ z{ 6 {|M9BUj
i
!
2!