o
    oh                     @   s  d dl mZ d dlmZmZmZmZmZm	Z	m
Z
 d dlmZ d dlmZ d dlmZmZmZmZmZ d dlmZmZ d dlmZmZmZ d dlmZ d d	lmZ d d
l m!Z! d dl"m#Z# G dd deZ$G dd deZ%G dd deZ&G dd deZ'G dd deZ(G dd deZ)G dd deZ*G dd deZ+G dd deZ,G dd deZ-d d! Z.G d"d# d#eZ/d/d%d&Z0d0d(d)Z1d/d*d+Z2d1d-d.Z3d,S )2    )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                   @   p   e Zd ZU dZee ed< dZdZdZ	e
dd ZdddZdd	 Zd
d Zdd Zdd Zdd Zdd ZdS )rea  
    Returns real part of expression. This function performs only
    elementary analysis and so it will fail to decompose properly
    more complicated expressions. If completely simplified result
    is needed then use ``Basic.as_real_imag()`` or perform complex
    expansion on instance of this function.

    Examples
    ========

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

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    Returns
    =======

    expr : Expr
        Real part of expression.

    See Also
    ========

    im
    argsTc                 C   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%   x/var/www/html/construction_image-detection-poc/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&   r/   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   r8   rI   xr%   r%   r&   _eval_derivativet      zre._eval_derivativec                 K   s   | j d tt| j d   S Nr   )r   r   r8   rI   r;   kwargsr%   r%   r&   _eval_rewrite_as_im{   s   zre._eval_rewrite_as_imc                 C      | j d jS rU   r   is_algebraicrI   r%   r%   r&   _eval_is_algebraic~      zre._eval_is_algebraicc                 C   s   t | jd j| jd jgS rU   )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   ra   rb   rc   r\   r%   r%   r&   _eval_is_complex   rf   zre._eval_is_complexNT)__name__
__module____qualname____doc__tTupler
   __annotations__r+   
unbranched_singularitiesclassmethodrE   r/   rS   rX   r]   r`   re   rg   r%   r%   r%   r&   r      s   
 )

(r   c                   @   r   )r8   a  
    Returns imaginary part of expression. This function performs only
    elementary analysis and so it will fail to decompose properly more
    complicated expressions. If completely simplified result is needed then
    use ``Basic.as_real_imag()`` or perform complex expansion on instance of
    this function.

    Examples
    ========

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

    Parameters
    ==========

    arg : Expr
        Real or complex expression.

    Returns
    =======

    expr : Expr
        Imaginary part of expression.

    See Also
    ========

    re
    r   Tc                 C   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   r.   r/   r0   r1   r2   r8   r   r   r3   r4   r5   r6   r7   r   r9   r%   r%   r&   rE      s<   





zim.evalc                 K   rF   )zC
        Return the imaginary part with a zero real part.

        rG   rH   r%   r%   r&   r/      rL   zim.as_real_imagc                 C   rM   rN   )r+   r   r8   r   r,   r   r   rQ   r%   r%   r&   rS      rT   zim._eval_derivativec                 K   s   t  | jd t| jd   S rU   )r   r   r   rV   r%   r%   r&   _eval_rewrite_as_re   s   zim._eval_rewrite_as_rec                 C   rY   rU   rZ   r\   r%   r%   r&   r]      r^   zim._eval_is_algebraicc                 C   rY   rU   r   r+   r\   r%   r%   r&   r`      r^   zim._eval_is_zeroc                 C   ra   rb   rc   r\   r%   r%   r&   re      rf   zim._eval_is_finitec                 C   ra   rb   rc   r\   r%   r%   r&   rg     rf   zim._eval_is_complexNrh   )ri   rj   rk   rl   rm   r
   rn   r+   ro   rp   rq   rE   r/   rS   rs   r]   r`   re   rg   r%   r%   r%   r&   r8      s   
 )

'r8   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   r_   Abs)rI   rK   s	__class__r%   r&   rw   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_mulru   is_extended_negativeis_extended_positiver,   r8   is_comparabler   r5   r   Oner7   _new_rawargsr)   r_   r-   NegativeOner0   r1   is_PowexpHalf)	r:   r;   rD   r   unkry   rB   aiarg2r%   r%   r&   rE   I  sT   


z	sign.evalc                 C   s   t | jd jrtjS d S rU   )r   r   r_   r   r   r\   r%   r%   r&   	_eval_Abs{  s   zsign._eval_Absc                 C   s   t t| jd S rU   )ru   r2   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   TrO   )r   r+   'sympy.functions.special.delta_functionsr   r   r,   r   )rI   rR   r   r%   r%   r&   rS     s   zsign._eval_derivativec                 C   ra   rb   )r   is_nonnegativer\   r%   r%   r&   _eval_is_nonnegative  rf   zsign._eval_is_nonnegativec                 C   ra   rb   )r   is_nonpositiver\   r%   r%   r&   _eval_is_nonpositive  rf   zsign._eval_is_nonpositivec                 C   rY   rU   )r   r,   r\   r%   r%   r&   _eval_is_imaginary  r^   zsign._eval_is_imaginaryc                 C   rY   rU   rt   r\   r%   r%   r&   _eval_is_integer  r^   zsign._eval_is_integerc                 C   rY   rU   )r   r_   r\   r%   r%   r&   r`     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 rU   )r   r   r_   
is_integeris_evenr   r   )rI   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 rU   )r   subsfuncdirr   r   r   )rI   rR   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 )Nrr   r   )r   T)r+   r   rV   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   rr   r   r   r+   rI   r;   rW   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 rb   )r   r   rx   rV   r%   r%   r&   _eval_rewrite_as_Abs  s    zsign._eval_rewrite_as_Absc                 K   s   |  t| jd S rU   )r   r   r   )rI   rW   r%   r%   r&   _eval_simplify  s   zsign._eval_simplifyr   )ri   rj   rk   rl   
is_complexrp   rw   rq   rE   r   r   rS   r   r   r   r   r`   r   r   r   r   r   r   __classcell__r%   r%   rz   r&   ru   	  s*    6
1

	ru   c                   @   s   e Zd ZU dZee ed< dZdZdZ	dZ
dZd,ddZedd	 Zd
d Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zd-dd Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+S ).rx   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   TFrr   c                 C   s    |dkrt | jd S t| |)zE
        Get the first derivative of the argument to Abs().

        rr   r   )ru   r   r   )rI   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(): %sFrO   )r   logc                 s   s    | ]}|j V  qd S r    )is_infiniter#   rB   r%   r%   r&   r'   P  s    zAbs.eval.<locals>.<genexpr>c                 3   s     | ]}  |jd  V  qdS )r   N)r6   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    )r6   r2   )r#   u)conjr%   r&   r'   h  s    )8sympy.simplify.simplifyr   hasattrr   r1   r
   	TypeErrortypeas_numer_denomfree_symbolsr|   r   r   r   r   is_negativebaser5   r   r   r   r   r)   r*   r   &sympy.functions.elementary.exponentialr   as_base_expr+   r   r   rx   is_extended_nonnegativer   r~   r   r8   r6   r   r/   r   r   is_positiveis_AddNegativeInfinityanyr_   r-   is_extended_nonpositiver,   r2   atomsallxreplacer   r   )r:   r;   r   objr   dknownr   tbnewtnewr   r   r   exponentrB   rC   zr   new_conjr   abs_free_argr%   )r;   r   r&   rE   
  s   








 

zAbs.evalc                 C   ra   rb   rc   r\   r%   r%   r&   _eval_is_realk  rf   zAbs._eval_is_realc                 C      | j d jr| j d jS d S rU   )r   r+   r   r\   r%   r%   r&   r   o     zAbs._eval_is_integerc                 C      t | jd jS rU   r   _argsr_   r\   r%   r%   r&   _eval_is_extended_nonzeros     zAbs._eval_is_extended_nonzeroc                 C   rY   rU   )r   r_   r\   r%   r%   r&   r`   v  r^   zAbs._eval_is_zeroc                 C   r   rU   r   r\   r%   r%   r&   _eval_is_extended_positivey  r   zAbs._eval_is_extended_positivec                 C   r   rU   )r   r+   is_rationalr\   r%   r%   r&   _eval_is_rational|  r   zAbs._eval_is_rationalc                 C   r   rU   )r   r+   r   r\   r%   r%   r&   _eval_is_even  r   zAbs._eval_is_evenc                 C   r   rU   )r   r+   is_oddr\   r%   r%   r&   _eval_is_odd  r   zAbs._eval_is_oddc                 C   rY   rU   rZ   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   rr   )r   r+   r   r   r   r   
is_Integer)rI   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   leadtermr6   r   r   ru   expand)rI   rR   r   r   r   r   	directionry   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 rN   )
r   r+   r,   r   ru   r2   r   r8   rx   rewrite)rI   rR   rvr%   r%   r&   rS     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 rb   )r+   r   r,   r   rV   r%   r%   r&   r     s
   $zAbs._eval_rewrite_as_Piecewisec                 K   s   |t | S r    ru   rV   r%   r%   r&   _eval_rewrite_as_sign  r^   zAbs._eval_rewrite_as_signc                 K   s   t |t| S r    )r   r2   rV   r%   r%   r&   _eval_rewrite_as_conjugate  r   zAbs._eval_rewrite_as_conjugateN)rr   r   )ri   rj   rk   rl   rm   r
   rn   r+   r~   r   ro   rp   r   rq   rE   r   r   r   r`   r   r   r   r   r]   r   r   rS   r   r   r   r   r%   r%   r%   r&   rx     s6   
 9


`
	rx   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; 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   rr   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>atan2FrO   )ranger1   r   r+   r   r)   r   r   r   periodic_argumentr   r8   r   Piis_Atomr   as_coeff_Mulr|   r   ru   r   r   r   (sympy.functions.elementary.trigonometricr   r/   	is_number)r:   r;   rB   r   r   r   i_rD   arg_r   rR   yr   r%   r%   r&   rE     sH   






zarg.evalc                 C   sF   | j d  \}}|t||dd |t||dd  |d |d   S )Nr   TrO   r   )r   r/   r   )rI   r   rR   r  r%   r%   r&   rS     s   zarg._eval_derivativec                 K   s(   ddl m} | jd  \}}|||S )Nr   r   )r   r   r   r/   )rI   r;   rW   r   rR   r  r%   r%   r&   _eval_rewrite_as_atan2  s   
zarg._eval_rewrite_as_atan2N)ri   rj   rk   rl   r+   is_realrd   rp   rq   rE   rS   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 )r2   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&   rE   O     zconjugate.evalc                 C   s   t S r    )r2   r\   r%   r%   r&   inverseU  s   zconjugate.inversec                 C      t | jd ddS rN   rx   r   r\   r%   r%   r&   r   X  r   zconjugate._eval_Absc                 C      t | jd S rU   	transposer   r\   r%   r%   r&   _eval_adjoint[     zconjugate._eval_adjointc                 C   
   | j d S rU   r   r\   r%   r%   r&   r   ^     
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 rN   )r  r2   r   r   r,   rQ   r%   r%   r&   rS   a  s
   zconjugate._eval_derivativec                 C   r
  rU   adjointr   r\   r%   r%   r&   _eval_transposeg  r  zconjugate._eval_transposec                 C   rY   rU   rZ   r\   r%   r%   r&   r]   j  r^   zconjugate._eval_is_algebraicN)ri   rj   rk   rl   rp   rq   rE   r  r   r  r   rS   r  r]   r%   r%   r%   r&   r2   !  s    +
r2   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&   rE     r  ztranspose.evalc                 C   r
  rU   r2   r   r\   r%   r%   r&   r    r  ztranspose._eval_adjointc                 C   r
  rU   r  r\   r%   r%   r&   r     r  ztranspose._eval_conjugatec                 C   r  rU   r  r\   r%   r%   r&   r    r  ztranspose._eval_transposeN)	ri   rj   rk   rl   rq   rE   r  r   r  r%   r%   r%   r&   r  n  s    (
r  c                   @   sF   e Zd ZdZedd Zdd Zdd Zdd	 ZdddZ	dd Z
d
S )r  a  
    Conjugate transpose or Hermite conjugation.

    Examples
    ========

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

    Parameters
    ==========

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

    Returns
    =======

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

    c                 C   s0   |  }|d ur
|S | }|d urt|S d S r    )r  r  r2   r  r%   r%   r&   rE     s   zadjoint.evalc                 C   r  rU   r  r\   r%   r%   r&   r    r  zadjoint._eval_adjointc                 C   r
  rU   r  r\   r%   r%   r&   r     r  zadjoint._eval_conjugatec                 C   r
  rU   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   )rI   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)rI   r  r   r  pformr%   r%   r&   _pretty  s   zadjoint._prettyr    )ri   rj   rk   rl   rq   rE   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   r7   r   r   )	r:   r;   argumentarr   r   r<   r>   positiver%   r%   r&   rE     s4   zpolar_lift.evalc                 C   s   | j d |S )z. Careful! any evalf of polar numbers is flaky r   )r   _eval_evalf)rI   precr%   r%   r&   r(  6  s   zpolar_lift._eval_evalfc                 C   r  rN   r	  r\   r%   r%   r&   r   :  r   zpolar_lift._eval_AbsN)
ri   rj   rk   rl   r$  r   rq   rE   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   rr   )r   r   r   r|   r   r$  r;   r1   r   r/   r   unbranched_argumentr   r#  r   )	r:   r&  r   r   r   ro   rB   r   r8   r%   r%   r&   _getunbranchedg  s*   

z periodic_argument._getunbranchedc           	      C   s
  |j sd S |tkrt|trt|j S t|t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#   rR   r%   r%   r&   r         z*periodic_argument.eval.<locals>.<listcomp>)atanr   ceiling)r   r   r1   principal_branchr   r   r   r   r|   r7   r   r+  r   r.  r   r6   #sympy.functions.elementary.integersr0  r   r   )	r:   r&  periodnewargsro   r.  r   r0  r   r%   r%   r&   rE   ~  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   r/  )	r   r   r   r+  r(  r2  r0  r   r   )rI   r)  r   r3  ro   ubr0  r%   r%   r&   r(    s   


 zperiodic_argument._eval_evalfN)ri   rj   rk   rl   rq   r+  rE   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 )	r1  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    )r1   r   r   )exprr%   r%   r&   mr  s   
z!principal_branch.eval.<locals>.mrr%   rr   r   T)r   r   r1   r   r1  r   r   r   r6   replacer   r$  r   r}   r   tupler   r*  r#  r   )rI   rR   r3  r   r5  bargplr7  resrD   mothersr  r;   r%   r%   r&   rE     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   )rI   r)  r   r3  pr   r%   r%   r&   r(    s   
zprincipal_branch._eval_evalfN)	ri   rj   rk   rl   r$  r   rq   rE   r(  r%   r%   r%   r&   r1    s    (
3r1  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   2  r   z_polarify.<locals>.<listcomp>FrB  c                    rA  )FrB  rD  rF  rG  r%   r&   r   9  r   rr   rH  rC  c                    s(   g | ]}t |trt| d n|qS )rB  )r1   r
   rE  rF  rI  r%   r&   r   D  s
    
)sympy.integrals.integralsr@  r$  r   r   r1   r   r   r   r   r   r   r   r   Exp1rE  r   r0   functionr5   r9  )
eqrH  rC  r@  rr   limitslimitvarrestr%   rI  r&   rE  '  s:   

rE  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#   ry   r%   r%   r&   r   u  s    zpolarify.<locals>.<dictcomp>c                 S   s   i | ]\}}||qS r%   r%   )r#   ry   rN  r%   r%   r&   r   w  r-  )rE  r   r   r   items)rM  r   rH  repsr%   r%   r&   polarifyH  s   (
rW  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   rr   r   )z==z!=c                    s   g | ]}t | qS r%   _unpolarifyr,  exponents_onlyr%   r&   r     r-  z_unpolarify.<locals>.<listcomp>ro   Fc                    s   g | ]}t |  qS r%   rX  r,  rZ  r%   r&   r     s    c                    s   g | ]}t | d qS rh   rX  r,  rZ  r%   r&   r     r   )r1   r	   r   r   r   r   rY  r1  r   r   r   r|   
is_Booleanis_Relationalrel_opr   r   r   r   r   r0   getattr)rM  r[  rC  r   r   expor   r%   rZ  r&   rY  z  s@   


rY  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!  rr   )	r1   boolr   
unpolarifyr   rY  r   r   r   )rM  r   r[  changedrC  r<  r   r%   r%   r&   rb    s(   


rb  )F)TF)NF)4typingr   rm   
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   r8   ru   rx   r;   r2   r  r  r   r   r*  r1  rE  rW  rY  rb  r%   r%   r%   r&   <module>   s:    $z{ 6 {iM9BUj
i
!
2!