U
    ZÊ¹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 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)„Z1d1d*d+„Z2d2d-d.„Z3d,S )3é    )ÚTuple)ÚSÚAddÚMulÚsympifyÚSymbolÚDummyÚBasic)ÚExpr)Úfactor_terms)ÚFunctionÚ
DerivativeÚArgumentIndexErrorÚAppliedUndefÚ
expand_mul)Ú	fuzzy_notÚfuzzy_or)ÚpiÚIÚoo)ÚPow)ÚEq)Úsqrt)Ú	Piecewisec                   @   sp   e Zd ZU dZee 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
    ÚargsTc                 C   sD  |t jkrt jS |t jkr t jS |jr*|S |js:t| jr@t jS |jrR| ¡ d S |j	rpt
|tƒrpt|jd ƒS g g g   }}}t |¡}|D ]p}| t¡}|d k	r¶|js´| |¡ qŽ| t¡sÒ|jrÒ| |¡ qŽ|j|d�}|� rô| |d ¡ qŽ| |¡ qŽt|ƒt|ƒk�r@dd„ |||fD ƒ\}	}
}| |	ƒt|
ƒ | S d S )Nr   ©Úignorec                 s   s   | ]}t |Ž V  qd S ©N©r   ©Ú.0Zxs© r"   úc/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sympy/functions/elementary/complexes.pyÚ	<genexpr>i   s     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   ÚtermZcoeffZ	real_imagÚaÚbÚcr"   r"   r#   ÚevalD   s8    



zre.evalc                 K   s
   | t jfS )zF
        Returns the real number with a zero imaginary part.

        ©r   r)   ©ÚselfÚdeepÚhintsr"   r"   r#   r+   m   s    zre.as_real_imagc                 C   s^   |j s| jd j r*tt| jd |dd�ƒS |js<| jd jrZt tt| jd |dd�ƒ S d S ©Nr   T©Úevaluate)r'   r   r   r   r(   r   r4   ©rA   Úxr"   r"   r#   Ú_eval_derivativet   s    ÿzre._eval_derivativec                 K   s   | j d tt| j d ƒ  S ©Nr   )r   r   r4   ©rA   r7   Úkwargsr"   r"   r#   Ú_eval_rewrite_as_im{   s    zre._eval_rewrite_as_imc                 C   s   | j d jS rJ   ©r   Zis_algebraic©rA   r"   r"   r#   Ú_eval_is_algebraic~   s    zre._eval_is_algebraicc                 C   s   t | jd j| jd jgƒS rJ   )r   r   r(   Úis_zerorO   r"   r"   r#   Ú_eval_is_zero�   s    zre._eval_is_zeroc                 C   s   | j d jrdS d S ©Nr   T©r   Ú	is_finiterO   r"   r"   r#   Ú_eval_is_finite…   s    zre._eval_is_finitec                 C   s   | j d jrdS d S rS   rT   rO   r"   r"   r#   Ú_eval_is_complex‰   s    zre._eval_is_complexN)T)Ú__name__Ú
__module__Ú__qualname__Ú__doc__ÚtTupler
   Ú__annotations__r'   Ú
unbranchedÚ_singularitiesÚclassmethodr>   r+   rI   rM   rP   rR   rV   rW   r"   r"   r"   r#   r      s   
)
(
r   c                   @   sp   e Zd ZU dZee 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 )r4   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   Tc                 C   sL  |t jkrt jS |t jkr t jS |jr,t jS |js<t| jrFt | S |jrX| ¡ d S |j	rxt
|tƒrxt|jd ƒ S g g g   }}}t |¡}|D ]p}| t¡}|d k	rÊ|js¾| |¡ n
| |¡ q–| t¡sÚ|js–|j|d�}|� rü| |d ¡ q–| |¡ q–t|ƒt|ƒk�rHdd„ |||fD ƒ\}	}
}| |	ƒt|
ƒ | S d S )Né   r   r   c                 s   s   | ]}t |Ž V  qd S r   r   r    r"   r"   r#   r$   â   s     zim.eval.<locals>.<genexpr>)r   r%   r&   r'   r)   r(   r   r*   r+   r,   r-   r.   r4   r   r   r/   r0   r1   r2   r3   r   r5   r"   r"   r#   r>   ¾   s8    




zim.evalc                 K   s
   | t jfS )zC
        Return the imaginary part with a zero real part.

        r?   r@   r"   r"   r#   r+   æ   s    zim.as_real_imagc                 C   s^   |j s| jd j r*tt| jd |dd�ƒS |js<| jd jrZt tt| jd |dd�ƒ S d S rD   )r'   r   r4   r   r(   r   r   rG   r"   r"   r#   rI   í   s    ÿzim._eval_derivativec                 K   s   t  | jd t| jd ƒ  S rJ   )r   r   r   rK   r"   r"   r#   Ú_eval_rewrite_as_reô   s    zim._eval_rewrite_as_rec                 C   s   | j d jS rJ   rN   rO   r"   r"   r#   rP   ÷   s    zim._eval_is_algebraicc                 C   s   | j d jS rJ   ©r   r'   rO   r"   r"   r#   rR   ú   s    zim._eval_is_zeroc                 C   s   | j d jrdS d S rS   rT   rO   r"   r"   r#   rV   ý   s    zim._eval_is_finitec                 C   s   | j d jrdS d S rS   rT   rO   r"   r"   r#   rW     s    zim._eval_is_complexN)T)rX   rY   rZ   r[   r\   r
   r]   r'   r^   r_   r`   r>   r+   rI   rb   rP   rR   rV   rW   r"   r"   r"   r#   r4   Ž   s   
)
'
r4   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kr:| jd t| jd ƒ S |S )Nr   F)ÚsuperÚdoitr   rQ   ÚAbs)rA   rC   Ús©Ú	__class__r"   r#   rf   C  s    
z	sign.doitc           	      C   s@  |j r®| ¡ \}}g }t|ƒ}|D ]Z}|jr4| }q"|jr<q"|jrrt|ƒ}|jrf|t9 }|jrp| }q|| 	|¡ q"| 	|¡ q"|t
jkrœt|ƒt|ƒkrœd S || |j|Ž ƒ S |t
jkr¾t
jS |jrÊt
jS |jrÖt
jS |jrât
jS |jröt|tƒrö|S |j�r<|j�r|jt
jk�rtS t | }|j�r.tS |j�r<t S d S r   )Úis_MulÚas_coeff_mulrd   Úis_extended_negativeÚis_extended_positiver(   r4   Úis_comparabler   r1   r   ÚOner3   Z_new_rawargsr%   rQ   r)   ÚNegativeOner,   r-   Úis_PowÚexpÚHalf)	r6   r7   r=   r   Úunkrh   r;   ZaiÚarg2r"   r"   r#   r>   I  sN    


z	sign.evalc                 C   s   t | jd jƒrtjS d S rJ   )r   r   rQ   r   rp   rO   r"   r"   r#   Ú	_eval_Abs{  s    zsign._eval_Absc                 C   s   t t| jd ƒƒS rJ   )rd   r.   r   rO   r"   r"   r#   Ú_eval_conjugate  s    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r‚ddlm} dt| j d |dd� |t | j d  ƒ S d S )Nr   )Ú
DiracDeltaé   TrE   )r   r'   Ú'sympy.functions.special.delta_functionsry   r   r(   r   )rA   rH   ry   r"   r"   r#   rI   ‚  s    ÿÿzsign._eval_derivativec                 C   s   | j d jrdS d S rS   )r   Zis_nonnegativerO   r"   r"   r#   Ú_eval_is_nonnegativeŒ  s    zsign._eval_is_nonnegativec                 C   s   | j d jrdS d S rS   )r   Zis_nonpositiverO   r"   r"   r#   Ú_eval_is_nonpositive�  s    zsign._eval_is_nonpositivec                 C   s   | j d jS rJ   )r   r(   rO   r"   r"   r#   Ú_eval_is_imaginary”  s    zsign._eval_is_imaginaryc                 C   s   | j d jS rJ   rc   rO   r"   r"   r#   Ú_eval_is_integer—  s    zsign._eval_is_integerc                 C   s   | j d jS rJ   )r   rQ   rO   r"   r"   r#   rR   š  s    zsign._eval_is_zeroc                 C   s&   t | jd jƒr"|jr"|jr"tjS d S rJ   )r   r   rQ   Ú
is_integerÚis_evenr   rp   )rA   Ú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 rPtj S tjS rJ   )r   ÚsubsÚfuncÚdirr   r   rp   )rA   rH   ÚnÚlogxÚcdirZarg0Z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 )Nra   r   éÿÿÿÿ)r   T)r'   r   rK   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   ©Ú	Heavisiderz   ra   ©r{   rŽ   r'   ©rA   r7   rL   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 rS   )r   r   rg   rK   r"   r"   r#   Ú_eval_rewrite_as_Abs·  s    zsign._eval_rewrite_as_Absc                 K   s   |   t| jd ƒ¡S rJ   )r…   r   r   )rA   rL   r"   r"   r#   Ú_eval_simplifyº  s    zsign._eval_simplify)r   )rX   rY   rZ   r[   Z
is_complexr_   rf   r`   r>   rw   rx   rI   r|   r}   r~   r   rR   rƒ   rŠ   rŒ   r‘   r’   r“   Ú__classcell__r"   r"   ri   r#   rd   	  s(   6
1

	rd   c                   @   sÊ   e Zd ZU dZee 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 ).rg   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   TFra   c                 C   s$   |dkrt | jd ƒS t| |ƒ‚dS )zE
        Get the first derivative of the argument to Abs().

        ra   r   N)rd   r   r   )rA   Zargindexr"   r"   r#   Úfdiff   s    z	Abs.fdiffc                    s´  ddl m} tˆ dƒr*ˆ  ¡ }|d k	r*|S tˆ tƒsDtdtˆ ƒ ƒ‚|ˆ dd�‰ ˆ  ¡ \}}|j	rx|j	sx| |ƒ| |ƒ S ˆ j
�r2g }g }ˆ jD ]v}|jrÜ|jjrÜ|jjrÜ| |jƒ}	t|	| ƒrÈ| |¡ n| t|	|jƒ¡ qŽ| |ƒ}
t|
| ƒrú| |¡ qŽ| |
¡ qŽt|Ž }|�r$| t|Ž dd�ntj}|| S ˆ tjk�rDtjS ˆ tjk�rTtS ddlm}m} ˆ j�r*ˆ  ¡ \}}|j�rò|j�r²|j�r”ˆ S |tjk�r¦tjS t|ƒ| S |j �rÆ|t!|ƒ S |j"�rî| t!|ƒ |t# t$|ƒ ƒ S d S | %t&¡�s*||ƒ '¡ \}}|t(|  }|t!|| ƒƒS tˆ |ƒ�rH|t!ˆ jd ƒƒS tˆ t)ƒ�rrˆ j*�r`ˆ S ˆ j�rnˆ  S d S ˆ j+�r¦ˆ  %ttj,¡�r¦t-dd	„ ˆ  '¡ D ƒƒ�r¦tS ˆ j.�r´tj/S ˆ j �rÀˆ S ˆ j0�rÎˆ  S ˆ j1�rìt( ˆ  }|j �rì|S ˆ j�rød 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 )Nr   )Úsignsimprw   zBad argument type for Abs(): %sFrE   )rs   Úlogc                 s   s   | ]}|j V  qd S r   )Úis_infinite©r!   r;   r"   r"   r#   r$   P  s     zAbs.eval.<locals>.<genexpr>c                 3   s   | ]}ˆ   |jd  ¡V  qdS )r   N)r2   r   ©r!   Úi©r7   r"   r#   r$   b  s     c                 S   s   i | ]}|t d d�“qS )T)Úreal)r   rš   r"   r"   r#   Ú
<dictcomp>f  s      zAbs.eval.<locals>.<dictcomp>c                 S   s   g | ]}|j d kr|‘qS r   )r'   r™   r"   r"   r#   Ú
<listcomp>g  s     
 zAbs.eval.<locals>.<listcomp>c                 3   s   | ]}ˆ   t|ƒ¡V  qd S r   )r2   r.   )r!   Úu)Úconjr"   r#   r$   h  s     )8Zsympy.simplify.simplifyr–   Úhasattrrw   r-   r
   Ú	TypeErrorÚtypeZas_numer_denomÚfree_symbolsrk   r   rr   rs   r€   Zis_negativeÚbaser1   r   r   r   rp   r%   r&   r   Ú&sympy.functions.elementary.exponentialr—   Zas_base_expr'   r�   rq   rg   Úis_extended_nonnegativer   rm   r   r4   r2   r   r+   r   r   Úis_positiveÚis_AddÚNegativeInfinityÚanyrQ   r)   Zis_extended_nonpositiver(   r.   ÚatomsÚallZxreplacer   r   )r6   r7   r–   Úobjr‡   ÚdZknownru   ÚtZbnewZtnewrs   r—   r¦   Úexponentr;   r<   Úzrv   Znew_conjr   Zabs_free_argr"   )r7   r¡   r#   r>   
  s¦    





 

zAbs.evalc                 C   s   | j d jrdS d S rS   rT   rO   r"   r"   r#   Ú_eval_is_realk  s    zAbs._eval_is_realc                 C   s   | j d jr| j d jS d S rJ   )r   r'   r€   rO   r"   r"   r#   r   o  s    zAbs._eval_is_integerc                 C   s   t | jd jƒS rJ   ©r   Ú_argsrQ   rO   r"   r"   r#   Ú_eval_is_extended_nonzeros  s    zAbs._eval_is_extended_nonzeroc                 C   s   | j d jS rJ   )r¶   rQ   rO   r"   r"   r#   rR   v  s    zAbs._eval_is_zeroc                 C   s   t | jd jƒS rJ   rµ   rO   r"   r"   r#   Ú_eval_is_extended_positivey  s    zAbs._eval_is_extended_positivec                 C   s   | j d jr| j d jS d S rJ   )r   r'   Zis_rationalrO   r"   r"   r#   Ú_eval_is_rational|  s    zAbs._eval_is_rationalc                 C   s   | j d jr| j d jS d S rJ   )r   r'   r�   rO   r"   r"   r#   Ú_eval_is_even€  s    zAbs._eval_is_evenc                 C   s   | j d jr| j d jS d S rJ   )r   r'   Zis_oddrO   r"   r"   r#   Ú_eval_is_odd„  s    zAbs._eval_is_oddc                 C   s   | j d jS rJ   rN   rO   r"   r"   r#   rP   ˆ  s    zAbs._eval_is_algebraicc                 C   sP   | j d jrL|jrL|jr&| j d | S |tjk	rL|jrL| j d |d  |  S d S )Nr   ra   )r   r'   r€   r�   r   rq   Z
is_Integer)rA   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   Zleadtermr2   r„   rŠ   rd   Úexpand)rA   rH   r‡   rˆ   r‰   r—   Ú	directionrh   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 rD   )
r   r'   r(   r   rd   r.   r   r4   rg   Zrewrite)rA   rH   Úrvr"   r"   r#   rI   ›  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rHtt| t| dkft | dfƒS d S rS   )r'   r   r(   r   rK   r"   r"   r#   rŒ   «  s    zAbs._eval_rewrite_as_Piecewisec                 K   s   |t |ƒ S r   ©rd   rK   r"   r"   r#   Ú_eval_rewrite_as_sign±  s    zAbs._eval_rewrite_as_signc                 K   s   t |t|ƒ ƒS r   )r   r.   rK   r"   r"   r#   Ú_eval_rewrite_as_conjugate´  s    zAbs._eval_rewrite_as_conjugateN)ra   )r   )rX   rY   rZ   r[   r\   r
   r]   r'   rm   r¨   r^   r_   r•   r`   r>   r´   r   r·   rR   r¸   r¹   rº   r»   rP   rƒ   rŠ   rI   r‘   rŒ   rÀ   rÁ   r"   r"   r"   r#   rg   ¾  s4   
9


`
	rg   c                   @   s<   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	S )
r7   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   s^  |}t dƒD ]6}t|| ƒr&|jd }q|dkr>|jr>tj  S  qJqtjS ddlm}m} t||ƒrnt	|t
ƒS t||ƒr¶t|jd ƒ}|jr¶|dtj ; }|tjkr²|dtj 8 }|S |jsôt|ƒ ¡ \}}|jrætdd„ |jD ƒŽ }t|ƒ| }n|}tdd„ | t¡D ƒƒ�rd S dd	lm}	 | ¡ \}
}|	||
ƒ}|j�rD|S ||k�rZ| |d
d�S d S )Né   r   rz   ©rs   Ú	exp_polarc                 S   s$   g | ]}t |ƒd kr|nt |ƒ‘qS ))r‹   ra   r¿   r™   r"   r"   r#   rŸ     s   ÿzarg.eval.<locals>.<listcomp>c                 s   s   | ]}|j d kV  qd S r   )rn   rš   r"   r"   r#   r$     s     zarg.eval.<locals>.<genexpr>©Úatan2FrE   )Úranger-   r   r'   r   r%   r§   rs   rÄ   Úperiodic_argumentr   r4   ro   ÚPiÚis_Atomr   Zas_coeff_Mulrk   r   rd   r¬   r­   r   Ú(sympy.functions.elementary.trigonometricrÆ   r+   Ú	is_number)r6   r7   r;   r›   rs   rÄ   Zi_r=   Zarg_rÆ   rH   Úyr¾   r"   r"   r#   r>   í  sF    





ÿ

zarg.evalc                 C   sF   | j d  ¡ \}}|t||dd� |t||dd�  |d |d   S )Nr   TrE   rz   )r   r+   r   )rA   r±   rH   rÍ   r"   r"   r#   rI     s    ÿÿzarg._eval_derivativec                 K   s(   ddl m} | jd  ¡ \}}|||ƒS )Nr   rÅ   )rË   rÆ   r   r+   )rA   r7   rL   rÆ   rH   rÍ   r"   r"   r#   Ú_eval_rewrite_as_atan2  s    zarg._eval_rewrite_as_atan2N)rX   rY   rZ   r[   r'   Úis_realrU   r_   r`   r>   rI   rÎ   r"   r"   r"   r#   r7   ¸  s   /
(r7   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 )r.   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   s   |  ¡ }|d k	r|S d S r   )rx   ©r6   r7   r¯   r"   r"   r#   r>   O  s    zconjugate.evalc                 C   s   t S r   )r.   rO   r"   r"   r#   ÚinverseU  s    zconjugate.inversec                 C   s   t | jd dd�S rD   ©rg   r   rO   r"   r"   r#   rw   X  s    zconjugate._eval_Absc                 C   s   t | jd ƒS rJ   ©Ú	transposer   rO   r"   r"   r#   Ú_eval_adjoint[  s    zconjugate._eval_adjointc                 C   s
   | j d S rJ   ©r   rO   r"   r"   r#   rx   ^  s    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 rD   )rÏ   r.   r   r   r(   rG   r"   r"   r#   rI   a  s    zconjugate._eval_derivativec                 C   s   t | jd ƒS rJ   ©Úadjointr   rO   r"   r"   r#   Ú_eval_transposeg  s    zconjugate._eval_transposec                 C   s   | j d jS rJ   rN   rO   r"   r"   r#   rP   j  s    zconjugate._eval_is_algebraicN)rX   rY   rZ   r[   r_   r`   r>   rÑ   rw   rÕ   rx   rI   rÙ   rP   r"   r"   r"   r#   r.   !  s   +
r.   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   s   |  ¡ }|d k	r|S d S r   )rÙ   rÐ   r"   r"   r#   r>   —  s    ztranspose.evalc                 C   s   t | jd ƒS rJ   ©r.   r   rO   r"   r"   r#   rÕ   �  s    ztranspose._eval_adjointc                 C   s   t | jd ƒS rJ   r×   rO   r"   r"   r#   rx      s    ztranspose._eval_conjugatec                 C   s
   | j d S rJ   rÖ   rO   r"   r"   r#   rÙ   £  s    ztranspose._eval_transposeN)	rX   rY   rZ   r[   r`   r>   rÕ   rx   rÙ   r"   r"   r"   r#   rÔ   n  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 k	r|S | ¡ }|d k	r,t|ƒS d S r   )rÕ   rÙ   r.   rÐ   r"   r"   r#   r>   Â  s    zadjoint.evalc                 C   s
   | j d S rJ   rÖ   rO   r"   r"   r#   rÕ   Ë  s    zadjoint._eval_adjointc                 C   s   t | jd ƒS rJ   rÓ   rO   r"   r"   r#   rx   Î  s    zadjoint._eval_conjugatec                 C   s   t | jd ƒS rJ   rÚ   rO   r"   r"   r#   rÙ   Ñ  s    zadjoint._eval_transposeNc                 G   s,   |  | jd ¡}d| }|r(d||f }|S )Nr   z%s^{\dagger}z\left(%s\right)^{%s})Ú_printr   )rA   Úprinterrs   r   r7   Útexr"   r"   r#   Ú_latexÔ  s
    zadjoint._latexc                 G   sF   ddl m} |j| jd f|žŽ }|jr6||dƒ }n||dƒ }|S )Nr   )Ú
prettyFormu   â€ ú+)Z sympy.printing.pretty.stringpictrß   rÛ   r   Z_use_unicode)rA   rÜ   r   rß   Zpformr"   r"   r#   Ú_prettyÛ  s    zadjoint._pretty)N)rX   rY   rZ   r[   r`   r>   rÕ   rx   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rT||ƒ}|dtd t d tfkrTddlm} |t| ƒt|ƒ S |jrb|j	}n|g}g }g }g }|D ]2}|j
rŽ||g7 }qx|jr ||g7 }qx||g7 }qxt|ƒt|ƒk �r|rÚt|| Ž tt|Ž ƒ S |rêt|| Ž S ddlm} t|Ž |dƒ S d S )Nr   rœ   rz   ©rÄ   )Z$sympy.functions.elementary.complexesr7   rÌ   r   r§   rÄ   r   Úabsrk   r   Úis_polarr©   r3   r   râ   )	r6   r7   ÚargumentÚarrÄ   r   r8   r9   Zpositiver"   r"   r#   r>     s2    zpolar_lift.evalc                 C   s   | j d  |¡S )z. Careful! any evalf of polar numbers is flaky r   )r   Ú_eval_evalf)rA   Úprecr"   r"   r#   rè   6  s    zpolar_lift._eval_evalfc                 C   s   t | jd dd�S rD   rÒ   rO   r"   r"   r#   rw   :  s    zpolar_lift._eval_AbsN)
rX   rY   rZ   r[   rå   ro   r`   r>   rè   rw   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 ]”}|jsD|t|ƒ7 }q,t||ƒrb||j 	¡ d 7 }q,|j
rœ|j 	¡ \}}||t|jƒ ||t|jƒƒ  7 }q,t|tƒrº|t|jd ƒ7 }q, d S q,|S )Nr   )rÄ   r—   ra   )r§   rÄ   r—   rk   r   rå   r7   r-   rs   r+   rr   Úunbranched_argumentr¦   rä   râ   )	r6   rç   rÄ   r—   r   r^   r;   r   r4   r"   r"   r#   Ú_getunbranchedg  s*    
ÿÿ
z periodic_argument._getunbranchedc           	      C   s
  |j s
d S |tkr&t|tƒr&t|jŽ S t|tƒrL|dt krLt|jd |ƒS |jr‚dd„ |jD ƒ}t	|ƒt	|jƒkr‚tt
|Ž |ƒS |  |¡}|d kr˜d S ddlm}m} | t||¡rºd S |tkrÆ|S |tk�rddlm} ||| tj ƒ| }| |¡�s|| S d S )Nrz   r   c                 S   s   g | ]}|j s|‘qS r"   )r©   ©r!   rH   r"   r"   r#   rŸ   ‹  s      z*periodic_argument.eval.<locals>.<listcomp>)ÚatanrÆ   ©Úceiling)rn   r   r-   Úprincipal_branchrÈ   r   râ   r   rk   r3   r   rë   rË   rí   rÆ   r2   Ú#sympy.functions.elementary.integersrï   r   rt   )	r6   rç   ÚperiodZnewargsr^   rí   rÆ   rï   r‡   r"   r"   r#   r>   ~  s.    


zperiodic_argument.evalc                 C   sn   | j \}}|tkr2t |¡}|d kr(| S | |¡S t|tƒ |¡}ddlm} |||| tj ƒ|   |¡S )Nr   rî   )	r   r   rÈ   rë   rè   rñ   rï   r   rt   )rA   ré   r³   rò   r^   Úubrï   r"   r"   r#   rè   œ  s    


zperiodic_argument._eval_evalfN)rX   rY   rZ   r[   r`   rë   r>   rè   r"   r"   r"   r#   rÈ   >  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 )	rð   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r2|S t|tƒ}t||ƒ}||krÔ| t¡sÔ| t¡sÔt|ƒ}dd„ }| 	t|¡}t|tƒ}| t¡sÔ||kr°|t
||  ƒ| }n|}|jsÐ| |¡sÐ||dƒ9 }|S |jsæ|d }	}
n|j|jŽ \}	}
g }|
D ]"}|j�r|	|9 }	n
||g7 }� qþt|ƒ}
t|	|ƒ}| t¡�rDd S |j�rºt|	ƒ|k�sx|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 )	Nr   rã   c                 S   s   t | tƒst| ƒS | S r   )r-   r   râ   )Úexprr"   r"   r#   Úmr÷  s    
z!principal_branch.eval.<locals>.mrr"   ra   rz   T)r§   rÄ   r-   râ   rð   r   r   rÈ   r2   Úreplacer   rå   r¥   rl   r©   ÚtuplerÌ   rê   rä   r   )rA   rH   rò   rÄ   ró   ZbargÚplrõ   Úresr=   ÚmZothersrÍ   r7   r"   r"   r#   r>   ê  s^    


ÿ



ÿÿÿ
",ÿzprincipal_branch.evalc                 C   sZ   | j \}}t||ƒ |¡}t|ƒtks0|t kr4| S ddlm} t|ƒ|t| ƒ  |¡S )Nr   )rs   )r   rÈ   rè   rä   r   r§   rs   r   )rA   ré   r³   rò   Úprs   r"   r"   r#   rè     s    
zprincipal_branch._eval_evalfN)	rX   rY   rZ   r[   rå   ro   r`   r>   rè   r"   r"   r"   r#   rð   ¾  s   (
3rð   Fc           
         sh  ddl m} | jr| S | jr(ˆs(t| ƒS t| tƒrBˆsBˆ rBt| ƒS | jrL| S | jr|| j	‡ fdd„| j
D ƒŽ }ˆ rxt|ƒS |S | jr¨| jtjkr¨|  	tjt| jˆ dd�¡S | jrÈ| j	‡ fdd„| j
D ƒŽ S t| |ƒ�rHt| jˆ ˆd�}g }| j
dd … D ]>}t|d dˆd	�}t|dd … ˆ ˆd	�}	| |f|	 ¡ � qö||ft|ƒ Ž S | j	‡ ‡fd
d„| j
D ƒŽ S d S )Nr   )ÚIntegralc                    s   g | ]}t |ˆ d d�‘qS )T©Úpause©Ú	_polarify©r!   r7   ©Úliftr"   r#   rŸ   2  s     z_polarify.<locals>.<listcomp>Frý   c                    s   g | ]}t |ˆ d d�‘qS )Frý   rÿ   r  r  r"   r#   rŸ   9  s     ra   ©r  rþ   c                    s(   g | ] }t |tƒr t|ˆ ˆd �n|‘qS )rý   )r-   r
   r   r  r  r"   r#   rŸ   D  s    ÿ)Zsympy.integrals.integralsrü   rå   rÌ   râ   r-   r   rÊ   rª   r…   r   rr   r¦   r   ZExp1r   rs   r,   Úfunctionr1   r÷   )
Úeqr  rþ   rü   Úrr…   ZlimitsÚlimitÚvarÚrestr"   r  r#   r   '  s:    
ÿr   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)Zpolar)r   Úname)r!   rh   r"   r"   r#   rž   u  s      zpolarify.<locals>.<dictcomp>c                 S   s   i | ]\}}||“qS r"   r"   )r!   rh   r  r"   r"   r#   rž   w  s      )r   r   r¥   r„   Úitems)r  r„   r  Zrepsr"   r"   r#   ÚpolarifyH  s    (
r  c                    sX  t | tƒr| jr| S |sØddlm}m} t | |ƒrB|t| jˆ ƒƒS t | tƒrn| jd dt	 krnt| jd ˆ ƒS | j
s¤| js¤| js¤| jr¾| jdkršd| jks¤| jdkr¾| j‡ fdd„| jD ƒŽ S t | tƒrØt| 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Ã   ra   rz   )z==z!=c                    s   g | ]}t |ˆ ƒ‘qS r"   ©Ú_unpolarifyrì   ©Úexponents_onlyr"   r#   rŸ   Š  s     z_unpolarify.<locals>.<listcomp>r^   Fc                    s   g | ]}t |ˆ ˆ ƒ‘qS r"   r  rì   r  r"   r#   rŸ   •  s   ÿc                    s   g | ]}t |ˆ d ƒ‘qS )Tr  rì   r  r"   r#   rŸ   ˜  s     )r-   r	   rÊ   r§   rs   rÄ   r  rð   r   r   rª   rk   Z
is_BooleanZis_RelationalZrel_opr…   râ   rr   r¦   r€   r,   Úgetattr)r  r  rþ   rs   rÄ   Zexpor¦   r"   r  r#   r  z  sH    
ÿÿÿþýýü
ÿÿr  Nc                 C   s–   t | tƒr| S t| ƒ} |dk	r,t|  |¡ƒS d}d}|r<d}|rpd}t| ||ƒ}|| kr`d}|} t |tƒr<|S q<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ã   ra   )	r-   Úboolr   Ú
unpolarifyr„   r  r§   rÄ   râ   )r  r„   r  Úchangedrþ   rù   rÄ   r"   r"   r#   r  ›  s&    

r  )F)TF)F)NF)4Útypingr   r\   Z
sympy.corer   r   r   r   r   r   r	   Zsympy.core.exprr
   Zsympy.core.exprtoolsr   Zsympy.core.functionr   r   r   r   r   Zsympy.core.logicr   r   Zsympy.core.numbersr   r   r   Zsympy.core.powerr   Zsympy.core.relationalr   Z(sympy.functions.elementary.miscellaneousr   Z$sympy.functions.elementary.piecewiser   r   r4   rd   rg   r7   r.   rÔ   rØ   râ   rÈ   rê   rð   r   r  r  r  r"   r"   r"   r#   Ú<module>   s8   $z{ 6 {iM9BUji
!
2
!