
    Ed                        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e          Z$ G d de          Z% G d de          Z& G d de          Z' G d de          Z( G d de          Z) G d de          Z* G d de          Z+ G d de          Z, G d de          Z-d  Z. G d! d"e          Z/d*d$Z0d+d&Z1d*d'Z2d,d)Z3d(S )-    )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                   x    e Zd ZU dZee         ed<   dZdZdZ	e
d             ZddZd Zd Zd Zd	 Zd
 Z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                    |t           j        u rt           j        S |t           j        u rt           j        S |j        r|S |j        st           j        |z  j        rt           j        S |j        r|                                d         S |j	        r/t          |t                    rt          |j        d                   S g g g }}}t          j        |          }|D ]}|                    t           j                  }||j        s|                    |           @|                    t           j                  s|j        r|                    |           ||                    |          }|r|                    |d                    |                    |           t'          |          t'          |          k    r1d |||fD             \  }	}
} | |	          t)          |
          z
  |z   S d S )Nr   ignorec              3   (   K   | ]}t          | V  d S Nr   .0xss     Dlib/python3.11/site-packages/sympy/functions/elementary/complexes.py	<genexpr>zre.eval.<locals>.<genexpr>i   &      MM38MMMMMM    )r   NaNComplexInfinityis_extended_realis_imaginaryImaginaryUnit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cs               r'   evalzre.evalD   s   !%< %	*5LA%% #	*5L! !	*J 	*!/#"5!G 	*6M] 	*##%%a((_ 	*C!;!; 	*chqk??" ,.r2hH=%%D . .++AO<< . 1 / ...!/22 
.t7L 
.OOD))))
 !% 1 1 1 = =I  . 	!5555 ----4yyCMM) *MMx8.LMMM1as1vv1~))* *r*   c                     | t           j        fS )zF
        Returns the real number with a zero imaginary part.

        r   r0   selfdeephintss      r'   r2   zre.as_real_imagm       
 af~r*   c                 .   |j         s| j        d         j         r*t          t          | j        d         |d                    S |j        s| j        d         j        r8t
          j         t          t          | j        d         |d                    z  S d S Nr   Tevaluate)r-   r   r   r   r.   r   r/   r;   rL   xs     r'   _eval_derivativezre._eval_derivativet        	B1!> 	Bj1q4@@@AAA> 	ATYq\6 	AO#Z	!a$???@@A A	A 	Ar*   c                 l    | j         d         t          j        t          | j         d                   z  z
  S Nr   )r   r   r/   r;   rL   r>   kwargss      r'   _eval_rewrite_as_imzre._eval_rewrite_as_im{   s(    y|aob1.>.>>>>r*   c                 &    | j         d         j        S rY   r   is_algebraicrL   s    r'   _eval_is_algebraiczre._eval_is_algebraic~       y|((r*   c                 d    t          | j        d         j        | j        d         j        g          S rY   )r   r   r.   is_zeror`   s    r'   _eval_is_zerozre._eval_is_zero   s'    12DIaL4HIJJJr*   c                 .    | j         d         j        rdS d S Nr   Tr   	is_finiter`   s    r'   _eval_is_finitezre._eval_is_finite   "    9Q<! 	4	 	r*   c                 .    | j         d         j        rdS d S rg   rh   r`   s    r'   _eval_is_complexzre._eval_is_complex   rk   r*   NT)__name__
__module____qualname____doc__tTupler   __annotations__r-   
unbranched_singularitiesclassmethodrH   r2   rV   r\   ra   re   rj   rm    r*   r'   r   r      s         ' 'R ,JN&* &* [&*P   A A A? ? ?) ) )K K K      r*   r   c                   x    e Zd ZU dZee         ed<   dZdZdZ	e
d             ZddZd Zd Zd Zd	 Zd
 Zd ZdS )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   Tc                     |t           j        u rt           j        S |t           j        u rt           j        S |j        rt           j        S |j        st           j        |z  j        rt           j         |z  S |j        r|                                d         S |j	        r0t          |t                    rt          |j        d                    S g g g }}}t          j        |          }|D ]}|                    t           j                  }|3|j        s|                    |           @|                    |           V|                    t           j                  s|j        sI|                    |          }|r|                    |d                    |                    |           t'          |          t'          |          k    r1d |||fD             \  }	}
} | |	          t)          |
          z   |z   S d S )N   r   r   c              3   (   K   | ]}t          | V  d S r"   r#   r$   s     r'   r(   zim.eval.<locals>.<genexpr>   r)   r*   )r   r+   r,   r-   r0   r.   r/   r1   r2   r3   r4   r5   r;   r   r   r6   r7   r8   r9   r:   r   r<   s               r'   rH   zim.eval   s   !%< $	*5LA%% "	*5L!  	*6M 	*!/#"5!G 	*O#c))] 	*##%%a((_ 	*C!;!; 	*sx{OO##+-r2hH=%%D . .++AO<< . 1 / .... ....XXao.. .d6K . !% 1 1 1 = =I  . 	!5555 ---4yyCMM) *MMx8.LMMM1as1vv1~))* *r*   c                     | t           j        fS )zC
        Return the imaginary part with a zero real part.

        rJ   rK   s      r'   r2   zim.as_real_imag   rO   r*   c                 .   |j         s| j        d         j         r*t          t          | j        d         |d                    S |j        s| j        d         j        r8t
          j         t          t          | j        d         |d                    z  S d S rQ   )r-   r   r;   r   r.   r   r/   r   rT   s     r'   rV   zim._eval_derivative   rW   r*   c                 n    t           j         | j        d         t          | j        d                   z
  z  S rY   )r   r/   r   r   rZ   s      r'   _eval_rewrite_as_rezim._eval_rewrite_as_re   s+    149Q<0@0@!@AAr*   c                 &    | j         d         j        S rY   r^   r`   s    r'   ra   zim._eval_is_algebraic   rb   r*   c                 &    | j         d         j        S rY   r   r-   r`   s    r'   re   zim._eval_is_zero       y|,,r*   c                 .    | j         d         j        rdS d S rg   rh   r`   s    r'   rj   zim._eval_is_finite   rk   r*   c                 .    | j         d         j        rdS d S rg   rh   r`   s    r'   rm   zim._eval_is_complex  rk   r*   Nrn   )ro   rp   rq   rr   rs   r   rt   r-   ru   rv   rw   rH   r2   rV   r   ra   re   rj   rm   rx   r*   r'   r;   r;      s         ' 'R ,JN%* %* [%*N   A A AB B B) ) )- - -      r*   r;   c                        e Zd ZdZdZdZ fdZed             Zd Z	d Z
d Zd Zd	 Zd
 Zd Zd Zd ZddZd Zd Zd Zd Z x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                     t                                                      }|| k    r<| j        d         j        du r(| j        d         t	          | j        d                   z  S |S )Nr   F)superdoitr   rd   Abs)rL   rN   s	__class__s      r'   r   z	sign.doitC  sY    GGLLNN9 	41-6 	49Q<#dil"3"333r*   c                    |j         r|                                \  }}g }t          |          }|D ]w}|j        r| }|j        r|j        rFt          |          }|j        r|t          j	        z  }|j        r| }L|
                    |           b|
                    |           x|t          j        u r"t          |          t          |          k    rd S | |  |j        |           z  S |t          j        u 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        u rt          j	        S t          j	         |z  }|j        rt          j	        S |j        rt          j	         S d S d S r"   )is_Mulas_coeff_mulr   is_extended_negativeis_extended_positiver.   r;   is_comparabler   r/   r8   Oner:   _new_rawargsr+   rd   r0   NegativeOner3   r4   is_PowexpHalf)	r=   r>   rG   r   unkr   rE   aiarg2s	            r'   rH   z	sign.evalI  s    : 	3&&((GAtCQA & &) &AA+ &~ &UU+ *0A!6 ' &'BJJqMMMM

1AEz c#hh#d))3 tss+3+S12222!%< 	5L; 	6M# 	5L# 	!= ? 	#t$$ 
 		(z 'cg/ ' &O#c)D( '&( (''		( 		(( (r*   c                 \    t          | j        d         j                  rt          j        S d S rY   )r   r   rd   r   r   r`   s    r'   	_eval_Abszsign._eval_Abs{  s,    TYq\)** 	5L	 	r*   c                 P    t          t          | j        d                             S rY   )r   r5   r   r`   s    r'   _eval_conjugatezsign._eval_conjugate  s    Idil++,,,r*   c                 ^   | j         d         j        r=ddlm} dt	          | j         d         |d          z   || j         d                   z  S | j         d         j        rKddlm} dt	          | j         d         |d          z   |t          j         | j         d         z            z  S d S )Nr   )
DiracDelta   TrR   )r   r-   'sympy.functions.special.delta_functionsr   r   r.   r   r/   )rL   rU   r   s      r'   rV   zsign._eval_derivative  s    9Q<( 	>JJJJJJz$)A,DAAAA*TYq\**+ +Yq\& 	>JJJJJJz$)A,DAAAA*ao-	!<==> >	> 	>r*   c                 .    | j         d         j        rdS d S rg   )r   is_nonnegativer`   s    r'   _eval_is_nonnegativezsign._eval_is_nonnegative  "    9Q<& 	4	 	r*   c                 .    | j         d         j        rdS d S rg   )r   is_nonpositiver`   s    r'   _eval_is_nonpositivezsign._eval_is_nonpositive  r   r*   c                 &    | j         d         j        S rY   )r   r.   r`   s    r'   _eval_is_imaginaryzsign._eval_is_imaginary  rb   r*   c                 &    | j         d         j        S rY   r   r`   s    r'   _eval_is_integerzsign._eval_is_integer  r   r*   c                 &    | j         d         j        S rY   )r   rd   r`   s    r'   re   zsign._eval_is_zero  s    y|##r*   c                     t          | j        d         j                  r|j        r|j        rt
          j        S d S d S d S rY   )r   r   rd   
is_integeris_evenr   r   )rL   others     r'   _eval_powerzsign._eval_power  sY    dil*++		 M	
 5L	 	 	 	 	 	r*   r   c                    | j         d         }|                    |d          }|dk    r|                     |          S |dk    r|                    ||          }t	          |          dk     rt
          j         nt
          j        S rY   )r   subsfuncdirr   r   r   )rL   rU   nlogxcdirarg0x0s          r'   _eval_nserieszsign._eval_nseries  sx    y|YYq!__7 	!99R== 19 	%88At$$DDA0vv150r*   c                 N    |j         rt          d|dk    fd|dk     fd          S d S )Nr{   r   )r   T)r-   r   rZ   s      r'   _eval_rewrite_as_Piecewisezsign._eval_rewrite_as_Piecewise  s<     	Eaq\Ba=)DDD	E 	Er*   c                 B    ddl m} |j        r ||          dz  dz
  S d S )Nr   	Heavisider   r{   r   r   r-   rL   r>   r[   r   s       r'   _eval_rewrite_as_Heavisidezsign._eval_rewrite_as_Heaviside  sA    EEEEEE 	*9S>>A%))	* 	*r*   c                 f    t          dt          |d          f|t          |          z  df          S rg   )r   r   r   rZ   s      r'   _eval_rewrite_as_Abszsign._eval_rewrite_as_Abs  s-    !RQZZ3S>4*@AAAr*   c                 \    |                      t          | j        d                             S rY   )r   r   r   )rL   r[   s     r'   _eval_simplifyzsign._eval_simplify  s"    yydil33444r*   r   )ro   rp   rq   rr   
is_complexrv   r   rw   rH   r   r   rV   r   r   r   r   re   r   r   r   r   r   r   __classcell__)r   s   @r'   r   r   	  sH       4 4l JN     /( /( [/(b  - - -> > >    ) ) )- - -$ $ $  1 1 1 1E E E* * *
B B B5 5 5 5 5 5 5r*   r   c                       e Zd ZU dZee         ed<   dZdZdZ	dZ
dZddZed             Zd Zd	 Zd
 Zd Zd Zd Zd Zd Zd Zd ZddZd Zd Zd Zd Zd ZdS )r   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   TFr{   c                 b    |dk    rt          | j        d                   S t          | |          )zE
        Get the first derivative of the argument to Abs().

        r{   r   )r   r   r   )rL   argindexs     r'   fdiffz	Abs.fdiff   s4    
 q= 	5	!%%%$T8444r*   c                 h
   ddl m} t          d          r                                }||S t	          t
                    st          dt                    z             |d                                          \  }}|j	        r|j	        s | |           | |          z  S j
        rg }g }j        D ]}|j        rw|j        j        rk|j        j        r_ | |j                  }	t	          |	|           r|                    |           W|                    t%          |	|j                              | |          }
t	          |
|           r|                    |           |                    |
           t'          | }|r | t'          | d          nt(          j        }||z  S t(          j        u rt(          j        S t(          j        u rt(          j        S ddlm}m} j        r                                \  }}|j        r|j        r5|j        rS |t(          j        u rt(          j        S t?          |          |z  S |j         r|tC          |          z  S |j"        r:| tC          |          z   |t(          j#         tI          |          z            z  S d S |%                    tL                    sH ||          '                                \  }}|tP          |z  z   } |tC          ||z                      S t	          |          r# |tC          j        d                             S t	          tR                    rj*        rS j        r S d S j+        ra%                    t(          j        t(          j,                  r7t[          d '                                D                       rt(          j        S j.        rt(          j/        S j         rS j0        r S j1        rt(          j2         z  }|j         r|S j        rd S  |3                                d          4                    tf                    4                    tf                    z
  }|rtk          fd	|D                       rd S k    r k    r4                    t>                    }6                    d
 |D                       }d |j	        D             }|rtk          fd|D                       s#to          tq          z                      S d S d S d S )Nr   )signsimpr   zBad argument type for Abs(): %sFrR   )r   logc              3   $   K   | ]}|j         V  d S r"   )is_infiniter%   rE   s     r'   r(   zAbs.eval.<locals>.<genexpr>P  s$      ==Q1=======r*   c              3   X   K   | ]$}                     |j        d                    V  %dS )r   N)r9   r   )r%   ir>   s     r'   r(   zAbs.eval.<locals>.<genexpr>b  s5      AA1CGGAF1I..AAAAAAr*   c                 0    i | ]}|t          d           S )T)real)r	   r%   r   s     r'   
<dictcomp>zAbs.eval.<locals>.<dictcomp>f  s%    (M(M(MEt,<,<,<(M(M(Mr*   c                      g | ]}|j         	|S r"   )r-   r   s     r'   
<listcomp>zAbs.eval.<locals>.<listcomp>g  s     VVV1;MV1VVVr*   c              3   \   K   | ]&}                     t          |                    V  'd S r"   )r9   r5   )r%   uconjs     r'   r(   zAbs.eval.<locals>.<genexpr>h  s5      !F!FQ$((9Q<<"8"8!F!F!F!F!F!Fr*   )9sympy.simplify.simplifyr   hasattrr   r4   r   	TypeErrortypeas_numer_denomfree_symbolsr   r   r   r   r   is_negativebaser8   r   r   r   r   r+   r,   Infinity&sympy.functions.elementary.exponentialr   as_base_expr-   r   r   r   is_extended_nonnegativer   r   Pir;   r9   r   r2   r   r   is_positiveis_AddNegativeInfinityanyrd   r0   is_extended_nonpositiver.   r/   r5   atomsallxreplacer   r   )r=   r>   r   objr   dknownr   tbnewtnewr   r   r   exponentrE   rF   zr   new_conjr    abs_free_argr   s    `                    @r'   rH   zAbs.eval
  s   4444443$$ 	--//C 
#t$$ 	K=S		IJJJ hsU+++!!##1> 	!!. 	!3q66##a&&= : 	ECX + +8 + 0 +QU5F +3qv;;D!$,, 7

1Squ%5%566663q66D!$,, +

1T****KE47B##c3i%0000QUC9!%< 	5L!## 	:CCCCCCCC: 	+ __..ND($ +& /' #"
q}, % ut99h../ .H--, I!EBxLL0adU2h<<5G1H1HHHXXf%% +s4yy--//1!Gs2hqj>>***c3 	(3r#(1+'''c<(( 	 
 tF: 	"#''!*a.@AA 	"==#*:*:*<*<===== "z!; 	6M& 	J& 	4K 	O#c)D+  	F x%888::i((399Y+?+?? 	AAAAAAAAA 	F$; 	234%< 	2YYs^^F<<(M(Mf(M(M(MNNLVVl7VVVC 2c!F!F!F!F#!F!F!FFF 2Js4x00111	2 	2 	2 	22 2r*   c                 .    | j         d         j        rdS d S rg   rh   r`   s    r'   _eval_is_realzAbs._eval_is_realk  rk   r*   c                 N    | j         d         j        r| j         d         j        S d S rY   )r   r-   r   r`   s    r'   r   zAbs._eval_is_integero  s,    9Q<( 	+9Q<**	+ 	+r*   c                 @    t          | j        d         j                  S rY   r   _argsrd   r`   s    r'   _eval_is_extended_nonzerozAbs._eval_is_extended_nonzeros      A.///r*   c                 &    | j         d         j        S rY   )r
  rd   r`   s    r'   re   zAbs._eval_is_zerov  s    z!}$$r*   c                 @    t          | j        d         j                  S rY   r	  r`   s    r'   _eval_is_extended_positivezAbs._eval_is_extended_positivey  r  r*   c                 N    | j         d         j        r| j         d         j        S d S rY   )r   r-   is_rationalr`   s    r'   _eval_is_rationalzAbs._eval_is_rational|  s,    9Q<( 	,9Q<++	, 	,r*   c                 N    | j         d         j        r| j         d         j        S d S rY   )r   r-   r   r`   s    r'   _eval_is_evenzAbs._eval_is_even  s,    9Q<( 	(9Q<''	( 	(r*   c                 N    | j         d         j        r| j         d         j        S d S rY   )r   r-   is_oddr`   s    r'   _eval_is_oddzAbs._eval_is_odd  s,    9Q<( 	'9Q<&&	' 	'r*   c                 &    | j         d         j        S rY   r^   r`   s    r'   ra   zAbs._eval_is_algebraic  rb   r*   c                     | j         d         j        rI|j        rB|j        r| j         d         |z  S |t          j        ur|j        r| j         d         |dz
  z  | z  S d S )Nr   r{   )r   r-   r   r   r   r   
is_Integer)rL   r  s     r'   r   zAbs._eval_power  sq    9Q<( 	9X-@ 	9 9y|X--. 983F 9y|hl3D88r*   r   c                 b   ddl m} | j        d                             |          d         }|                     ||                    r|                     ||          |          }| j        d                             |||          }t          |          |z                                  S )Nr   )r   )r   r   )	r   r   r   leadtermr9   r   r   r   expand)rL   rU   r   r   r   r   	directionr   s           r'   r   zAbs._eval_nseries  s    >>>>>>IaL))!,,Q/	==Q   	5!ss1vvt44IIaL&&qAD&99Y!))+++r*   c                 T   | j         d         j        s| j         d         j        rEt          | j         d         |d          t	          t          | j         d                             z  S t          | j         d                   t          t          | j         d                   |d          z  t          | j         d                   t          t          | j         d                   |d          z  z   t          | j         d                   z  }|	                    t                    S rQ   )
r   r-   r.   r   r   r5   r   r;   r   rewrite)rL   rU   rvs      r'   rV   zAbs._eval_derivative  s   9Q<( 	0DIaL,E 	0dilA===y1..//0 01Bty|,<,<a" " " 	!--
2dil;K;KD1" 1" 1" ""%(1%6%67 zz$r*   c                 V    ddl m} |j        r| ||           ||           z
  z  S d S )Nr   r   r   r   s       r'   r   zAbs._eval_rewrite_as_Heaviside  sN     	FEEEEE 	:		#C4899	: 	:r*   c                     |j         rt          ||dk    f| df          S |j        r1t          t          |z  t          |z  dk    ft           |z  df          S d S rg   )r-   r   r.   r   rZ   s      r'   r   zAbs._eval_rewrite_as_Piecewise  so     	Bc3!8_tTl;;; 	BaeQsUaZ0A2c64.AAA	B 	Br*   c                 &    |t          |          z  S r"   r   rZ   s      r'   _eval_rewrite_as_signzAbs._eval_rewrite_as_sign  s    499}r*   c                 @    t          |t          |          z            S r"   )r   r5   rZ   s      r'   _eval_rewrite_as_conjugatezAbs._eval_rewrite_as_conjugate  s    C	#&'''r*   N)r{   r   )ro   rp   rq   rr   rs   r   rt   r-   r   r   ru   rv   r   rw   rH   r  r   r  re   r  r  r  r  ra   r   r   rV   r   r   r&  r(  rx   r*   r'   r   r     sz        7 7r , "JN5 5 5 5 ^2 ^2 [^2@  + + +0 0 0% % %0 0 0, , ,( ( (' ' ') ) )  , , , ,     : : :B B B  ( ( ( ( (r*   r   c                   D    e Zd ZdZdZdZdZdZed             Z	d Z
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                    |}t          d          D ]<}t          ||           r|j        d         } |dk    r|j        rt          j        c S  nt          j        S ddlm} t          ||          rt          |t                    S |j
        sVt          |                                          \  }}|j        rt          d |j        D              }t          |          |z  }n|}t!          d |                    t$                    D                       rd S ddlm} |                                \  }}	 ||	|          }
|
j        r|
S ||k    r | |d	          S d S )
N   r   r   	exp_polarc                 R    g | ]$}t          |          d vr|nt          |          %S ))r   r{   r%  r   s     r'   r   zarg.eval.<locals>.<listcomp>  sE     0 0 0 ! $(77'#9 QQGG0 0 0r*   c              3   (   K   | ]}|j         d u V  d S r"   )r   r   s     r'   r(   zarg.eval.<locals>.<genexpr>  s*      PP!q%-PPPPPPr*   atan2FrR   )ranger4   r   r-   r   r+   r   r-  periodic_argumentr   is_Atomr   as_coeff_Mulr   r   r   r   r   r   (sympy.functions.elementary.trigonometricr1  r2   	is_number)r=   r>   rE   r   r-  rG   arg_r1  rU   yr!  s              r'   rH   zarg.eval  s   q 	 	A!S!! F1I6 !a0 !5LLL5LDDDDDDc9%% 	.$S"---{ 	"3''4466GAt{ 1 0 0%)Y0 0 0 1774<DDDPPtzz,7O7OPPPPP 	FBBBBBB  ""1U1a[[< 	I3; 	-3te,,,,	- 	-r*   c                     | j         d                                         \  }}|t          ||d          z  |t          ||d          z  z
  |dz  |dz  z   z  S )Nr   TrR   r   )r   r2   r   )rL   r   rU   r9  s       r'   rV   zarg._eval_derivative  sm    y|((**1Jq!d3333aq!d33374 4891q!tE 	Er*   c                 j    ddl m} | j        d                                         \  }} |||          S )Nr   r0  )r6  r1  r   r2   )rL   r>   r[   r1  rU   r9  s         r'   _eval_rewrite_as_atan2zarg._eval_rewrite_as_atan2  s?    BBBBBBy|((**1uQ{{r*   N)ro   rp   rq   rr   r-   is_realri   rv   rw   rH   rV   r<  rx   r*   r'   r>   r>     sq        - -^ GIN- - [-@E E E
    r*   r>   c                   V    e Zd ZdZdZed             Zd Zd Zd Z	d Z
d Zd	 Zd
 ZdS )r5   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                 6    |                                 }||S d S r"   )r   r=   r>   r   s      r'   rH   zconjugate.evalG  *    !!## 	J	 	r*   c                     t           S r"   )r5   r`   s    r'   inversezconjugate.inverseM  s    r*   c                 :    t          | j        d         d          S rQ   r   r   r`   s    r'   r   zconjugate._eval_AbsP      49Q<$////r*   c                 6    t          | j        d                   S rY   	transposer   r`   s    r'   _eval_adjointzconjugate._eval_adjointS      1&&&r*   c                     | j         d         S rY   r   r`   s    r'   r   zconjugate._eval_conjugateV      y|r*   c                     |j         r*t          t          | j        d         |d                    S |j        r+t          t          | j        d         |d                     S d S rQ   )r=  r5   r   r   r.   rT   s     r'   rV   zconjugate._eval_derivativeY  sm    9 	JZ	!a$GGGHHH^ 	Jj1q4HHHIIII	J 	Jr*   c                 6    t          | j        d                   S rY   adjointr   r`   s    r'   _eval_transposezconjugate._eval_transpose_      ty|$$$r*   c                 &    | j         d         j        S rY   r^   r`   s    r'   ra   zconjugate._eval_is_algebraicb  rb   r*   N)ro   rp   rq   rr   rv   rw   rH   rC  r   rJ  r   rV   rS  ra   rx   r*   r'   r5   r5     s        * *V N  [
  0 0 0' ' '  J J J% % %) ) ) ) )r*   r5   c                   :    e Zd ZdZed             Zd Zd Zd ZdS )rI  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                 6    |                                 }||S d S r"   )rS  r@  s      r'   rH   ztranspose.eval  rA  r*   c                 6    t          | j        d                   S rY   r5   r   r`   s    r'   rJ  ztranspose._eval_adjoint  rK  r*   c                 6    t          | j        d                   S rY   rQ  r`   s    r'   r   ztranspose._eval_conjugate  rT  r*   c                     | j         d         S rY   rM  r`   s    r'   rS  ztranspose._eval_transpose  rN  r*   N)	ro   rp   rq   rr   rw   rH   rJ  r   rS  rx   r*   r'   rI  rI  f  sg        & &P   [
' ' '% % %    r*   rI  c                   H    e Zd ZdZed             Zd Zd Zd Zd	dZ	d Z
dS )
rR  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                     |                                 }||S |                                }|t          |          S d S r"   )rJ  rS  r5   r@  s      r'   rH   zadjoint.eval  sO    !! 	J!!## 	"S>>!	" 	"r*   c                     | j         d         S rY   rM  r`   s    r'   rJ  zadjoint._eval_adjoint  rN  r*   c                 6    t          | j        d                   S rY   rH  r`   s    r'   r   zadjoint._eval_conjugate  rK  r*   c                 6    t          | j        d                   S rY   rY  r`   s    r'   rS  zadjoint._eval_transpose  rK  r*   Nc                 f    |                     | j        d                   }d|z  }|r	d|d|d}|S )Nr   z%s^{\dagger}z\left(z	\right)^{})_printr   )rL   printerr   r   r>   texs         r'   _latexzadjoint._latex  sG    nnTYq\**# 	7 	7-0SS###6C
r*   c                     ddl m}  |j        | j        d         g|R  }|j        r| |d          z  }n| |d          z  }|S )Nr   )
prettyFormu   †+) sympy.printing.pretty.stringpictrh  rc  r   _use_unicode)rL   rd  r   rh  pforms        r'   _prettyzadjoint._pretty  sk    ??????ty|3d333 	+::l333EE::c??*Er*   r"   )ro   rp   rq   rr   rw   rH   rJ  r   rS  rf  rm  rx   r*   r'   rR  rR    s         4 " " ["  ' ' '' ' '       r*   rR  c                   <    e Zd ZdZdZdZed             Zd Z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                    ddl m} |j        rR ||          }|dt          dz  t           dz  t          fv r)ddlm}  |t          |z            t          |          z  S |j        r|j	        }n|g}g }g }g }|D ]$}|j
        r||gz  }|j        r||gz  }||gz  }%t          |          t          |          k     rN|r#t          ||z    t          t          |           z  S |rt          ||z    S ddlm} t          |  |d          z  S d S )Nr   r>   r   r,  )$sympy.functions.elementary.complexesr>   r7  r   r   r-  r   absr   r   is_polarr   r:   r   ro  )	r=   r>   argumentarr-  r   r?   rA   positives	            r'   rH   zpolar_lift.eval
  s   HHHHHH= 	0#B
 aAs1ub)) 0LLLLLL y2s3xx//: 	8DD5D 	" 	"C| "SE! "SE!SE!x==3t99$ 	3 3X02:c8n3M3MMM 3X022LLLLLLH~iill22	3 	3r*   c                 B    | j         d                             |          S )z. Careful! any evalf of polar numbers is flaky r   )r   _eval_evalf)rL   precs     r'   ry  zpolar_lift._eval_evalf.  s    y|''---r*   c                 :    t          | j        d         d          S rQ   rE  r`   s    r'   r   zpolar_lift._eval_Abs2  rF  r*   N)
ro   rp   rq   rr   rt  r   rw   rH   ry  r   rx   r*   r'   ro  ro    sc        # #J HM!3 !3 [!3F. . .0 0 0 0 0r*   ro  c                   D    e Zd ZdZed             Zed             Zd ZdS )r3  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           	      
   ddl m}m} |j        r|j        }n|g}d}|D ]}|j        s|t          |          z  }t          ||          r#||j        	                                d         z  }O|j
        rX|j        	                                \  }}||t          |j                  z  | |t          |j                            z  z   z  }t          |t                    r|t          |j        d                   z  } d S |S )Nr   )r-  r   r{   )r   r-  r   r   r   rt  r>   r4   r   r2   r   unbranched_argumentr   rs  ro  )	r=   rv  r-  r   r   ru   rE   r   r;   s	            r'   _getunbranchedz periodic_argument._getunbranched_  s1   IIIIIIII9 	7DD4D
 	 	A: c!ff$

Ay)) 	ae0022155

 ++--Bb!4F" "  S[[!1!112 2

Az** c!&)nn,

ttr*   c                    |j         sd S |t          k    r#t          |t                    rt	          |j         S t          |t                    r)|dt          z  k    rt	          |j        d         |          S |j        rMd |j        D             }t          |          t          |j                  k    rt	          t          | |          S |                     |          }|d S ddlm}m} |                    t          ||          rd S |t          k    r|S |t          k    r>ddlm}  |||z  t$          j        z
            |z  }|                    |          s||z
  S d S d S )Nr   r   c                      g | ]}|j         	|S rx   )r   )r%   rU   s     r'   r   z*periodic_argument.eval.<locals>.<listcomp>  s    ???Q?q???r*   )atanr1  ceiling)r   r   r4   principal_branchr3  r   ro  r   r   r:   r   r  r6  r  r1  r9   #sympy.functions.elementary.integersr  r   r   )	r=   rv  periodnewargsru   r  r1  r  r   s	            r'   rH   zperiodic_argument.evalv  s    * 	4R< 	/Jr+;<< 	/$bg..b*%% 	9&AbD. 	9$RWQZ8889 	@??"'???G7||s27||+ @(g???''++
 	4HHHHHHHH>>+UD99 	4R< 	R< 	&CCCCCC
6)AF233F:A55>> &!A~%		& 	&& &r*   c                 V   | j         \  }}|t          k    r3t                              |          }|| S |                    |          S t          |t                                        |          }ddlm} | |||z  t          j        z
            |z  z
                      |          S )Nr   r  )	r   r   r3  r  ry  r  r  r   r   )rL   rz  r  r  ru   ubr  s          r'   ry  zperiodic_argument._eval_evalf  s    I	6R< 	0*99!<<J ))$///q"%%11$77??????WWRY/0077DDTJJJr*   N)ro   rp   rq   rr   rw   r  rH   ry  rx   r*   r'   r3  r3  6  si        & &P   [, & & [&:	K 	K 	K 	K 	Kr*   r3  c                 ,    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
    )r3  r   rq  s    r'   r~  r~    s    & S"%%%r*   c                   6    e Zd ZdZdZdZed             Z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                 Z   ddl m} t          |t                    rt	          |j        d         |          S |t          k    r|S t          |t                    }t          ||          }||k    r|                    t                    s|                    t                    st          |          }d }|	                    t          |          }t          |t                    }|                    t                    sN||k    r |t          ||z
  z            |z  }n|}|j        s#|                    |          s| |d          z  }|S |j        s|d}
}	n |j        |j         \  }	}
g }|
D ]}|j        r|	|z  }	||gz  }t          |          }
t          |	|          }|                    t                    rd S |j        rt#          |	          |k    s|dk    rt|
dk    rn|	dk    rh|dk    r't%          |	          t	          t'          |
 |          z  S t	           |t          |z            t'          |
 z  |          t%          |	          z  S |j        rLt%          |          |dz  k     dk    s	||dz  k    r-|
dk    r% ||t          z            t%          |	          z  S d S d S d S )Nr   r,  c                 N    t          | t                    st          |           S | S r"   )r4   r   ro  )exprs    r'   mrz!principal_branch.eval.<locals>.mr  s'    !$// ,%d+++r*   rx   r{   r   T)r   r-  r4   ro  r  r   r   r3  r9   replacer   rt  r   r   r   tupler7  r~  rs  r   )rL   rU   r  r-  r  bargplr  resrG   mothersr9  r>   s                 r'   rH   zprincipal_branch.eval  s   DDDDDDa$$ 	7#AF1Iv666R< 	Hq"%% F++: 	bff%677 	!233	AB   J++B"2r**B66*%% : #)AtbyM2225CCC| (CGGI,>,> (99Q<<'C
~ 	3bqAA!1>1>2DAq 	 	A} Q1#&MM6**77$%% 	4= 	M1!44; 	M"ax	M,-G	M89Q	Max @1vv.sAw????#IIae$4$4S!W$<fEEc!ffLL= 	+s3xx&(2t; 	+sfQh 	+G	+9SU##CFF**	+ 	+ 	+ 	+ 	+ 	+r*   c                     | j         \  }}t          ||                              |          }t          |          t          k    s|t           k    r| S ddlm} t          |           |t          |z            z                      |          S )Nr   )r   )r   r3  ry  rs  r   r   r   r   )rL   rz  r  r  pr   s         r'   ry  zprincipal_branch._eval_evalf  s    I	6a((44T::q66B; 	!s( 	K>>>>>>Ass1Q3xx,,T222r*   N)	ro   rp   rq   rr   rt  r   rw   rH   ry  rx   r*   r'   r  r    sT        & &P HM1+ 1+ [1+f3 3 3 3 3r*   r  Fc                 v   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| j
        D              }rt	          |          S |S | j        rJ| j        t          j        k    r5| 	                    t          j        t          | j        d                    S | j        r | j	        fd| j
        D              S t          | |          rt          | j                  }g }| j
        dd          D ]M}t          |d         d          }t          |dd                    }	|                    |f|	z              N ||ft)          |          z    S  | j	        fd	| j
        D              S )
Nr   )Integralc                 4    g | ]}t          |d           S )Tpause	_polarifyr%   r>   lifts     r'   r   z_polarify.<locals>.<listcomp>*  s(    JJJ3iT666JJJr*   Fr  c                 4    g | ]}t          |d           S )Fr  r  r  s     r'   r   z_polarify.<locals>.<listcomp>1  s(    NNNs3E:::NNNr*   r{   )r  r  c                 b    g | ]+}t          |t                    rt          |           n|,S )r  )r4   r   r  )r%   r>   r  r  s     r'   r   z_polarify.<locals>.<listcomp><  sR     O O O?BJsD11;3E::::7:O O Or*   )sympy.integrals.integralsr  rt  r7  ro  r4   r   r4  r   r   r   r   r   r   Exp1r  r   r3   functionr8   r  )
eqr  r  r  rr   limitslimitvarrests
    ``       r'   r  r    s6   222222	{ 		| E "~~"f Pe P P"~~	 P		 PBGJJJJ"'JJJK 	!a== 	 Prw!&( PwwqvyUCCCDDD	 PrwNNNNbgNNNOO	B	!	! Pd%888WQRR[ 	) 	)EE!H5>>>CU122YT???DMM3&4-((((x4'E&MM133rw O O O O OFHgO O O P 	Pr*   Tc                     |rd}t          t          |           |          } |s| S d | j        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                 <    i | ]}|t          |j        d           S )T)polar)r	   name)r%   r   s     r'   r   zpolarify.<locals>.<dictcomp>m  s)    BBBQAuQV4(((BBBr*   c                     i | ]\  }}||	S rx   rx   )r%   r   r  s      r'   r   zpolarify.<locals>.<dictcomp>o  s    ...A1...r*   )r  r   r   r   items)r  r   r  repss       r'   polarifyr  @  sz    P  	72;;	%	%B 	BB"/BBBD	B.......r*   c                 n   t          | t                    r| j        r| S |sddlm}m} t          | |          r |t          | j                            S t          | t                    r4| j        d         dt          z  k    rt          | j        d                   S | j
        s0| j        s)| j        s"| j        r6| j        dv r	d| j        v s	| j        dvr | j        fd| j        D              S t          | t                     rt          | j        d                   S | j        r9t          | j                  }t          | j        |j        o|            }||z  S | j        r1t+          | j        dd          r | j        fd	| j        D              S  | j        fd
| j        D              S )Nr   )r   r-  r{   r   )z==z!=c                 0    g | ]}t          |          S rx   _unpolarifyr%   rU   exponents_onlys     r'   r   z_unpolarify.<locals>.<listcomp>  s#    MMM[N;;MMMr*   ru   Fc                 2    g | ]}t          |          S rx   r  r  s     r'   r   z_unpolarify.<locals>.<listcomp>  s5        %QGG   r*   c                 2    g | ]}t          |d           S rn   r  r  s     r'   r   z_unpolarify.<locals>.<listcomp>  s%    KKKa[ND99KKKr*   )r4   r
   r4  r   r   r-  r  r  r   r   r   r   
is_Booleanis_Relationalrel_opr   ro  r   r   r   r3   getattr)r  r  r  r   r-  expor   s    `     r'   r  r  r  s+   b%   BJ 	 ;IIIIIIIIb)$$ 	<3{26>::;;;b*++ 	;
ad0B 	;rwqz>:::I	O	O&(m	O	O 	\)	O /027l	O 	-		O 27MMMMRWMMMNNb*%% 	;rwqz>:::	y 26>2227N.Y/1 1Tz	~ '"'<?? rw    W    	 27KKKK27KKKLLr*   Nc                    t          | t                    r| S t          |           } |"t          |                     |                    S d}d}|rd}|r6d}t          | ||          }|| k    rd}|} t          |t                    r|S |6d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,  r{   )	r4   boolr   
unpolarifyr   r  r   r-  ro  )r  r   r  changedr  r  r-  s          r'   r  r    s    " "d 		B )"''$--(((GE 
 "ne44"9 	GBc4   	J   A@@@@@88YYq\\1jmmQ7888r*   )F)TF)NF)4typingr   rs   
sympy.corer   r   r   r   r   r	   r
   sympy.core.exprr   sympy.core.exprtoolsr   sympy.core.functionr   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;   r   r   r>   r5   rI  rR  ro  r3  r~  r  r  r  r  r  rx   r*   r'   <module>r     s   " " " " " " A A A A A A A A A A A A A A A A A A             - - - - - -              0 0 0 0 0 0 0 0 ( ( ( ( ( ( ( ( ( (             $ $ $ $ $ $ 9 9 9 9 9 9 : : : : : :w w w w w w w wtu u u u u u u uvr5 r5 r5 r5 r58 r5 r5 r5jw( w( w( w( w(( w( w( w(t^ ^ ^ ^ ^( ^ ^ ^BJ) J) J) J) J) J) J) J)Z6 6 6 6 6 6 6 6r; ; ; ; ;h ; ; ;DR0 R0 R0 R0 R0 R0 R0 R0jgK gK gK gK gK gK gK gKT& & &,f3 f3 f3 f3 f3x f3 f3 f3RP P P PB// // // //dM M M MB&9 &9 &9 &9 &9 &9r*   