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

    Examples
    ========

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

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    Returns
    =======

    expr : Expr
        Real part of expression.

    See Also
    ========

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

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

    Examples
    ========

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

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    Returns
    =======

    expr : Expr
        Imaginary part of expression.

    See Also
    ========

    re
    r   r   Tc                 C  sH  |t ju rt jS |t ju rt jS |jrt jS |jst| jr#t | S |jr,| d S |j	r<t
|tr<t|jd  S g g g }}}t|}|D ]7}|t}|d ure|js_|| qK|| qK|tsm|js|j|d}|r}||d  qK|| qKt|t|k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:   r   r   r5   r6   r7   r8   r9   r   r;   r'   r'   r(   rG      s<   





zim.evalc                 K  rH   )zC
        Return the imaginary part with a zero real part.

        rI   rJ   r'   r'   r(   r1      rN   zim.as_real_imagc                 C  rO   rP   )r-   r   r:   r   r.   r   r   rS   r'   r'   r(   rU      rV   zim._eval_derivativec                 K  s   t  | jd t| jd   S rW   )r   r   r   rX   r'   r'   r(   _eval_rewrite_as_re   s   zim._eval_rewrite_as_rec                 C  r[   rW   r\   r^   r'   r'   r(   r_      r`   zim._eval_is_algebraicc                 C  r[   rW   r   r-   r^   r'   r'   r(   rb      r`   zim._eval_is_zeroc                 C  rc   rd   re   r^   r'   r'   r(   rg      rh   zim._eval_is_finitec                 C  rc   rd   re   r^   r'   r'   r(   ri     rh   zim._eval_is_complexNrj   )rk   rl   rm   rn   ro   r-   rp   rq   rr   rG   r1   rU   rt   r_   rb   rg   ri   r'   r'   r'   r(   r:      s   
 )

'r:   c                      s   e Zd ZdZdZdZ fddZedd Zdd Z	d	d
 Z
dd Zdd Zdd Zdd Zdd Zdd Zdd Zd$ddZdd Zdd Zd d! Zd"d# Z  ZS )%signa  
    Returns the complex sign of an expression:

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

    If the expression is real the sign will be:

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

    If the expression is imaginary the sign will be:

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

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

    Examples
    ========

    >>> from sympy import sign, I

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

    Parameters
    ==========

    arg : Expr
        Real or imaginary expression.

    Returns
    =======

    expr : Expr
        Complex sign of expression.

    See Also
    ========

    Abs, conjugate
    Tc                   s>   t   }|| kr| jd jdu r| jd t| jd  S |S )Nr   F)superdoitr   ra   Abs)rK   rM   s	__class__r'   r(   rx   C  s   
z	sign.doitc           	      C  s:  |j rW| \}}g }t|}|D ]-}|jr| }q|jrq|jr9t|}|jr3|t9 }|jr2| }q|	| q|	| q|t
ju rNt|t|krNd S || |j|  S |t
ju r_t
jS |jret
jS |jrkt
jS |jrqt
jS |jr{t|tr{|S |jr|jr|jt
ju rtS t | }|jrtS |jrt S d S d S r"   )is_Mulas_coeff_mulrv   is_extended_negativeis_extended_positiver.   r:   is_comparabler   r7   r   Oner9   _new_rawargsr+   ra   r/   NegativeOner2   r3   is_PowexpHalf)	r<   r=   rF   r   unkrz   rD   aiarg2r'   r'   r(   rG   I  sT   


z	sign.evalc                 C  s   t | jd jrtjS d S rW   )r   r   ra   r   r   r^   r'   r'   r(   	_eval_Abs{  s   zsign._eval_Absc                 C  s   t t| jd S rW   )rv   r4   r   r^   r'   r'   r(   _eval_conjugate     zsign._eval_conjugatec                 C  s   | j d jrddlm} dt| j d |dd || j d  S | j d jrAddlm} dt| j d |dd |t | j d   S d S )Nr   )
DiracDelta   TrQ   )r   r-   'sympy.functions.special.delta_functionsr   r   r.   r   )rK   rT   r   r'   r'   r(   rU     s   zsign._eval_derivativec                 C  rc   rd   )r   is_nonnegativer^   r'   r'   r(   _eval_is_nonnegative  rh   zsign._eval_is_nonnegativec                 C  rc   rd   )r   is_nonpositiver^   r'   r'   r(   _eval_is_nonpositive  rh   zsign._eval_is_nonpositivec                 C  r[   rW   )r   r.   r^   r'   r'   r(   _eval_is_imaginary  r`   zsign._eval_is_imaginaryc                 C  r[   rW   ru   r^   r'   r'   r(   _eval_is_integer  r`   zsign._eval_is_integerc                 C  r[   rW   )r   ra   r^   r'   r'   r(   rb     r`   zsign._eval_is_zeroc                 C  s.   t | jd jr|jr|jrtjS d S d S d S rW   )r   r   ra   
is_integeris_evenr   r   )rK   otherr'   r'   r(   _eval_power  s   zsign._eval_powerr   c                 C  sV   | j d }||d}|dkr| |S |dkr|||}t|dk r(tj S tjS rW   )r   subsfuncdirr   r   r   )rK   rT   nlogxcdirarg0x0r'   r'   r(   _eval_nseries  s   

zsign._eval_nseriesc                 K  s&   |j rtd|dkfd|dk fdS d S )Nrs   r   )r   T)r-   r   rX   r'   r'   r(   _eval_rewrite_as_Piecewise  s   zsign._eval_rewrite_as_Piecewisec                 K  s&   ddl m} |jr||d d S d S )Nr   	Heavisider   rs   r   r   r-   rK   r=   rY   r   r'   r'   r(   _eval_rewrite_as_Heaviside  s   zsign._eval_rewrite_as_Heavisidec                 K  s    t dt|df|t| dfS rd   )r   r   ry   rX   r'   r'   r(   _eval_rewrite_as_Abs  s    zsign._eval_rewrite_as_Absc                 K  s   |  t| jd S rW   )r   r   r   )rK   rY   r'   r'   r(   _eval_simplify  s   zsign._eval_simplifyr   )rk   rl   rm   rn   
is_complexrq   rx   rr   rG   r   r   rU   r   r   r   r   rb   r   r   r   r   r   r   __classcell__r'   r'   r{   r(   rv   	  s*    6
1

	rv   c                   @  s   e Zd ZU dZded< dZdZdZdZdZ	d-ddZ
ed	d
 Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zd.d d!Zd"d# Zd$d% Zd&d' Zd(d) Zd*d+ Zd,S )/ry   ab  
    Return the absolute value of the argument.

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

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

    Examples
    ========

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

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

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

    Abs will always return a SymPy object.

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    Returns
    =======

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

    See Also
    ========

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

        rs   r   )rv   r   r   )rK   argindexr'   r'   r(   fdiff   s   
z	Abs.fdiffc                   s  ddl m} t dr  }|d ur|S t ts"tdt  | dd   \}}|j	r<|j	s<| || | S  j
rg }g } jD ];}|jrm|jjrm|jjrm| |j}	t|	| rc|| qF|t|	|j qF| |}
t|
| r||| qF||
 qFt| }|r| t| ddntj}|| S  tju rtjS  tju rtS ddlm}m}  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$|  S d S |%t&s||' \}}|t(|  }|t!|| S t |r|t! jd S t t)r/ j*r& S  jr-  S d S  j+rI %ttj,rIt-dd	  ' D rItS  j.rPtj/S  j rV S  j0r]  S  j1rlt(   }|j rl|S  jrrd S | 2 dd3t2 3t2 }|rt4 fd
d	|D rd S  krΈ  krЈ 3t} 5dd |D }dd |j	D }|rt4fdd	|D st6t7  S d S d S d S )Nr   )signsimpr   zBad argument type for Abs(): %sFrQ   )r   logc                 s  s    | ]}|j V  qd S r"   )is_infiniter%   rD   r'   r'   r(   r)   P  s    zAbs.eval.<locals>.<genexpr>c                 3  s     | ]}  |jd  V  qdS )r   N)r8   r   r%   ir=   r'   r(   r)   b  s    c                 S  s   i | ]}|t d dqS )T)real)r   r   r'   r'   r(   
<dictcomp>f      zAbs.eval.<locals>.<dictcomp>c                 S  s   g | ]	}|j d u r|qS r"   )r-   r   r'   r'   r(   
<listcomp>g      zAbs.eval.<locals>.<listcomp>c                 3  s    | ]
}  t|V  qd S r"   )r8   r4   )r%   u)conjr'   r(   r)   h  s    )8sympy.simplify.simplifyr   hasattrr   r3   r
   	TypeErrortypeas_numer_denomfree_symbolsr}   r   r   r   r   is_negativebaser7   r   r   r   r   r+   r,   r   &sympy.functions.elementary.exponentialr   as_base_expr-   r   r   ry   is_extended_nonnegativer   r   r   r:   r8   r   r1   r   r   is_positiveis_AddNegativeInfinityanyra   r/   is_extended_nonpositiver.   r4   atomsallxreplacer   r   )r<   r=   r   objr   dknownr   tbnewtnewr   r   r   exponentrD   rE   zr   new_conjr    abs_free_argr'   )r=   r   r(   rG   
  s   








 

zAbs.evalc                 C  rc   rd   re   r^   r'   r'   r(   _eval_is_realk  rh   zAbs._eval_is_realc                 C     | j d jr| j d jS d S rW   )r   r-   r   r^   r'   r'   r(   r   o     zAbs._eval_is_integerc                 C     t | jd jS rW   r   _argsra   r^   r'   r'   r(   _eval_is_extended_nonzeros     zAbs._eval_is_extended_nonzeroc                 C  r[   rW   )r   ra   r^   r'   r'   r(   rb   v  r`   zAbs._eval_is_zeroc                 C  r   rW   r   r^   r'   r'   r(   _eval_is_extended_positivey  r   zAbs._eval_is_extended_positivec                 C  r   rW   )r   r-   is_rationalr^   r'   r'   r(   _eval_is_rational|  r   zAbs._eval_is_rationalc                 C  r   rW   )r   r-   r   r^   r'   r'   r(   _eval_is_even  r   zAbs._eval_is_evenc                 C  r   rW   )r   r-   is_oddr^   r'   r'   r(   _eval_is_odd  r   zAbs._eval_is_oddc                 C  r[   rW   r\   r^   r'   r'   r(   r_     r`   zAbs._eval_is_algebraicc                 C  sP   | j d jr&|jr&|jr| j d | S |tjur&|jr&| j d |d  |  S d S )Nr   rs   )r   r-   r   r   r   r   
is_Integer)rK   r   r'   r'   r(   r     s   zAbs._eval_powerr   c                 C  sd   ddl m} | jd |d }|||r||||}| jd j|||d}t||  S )Nr   )r   )r   r   )	r   r   r   leadtermr8   r   r   rv   expand)rK   rT   r   r   r   r   	directionrz   r'   r'   r(   r     s   zAbs._eval_nseriesc                 C  s   | j d js| j d jrt| j d |ddtt| j d  S t| j d tt| j d |dd t| j d tt| j d |dd  t| j d  }|	tS rP   )
r   r-   r.   r   rv   r4   r   r:   ry   rewrite)rK   rT   rvr'   r'   r(   rU     s   
zAbs._eval_derivativec                 K  s,   ddl m} |jr|||||   S d S )Nr   r   r   r   r'   r'   r(   r     s   zAbs._eval_rewrite_as_Heavisidec                 K  sL   |j rt||dkf| dfS |jr$tt| t| dkft | dfS d S rd   )r-   r   r.   r   rX   r'   r'   r(   r     s
   $zAbs._eval_rewrite_as_Piecewisec                 K  s   |t | S r"   rv   rX   r'   r'   r(   _eval_rewrite_as_sign  r`   zAbs._eval_rewrite_as_signc                 K  s   t |t| S r"   )r   r4   rX   r'   r'   r(   _eval_rewrite_as_conjugate  r   zAbs._eval_rewrite_as_conjugateN)rs   r   )rk   rl   rm   rn   ro   r-   r   r   rp   rq   r   rr   rG   r   r   r   rb   r   r   r   r   r_   r   r   rU   r   r   r   r   r'   r'   r'   r(   ry     s6   
 9


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

    Examples
    ========

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

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    Returns
    =======

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

    Tc                 C  sV  |}t dD ]}t|| r|jd }q|dkr|jrtj  S  ntjS ddlm}m} t||r6t	|t
S t||rZt|jd }|jrZ|dtj ; }|tjkrX|dtj 8 }|S |jsyt| \}}|jrrtdd |jD  }t|| }n|}tdd |tD rd S dd	lm}	 | \}
}|	||
}|jr|S ||kr| |d
dS d S )N   r   r   r   	exp_polarc                 S  s$   g | ]}t |d vr|nt |qS ))r   rs   r   r   r'   r'   r(   r     s
    zarg.eval.<locals>.<listcomp>c                 s  s    | ]}|j d u V  qd S r"   )r   r   r'   r'   r(   r)     s    zarg.eval.<locals>.<genexpr>atan2FrQ   )ranger3   r   r-   r   r+   r   r   r   periodic_argumentr   r:   r   Piis_Atomr   as_coeff_Mulr}   r   rv   r   r   r   (sympy.functions.elementary.trigonometricr   r1   	is_number)r<   r=   rD   r   r   r   i_rF   arg_r   rT   yr   r'   r'   r(   rG     sH   






zarg.evalc                 C  sF   | j d  \}}|t||dd |t||dd  |d |d   S )Nr   TrQ   r   )r   r1   r   )rK   r   rT   r  r'   r'   r(   rU     s   zarg._eval_derivativec                 K  s(   ddl m} | jd  \}}|||S )Nr   r   )r   r   r   r1   )rK   r=   rY   r   rT   r  r'   r'   r(   _eval_rewrite_as_atan2  s   
zarg._eval_rewrite_as_atan2c                 C  sV   | j d }tddd}|dkrd}|||| }|jrtjS |jr%tjS td|  )Nr   r   T)positivers   zCannot expand %s around 0)	r   r   r   r   r   r/   r   r   r   )rK   rT   r   r   r   r   r   r'   r'   r(   _eval_as_leading_term   s   
zarg._eval_as_leading_termr   c                 C  s,   ddl m} |dkr|dS | j|||dS )Nr   )Orderrs   )r   r   )sympy.series.orderr  r  )rK   rT   r   r   r   r  r'   r'   r(   r   -  s   zarg._eval_nseriesNr   )rk   rl   rm   rn   r-   is_realrf   rq   rr   rG   rU   r  r  r   r'   r'   r'   r(   r=     s    /
(r=   c                   @  sX   e Zd ZdZdZedd Zdd Zdd Zd	d
 Z	dd Z
dd Zdd Zdd ZdS )r4   a>  
    Returns the *complex conjugate* [1]_ of an argument.
    In mathematics, the complex conjugate of a complex number
    is given by changing the sign of the imaginary part.

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

    Examples
    ========

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

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    Returns
    =======

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

    See Also
    ========

    sign, Abs

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Complex_conjugation
    Tc                 C     |  }|d ur
|S d S r"   )r   r<   r=   r   r'   r'   r(   rG   b     zconjugate.evalc                 C  s   t S r"   )r4   r^   r'   r'   r(   inverseh  s   zconjugate.inversec                 C     t | jd ddS rP   ry   r   r^   r'   r'   r(   r   k  r   zconjugate._eval_Absc                 C     t | jd S rW   	transposer   r^   r'   r'   r(   _eval_adjointn     zconjugate._eval_adjointc                 C  
   | j d S rW   r   r^   r'   r'   r(   r   q     
zconjugate._eval_conjugatec                 C  sB   |j rtt| jd |ddS |jrtt| jd |dd S d S rP   )r  r4   r   r   r.   rS   r'   r'   r(   rU   t  s
   zconjugate._eval_derivativec                 C  r  rW   adjointr   r^   r'   r'   r(   _eval_transposez  r  zconjugate._eval_transposec                 C  r[   rW   r\   r^   r'   r'   r(   r_   }  r`   zconjugate._eval_is_algebraicN)rk   rl   rm   rn   rq   rr   rG   r  r   r  r   rU   r  r_   r'   r'   r'   r(   r4   4  s    +
r4   c                   @  s4   e Zd ZdZedd Zdd Zdd Zdd	 Zd
S )r  a  
    Linear map transposition.

    Examples
    ========

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

    Parameters
    ==========

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

    Returns
    =======

    value : Matrix
        Transpose of arg.

    c                 C  r	  r"   )r  r
  r'   r'   r(   rG     r  ztranspose.evalc                 C  r  rW   r4   r   r^   r'   r'   r(   r    r  ztranspose._eval_adjointc                 C  r  rW   r  r^   r'   r'   r(   r     r  ztranspose._eval_conjugatec                 C  r  rW   r  r^   r'   r'   r(   r    r  ztranspose._eval_transposeN)	rk   rl   rm   rn   rr   rG   r  r   r  r'   r'   r'   r(   r    s    (
r  c                   @  sF   e Zd ZdZedd Zdd Zdd Zdd	 ZdddZ	dd Z
d
S )r  a  
    Conjugate transpose or Hermite conjugation.

    Examples
    ========

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

    Parameters
    ==========

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

    Returns
    =======

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

    c                 C  s0   |  }|d ur
|S | }|d urt|S d S r"   )r  r  r4   r
  r'   r'   r(   rG     s   zadjoint.evalc                 C  r  rW   r  r^   r'   r'   r(   r    r  zadjoint._eval_adjointc                 C  r  rW   r  r^   r'   r'   r(   r     r  zadjoint._eval_conjugatec                 C  r  rW   r  r^   r'   r'   r(   r    r  zadjoint._eval_transposeNc                 G  s,   | | jd }d| }|rd||f }|S )Nr   z%s^{\dagger}z\left(%s\right)^{%s})_printr   )rK   printerr   r   r=   texr'   r'   r(   _latex  s
   zadjoint._latexc                 G  sJ   ddl m} |j| jd g|R  }|jr||d }|S ||d }|S )Nr   )
prettyFormu   †+) sympy.printing.pretty.stringpictr  r  r   _use_unicode)rK   r  r   r  pformr'   r'   r(   _pretty  s   zadjoint._prettyr"   )rk   rl   rm   rn   rr   rG   r  r   r  r  r$  r'   r'   r'   r(   r    s    

r  c                   @  s4   e Zd ZdZdZdZedd Zdd Zdd	 Z	d
S )
polar_lifta  
    Lift argument to the Riemann surface of the logarithm, using the
    standard branch.

    Examples
    ========

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

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

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    See Also
    ========

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

    Examples
    ========

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

    Parameters
    ==========

    ar : Expr
        A polar number.

    period : Expr
        The period $P$.

    See Also
    ========

    sympy.functions.elementary.exponential.exp_polar
    polar_lift : Lift argument to the Riemann surface of the logarithm
    principal_branch
    c           	      C  s   ddl m}m} |jr|j}n|g}d}|D ]I}|js"|t|7 }qt||r1||j	 d 7 }q|j
rN|j	 \}}||t|j ||t|j  7 }qt|tr]|t|jd 7 }q d S |S )Nr   )r   r   rs   )r   r   r   r}   r   r)  r=   r3   r   r1   r   unbranched_argumentr   r(  r%  )	r<   r+  r   r   r   rp   rD   r   r:   r'   r'   r(   _getunbranchedz  s*   

z periodic_argument._getunbranchedc           	      C  s
  |j sd S |tkrt|trt|j S t|tr&|dt kr&t|jd |S |jrAdd |jD }t	|t	|jkrAtt
| |S | |}|d u rLd S ddlm}m} |t||r]d S |tkrc|S |tkrddlm} ||| tj | }||s|| S d S d S )Nr   r   c                 S  s   g | ]}|j s|qS r'   )r   r%   rT   r'   r'   r(   r         z*periodic_argument.eval.<locals>.<listcomp>)atanr   ceiling)r   r   r3   principal_branchr   r   r%  r   r}   r9   r   r/  r   r2  r   r8   #sympy.functions.elementary.integersr4  r   r   )	r<   r+  periodnewargsrp   r2  r   r4  r   r'   r'   r(   rG     s2   


zperiodic_argument.evalc                 C  sn   | j \}}|tkrt|}|d u r| S ||S t|t|}ddlm} |||| tj |  |S )Nr   r3  )	r   r   r   r/  r,  r6  r4  r   r   )rK   r-  r   r7  rp   ubr4  r'   r'   r(   r,    s   


 zperiodic_argument._eval_evalfN)rk   rl   rm   rn   rr   r/  rG   r,  r'   r'   r'   r(   r   Q  s    (

r   c                 C  s
   t | tS )a\  
    Returns periodic argument of arg with period as infinity.

    Examples
    ========

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

    See also
    ========

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

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

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

    Examples
    ========

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

    Parameters
    ==========

    x : Expr
        A polar number.

    period : Expr
        Positive real number or infinity.

    See Also
    ========

    sympy.functions.elementary.exponential.exp_polar
    polar_lift : Lift argument to the Riemann surface of the logarithm
    periodic_argument
    TFc                 C  s  ddl m} t|trt|jd |S |tkr|S t|t}t||}||krj|tsj|tsjt|}dd }|	t|}t|t}|tsj||krX|t
||  | }n|}|jsh||sh||d9 }|S |jss|d}	}
n|j|j \}	}
g }|
D ]}|jr|	|9 }	q||g7 }qt|}
t|	|}|trd S |jrt|	|ks|dkr|
dkr|	dkr|dkrt|	tt|
 | S t|t
| t|
  |t|	 S |jrt||d k dks||d kr|
dkr||t
 t|	 S d S d S d S )	Nr   r&  c                 S  s   t | ts	t| S | S r"   )r3   r   r%  )exprr'   r'   r(   mr
  s   
z!principal_branch.eval.<locals>.mrr'   rs   r   T)r   r   r3   r%  r5  r   r   r   r8   replacer   r)  r   r~   r   tupler   r.  r(  r   )rK   rT   r7  r   r9  bargplr;  resrF   mothersr  r=   r'   r'   r(   rG     sX   







"&zprincipal_branch.evalc                 C  sZ   | j \}}t|||}t|tks|t kr| S ddlm} t||t|  |S )Nr   )r   )r   r   r,  r(  r   r   r   r   )rK   r-  r   r7  pr   r'   r'   r(   r,  1  s   
zprincipal_branch._eval_evalfN)	rk   rl   rm   rn   r)  r   rr   rG   r,  r'   r'   r'   r(   r5    s    (
3r5  Fc           
        s`  ddl m} | jr| S | jrst| S t| tr!s! r!t| S | jr&| S | jr>| j	 fdd| j
D  } r<t|S |S | jrT| jtjkrT| 	tjt| j ddS | jrd| j	 fdd| j
D  S t| |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   E  r   z_polarify.<locals>.<listcomp>FrF  c                   rE  )FrF  rH  rJ  rK  r'   r(   r   L  r   rs   rL  rG  c                   s(   g | ]}t |trt| d n|qS )rF  )r3   r
   rI  rJ  rM  r'   r(   r   W  s
    
)sympy.integrals.integralsrD  r)  r   r%  r3   r   r   r   r   r   r   r   r   Exp1rI  r   r2   functionr7   r=  )
eqrL  rG  rD  rr   limitslimitvarrestr'   rM  r(   rI  :  s:   

rI  Tc                 C  sN   |rd}t t| |} |s| S dd | jD }| |} | dd | D fS )a  
    Turn all numbers in eq into their polar equivalents (under the standard
    choice of argument).

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

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

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

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

    Examples
    ========

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

    Adds are treated carefully:

    >>> polarify(1 + sin((1 + I)*x))
    (sin(_x*polar_lift(1 + I)) + 1, {_x: x})
    Fc                 S  s   i | ]
}|t |jd dqS )T)polar)r   name)r%   rz   r'   r'   r(   r     s    zpolarify.<locals>.<dictcomp>c                 S  s   i | ]\}}||qS r'   r'   )r%   rz   rR  r'   r'   r(   r     r1  )rI  r   r   r   items)rQ  r   rL  repsr'   r'   r(   polarify[  s   (
r[  c                   sR  t | tr| jr
| S |slddlm}m} t | |r!|t| j S t | tr7| jd dt	 kr7t| jd  S | j
sR| jsR| jsR| jr_| jdv rMd| jv sR| jdvr_| j fdd| jD  S t | trlt| jd  S | jrt| j }t| j |jo~|  }|| S | jrt| jdd	r| j fd
d| jD  S | j fdd| jD  S )Nr   r   rs   r   )z==z!=c                   s   g | ]}t | qS r'   _unpolarifyr0  exponents_onlyr'   r(   r     r1  z_unpolarify.<locals>.<listcomp>rp   Fc                   s   g | ]}t |  qS r'   r\  r0  r^  r'   r(   r     s    c                   s   g | ]}t | d qS rj   r\  r0  r^  r'   r(   r     r   )r3   r	   r   r   r   r   r]  r5  r   r   r   r}   
is_Booleanis_Relationalrel_opr   r%  r   r   r   r2   getattr)rQ  r_  rG  r   r   expor   r'   r^  r(   r]    s@   


r]  Nc                 C  s   t | tr| S t| } |durt| |S d}d}|rd}|r9d}t| ||}|| kr0d}|} t |tr7|S |s ddlm} ||ddtddiS )a  
    If `p` denotes the projection from the Riemann surface of the logarithm to
    the complex line, return a simplified version `eq'` of `eq` such that
    `p(eq') = p(eq)`.
    Also apply the substitution subs in the end. (This is a convenience, since
    ``unpolarify``, in a certain sense, undoes :func:`polarify`.)

    Examples
    ========

    >>> from sympy import unpolarify, polar_lift, sin, I
    >>> unpolarify(polar_lift(I + 2))
    2 + I
    >>> unpolarify(sin(polar_lift(I + 7)))
    sin(7 + I)
    NTFr   r&  rs   )	r3   boolr   
unpolarifyr   r]  r   r   r%  )rQ  r   r_  changedrG  r@  r   r'   r'   r(   rf    s(   


rf  )F)TF)NF)4
__future__r   
sympy.corer   r   r   r   r   r   r	   sympy.core.exprr
   sympy.core.exprtoolsr   sympy.core.functionr   r   r   r   r   r   sympy.core.logicr   r   sympy.core.numbersr   r   r   sympy.core.powerr   sympy.core.relationalr   (sympy.functions.elementary.miscellaneousr   $sympy.functions.elementary.piecewiser   r   r:   rv   ry   r=   r4   r  r  r%  r   r.  r5  rI  r[  r]  rf  r'   r'   r'   r(   <module>   s:    $ z{ 6 {|M9BUj
i
!
2!