o
    §ƒð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'   ú¦/tmp/claude-1000/-var-www-html-academy/3f42efd1-c2b7-4d08-9b05-30d86bb35479/scratchpad/piper/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ÚincludedÚ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:   ©rK   Úxr'   r'   r(   Ú_eval_derivativet   ó   ÿÿzre._eval_derivativec                 K  s   | j d tt| j d ƒ  S ©Nr   )r   r   r:   ©rK   r=   Úkwargsr'   r'   r(   Ú_eval_rewrite_as_im{   s   zre._eval_rewrite_as_imc                 C  ó   | j d jS rW   ©r   Úis_algebraic©rK   r'   r'   r(   Ú_eval_is_algebraic~   ó   zre._eval_is_algebraicc                 C  s   t | jd j| jd jgƒS rW   )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  rc   rd   re   r^   r'   r'   r(   Ú_eval_is_complex‰   rh   zre._eval_is_complexN©T)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__r-   Ú
unbranchedÚ_singularitiesÚclassmethodrG   r1   rU   rZ   r_   rb   rg   ri   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(   rG   ¾   s<   





€ýzim.evalc                 K  rH   )zC
        Return the imaginary part with a zero real part.

        rI   rJ   r'   r'   r(   r1   æ   rN   zim.as_real_imagc                 C  rO   rP   )r-   r   r:   r   r.   r   r   rS   r'   r'   r(   rU   í   rV   zim._eval_derivativec                 K  s   t  | jd t| jd ƒ  S rW   )r   r   r   rX   r'   r'   r(   Ú_eval_rewrite_as_reô   s   zim._eval_rewrite_as_rec                 C  r[   rW   r\   r^   r'   r'   r(   r_   ÷   r`   zim._eval_is_algebraicc                 C  r[   rW   ©r   r-   r^   r'   r'   r(   rb   ú   r`   zim._eval_is_zeroc                 C  rc   rd   re   r^   r'   r'   r(   rg   ý   rh   zim._eval_is_finitec                 C  rc   rd   re   r^   r'   r'   r(   ri     rh   zim._eval_is_complexNrj   )rk   rl   rm   rn   ro   r-   rp   rq   rr   rG   r1   rU   rt   r_   rb   rg   ri   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   ra   ÚAbs)rK   rM   Ús©Ú	__class__r'   r(   rx   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_mulrv   Úis_extended_negativeÚis_extended_positiver.   r:   Úis_comparabler   r7   r   ÚOner9   Ú_new_rawargsr+   ra   r/   ÚNegativeOner2   r3   Úis_PowÚexpÚHalf)	r<   r=   rF   r   Úunkrz   rD   ÚaiÚarg2r'   r'   r(   rG   I  sT   €


÷z	sign.evalc                 C  s   t | jd jƒrtjS d S rW   )r   r   ra   r   r‚   r^   r'   r'   r(   Ú	_eval_Abs{  s   ÿzsign._eval_Absc                 C  s   t t| jd ƒƒS rW   )rv   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é   TrQ   )r   r-   Ú'sympy.functions.special.delta_functionsrŽ   r   r.   r   )rK   rT   rŽ   r'   r'   r(   rU   ‚  s   ÿÿþzsign._eval_derivativec                 C  rc   rd   )r   Úis_nonnegativer^   r'   r'   r(   Ú_eval_is_nonnegativeŒ  rh   zsign._eval_is_nonnegativec                 C  rc   rd   )r   Úis_nonpositiver^   r'   r'   r(   Ú_eval_is_nonpositive�  rh   zsign._eval_is_nonpositivec                 C  r[   rW   )r   r.   r^   r'   r'   r(   Ú_eval_is_imaginary”  r`   zsign._eval_is_imaginaryc                 C  r[   rW   ru   r^   r'   r'   r(   Ú_eval_is_integer—  r`   zsign._eval_is_integerc                 C  r[   rW   )r   ra   r^   r'   r'   r(   rb   š  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 rW   )r   r   ra   Ú
is_integerÚis_evenr   r‚   )rK   Ú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 rW   )r   ÚsubsÚfuncÚdirr   r   r‚   )rK   rT   Ú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 )Nrs   r   éÿÿÿÿ)r   T)r-   r   rX   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�   rs   ©r�   r§   r-   ©rK   r=   rY   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 rd   )r   r   ry   rX   r'   r'   r(   Ú_eval_rewrite_as_Abs·  s    zsign._eval_rewrite_as_Absc                 K  s   |   t| jd ƒ¡S rW   )rœ   r   r   )rK   rY   r'   r'   r(   Ú_eval_simplifyº  s   zsign._eval_simplify©r   )rk   rl   rm   rn   Ú
is_complexrq   rx   rr   rG   r‹   rŒ   rU   r’   r”   r•   r–   rb   rš   r£   r¥   rª   r«   r¬   Ú__classcell__r'   r'   r{   r(   rv   	  s*    6
1

	rv   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 )/ry   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   TFrs   c                 C  s    |dkrt | jd ƒS t| |ƒ‚)zE
        Get the first derivative of the argument to Abs().

        rs   r   )rv   r   r   )rK   Ú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(): %sFrQ   )r†   Úlogc                 s  s   � | ]}|j V  qd S r"   )Úis_infinite©r%   rD   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„   ry   Úis_extended_nonnegativer   r   r   r:   r8   r   r1   r   r   Úis_positiveÚis_AddÚNegativeInfinityÚanyra   r/   Úis_extended_nonpositiver.   r4   ÚatomsÚallÚxreplacer   r   )r<   r=   r²   Úobjrž   ÚdÚknownrˆ   ÚtÚbnewÚtnewr†   r³   rÇ   ÚexponentrD   rE   ÚzrŠ   Únew_conjr    Úabs_free_argr'   )r=   r¿   r(   rG   
  sª   








 

ûzAbs.evalc                 C  rc   rd   re   r^   r'   r'   r(   Ú_eval_is_realk  rh   zAbs._eval_is_realc                 C  ó   | j d jr| j d jS d S rW   )r   r-   r—   r^   r'   r'   r(   r–   o  ó   ÿzAbs._eval_is_integerc                 C  ó   t | jd jƒS rW   ©r   Ú_argsra   r^   r'   r'   r(   Ú_eval_is_extended_nonzeros  ó   zAbs._eval_is_extended_nonzeroc                 C  r[   rW   )râ   ra   r^   r'   r'   r(   rb   v  r`   zAbs._eval_is_zeroc                 C  rà   rW   rá   r^   r'   r'   r(   Ú_eval_is_extended_positivey  rä   zAbs._eval_is_extended_positivec                 C  rÞ   rW   )r   r-   Úis_rationalr^   r'   r'   r(   Ú_eval_is_rational|  rß   zAbs._eval_is_rationalc                 C  rÞ   rW   )r   r-   r˜   r^   r'   r'   r(   Ú_eval_is_even€  rß   zAbs._eval_is_evenc                 C  rÞ   rW   )r   r-   Úis_oddr^   r'   r'   r(   Ú_eval_is_odd„  rß   zAbs._eval_is_oddc                 C  r[   rW   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   rs   )r   r-   r—   r˜   r   r„   Ú
is_Integer)rK   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£   rv   Úexpand)rK   rT   rž   rŸ   r    r³   Ú	directionrz   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 rP   )
r   r-   r.   r   rv   r4   r   r:   ry   Úrewrite)rK   rT   Úrvr'   r'   r(   rU   ›  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 rd   )r-   r   r.   r   rX   r'   r'   r(   r¥   «  s
   $ÿzAbs._eval_rewrite_as_Piecewisec                 K  s   |t |ƒ S r"   ©rv   rX   r'   r'   r(   Ú_eval_rewrite_as_sign±  r`   zAbs._eval_rewrite_as_signc                 K  s   t |t|ƒ ƒS r"   )r   r4   rX   r'   r'   r(   Ú_eval_rewrite_as_conjugate´  rä   zAbs._eval_rewrite_as_conjugateN)rs   r­   )rk   rl   rm   rn   ro   r-   r   rÊ   rp   rq   r±   rr   rG   rÝ   r–   rã   rb   rå   rç   rè   rê   r_   rš   r£   rU   rª   r¥   rò   ró   r'   r'   r'   r(   ry   ¾  s6   
 9


`
	ry   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¤   rs   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>©Úatan2FrQ   )Úranger3   r   r-   r   r+   rÈ   r†   rö   Úperiodic_argumentr   r:   r�   ÚPiÚis_Atomr   Úas_coeff_Mulr}   r   rv   rÎ   rÐ   r   Ú(sympy.functions.elementary.trigonometricrø   r1   Ú	is_number)r<   r=   rD   r·   r†   rö   Úi_rF   Úarg_rø   rT   Úyrð   r'   r'   r(   rG   í  sH   





ÿ
ÿzarg.evalc                 C  sF   | j d  ¡ \}}|t||dd� |t||dd�  |d |d   S )Nr   TrQ   r�   )r   r1   r   )rK   rÖ   rT   r  r'   r'   r(   rU     s   ÿÿzarg._eval_derivativec                 K  s(   ddl m} | jd  ¡ \}}|||ƒS )Nr   r÷   )rþ   rø   r   r1   )rK   r=   rY   rø   rT   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)Úpositivers   zCannot expand %s around 0)	r   r   r›   rË   r   r/   rÆ   rû   r   )rK   rT   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   )ÚOrderrs   )rŸ   r    )Úsympy.series.orderr  r  )rK   rT   rž   rŸ   r    r  r'   r'   r(   r£   -  s   zarg._eval_nseriesNr­   )rk   rl   rm   rn   r-   Úis_realrf   rq   rr   rG   rU   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(   rG   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 rP   ©ry   r   r^   r'   r'   r(   r‹   k  r�   zconjugate._eval_Absc                 C  ó   t | jd ƒS rW   ©Ú	transposer   r^   r'   r'   r(   Ú_eval_adjointn  ó   zconjugate._eval_adjointc                 C  ó
   | j d S rW   ©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 rP   )r  r4   r   r   r.   rS   r'   r'   r(   rU   t  s
   ÿzconjugate._eval_derivativec                 C  r  rW   ©Úadjointr   r^   r'   r'   r(   Ú_eval_transposez  r  zconjugate._eval_transposec                 C  r[   rW   r\   r^   r'   r'   r(   r_   }  r`   zconjugate._eval_is_algebraicN)rk   rl   rm   rn   rq   rr   rG   r  r‹   r  rŒ   rU   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(   rG   ª  r  ztranspose.evalc                 C  r  rW   ©r4   r   r^   r'   r'   r(   r  °  r  ztranspose._eval_adjointc                 C  r  rW   r  r^   r'   r'   r(   rŒ   ³  r  ztranspose._eval_conjugatec                 C  r  rW   r  r^   r'   r'   r(   r  ¶  r  ztranspose._eval_transposeN)	rk   rl   rm   rn   rr   rG   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(   rG   Õ  s   ÿzadjoint.evalc                 C  r  rW   r  r^   r'   r'   r(   r  Þ  r  zadjoint._eval_adjointc                 C  r  rW   r  r^   r'   r'   r(   rŒ   á  r  zadjoint._eval_conjugatec                 C  r  rW   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   )rK   Ú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)rK   r  r   r  Úpformr'   r'   r(   Ú_prettyî  s   ÿzadjoint._prettyr"   )rk   rl   rm   rn   rr   rG   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(   rG   %  s4   ùzpolar_lift.evalc                 C  s   | j d  |¡S )z. Careful! any evalf of polar numbers is flaky r   )r   Ú_eval_evalf)rK   Úprecr'   r'   r(   r,  I  s   zpolar_lift._eval_evalfc                 C  r  rP   r  r^   r'   r'   r(   r‹   M  r�   zpolar_lift._eval_AbsN)
rk   rl   rm   rn   r)  r�   rr   rG   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³   rs   )rÈ   rö   r³   r}   r   r)  r=   r3   r†   r1   r…   Úunbranched_argumentrÇ   r(  r%  )	r<   r+  rö   r³   r   rp   rD   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%   rT   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þ   r2  rø   r8   Ú#sympy.functions.elementary.integersr4  r   r‡   )	r<   r+  ÚperiodÚnewargsrp   r2  rø   r4  rž   r'   r'   r(   rG   ‘  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   r3  )	r   r   rú   r/  r,  r6  r4  r   r‡   )rK   r-  rÚ   r7  rp   Úubr4  r'   r'   r(   r,  ¯  s   


 zperiodic_argument._eval_evalfN)rk   rl   rm   rn   rr   r/  rG   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 )	r5  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'   rs   r�   T)rÈ   rö   r3   r%  r5  r   r   rú   r8   Úreplacer   r)  rÅ   r~   rË   Útuplerÿ   r.  r(  r   )rK   rT   r7  rö   r9  ÚbargÚplr;  ÚresrF   ÚmÚothersr  r=   r'   r'   r(   rG   ý  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   )rK   r-  rÚ   r7  Úpr†   r'   r'   r(   r,  1  s   
zprincipal_branch._eval_evalfN)	rk   rl   rm   rn   r)  r�   rr   rG   r,  r'   r'   r'   r(   r5  Ñ  s    (
3r5  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>FrF  c                   rE  )FrF  rH  rJ  rK  r'   r(   r¼   L  r½   rs   ©rL  rG  c                   s(   g | ]}t |tƒrt|ˆ ˆd �n|‘qS )rF  )r3   r
   rI  rJ  rM  r'   r(   r¼   W  s
    
ÿÿ)Úsympy.integrals.integralsrD  r)  rÿ   r%  r3   r   rü   rÌ   rœ   r   r…   rÇ   r   ÚExp1rI  r†   r2   Úfunctionr7   r=  )
ÚeqrL  rG  rD  Úrrœ   ÚlimitsÚlimitÚvarÚrestr'   rM  r(   rI  :  s:   

ÿrI  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%   rz   r'   r'   r(   rº   ˆ  s    zpolarify.<locals>.<dictcomp>c                 S  s   i | ]\}}||“qS r'   r'   )r%   rz   rR  r'   r'   r(   rº   Š  r1  )rI  r   rÅ   r›   Úitems)rQ  r›   rL  Úrepsr'   r'   r(   Úpolarify[  s   (
r[  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õ   rs   r�   )z==z!=c                   s   g | ]}t |ˆ ƒ‘qS r'   ©Ú_unpolarifyr0  ©Úexponents_onlyr'   r(   r¼   �  r1  z_unpolarify.<locals>.<listcomp>rp   Fc                   s   g | ]}t |ˆ ˆ ƒ‘qS r'   r\  r0  r^  r'   r(   r¼   ¨  s    ÿc                   s   g | ]}t |ˆ d ƒ‘qS rj   r\  r0  r^  r'   r(   r¼   «  r»   )r3   r	   rü   rÈ   r†   rö   r]  r5  r   r   rÌ   r}   Ú
is_BooleanÚis_RelationalÚrel_oprœ   r%  r…   rÇ   r—   r2   Úgetattr)rQ  r_  rG  r†   rö   ÚexporÇ   r'   r^  r(   r]  �  s@   
ÿÿÿþ

ÿÿr]  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&  rs   )	r3   Úboolr   Ú
unpolarifyr›   r]  rÈ   rö   r%  )rQ  r›   r_  ÚchangedrG  r@  rö   r'   r'   r(   rf  ®  s(   

ù
rf  )F)TF)NF)4Ú
__future__r   Ú
sympy.corer   r   r   r   r   r   r	   Úsympy.core.exprr
   Ú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:   rv   ry   r=   r4   r  r  r%  rú   r.  r5  rI  r[  r]  rf  r'   r'   r'   r(   Ú<module>   s:    $ z{ 6 {|M9BUj
i
!
2!