o
    8Vaa                     @   s  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 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mZmZ d d	lmZ d d
l m!Z! d dl"m#Z# d dl$m%Z%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Z0d!d" Z1G d#d$ d$eZ2d0d&d'Z3d1d)d*Z4d0d+d,Z5i d%fd-d.Z6d/S )2    )SAddMulsympifySymbolDummyBasic)Expr)factor_terms)Function
DerivativeArgumentIndexErrorAppliedUndef)	fuzzy_notfuzzy_or)piIoo)Eq)exp	exp_polarlog)ceiling)sqrt)	Piecewise)atanatan2c                   @   b   e Zd ZdZ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
    Tc                 C   sF  |t ju rt jS |t ju rt jS |jr|S |jst j| jr!t jS |jr*| d S |j	r9t
|tr9t|jd S g g g }}}t|}|D ]9}|t j}|d ur]|js\|| qH|t jsl|jrl|| qH|j|d}|r|||d  qH|| qHt|t|krdd |||fD \}	}
}| |	t|
 | S d S )Nr   ignorec                 s       | ]}t | V  qd S Nr   .0Zxs r&   F/usr/lib/python3/dist-packages/sympy/functions/elementary/complexes.py	<genexpr>g       zre.eval.<locals>.<genexpr>)r   NaNComplexInfinityis_extended_realis_imaginaryImaginaryUnitZero	is_Matrixas_real_imagis_Function
isinstance	conjugater   argsr   	make_argsas_coefficientappendhaslenimclsargincludedZrevertedexcludedr5   ZtermZcoeffZ	real_imagabcr&   r&   r'   evalB   s<   



zre.evalc                 K   
   | t jfS )zF
        Returns the real number with a zero imaginary part.

        r   r/   selfZdeephintsr&   r&   r'   r1   k      
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j tt| jd |dd S d S Nr   TZevaluate)r,   r5   r   r   r-   r   r.   r;   rH   xr&   r&   r'   _eval_derivativer      zre._eval_derivativec                 K   s   | j d tjt| j d   S Nr   )r5   r   r.   r;   rH   r>   kwargsr&   r&   r'   _eval_rewrite_as_imy   s   zre._eval_rewrite_as_imc                 C      | j d jS rR   r5   Zis_algebraicrH   r&   r&   r'   _eval_is_algebraic|      zre._eval_is_algebraicc                 C   s   t | jd j| jd jgS rR   )r   r5   r-   is_zerorX   r&   r&   r'   _eval_is_zero   s   zre._eval_is_zeroc                 C      | j d jrdS d S Nr   Tr5   	is_finiterX   r&   r&   r'   _eval_is_finite      zre._eval_is_finitec                 C   r]   r^   r_   rX   r&   r&   r'   _eval_is_complex   rb   zre._eval_is_complexNT)__name__
__module____qualname____doc__r,   
unbranched_singularitiesclassmethodrD   r1   rP   rU   rY   r\   ra   rc   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
    Tc                 C   sP  |t ju rt jS |t ju rt jS |jrt jS |jst j| jr%t j | S |jr.| d S |j	r>t
|tr>t|jd  S g g g }}}t|}|D ]9}|t j}|d urh|jsb|| qM|| qM|t jsq|js|j|d}|r||d  qM|| qMt|t|krd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;   r5   r   r6   r7   r8   r9   r:   r   r<   r&   r&   r'   rD      s<   



zim.evalc                 K   rE   )zC
        Return the imaginary part with a zero real part.

        rF   rG   r&   r&   r'   r1      rJ   zim.as_real_imagc                 C   rK   rL   )r,   r5   r;   r   r-   r   r.   r   rN   r&   r&   r'   rP      rQ   zim._eval_derivativec                 K   s    t j | jd t| jd   S rR   )r   r.   r5   r   rS   r&   r&   r'   _eval_rewrite_as_re       zim._eval_rewrite_as_rec                 C   rV   rR   rW   rX   r&   r&   r'   rY      rZ   zim._eval_is_algebraicc                 C   rV   rR   r5   r,   rX   r&   r&   r'   r\      rZ   zim._eval_is_zeroc                 C   r]   r^   r_   rX   r&   r&   r'   ra      rb   zim._eval_is_finitec                 C   r]   r^   r_   rX   r&   r&   r'   rc      rb   zim._eval_is_complexNrd   )re   rf   rg   rh   r,   ri   rj   rk   rD   r1   rP   rm   rY   r\   ra   rc   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.functions import sign
    >>> from sympy.core.numbers import 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doitr5   r[   Abs)rH   rI   s	__class__r&   r'   rr   @  s   
z	sign.doitc           	      C   sD  |j rX| \}}g }t|}|D ].}|jr| }q|jrq|jr:t|}|jr4|tj	9 }|jr3| }q|
| q|
| q|tju rOt|t|krOd S || |j|  S |tju r`tjS |jrftjS |jrltjS |jrrtjS |jr|t|tr||S |jr|jr|jtju rtj	S tj	 | }|jrtj	S |jrtj	 S d S d S r"   )is_Mulas_coeff_mulrp   is_extended_negativeis_extended_positiver-   r;   is_comparabler   r.   r8   Oner:   Z_new_rawargsr*   r[   r/   NegativeOner2   r3   is_Powr   Half)	r=   r>   rC   r5   unkrt   rA   Zaiarg2r&   r&   r'   rD   F  sT   


z	sign.evalc                 C   s   t | jd jrtjS d S rR   )r   r5   r[   r   r|   rX   r&   r&   r'   	_eval_Absx  s   zsign._eval_Absc                 C   s   t t| jd S rR   )rp   r4   r5   rX   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rBddlm} dt| j d |dd |tj | j d   S d S )Nr   )
DiracDelta   TrM   )r5   r,   'sympy.functions.special.delta_functionsr   r   r-   r   r.   )rH   rO   r   r&   r&   r'   rP     s   zsign._eval_derivativec                 C   r]   r^   )r5   Zis_nonnegativerX   r&   r&   r'   _eval_is_nonnegative  rb   zsign._eval_is_nonnegativec                 C   r]   r^   )r5   Zis_nonpositiverX   r&   r&   r'   _eval_is_nonpositive  rb   zsign._eval_is_nonpositivec                 C   rV   rR   )r5   r-   rX   r&   r&   r'   _eval_is_imaginary  rZ   zsign._eval_is_imaginaryc                 C   rV   rR   ro   rX   r&   r&   r'   _eval_is_integer  rZ   zsign._eval_is_integerc                 C   rV   rR   )r5   r[   rX   r&   r&   r'   r\     rZ   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 rR   )r   r5   r[   
is_integeris_evenr   r|   )rH   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 rR   )r5   subsfuncdirr   r   r|   )rH   rO   nlogxcdirZarg0Zx0r&   r&   r'   _eval_nseries  s   

zsign._eval_nseriesc                 K   s&   |j rtd|dkfd|dk fdS d S )Nrl   r   )r   T)r,   r   rS   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   rl   r   r   r,   rH   r>   rT   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 r^   )r   r   rs   rS   r&   r&   r'   _eval_rewrite_as_Abs  rn   zsign._eval_rewrite_as_Absc                 K   s   |  t| jd S rR   )r   r
   r5   )rH   rT   r&   r&   r'   _eval_simplify  s   zsign._eval_simplifyr   )re   rf   rg   rh   Z
is_complexrj   rr   rk   rD   r   r   rP   r   r   r   r   r\   r   r   r   r   r   r   __classcell__r&   r&   ru   r'   rp     s*    7
1

	rp   c                   @   s   e Zd ZdZ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 )-rs   aV  
    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
    TFrl   c                 C   s    |dkrt | jd S t| |)zE
        Get the first derivative of the argument to Abs().

        rl   r   )rp   r5   r   )rH   Zargindexr&   r&   r'   fdiff  s   
z	Abs.fdiffc                    s  ddl m} ddlm} ddlm} t dr!  }|d ur!|S t t	s.t
dt  | dd   \}}|jrH|jsH| || | S  jrg }g }	 jD ];}
|
jry|
jjry|
jjry| |
j}t|| ro|	|
 qR||||
j qR| |
}t|| r|	|
 qR|| qRt| }|	r| t|	 ddntj}	||	 S  tju rtjS  tju rtjS  jr  \}}|jr|jr|jrȈ S |tju rtjS t || S |j!r|t"| S |j#r| t"| ttj$ t%|  S d S |&t'st(|) \}}|t*|  }tt"|| S t tr tt" jd S t t+r5 j,r, S  jr3  S d S  j-rQ &tjtj.rQt/d	d
  ) D rQtjS  j0rXtj1S  j!r^ S  j2re  S  j3rutj4   }|j!ru|S  jr{d S | 5 dd6t5 6t5 }|rt7 fdd
|D rd S  kr׈  krو 6t } 8dd |D }dd |jD }	|	rt7fdd
|	D st9|  S d S d S d S )Nr   )signsimp)
expand_mul)Powr   zBad argument type for Abs(): %sFrM   c                 s   s    | ]}|j V  qd S r"   )Zis_infiniter%   rA   r&   r&   r'   r(   K  s    zAbs.eval.<locals>.<genexpr>c                 3   s     | ]}  |jd  V  qdS )r   N)r9   r5   r%   ir>   r&   r'   r(   ]  s    c                 S   s   i | ]}|t d dqS )T)real)r   r   r&   r&   r'   
<dictcomp>a      zAbs.eval.<locals>.<dictcomp>c                 S   s   g | ]	}|j d u r|qS r"   )r,   r   r&   r&   r'   
<listcomp>b      zAbs.eval.<locals>.<listcomp>c                 3   s    | ]
}  t|V  qd S r"   )r9   r4   )r%   u)conjr&   r'   r(   c  s    ):Zsympy.simplify.simplifyr   sympy.core.functionr   Zsympy.core.powerr   hasattrr   r3   r	   	TypeErrortypeZas_numer_denomfree_symbolsrw   r5   r~   r   r   Zis_negativebaser8   r   r   r|   r*   r+   ZInfinityZas_base_expr,   r   r}   rs   is_extended_nonnegativer   ry   ZPir;   r9   r   r   r1   r   r   is_positiveis_AddZNegativeInfinityanyr[   r/   Zis_extended_nonpositiver-   r.   r4   atomsallZxreplacer   )r=   r>   r   r   r   objr   dZknownr   tZbnewZtnewr   exponentrA   rB   zr   Znew_conjr    Zabs_free_argr&   )r>   r   r'   rD     s   








"
zAbs.evalc                 C   r]   r^   r_   rX   r&   r&   r'   _eval_is_realf  rb   zAbs._eval_is_realc                 C      | j d jr| j d jS d S rR   )r5   r,   r   rX   r&   r&   r'   r   j     zAbs._eval_is_integerc                 C   s   t | jd jS rR   )r   _argsr[   rX   r&   r&   r'   _eval_is_extended_nonzeron  s   zAbs._eval_is_extended_nonzeroc                 C   rV   rR   )r   r[   rX   r&   r&   r'   r\   q  rZ   zAbs._eval_is_zeroc                 C   s   | j }|d ur
| S d S r"   )r[   )rH   Zis_zr&   r&   r'   _eval_is_extended_positivet  s   zAbs._eval_is_extended_positivec                 C   r   rR   )r5   r,   Zis_rationalrX   r&   r&   r'   _eval_is_rationaly  r   zAbs._eval_is_rationalc                 C   r   rR   )r5   r,   r   rX   r&   r&   r'   _eval_is_even}  r   zAbs._eval_is_evenc                 C   r   rR   )r5   r,   Zis_oddrX   r&   r&   r'   _eval_is_odd  r   zAbs._eval_is_oddc                 C   rV   rR   rW   rX   r&   r&   r'   rY     rZ   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   rl   )r5   r,   r   r   r   r}   Z
is_Integer)rH   r   r&   r&   r'   r     s   zAbs._eval_powerr   c                 C   sX   | j d |d }|t|r|t||}| j d j|||d}t||  S )Nr   )r   r   )r5   Zleadtermr9   r   r   r   rp   expand)rH   rO   r   r   r   Z	directionrt   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 rL   )
r5   r,   r-   r   rp   r4   r   r;   rs   Zrewrite)rH   rO   rvr&   r&   r'   rP     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 r^   )r,   r   r-   r   rS   r&   r&   r'   r     s
   $zAbs._eval_rewrite_as_Piecewisec                 K   s   |t | S r"   rp   rS   r&   r&   r'   _eval_rewrite_as_sign  rZ   zAbs._eval_rewrite_as_signc                 K   s   |t | tj S r"   )r4   r   r   rS   r&   r&   r'   _eval_rewrite_as_conjugate  r   zAbs._eval_rewrite_as_conjugateN)rl   r   )re   rf   rg   rh   r,   ry   r   ri   rj   r   rk   rD   r   r   r   r\   r   r   r   r   rY   r   r   rP   r   r   r   r   r&   r&   r&   r'   rs     s4    9


`
	rs   c                   @   s<   e Zd ZdZdZdZdZdZedd Z	dd Z
dd Zd	S )
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.

    Examples
    ========

    >>> from sympy.functions import arg
    >>> from sympy import I, sqrt
    >>> 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

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    Returns
    =======

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

    Tc                 C   s   t |tr
t|tS |js)t| \}}|jr"tdd |j	D  }t
|| }n|}tdd |tD r9d S | \}}t||}|jrI|S ||krS| |ddS d S )Nc                 S   s$   g | ]}t |d vr|nt |qS ))r   rl   r   r   r&   r&   r'   r     s
    zarg.eval.<locals>.<listcomp>c                 s   s    | ]}|j d u V  qd S r"   )rz   r   r&   r&   r'   r(     s    zarg.eval.<locals>.<genexpr>FrM   )r3   r   periodic_argumentr   is_Atomr
   Zas_coeff_Mulrw   r   r5   rp   r   r   r   r1   r   	is_number)r=   r>   rC   Zarg_rO   yr   r&   r&   r'   rD     s&   


zarg.evalc                 C   sF   | j d  \}}|t||dd |t||dd  |d |d   S )Nr   TrM   r   )r5   r1   r   )rH   r   rO   r   r&   r&   r'   rP     s   zarg._eval_derivativec                 K   s   | j d  \}}t||S rR   )r5   r1   r   )rH   r>   rT   rO   r   r&   r&   r'   _eval_rewrite_as_atan2  s   
zarg._eval_rewrite_as_atan2N)re   rf   rg   rh   r,   is_realr`   rj   rk   rD   rP   r   r&   r&   r&   r'   r>     s    &
r>   c                   @   sP   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S )r4   a<  
    Returns the `complex conjugate` Ref[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'   rD   -     zconjugate.evalc                 C      t | jd ddS rL   rs   r5   rX   r&   r&   r'   r   3  r   zconjugate._eval_Absc                 C      t | jd S rR   	transposer5   rX   r&   r&   r'   _eval_adjoint6     zconjugate._eval_adjointc                 C   
   | j d S rR   r5   rX   r&   r&   r'   r   9     
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 rL   )r   r4   r   r5   r-   rN   r&   r&   r'   rP   <  s
   zconjugate._eval_derivativec                 C   r   rR   adjointr5   rX   r&   r&   r'   _eval_transposeB  r   zconjugate._eval_transposec                 C   rV   rR   rW   rX   r&   r&   r'   rY   E  rZ   zconjugate._eval_is_algebraicN)re   rf   rg   rh   rj   rk   rD   r   r   r   rP   r   rY   r&   r&   r&   r'   r4     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.functions import transpose
    >>> from sympy.matrices import MatrixSymbol
    >>> from sympy import Matrix
    >>> 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'   rD   t  r   ztranspose.evalc                 C   r   rR   r4   r5   rX   r&   r&   r'   r   z  r   ztranspose._eval_adjointc                 C   r   rR   r   rX   r&   r&   r'   r   }  r   ztranspose._eval_conjugatec                 C   r   rR   r   rX   r&   r&   r'   r     r   ztranspose._eval_transposeN)	re   rf   rg   rh   rk   rD   r   r   r   r&   r&   r&   r'   r   I  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
    >>> from sympy.matrices import 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'   rD     s   zadjoint.evalc                 C   r   rR   r   rX   r&   r&   r'   r     r   zadjoint._eval_adjointc                 C   r   rR   r   rX   r&   r&   r'   r     r   zadjoint._eval_conjugatec                 C   r   rR   r   rX   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})_printr5   )rH   printerr   r5   r>   Z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   †+)Z sympy.printing.pretty.stringpictr   r   r5   Z_use_unicode)rH   r   r5   r   Zpformr&   r&   r'   _pretty  s   zadjoint._prettyr"   )re   rf   rg   rh   rk   rD   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$tt| t| S |jr+|j}n|g}g }g }g }|D ]}|j	rA||g7 }q6|j
rJ||g7 }q6||g7 }q6t|t|k rv|rft||  tt|  S |rnt||  S t| td S d S )Nr   r   r   )Z$sympy.functions.elementary.complexesr>   r   r   r   r   absrw   r5   is_polarr   r:   r   r   )r=   r>   argumentarr5   r?   r@   Zpositiver&   r&   r'   rD     s0   zpolar_lift.evalc                 C   s   | j d |S )z. Careful! any evalf of polar numbers is flaky r   )r5   _eval_evalf)rH   precr&   r&   r'   r     s   zpolar_lift._eval_evalfc                 C   r   rL   r   rX   r&   r&   r'   r     r   zpolar_lift._eval_AbsN)
re   rf   rg   rh   r   r{   rk   rD   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(P*I) == 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 : ExprT
        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   |j r|j}n|g}d}|D ]I}|js|t|7 }qt|tr)||j d 7 }q|jrF|j \}}||t	|j
 |tt|j
  7 }qt|trU|t|jd 7 }q d S |S r   )rw   r5   r   r>   r3   r   r   r1   r~   unbranched_argumentr   r   r   r   )r=   r   r5   ri   rA   r   r;   r&   r&   r'   _getunbranchedC  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 |tttrUd S |tkr[|S |tkrst|| tj | }|tsu|| S d S d S )Nr   r   c                 S   s   g | ]}|j s|qS r&   )r   r%   rO   r&   r&   r'   r   f      z*periodic_argument.eval.<locals>.<listcomp>)rz   r   r3   principal_branchr   r5   r   r   rw   r:   r   r   r9   r   r   r   r   r   )r=   r   periodZnewargsri   r   r&   r&   r'   rD   Y  s.   


zperiodic_argument.evalc                 C   sb   | j \}}|tkrt|}|d u r| S ||S t|t|}|t|| tj |  |S r"   )r5   r   r   r   r   r   r   r   )rH   r   r   r   ri   ubr&   r&   r'   r   u  s   


 zperiodic_argument._eval_evalfN)re   rf   rg   rh   rk   r   rD   r   r&   r&   r&   r'   r     s    (

r   c                 C   s
   t | tS )a\  
    Returns periodic argument of arg with period as infinity.

    Examples
    ========

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

    See also
    ========

    periodic_argument
    )r   r   r   r&   r&   r'   r     s   
r   c                   @   s,   e Zd ZdZdZdZedd Zdd ZdS )	r   a  
    Represent a polar number reduced to its principal branch on a quotient
    of the Riemann surface of the logarithm.

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

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

    Examples
    ========

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

    Parameters
    ==========

    x : Expr
        A polar number.

    period : Expr
        Positive real number or infinity.

    See Also
    ========

    sympy.functions.elementary.exponential.exp_polar
    polar_lift : Lift argument to the Riemann surface of the logarithm
    periodic_argument
    TFc                    s  ddl m}m}m}m}mm  t|rt|j	d |S ||kr#|S t
||}t
||}||krw|t
sw|t
sw|}	 fdd}
|	|
}	t
|	|}|	sw||kre||||  |	 }n|	}|jsu||su||d9 }|S |js|d}}n|j|j \}}g }|D ]}|jr||9 }q||g7 }qt|}t
||}|t
rd S |jrt||ks|dkr|dkr|dkr|dkrt|t|| | S t||| ||  |t| S |jrt||d k dks||d kr	|dkr||| t| S d S d S d S )	Nr   )r   r   r   r   r   r   c                    s   t |  s	| S | S r"   )r3   )exprr   r   r&   r'   mr  s   
z!principal_branch.eval.<locals>.mrr&   rl   r   T)sympyr   r   r   r   r   r   r3   r   r5   r   r9   replacer   r   rx   r   tupler   r   r   )rH   rO   r   r   r   r   r   r   Zbargplr   resrC   mZothersr   r>   r&   r   r'   rD     s`    







"*zprincipal_branch.evalc                 C   sb   ddl m}m}m} | j\}}t|||}t||ks"|| kr$| S t||||  |S )Nr   )r   r   r   )r   r   r   r   r5   r   r   r   )rH   r   r   r   r   r   r   pr&   r&   r'   r     s   
zprincipal_branch._eval_evalfN)	re   rf   rg   rh   r   r{   rk   rD   r   r&   r&   r&   r'   r     s    (
3r   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| |rt| 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   
  r   z_polarify.<locals>.<listcomp>Fr  c                    r  )Fr  r
  r  r  r&   r'   r     r   rl   r  r	  c                    s(   g | ]}t |trt| d n|qS )r  )r3   r	   r  r  r  r&   r'   r     s
    
)r   r  r   r   r   r3   r   r   r   r   r5   r~   r   r   ZExp1r  r   r2   functionr8   r  )
eqr  r	  r  rr   Zlimitslimitvarrestr&   r  r'   r    s:   

r  Tc                 C   sN   |rd}t t| |} |s| S dd | jD }| |} | dd | D fS )a  
    Turn all numbers in eq into their polar equivalents (under the standard
    choice of argument).

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

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

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

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

    Examples
    ========

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

    Adds are treated carefully:

    >>> polarify(1 + sin((1 + I)*x))
    (sin(_x*polar_lift(1 + I)) + 1, {_x: x})
    Fc                 S   s   i | ]
}|t |jd dqS )T)Zpolar)r   name)r%   rt   r&   r&   r'   r   M  s    zpolarify.<locals>.<dictcomp>c                 S   s   i | ]\}}||qS r&   r&   )r%   rt   r  r&   r&   r'   r   O  r   )r  r   r   r   items)r  r   r  Zrepsr&   r&   r'   polarify   s   (
r  c                    sB  t | tr| jr
| S |sdt | trtt| j S t | tr/| jd dt kr/t| jd  S | j	sJ| j
sJ| jsJ| jrW| jdv rEd| jv sJ| jdvrW| j fdd| jD  S t | trdt| jd  S | jr}t| j }t| j |jov|  }|| S | jrt| jddr| j fd	d| jD  S | j fd
d| jD  S )Nrl   r   r   )z==z!=c                    s   g | ]}t | qS r&   _unpolarifyr   exponents_onlyr&   r'   r   a  r   z_unpolarify.<locals>.<listcomp>ri   Fc                    s   g | ]}t |  qS r&   r  r   r  r&   r'   r   l  s    c                    s   g | ]}t | d qS rd   r  r   r  r&   r'   r   o  r   )r3   r   r   r   r   r  r   r5   r   r   rw   Z
is_BooleanZis_RelationalZrel_opr   r   r~   r   r   r2   getattr)r  r  r	  Zexpor   r&   r  r'   r  R  sF   

r  c                 C   s   t | tr| S t| } |i krt| |S d}d}|rd}|r9d}t| ||}|| kr0d}|} t |tr7|S |s |t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 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)
    TFr   rl   )r3   boolr   
unpolarifyr   r  r   r   )r  r   r  Zchangedr	  r  r&   r&   r'   r  r  s&   


r  N)F)TF)7Z
sympy.corer   r   r   r   r   r   r   Zsympy.core.exprr	   Zsympy.core.exprtoolsr
   r   r   r   r   r   Zsympy.core.logicr   r   Zsympy.core.numbersr   r   r   Zsympy.core.relationalr   Z&sympy.functions.elementary.exponentialr   r   r   Z#sympy.functions.elementary.integersr   Z(sympy.functions.elementary.miscellaneousr   Z$sympy.functions.elementary.piecewiser   Z(sympy.functions.elementary.trigonometricr   r   r   r;   rp   rs   r>   r4   r   r   r   r   r   r   r  r  r  r  r&   r&   r&   r'   <module>   s<   $ xy 7 zKJ;CSf
i
!
2 