U
    9%e                     @   s$  d dl mZ d dlmZ d dl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mZ dd	lmZ dd
l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"m#Z# eej$Z%dd Z&dd Z'dd Z(G dd deeZ)edZ*ddl+m,Z,m-Z-m.Z. ddlm/Z/ dS )    )Tuple)defaultdict)
cmp_to_keyreduce)
attrgetter   )Basic)global_parameters)_fuzzy_groupfuzzy_or	fuzzy_not)S)AssocOpAssocOpDispatcher)cacheit)ilcmigcdequal_valued)Expr)UndefinedKind)is_sequencesiftc                 C   sP   t dd | jD }t| j| }||kr.dS ||k r:dS t|  |   k S )Nc                 s   s   | ]}|  rd V  qdS )r   N)could_extract_minus_sign.0i r   M/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/sympy/core/add.py	<genexpr>   s    z,_could_extract_minus_sign.<locals>.<genexpr>FT)sumargslenboolsort_key)exprZnegative_argsZpositive_argsr   r   r   _could_extract_minus_sign   s    r%   c                 C   s   | j td d S )Nkey)sort_args_sortkey)r    r   r   r   _addsort$   s    r*   c                  G   sp   t | } g }tj}| rN|  }|jr2| |j q|jrB||7 }q|| qt	| |rf|
d| t|S )a  Return a well-formed unevaluated Add: Numbers are collected and
    put in slot 0 and args are sorted. Use this when args have changed
    but you still want to return an unevaluated Add.

    Examples
    ========

    >>> from sympy.core.add import _unevaluated_Add as uAdd
    >>> from sympy import S, Add
    >>> from sympy.abc import x, y
    >>> a = uAdd(*[S(1.0), x, S(2)])
    >>> a.args[0]
    3.00000000000000
    >>> a.args[1]
    x

    Beyond the Number being in slot 0, there is no other assurance of
    order for the arguments since they are hash sorted. So, for testing
    purposes, output produced by this in some other function can only
    be tested against the output of this function or as one of several
    options:

    >>> opts = (Add(x, y, evaluate=False), Add(y, x, evaluate=False))
    >>> a = uAdd(x, y)
    >>> assert a in opts and a == uAdd(x, y)
    >>> uAdd(x + 1, x + 2)
    x + x + 3
    r   )listr   Zeropopis_Addextendr    	is_Numberappendr*   insertAdd
_from_args)r    Znewargscoar   r   r   _unevaluated_Add)   s    
r7   c                       s  e Zd ZU dZdZeedf ed< dZeZ	e
dd Ze
dd	 Zed
d Zdd Zedd ZdjddZdd Zedd ZdkddZdd ZdlddZe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!d0d. Z"d1d. Z#d2d. Z$d3d. Z%d4d. Z&d5d. Z'd6d. Z(d7d. Z)d8d9 Z*d:d; Z+d<d= Z,d>d? Z-d@dA Z.dBdC Z/ fdDdEZ0dFdG Z1dHdI Z2 fdJdKZ3dLdM Z4dNdO Z5dPdQ Z6edmdRdSZ7dndTdUZ8dodVdWZ9dXdY Z:dZd[ Z;d\d] Z<d^d_ Z=dpd`daZ>edbdc Z?ddde Z@edfdg ZA fdhdiZB  ZCS )qr3   a	  
    Expression representing addition operation for algebraic group.

    .. deprecated:: 1.7

       Using arguments that aren't subclasses of :class:`~.Expr` in core
       operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is
       deprecated. See :ref:`non-expr-args-deprecated` for details.

    Every argument of ``Add()`` must be ``Expr``. Infix operator ``+``
    on most scalar objects in SymPy calls this class.

    Another use of ``Add()`` is to represent the structure of abstract
    addition so that its arguments can be substituted to return different
    class. Refer to examples section for this.

    ``Add()`` evaluates the argument unless ``evaluate=False`` is passed.
    The evaluation logic includes:

    1. Flattening
        ``Add(x, Add(y, z))`` -> ``Add(x, y, z)``

    2. Identity removing
        ``Add(x, 0, y)`` -> ``Add(x, y)``

    3. Coefficient collecting by ``.as_coeff_Mul()``
        ``Add(x, 2*x)`` -> ``Mul(3, x)``

    4. Term sorting
        ``Add(y, x, 2)`` -> ``Add(2, x, y)``

    If no argument is passed, identity element 0 is returned. If single
    element is passed, that element is returned.

    Note that ``Add(*args)`` is more efficient than ``sum(args)`` because
    it flattens the arguments. ``sum(a, b, c, ...)`` recursively adds the
    arguments as ``a + (b + (c + ...))``, which has quadratic complexity.
    On the other hand, ``Add(a, b, c, d)`` does not assume nested
    structure, making the complexity linear.

    Since addition is group operation, every argument should have the
    same :obj:`sympy.core.kind.Kind()`.

    Examples
    ========

    >>> from sympy import Add, I
    >>> from sympy.abc import x, y
    >>> Add(x, 1)
    x + 1
    >>> Add(x, x)
    2*x
    >>> 2*x**2 + 3*x + I*y + 2*y + 2*x/5 + 1.0*y + 1
    2*x**2 + 17*x/5 + 3.0*y + I*y + 1

    If ``evaluate=False`` is passed, result is not evaluated.

    >>> Add(1, 2, evaluate=False)
    1 + 2
    >>> Add(x, x, evaluate=False)
    x + x

    ``Add()`` also represents the general structure of addition operation.

    >>> from sympy import MatrixSymbol
    >>> A,B = MatrixSymbol('A', 2,2), MatrixSymbol('B', 2,2)
    >>> expr = Add(x,y).subs({x:A, y:B})
    >>> expr
    A + B
    >>> type(expr)
    <class 'sympy.matrices.expressions.matadd.MatAdd'>

    Note that the printers do not display in args order.

    >>> Add(x, 1)
    x + 1
    >>> Add(x, 1).args
    (1, x)

    See Also
    ========

    MatAdd

    r   .r    Tc                    s  ddl m} ddlm} ddlm} d}t|dkr|\}}|jrL|| }}|jrf|jrf||gg df}|rt	dd |d D r|S g |d dfS i }t
j}	g }
g }|D ]H  jr jjrq|
D ]}| rd  qqĈ dkrq g fd	d
|
D  }
qn jr t
jks0|	t
jkrH jdkrH|sHt
jgg df  S |	jsZt|	|r|	 7 }	|	t
jkr|st
jgg df  S qnt |r |	}	qnt |r|  qnt |r|	rڈ |	n }	qnĈ t
jkr|	jdkr|st
jgg df  S t
j}	qn jr4| j qnr jrJ  \}}n\ jr  \}}|jr|js~|jr|jr|||  qt
j  }}n
t
j} }||kr||  |7  < || t
jkr|st
jgg df  S q|||< qg }d}|  D ]\}}|jrqnl|t
jkr2|| nT|jrX|j!|f|j  }|| n.|jrv|t"||dd n|t"|| |p|j# }q|	t
j$krdd
 |D }n|	t
j%krdd
 |D }|	t
jkrdd
 |D }|
r`g }|D ]<}|
D ]  |rd} qq|dk	r|| q||
 }|
D ]  |	r@t
j}	 q`q@t&| |	t
jk	r|'d|	 |r||7 }d}|rg |dfS |g dfS dS )a  
        Takes the sequence "seq" of nested Adds and returns a flatten list.

        Returns: (commutative_part, noncommutative_part, order_symbols)

        Applies associativity, all terms are commutable with respect to
        addition.

        NB: the removal of 0 is already handled by AssocOp.__new__

        See Also
        ========

        sympy.core.mul.Mul.flatten

        r   )AccumBounds)
MatrixExpr)TensExprN   c                 s   s   | ]}|j V  qd S Nis_commutativer   sr   r   r   r      s     zAdd.flatten.<locals>.<genexpr>c                    s   g | ]}  |s|qS r   )contains)r   o1or   r   
<listcomp>   s    
 zAdd.flatten.<locals>.<listcomp>Fevaluatec                 S   s   g | ]}|j s|js|qS r   )is_extended_nonnegativeis_realr   fr   r   r   rE   X  s       c                 S   s   g | ]}|j s|js|qS r   )is_extended_nonpositiverI   rJ   r   r   r   rE   [  s       c                 S   s    g | ]}|j r|jd k	s|qS r<   )	is_finiteis_extended_real)r   cr   r   r   rE   f  s     
T)(Z!sympy.calculus.accumulationboundsr8   Zsympy.matrices.expressionsr9   Zsympy.tensor.tensorr:   r!   is_Rationalis_Mulallr   r,   is_Orderr$   is_zerorA   r0   NaNComplexInfinityrM   
isinstance__add__r1   r.   r/   r    as_coeff_Mulis_Powas_base_exp
is_IntegerZis_negativeOneitems_new_rawargsMulr>   InfinityNegativeInfinityr*   r2   )clsseqr8   r9   r:   rvr6   btermscoeffZorder_factorsextrarB   rO   r@   eZnewseqZnoncommutativecsZnewseq2tr   rC   r   flatten   s    




	

	



zAdd.flattenc                 C   s   dd| j fS )N   r   )__name__)rc   r   r   r   	class_key  s    zAdd.class_keyc                 C   s8   t d}t|| j}t|}t|dkr.t}n|\}|S )Nkindr   )r   mapr    	frozensetr!   r   )selfkkindsresultr   r   r   rq     s    zAdd.kindc                 C   s   t | S r<   )r%   rt   r   r   r   r     s    zAdd.could_extract_minus_signc                    sp    r2t | j fdddd\}}| j| t|fS | jd  \}}|tjk	rd||| jdd  fS tj| jfS )aR  
        Returns a tuple (coeff, args) where self is treated as an Add and coeff
        is the Number term and args is a tuple of all other terms.

        Examples
        ========

        >>> from sympy.abc import x
        >>> (7 + 3*x).as_coeff_add()
        (7, (3*x,))
        >>> (7*x).as_coeff_add()
        (0, (7*x,))
        c                    s
   | j   S r<   )Zhas_freexdepsr   r   <lambda>      z"Add.as_coeff_add.<locals>.<lambda>T)binaryr   r   N)r   r    r_   tupleas_coeff_addr   r,   )rt   r|   l1l2rh   Znotratr   r{   r   r     s    
zAdd.as_coeff_addFNc                 C   sB   | j d | j dd  }}|jr$|r*|jr8|| j| fS tj| fS )zE
        Efficiently extract the coefficient of a summation.
        r   r   N)r    r0   rP   r_   r   r,   )rt   Zrationalr|   rh   r    r   r   r   as_coeff_Add  s    zAdd.as_coeff_Addc                    sx  ddl m} ddlm} t| jdkrtdd | jD r|jdkr||tj	dkr| j\}}|
tjrt|| }}|
tj}|r|jr|jr|jrtjS |jrtjS d S |jr| jr|| }|rt|\}}	|jdkrrdd	lm}
 |
|d |	d  }|jrdd
lm} ddlm ddlm} |
||| d |j }|||| t|	 |	tj  |j  S n.|dkrtt||	tj  d|d |	d   S n|jrtt|dkrtt dd | jD  \}}tdd |D rtd |D ]}	t|	 krt|	 q dkrtt! dstddlm    f fdd|D }t"dd t ||D  | } | | S d S )Nr   )pure_complex)is_eqr;   c                 s   s   | ]}|j V  qd S r<   is_infinite)r   _r   r   r   r     s     z"Add._eval_power.<locals>.<genexpr>Fr   )sqrt)factor_terms)sign)expand_multinomialc                 S   s   g | ]}|  qS r   )rY   r   r   r   r   rE     s     z#Add._eval_power.<locals>.<listcomp>c                 s   s   | ]}|j V  qd S r<   )Zis_Floatr   r   r   r   r     s     c                    s$   g | ]}|kr|n|  qS r   r   r   bigZbigsr   r   r   rE     s     c                 S   s   g | ]\}}|| qS r   r   )r   rO   mr   r   r   rE     s     )#Zevalfr   Z
relationalr   r!   r    anyrT   r   r]   rh   ImaginaryUnitrN   is_extended_negativer,   is_extended_positiverV   rP   	is_numberqZ(sympy.functions.elementary.miscellaneousr   	exprtoolsr   Z$sympy.functions.elementary.complexesr   functionr   pabs_unevaluated_Mulr0   zipr   r3   )rt   rj   r   r   r6   rf   Zicorirr   r   Dr   r   rootrO   r   Zaddpowr   r   r   _eval_power  s`    "

 


zAdd._eval_powerc                    s   | j  fdd| jD  S )Nc                    s   g | ]}|  qS r   )diffr   r6   r@   r   r   rE     s     z(Add._eval_derivative.<locals>.<listcomp>funcr    )rt   r@   r   r   r   _eval_derivative  s    zAdd._eval_derivativer   c                    s$    fdd| j D }| j| S )Nc                    s   g | ]}|j  d qS )nlogxcdir)Znseriesr   rl   r   r   r   rz   r   r   rE     s     z%Add._eval_nseries.<locals>.<listcomp>)r    r   )rt   rz   r   r   r   rg   r   r   r   _eval_nseries  s    zAdd._eval_nseriesc                 C   s0   |   \}}t|dkr,|d || |S d S )Nr   r   )r   r!   matches)rt   r$   	repl_dictrh   rg   r   r   r   _matches_simple  s    zAdd._matches_simplec                 C   s   |  |||S r<   )Z_matches_commutative)rt   r$   r   oldr   r   r   r     s    zAdd.matchesc           
         s   ddl m} tjtjf}| j| s,|j| rddlm} |d tj tj  i}dd | D }| 	||	| }| r|
 fdd	d
d	 }|	|}n| | }||}	|	jr|	S |S )zp
        Returns lhs - rhs, but treats oo like a symbol so oo - oo
        returns 0, instead of a nan.
        r   )signsimpr   )Dummyooc                 S   s   i | ]\}}||qS r   r   )r   ru   vr   r   r   
<dictcomp>  s      z(Add._combine_inverse.<locals>.<dictcomp>c                    s   | j o| j kS r<   )rZ   basery   r   r   r   r}     r~   z&Add._combine_inverse.<locals>.<lambda>c                 S   s   | j S r<   )r   ry   r   r   r   r}     r~   )Zsympy.simplify.simplifyr   r   ra   rb   hassymbolr   r^   xreplacereplacer0   )
lhsrhsr   infr   ZrepsZirepseqre   Zsrvr   r   r   _combine_inverse  s*      

zAdd._combine_inversec                 C   s   | j d | j| j dd  fS )aZ  Return head and tail of self.

        This is the most efficient way to get the head and tail of an
        expression.

        - if you want only the head, use self.args[0];
        - if you want to process the arguments of the tail then use
          self.as_coef_add() which gives the head and a tuple containing
          the arguments of the tail when treated as an Add.
        - if you want the coefficient when self is treated as a Mul
          then use self.as_coeff_mul()[0]

        >>> from sympy.abc import x, y
        >>> (3*x - 2*y + 5).as_two_terms()
        (5, 3*x - 2*y)
        r   r   Nr    r_   rx   r   r   r   as_two_terms%  s    zAdd.as_two_termsc           
         s4  |   \}}t|ts(t||dd S | \}tt}|jD ]}| \}}|| | qBt	|dkr|
 \}}	| jfdd|	D  t||fS | D ]0\}}	t	|	dkr|	d ||< q| j|	 ||< qdd tt|  D \ | j fddtt	D  t   }	}t|	t||fS )	a~  
        Decomposes an expression to its numerator part and its
        denominator part.

        Examples
        ========

        >>> from sympy.abc import x, y, z
        >>> (x*y/z).as_numer_denom()
        (x*y, z)
        >>> (x*(y + 1)/y**7).as_numer_denom()
        (x*(y + 1), y**7)

        See Also
        ========

        sympy.core.expr.Expr.as_numer_denom
        FrF   r   c                    s   g | ]}t  |qS r   )_keep_coeff)r   ni)nconr   r   rE   \  s     z&Add.as_numer_denom.<locals>.<listcomp>r   c                 S   s   g | ]}t |qS r   )r+   r   r   r   r   rE   f  s     c                    s6   g | ].}t  d | | g  |d d    qS )Nr   )r`   r   )denomsnumersr   r   rE   g  s   )	primitiverW   r3   r`   as_numer_denomr   r+   r    r1   r!   popitemr   r   r^   r   iterrange)
rt   contentr$   ZdconndrK   r   Zdidr   r   )r   r   r   r   r   9  s4    


zAdd.as_numer_denomc                    s   t  fdd| jD S )Nc                 3   s   | ]}|  V  qd S r<   )_eval_is_polynomialr   termsymsr   r   r   m  s     z*Add._eval_is_polynomial.<locals>.<genexpr>rR   r    rt   r   r   r   r   r   l  s    zAdd._eval_is_polynomialc                    s   t  fdd| jD S )Nc                 3   s   | ]}|  V  qd S r<   )_eval_is_rational_functionr   r   r   r   r   p  s     z1Add._eval_is_rational_function.<locals>.<genexpr>r   r   r   r   r   r   o  s    zAdd._eval_is_rational_functionc                    s   t  fdd| jD ddS )Nc                 3   s   | ]}|  V  qd S r<   )Zis_meromorphic)r   argr6   rz   r   r   r   s  s     z+Add._eval_is_meromorphic.<locals>.<genexpr>TZ
quick_exitr
   r    )rt   rz   r6   r   r   r   _eval_is_meromorphicr  s    zAdd._eval_is_meromorphicc                    s   t  fdd| jD S )Nc                 3   s   | ]}|  V  qd S r<   )_eval_is_algebraic_exprr   r   r   r   r   w  s     z.Add._eval_is_algebraic_expr.<locals>.<genexpr>r   r   r   r   r   r   v  s    zAdd._eval_is_algebraic_exprc                 C   s   t dd | jD ddS )Nc                 s   s   | ]}|j V  qd S r<   )rI   r   r   r   r   r   {  s     Add.<lambda>.<locals>.<genexpr>Tr   r   rx   r   r   r   r}   z  s    zAdd.<lambda>c                 C   s   t dd | jD ddS )Nc                 s   s   | ]}|j V  qd S r<   )rN   r   r   r   r   r   }  s     r   Tr   r   rx   r   r   r   r}   |  s    c                 C   s   t dd | jD ddS )Nc                 s   s   | ]}|j V  qd S r<   )Z
is_complexr   r   r   r   r     s     r   Tr   r   rx   r   r   r   r}   ~  s    c                 C   s   t dd | jD ddS )Nc                 s   s   | ]}|j V  qd S r<   )Zis_antihermitianr   r   r   r   r     s     r   Tr   r   rx   r   r   r   r}     s    c                 C   s   t dd | jD ddS )Nc                 s   s   | ]}|j V  qd S r<   )rM   r   r   r   r   r     s     r   Tr   r   rx   r   r   r   r}     s    c                 C   s   t dd | jD ddS )Nc                 s   s   | ]}|j V  qd S r<   )Zis_hermitianr   r   r   r   r     s     r   Tr   r   rx   r   r   r   r}     s    c                 C   s   t dd | jD ddS )Nc                 s   s   | ]}|j V  qd S r<   )
is_integerr   r   r   r   r     s     r   Tr   r   rx   r   r   r   r}     s    c                 C   s   t dd | jD ddS )Nc                 s   s   | ]}|j V  qd S r<   Zis_rationalr   r   r   r   r     s     r   Tr   r   rx   r   r   r   r}     s    c                 C   s   t dd | jD ddS )Nc                 s   s   | ]}|j V  qd S r<   )Zis_algebraicr   r   r   r   r     s     r   Tr   r   rx   r   r   r   r}     s    c                 C   s   t dd | jD S )Nc                 s   s   | ]}|j V  qd S r<   r=   r   r   r   r   r     s    r   r   rx   r   r   r   r}     s   c                 C   sB   d}| j D ]2}|j}|d kr" d S |dkr
|dkr8 d S d}q
|S )NFT)r    r   )rt   Zsawinfr6   Zainfr   r   r   _eval_is_infinite  s    
zAdd._eval_is_infinitec                 C   s   g }g }| j D ]}|jr>|jr q|jdkr6|| q d S q|jrV||tj  q|jrtj|j kr|tj\}}|tjfkr|jr||  q d S q d S q| j	| }|| kr|jrt
| j	| jS |jdkrdS d S )NF)r    rN   rT   r1   is_imaginaryr   r   rQ   as_coeff_mulr   r   )rt   nzZim_Ir6   rh   airf   r   r   r   _eval_is_imaginary  s.    



zAdd._eval_is_imaginaryc           	      C   s*  | j dkrd S g }d}d}d}| jD ]}|jr\|jr>|d7 }q|jdkrT|| q d S q$|jrl|d7 }q$|jrtj|jkr|	tj\}}|tjfkr|jrd}q d S q$ d S q$|t
| jkrdS t
|dt
| jfkrd S | j| }|jr|s|dkrdS |dkrdS |jdkr&dS d S )NFr   r   T)r>   r    rN   rT   r1   r   rQ   r   r   r   r!   r   )	rt   r   zZim_or_zimr6   rh   r   rf   r   r   r   _eval_is_zero  sD    







zAdd._eval_is_zeroc                 C   s:   dd | j D }|sdS |d jr6| j|dd   jS d S )Nc                 S   s   g | ]}|j d k	r|qS )T)is_evenrJ   r   r   r   rE     s     
 z$Add._eval_is_odd.<locals>.<listcomp>Fr   r   )r    Zis_oddr_   r   )rt   lr   r   r   _eval_is_odd  s
    
zAdd._eval_is_oddc                 C   sZ   | j D ]N}|j}|rFt| j }|| tdd |D r@ dS  d S |d kr d S qdS )Nc                 s   s   | ]}|j d kV  qdS )TNr   )r   rz   r   r   r   r     s     z*Add._eval_is_irrational.<locals>.<genexpr>TF)r    Zis_irrationalr+   removerR   )rt   rl   r6   Zothersr   r   r   _eval_is_irrational  s    


zAdd._eval_is_irrationalc                 C   sL   d }}| j D ]4}|jr(|r" dS d}q|jr>|r8 dS d}q qHqdS d S )Nr   Fr   T)r    Zis_nonnegativeZis_nonpositive)rt   nnnpr6   r   r   r   _all_nonneg_or_nonppos  s    
zAdd._all_nonneg_or_nonpposc                    s  | j rt  S |  \}}|jsddlm} ||}|d k	r|| }|| kr^|jr^|jr^dS t	| j
dkr|| }|d k	r|| kr|jrdS d } } }}	t }
dd | jD }|sdS |D ]~}|j}|j}|r|
t||jf d|
krd|
kr d S |rd}qn|jrd}qn|jr*d}q|d kr: d S d}	q|
r`t	|
dkrXd S |
 S |	rjd S |s|s|rdS |s|rdS |s|sdS d S )Nr   _monotonic_signTFc                 S   s   g | ]}|j s|qS r   rT   r   r   r   r   rE     s      z2Add._eval_is_extended_positive.<locals>.<listcomp>)r   super_eval_is_extended_positiver   rT   r   r   r   rH   r!   free_symbolssetr    r   addr   rL   r-   )rt   rO   r6   r   r   r@   posnonnegnonposunknown_signsaw_INFr    Zisposinfinite	__class__r   r   r     sd    

zAdd._eval_is_extended_positivec                 C   s   | j s|  \}}|js|jrddlm} ||}|d k	r|| }|| krT|jrTdS t| jdkr|| }|d k	r|| kr|jrdS d S Nr   r   T)r   r   rT   rH   r   r   r!   r   rt   rO   r6   r   r   r@   r   r   r   _eval_is_extended_nonnegative;  s    z!Add._eval_is_extended_nonnegativec                 C   s   | j s|  \}}|js|jrddlm} ||}|d k	r|| }|| krT|jrTdS t| jdkr|| }|d k	r|| kr|jrdS d S r  )r   r   rT   rL   r   r   r!   r   r  r   r   r   _eval_is_extended_nonpositiveJ  s    z!Add._eval_is_extended_nonpositivec                    s  | j rt  S |  \}}|jsddlm} ||}|d k	r|| }|| kr^|jr^|jr^dS t	| j
dkr|| }|d k	r|| kr|jrdS d } } }}	t }
dd | jD }|sdS |D ]~}|j}|j}|r|
t||jf d|
krd|
kr d S |rd}qn|jrd}qn|jr*d}q|d kr: d S d}	q|
r`t	|
dkrXd S |
 S |	rjd S |s|s|rdS |s|rdS |s|sdS d S )Nr   r   TFc                 S   s   g | ]}|j s|qS r   r   r   r   r   r   rE   j  s      z2Add._eval_is_extended_negative.<locals>.<listcomp>)r   r   _eval_is_extended_negativer   rT   r   r   r   rL   r!   r   r   r    r   r   r   rH   r-   )rt   rO   r6   r   r   r@   negr   r   r   r  r    Zisnegr  r  r   r   r	  Y  sd    

zAdd._eval_is_extended_negativec                    sd  j s2tjkr. | jkr.|    iS d S |  \}} \}}|jr|jr||krn|  || S || kr|   ||S |jr|js||kr`| j|| j| }}t	|t	|k r`t
|}	t
|}
|
|	k r|	|
 }| j || f fdd|D  S | j| }t
|}
|
|	k r`|	|
 }| j  ||f fdd|D  S d S )Nc                    s   g | ]}|  qS r   _subsr?   newr   r   r   rE     s     z"Add._eval_subs.<locals>.<listcomp>c                    s   g | ]}|  qS r   r  r?   r  r   r   rE     s     )r.   r   ra   r    r   r   rP   r   	make_argsr!   r   )rt   r   r  Z
coeff_selfZ
terms_selfZ	coeff_oldZ	terms_oldZargs_oldZ	args_selfZself_setZold_setZret_setr   r  r   
_eval_subs  sH    



zAdd._eval_subsc                 C   s   dd | j D }| j| S )Nc                 S   s   g | ]}|j s|qS r   rS   r   r   r   r   rE     s      zAdd.removeO.<locals>.<listcomp>r   rt   r    r   r   r   removeO  s    zAdd.removeOc                 C   s"   dd | j D }|r| j| S d S )Nc                 S   s   g | ]}|j r|qS r   r  r   r   r   r   rE     s      zAdd.getO.<locals>.<listcomp>r   r  r   r   r   getO  s    zAdd.getOc           
         s   ddl m  g }ttrngs8dgt  fdd| jD }|D ]x\}}|D ]"\}}||r`||kr`d} qq`|dkrqT||fg}	|D ]*\}}||r||krq|	||f q|	}qTt|S )a`  
        Returns the leading term and its order.

        Examples
        ========

        >>> from sympy.abc import x
        >>> (x + 1 + 1/x**5).extract_leading_order(x)
        ((x**(-5), O(x**(-5))),)
        >>> (1 + x).extract_leading_order(x)
        ((1, O(1)),)
        >>> (x + x**2).extract_leading_order(x)
        ((x, O(x)),)

        r   Orderc                    s$   g | ]}| |ft  fqS r   )r   rJ   r  pointsymbolsr   r   rE     s     z-Add.extract_leading_order.<locals>.<listcomp>N)	sympy.series.orderr  r+   r   r!   r    rA   r1   r   )
rt   r  r  lstrd   ZefZofrj   rD   Znew_lstr   r  r   extract_leading_order  s(    
zAdd.extract_leading_orderc           	      K   sR   | j }g g  }}|D ](}|j|d\}}|| || q| j| | j| fS )a4  
        Return a tuple representing a complex number.

        Examples
        ========

        >>> from sympy import I
        >>> (7 + 9*I).as_real_imag()
        (7, 9)
        >>> ((1 + I)/(1 - I)).as_real_imag()
        (0, 1)
        >>> ((1 + 2*I)*(1 + 3*I)).as_real_imag()
        (-5, 5)
        )deep)r    as_real_imagr1   r   )	rt   r  hintsZsargsre_partim_partr   rer   r   r   r   r    s    

zAdd.as_real_imagc              
      sv  ddl m}m} ddlm} ddlm ddlm}m	} ddl
m}	 |  }
|
d kr\|d}
|  }||rv||}tfdd	| jD rd
d
dddddddd	}|jf |}|	|}|js|j|dS dd |jD }|d kr|dn|  fdd|jD }|dd }}zF|D ]<}||}|r>||krH|}|}n||kr ||7 }q W n tk
rz   | Y S X |d kr| }|j}|d kr|  }|j}|d
krRz| }W n tk
r   tj}Y nX ||rtj}|d}tj}|jrB|j|| |d   }|d9 }q|j|dS |tj krn|j!"||
 S |S d S )Nr   )r   Symbolr  log)	Piecewisepiecewise_foldr   )
expand_mulc                 3   s   | ]}t | V  qd S r<   )rW   r   r$  r   r   r     s     z,Add._eval_as_leading_term.<locals>.<genexpr>TF)	r  r%  mulZ	power_expZ
power_baseZmultinomialbasicforcefactorr   r   c                 S   s   g | ]}|j r|qS r   r   r   r   r   r   rE     s      z-Add._eval_as_leading_term.<locals>.<listcomp>r   c                    s   g | ]}|j  d qS )r-  )as_leading_termr   )_logxr   rz   r   r   rE     s     r   r;   )#Zsympy.core.symbolr   r#  r  r  Z&sympy.functions.elementary.exponentialr%  Z$sympy.functions.elementary.piecewiser&  r'  r   r(  r  r  r   r   r    expandr.   r.  	TypeErrorsubsrT   ZtrigsimpcancelZgetnNotImplementedErrorr   r]   rS   r   ZpowsimprU   r   r4   )rt   rz   r   r   r   r#  r  r&  r'  r(  rD   r   Zlogflagsr$   r  Zleading_termsminZnew_exprr   orderrT   Zn0resincrr   )r/  r   r%  rz   r   _eval_as_leading_term  sv    
   





"zAdd._eval_as_leading_termc                 C   s   | j dd | jD  S )Nc                 S   s   g | ]}|  qS r   )Zadjointr   r   r   r   rE   F  s     z%Add._eval_adjoint.<locals>.<listcomp>r   rx   r   r   r   _eval_adjointE  s    zAdd._eval_adjointc                 C   s   | j dd | jD  S )Nc                 S   s   g | ]}|  qS r   )	conjugater   r   r   r   rE   I  s     z'Add._eval_conjugate.<locals>.<listcomp>r   rx   r   r   r   _eval_conjugateH  s    zAdd._eval_conjugatec                 C   s   | j dd | jD  S )Nc                 S   s   g | ]}|  qS r   )Z	transposer   r   r   r   rE   L  s     z'Add._eval_transpose.<locals>.<listcomp>r   rx   r   r   r   _eval_transposeK  s    zAdd._eval_transposec                 C   s  g }d}| j D ]B}| \}}|js.tj}|}|p:|tjk}||j|j|f q|st	t
dd |D d}t	tdd |D d}n,t	t
dd |D d}t	tdd |D d}||  krdkrn n
tj| fS |st|D ],\}\}	}
}tt|	| ||
  |||< qnTt|D ]J\}\}	}
}|
rLtt|	| ||
  |||< ntt|	|
|||< q|d js|d tjkr|d}nd	}t| |r|d| t||| j| fS )
a  
        Return ``(R, self/R)`` where ``R``` is the Rational GCD of ``self```.

        ``R`` is collected only from the leading coefficient of each term.

        Examples
        ========

        >>> from sympy.abc import x, y

        >>> (2*x + 4*y).primitive()
        (2, x + 2*y)

        >>> (2*x/3 + 4*y/9).primitive()
        (2/9, 3*x + 2*y)

        >>> (2*x/3 + 4.2*y).primitive()
        (1/3, 2*x + 12.6*y)

        No subprocessing of term factors is performed:

        >>> ((2 + 2*x)*x + 2).primitive()
        (1, x*(2*x + 2) + 2)

        Recursive processing can be done with the ``as_content_primitive()``
        method:

        >>> ((2 + 2*x)*x + 2).as_content_primitive()
        (2, x*(x + 1) + 1)

        See also: primitive() function in polytools.py

        Fc                 S   s   g | ]}|d  qS )r   r   r   r   r   r   rE   |  s     z!Add.primitive.<locals>.<listcomp>r   c                 S   s   g | ]}|d  qS r   r   r   r   r   r   rE   }  s     r   c                 S   s   g | ]}|d  r|d qS )r   r   r   r   r   r   r   rE     s      c                 S   s   g | ]}|d  r|d  qS r>  r   r   r   r   r   rE     s      N)r    rY   rP   r   r]   rV   r1   r   r   r   r   r   	enumerater   Rationalr0   r-   r*   r2   r_   )rt   rg   r   r6   rO   r   ZngcdZdlcmr   r   r   r   r   r   r   r   N  s<    #

" 	zAdd.primitivec                    s  | j fdd| jD   \}}sj|jsj|jrj| \}}|| }tdd |jD rb|}n|| }r|jr|j}g }d}	|D ]}
tt}t	
|
D ]@}|jr| \}}|jr|jr||j tt||j  q|s q|	dkrt| }	n|	t| @ }	|	s  q|| q|D ]J}t| D ]|	kr@| q@|D ]t	|  |< q`q0g  |	D ]>ttfdd|D d}|dkr |td  q rt	    fd	d|D } |j |  }||fS )
a  Return the tuple (R, self/R) where R is the positive Rational
        extracted from self. If radical is True (default is False) then
        common radicals will be removed and included as a factor of the
        primitive expression.

        Examples
        ========

        >>> from sympy import sqrt
        >>> (3 + 3*sqrt(2)).as_content_primitive()
        (3, 1 + sqrt(2))

        Radical content can also be factored out of the primitive:

        >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)
        (2, sqrt(2)*(1 + 2*sqrt(5)))

        See docstring of Expr.as_content_primitive for more examples.
        c                    s   g | ]}t |j d  qS ))radicalclear)r   as_content_primitiver   )rB  rA  r   r   rE     s
    z,Add.as_content_primitive.<locals>.<listcomp>c                 s   s   | ]}|  d  jV  qdS )r   N)rY   r\   r   r   r   r   r     s     z+Add.as_content_primitive.<locals>.<genexpr>Nc                    s   g | ]}|  qS r   r   )r   r   )r   r   r   rE     s     r   r   c                    s   g | ]}|  qS r   r   )r   r   )Gr   r   rE     s     )r   r    r   r\   r.   r   r   r   r+   r`   r  rZ   r[   rP   r   r1   r   intr   r   keysr-   r   r   r@  )rt   rA  rB  conZprimr   _pr    ZradsZcommon_qr   Z	term_radsr   rf   rj   r   gr   )rD  rB  r   rA  r   rC    sX     


zAdd.as_content_primitivec                 C   s   ddl m} tt| j|dS )Nr   )default_sort_keyr&   )ZsortingrJ  r   sortedr    )rt   rJ  r   r   r   _sorted_args  s    zAdd._sorted_argsc                    s*   ddl m  | j fdd| jD  S )Nr   )difference_deltac                    s   g | ]} |qS r   r   r   ddr   stepr   r   rE     s     z.Add._eval_difference_delta.<locals>.<listcomp>)Zsympy.series.limitseqrM  r   r    )rt   r   rP  r   rN  r   _eval_difference_delta  s    zAdd._eval_difference_deltac                 C   sJ   ddl m} |  \}}| \}}|tjks6td||j||jfS )z;
        Convert self to an mpmath mpc if possible
        r   )Floatz@Cannot convert Add to mpc. Must be of the form Number + Number*I)numbersrR  r   rY   r   r   AttributeErrorZ_mpf_)rt   rR  r   restr!  Z	imag_unitr   r   r   _mpc_  s    
z	Add._mpc_c                    s   t jst  S ttj| S r<   )r	   Z
distributer   __neg__r`   r   ZNegativeOnerx   r  r   r   rW    s    
zAdd.__neg__)FN)r   )NF)N)T)Nr   )FT)Dro   
__module____qualname____doc__	__slots__tTupler   __annotations__r.   Z
_args_typeclassmethodrm   rp   propertyrq   r   r   r   r   r   r   r   r   r   staticmethodr   r   r   r   r   r   r   Z_eval_is_realZ_eval_is_extended_realZ_eval_is_complexZ_eval_is_antihermitianZ_eval_is_finiteZ_eval_is_hermitianZ_eval_is_integerZ_eval_is_rationalZ_eval_is_algebraicZ_eval_is_commutativer   r   r   r   r   r   r   r  r  r	  r  r  r  r  r  r9  r:  r<  r=  r   rC  rL  rQ  rV  rW  __classcell__r   r   r  r   r3   Y   s   
V
 U



3




3)66%%

KP
H

r3   r   )r`   r   r   )r@  N)0typingr   r\  collectionsr   	functoolsr   r   operatorr   r*  r   
parametersr	   Zlogicr
   r   r   Z	singletonr   
operationsr   r   cacher   rS  r   r   r   r$   r   rq   r   Zsympy.utilities.iterablesr   r   comparer)   r%   r*   r7   r3   r   r)  r`   r   r   r@  r   r   r   r   <module>   s<   
0         4