
    oVh                    F   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 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 ddlmZ ddlm Z  d dl!m"Z"m#Z# erd dl$m%Z% d dl&m'Z' d Z(d Z)d Z* G d dee      Z+ ed      Z,ddl-m.Z.m/Z/m0Z0 ddl1m2Z2 y)    )annotations)TYPE_CHECKINGClassVar)defaultdict)reduce)
attrgetter   )_args_sortkey)global_parameters)_fuzzy_groupfuzzy_or	fuzzy_not)S)AssocOpAssocOpDispatcher)cacheit)ilcmigcd)Expr)UndefinedKind)is_sequencesift)NumberOrderc                    t        d | j                  D              }t        | j                        |z
  }||kD  ry||k  ryt        | j	                         |  j	                         k        S )Nc              3  @   K   | ]  }|j                         rd   yw)r	   N)could_extract_minus_sign).0is     >/home/dcms/DCMS/lib/python3.12/site-packages/sympy/core/add.py	<genexpr>z,_could_extract_minus_sign.<locals>.<genexpr>   s#      )a%%'  )s   FT)sumargslenboolsort_key)exprnegative_argspositive_argss      r!   _could_extract_minus_signr+      si      )499 ) )M		N]2M}$		& D5"2"2"4455    c                0    | j                  t               y )Nkey)sortr
   )r$   s    r!   _addsortr1   (   s    II-I r,   c                 d   t        |       } g }t        j                  }| r^| j                         }|j                  r| j                  |j                         n#|j                  r||z  }n|j                  |       | r^t        |       |r|j                  d|       t        j                  |      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appendr1   insertAdd
_from_args)r$   newargscoas       r!   _unevaluated_Addr@   -   s    : :DG	
B
HHJ88 KK[[!GBNN1  W	q">>'""r,   c                      e Zd ZU dZdZdZeZded<   e	rddd>dZ
ed?d       Zed@d	       Zed
        Zed        Zd Zed        ZdAdBdZd Zed        ZdCdZd ZdDdZed        Zed        ZdEdZd Zd Zd Z d Z!d Z"d Z#d Z$d Z%d Z&d  Z'd! Z(d" Z)d# Z*d$ Z+d% Z,d& Z-d' Z.d( Z/d) Z0d* Z1 fd+Z2d, Z3d- Z4 fd.Z5d/ Z6d0 Z7d1 Z8edFd2       Z9dGd3Z:d4 Z;d5 Z<d6 Z=d7 Z>d8 Z?dHd9Z@ed:        ZAd; ZBed<        ZC fd=ZD xZES )Ir;   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

     TzClassVar[Expr]identityevaluatec                    y NrB   )clsrE   r$   s      r!   __new__zAdd.__new__   s    r,   c                     y rG   rB   selfs    r!   r$   zAdd.args   s    r,   c                V   ddl m} ddlm} ddlm}m} d}t        |      dk(  rU|\  }}|j                  r||}}|j                  r|j                  r||gg df}|rt        d |d   D              r|S g |d   dfS i }	t        j                  }
g }g }|D ]  j                  rTj                  j                  r't!        fd|D              r<|D cg c]  }j#                  |      r| }}g|z   }dj$                  rt        j&                  u s |
t        j(                  u r&j*                  d	u r|st        j&                  gg dfc S |
j$                  st-        |
|      r/|
z  }
|
t        j&                  u r|st        j&                  gg dfc S t-        |      rj/                  |
      }
"t-        |      r|j1                         At-        |      r ||
      j3                  d	
      }
ht        j(                  u r8|
j*                  d	u r|st        j&                  gg dfc S t        j(                  }
j4                  rj6                  }|j9                  |       ݉j                  rj;                         \  }}nj<                  rlj?                         \  }}|j$                  r:|j@                  s|j                  r"|jB                  r|j1                  ||z         bt        jD                  }}nt        jD                  }}||	v r>|	|xx   |z  cc<   |	|   t        j&                  u s|rt        j&                  gg dfc S ||	|<    g }d	}|	jG                         D ]  \  }}|j                  r|t        jD                  u r|j1                  |       n|j                  r/ |jH                  |f|j6                  z    }|j1                  |       nE|j4                  r|j1                  tK        ||d	             n|j1                  tK        ||             |xs |jL                   } |
t        jN                  u r*|D cg c]  }|jP                  r|jR                  r|  }}n;|
t        jT                  u r)|D cg c]  }|jV                  r|jR                  r|  }}|
t        j(                  u r'|D cg c]  }|j*                  r|jX                  | }}|r^g }|D ](  t!        fd|D              r|j1                         * ||z   }|D ]%  j#                  |
      st        j                  }
 n t[        |       |
t        j                  ur|j]                  d|
       |r||z  }d}|rg |dfS |g dfS c c}w c c}w c c}w c c}w )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)TensExprTensAddN   c              3  4   K   | ]  }|j                     y wrG   is_commutative)r   ss     r!   r"   zAdd.flatten.<locals>.<genexpr>   s     7Aq''7   c              3  @   K   | ]  }|j                          y wrG   contains)r   o1os     r!   r"   zAdd.flatten.<locals>.<genexpr>   s     >"r{{1~>   FdeeprD   c              3  @   K   | ]  }|j                          y wrG   rY   )r   r\   ts     r!   r"   zAdd.flatten.<locals>.<genexpr>~  s     @Q1::a=@r]   T)/!sympy.calculus.accumulationboundsrN   sympy.matrices.expressionsrO   sympy.tensor.tensorrP   rQ   r%   is_Rationalis_Mulallr   r4   is_Orderr(   is_zeroanyrZ   r8   NaNComplexInfinity	is_finite
isinstance__add__r9   doitr6   r$   r7   as_coeff_Mulis_Powas_base_exp
is_Integeris_negativeOneitems_new_rawargsMulrU   Infinityis_extended_nonnegativeis_realNegativeInfinityis_extended_nonpositiveis_extended_realr1   r:   )rH   seqrN   rO   rP   rQ   rvr?   btermscoefforder_factorsextrar[   o_argscrV   enewseqnoncommutativecsfnewseq2r\   ra   s                          @@r!   flattenzAdd.flatten   s)   $ 	B99s8q=DAq}}!1}}88QT)B7A77I2a5$& %' ff%'"$ S	A zz66>>>>>.; R1::b> R R!"m 3 J%1+<+<"<u,eEE7B,,??j&DQJE~e !wD00A{+		%(Az*QAx(5)..E.:a'''??e+EEE7B,,)) +,66

6" ~~'1 }}1;;ALL$%MMammJJq!t$uua1 EE EzaA8quu$UEE7B,,agS	n KKM 	DDAqyyaeea  88 (1$-9BMM"%XXMM#aU";< MM#a),+C13C3C/CN1	D6 AJJ!'XA0I0IQYYaXFXa(((!'XA0I0IQYYaXFXA%%% "( QA010B0B0N  QF Q G &@-@@NN1%& },F" ::e$FFE 	 MM!U#eOF!N vt##2t##w !SZ Y YQs6   V+VV+V8VV!'V!4V!!V&c                     dd| j                   fS )N   r	   )__name__)rH   s    r!   	class_keyzAdd.class_key  s    !S\\!!r,   c                    t        d      }t        || j                        }t        |      }t	        |      dk7  rt
        }|S |\  }|S )Nkindr	   )r   mapr$   	frozensetr%   r   )rL   kkindsresults       r!   r   zAdd.kind  sM    vAtyy!% u:? #F  GFr,   c                    t        |       S rG   )r+   rK   s    r!   r   zAdd.could_extract_minus_sign  s    (..r,   c                <   r8t        | j                  fdd      \  }} | j                  | t        |      fS | j                  d   j	                         \  }}|t
        j                  ur||| j                  dd z   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                "     | j                    S rG   )has_free)xdepss    r!   <lambda>z"Add.as_coeff_add.<locals>.<lambda>  s    zqzz4/@ r,   T)binaryr   r	   N)r   r$   rx   tupleas_coeff_addr   r4   )rL   r   l1l2r   notrats    `    r!   r   zAdd.as_coeff_add  s     $))%@NFB$4$$b)5944		!113v&499QR=000vvtyy  r,   c                    | j                   d   | j                   dd }}|j                  r|r|j                  r| | j                  | fS t        j
                  | fS )zE
        Efficiently extract the coefficient of a summation.
        r   r	   N)r$   r8   re   rx   r   r4   )rL   rationalr   r   r$   s        r!   as_coeff_AddzAdd.as_coeff_Add  sW     iilDIIabMt??8u/@/@+$++T222vvt|r,   c                   ddl m} ddlm} t	        | j
                        dk(  rt        d | j
                  D              r|j                  du r ||t        j                        du r| j
                  \  }}|j                  t        j                        r||}}|j                  t        j                        }|rP|j                  rD|j                  r8|j                  rt        j                  S |j                  rt        j                   S y |j"                  r| j$                  r ||       }|r|\  }}	|j&                  dk(  rddlm}
  |
|dz  |	dz  z         }|j"                  rtdd	lm} dd
lm} ddlm}  |
 |||z
  dz              |j8                  z  }| |||z   t;        |	      z   ||	      t        j                  z  z   |j8                  z        z  S y |dk(  r,t=        ||	t        j                  z  z
  d|dz  |	dz  z   z        S y y y y )Nr	   )pure_complex)is_eqrR   c              3  4   K   | ]  }|j                     y wrG   )is_infinite)r   _s     r!   r"   z"Add._eval_power.<locals>.<genexpr>  s     &Hq}}&HrW   Fr   )sqrt)factor_terms)sign)expand_multinomial)evalfr   
relationalr   r%   r$   rj   ri   r   rv   r   ImaginaryUnitr   is_extended_negativer4   is_extended_positiverl   re   	is_numberq(sympy.functions.elementary.miscellaneousr   	exprtoolsr   $sympy.functions.elementary.complexesr   functionr   pabs_unevaluated_Mul)rL   exptr   r   r?   r   icorirr    r   Dr   r   r   roots                   r!   _eval_powerzAdd._eval_power  s   '%tyy>Q3&Hdii&H#H||u$tQUU);u)Dyy1771??+aqAggaoo.3//A4F4F00 vv00 000d#B166Q;MQTAqD[)A}};M@#L!a%$;<dffD#$6UCFNT!WQ__-DDtvv8N %O  O O % RZ+Aaoo--1a4!Q$;) )    !/r,   c                x     | j                   | j                  D cg c]  }|j                  |       c} S c c}w rG   )funcr$   diff)rL   rV   r?   s      r!   _eval_derivativezAdd._eval_derivative  s-    tyydii8166!98998s   7c           	         | j                   D cg c]  }|j                  ||||       }} | j                  | S c c}w )Nnlogxcdir)r$   nseriesr   )rL   r   r   r   r   ra   r   s          r!   _eval_nserieszAdd._eval_nseries  sA    BF))LQ148LLtyy%   Ms   <c                v    | j                         \  }}t        |      dk(  r|d   j                  ||z
  |      S y )Nr	   r   )r   r%   matches)rL   r(   	repl_dictr   r   s        r!   _matches_simplezAdd._matches_simple  s=    ((*uu:?8##D5L)<<r,   c                (    | j                  |||      S rG   )_matches_commutative)rL   r(   r   olds       r!   r   zAdd.matches  s    ((y#>>r,   c                2   ddl m} t        j                  t        j                  f} | j
                  | s |j
                  | rddlm}  |d      t        j                  t        j                   i}|j                         D ci c]  \  }}||
 }}}| j                  |      |j                  |      z
  }	|	j                        r|	j                  fdd       }	|	j                  |      }
n| |z
  }
 ||
      }|j                  r|S |
S c c}}w )zp
        Returns lhs - rhs, but treats oo like a symbol so oo - oo
        returns 0, instead of a nan.
        r   )signsimpr	   )Dummyooc                <    | j                   xr | j                  u S rG   )rr   base)r   r   s    r!   r   z&Add._combine_inverse.<locals>.<lambda>  s    ahh7166R< r,   c                    | j                   S rG   )r   )r   s    r!   r   z&Add._combine_inverse.<locals>.<lambda>  s
    aff r,   )sympy.simplify.simplifyr   r   rz   r}   hassymbolr   rw   xreplacereplacer8   )lhsrhsr   infr   repsr   virepseqr   srvr   s               @r!   _combine_inversezAdd._combine_inverse  s     	5zz1--.377C=GCGGSM%tB

B""RC)D '+jjl3daQT3E3d#cll4&88BvvbzZZ7$& U#BsBrlmms++ 4s   
Dc                X    | 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$   rx   rK   s    r!   as_two_termszAdd.as_two_terms"  s/    $ yy|.T..		!">>>r,   c                   | j                         \  }}t        |t              st        ||d      j	                         S |j	                         \  }}t        t              }|j                  D ])  }|j	                         \  }}||   j                  |       + t        |      dk(  rF|j                         \  }	}
 | j                  |
D cg c]  }t        ||       c} t        ||	      fS |j                         D 	
ci c](  \  }	}
|	t        |
      dkD  r | j                  |
 n|
d   * }}	}
t        t        |j                                D cg c]  }t        |       c}\  }} | j                  t!        t        |            D cg c]  }t        |d| ||   gz   ||dz   d z     c} t        | }	}
t        ||
      t        ||	      fS c c}w c c}
}	w c c}w c c}w )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
        FrD   r	   r   N)	primitivern   r;   ry   as_numer_denomr   r3   r$   r9   r%   popitemr   _keep_coeffrw   zipiterrange)rL   contentr(   ncondconndr   nididr   nd2r    denomsnumerss                  r!   r   zAdd.as_numer_denom6  s   ( ($$wu5DDFF++-
d  	A%%'FBrFMM"	
 r7a<::<DAq499234B+dB'467B47KL L EGHHJODAqq3q6A:)$))Q-1Q47OO ,/SYY[0A+BCa$q'Ctyy!#f+.0 vayk!9F1q56N!JL 0 125v,  4#[q%999 5 P D0s   G-GG"G"c                @    t        fd| j                  D              S )Nc              3  @   K   | ]  }|j                          y wrG   )_eval_is_polynomialr   termsymss     r!   r"   z*Add._eval_is_polynomial.<locals>.<genexpr>f  s     Hd4++D1Hr]   rg   r$   rL   r  s    `r!   r  zAdd._eval_is_polynomiale  s    HdiiHHHr,   c                @    t        fd| j                  D              S )Nc              3  @   K   | ]  }|j                          y wrG   )_eval_is_rational_functionr	  s     r!   r"   z1Add._eval_is_rational_function.<locals>.<genexpr>i  s     OT42248Or]   r  r  s    `r!   r  zAdd._eval_is_rational_functionh  s    OTYYOOOr,   c                H    t        fd| j                  D        d      S )Nc              3  B   K   | ]  }|j                          y wrG   )is_meromorphic)r   argr?   r   s     r!   r"   z+Add._eval_is_meromorphic.<locals>.<genexpr>l  s     K#S//15Ks   T
quick_exitr   r$   )rL   r   r?   s    ``r!   _eval_is_meromorphiczAdd._eval_is_meromorphick  s    KK'+- 	-r,   c                @    t        fd| j                  D              S )Nc              3  @   K   | ]  }|j                          y wrG   )_eval_is_algebraic_exprr	  s     r!   r"   z.Add._eval_is_algebraic_expr.<locals>.<genexpr>p  s     L$4//5Lr]   r  r  s    `r!   r  zAdd._eval_is_algebraic_expro  s    L$))LLLr,   c                >    t        d | j                  D        d      S )Nc              3  4   K   | ]  }|j                     y wrG   )r|   r   r?   s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>t  s     &q&rW   Tr  r  rK   s    r!   r   zAdd.<lambda>s  s    &DII&4"9 r,   c                >    t        d | j                  D        d      S )Nc              3  4   K   | ]  }|j                     y wrG   )r   r  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>v       /		/rW   Tr  r  rK   s    r!   r   zAdd.<lambda>u      ,/TYY/D+B r,   c                >    t        d | j                  D        d      S )Nc              3  4   K   | ]  }|j                     y wrG   )
is_complexr  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>x       )!)rW   Tr  r  rK   s    r!   r   zAdd.<lambda>w      L)tyy)d%< r,   c                >    t        d | j                  D        d      S )Nc              3  4   K   | ]  }|j                     y wrG   )is_antihermitianr  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>z  r!  rW   Tr  r  rK   s    r!   r   zAdd.<lambda>y  r"  r,   c                >    t        d | j                  D        d      S )Nc              3  4   K   | ]  }|j                     y wrG   )rm   r  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>|  s     ((rW   Tr  r  rK   s    r!   r   zAdd.<lambda>{  s    <(dii(T$; r,   c                >    t        d | j                  D        d      S )Nc              3  4   K   | ]  }|j                     y wrG   )is_hermitianr  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>~       +A+rW   Tr  r  rK   s    r!   r   zAdd.<lambda>}      l++'> r,   c                >    t        d | j                  D        d      S )Nc              3  4   K   | ]  }|j                     y wrG   )
is_integerr  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>  r&  rW   Tr  r  rK   s    r!   r   zAdd.<lambda>  r'  r,   c                >    t        d | j                  D        d      S )Nc              3  4   K   | ]  }|j                     y wrG   is_rationalr  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>  s     *1*rW   Tr  r  rK   s    r!   r   zAdd.<lambda>  s    \*		*t&= r,   c                >    t        d | j                  D        d      S )Nc              3  4   K   | ]  }|j                     y wrG   )is_algebraicr  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>  r0  rW   Tr  r  rK   s    r!   r   zAdd.<lambda>  r1  r,   c                :    t        d | j                  D              S )Nc              3  4   K   | ]  }|j                     y wrG   rT   r  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>  s      5-5-rW   r  rK   s    r!   r   zAdd.<lambda>  s     5-"&))5- )- r,   c                f    d}| j                   D ]  }|j                  }| y |du s|du r y d}! |S )NFT)r$   r   )rL   sawinfr?   ainfs       r!   _eval_is_infinitezAdd._eval_is_infinite  sH     	A==D|T>	 r,   c                   g }g }| j                   D ]  }|j                  r/|j                  r|j                  du r|j                  |       < y |j                  r#|j                  |t
        j                  z         m|j                  rst
        j                  |j                   v rW|j                  t
        j                        \  }}|t
        j                  fk(  r|j                  r|j                  |         y  y   | j                  | }|| k7  r>|j                  r"t         | j                  | j                        S |j                  du ryy y NF)r$   r   ri   r9   is_imaginaryr   r   rf   as_coeff_mulr   r   )rL   nzim_Ir?   r   air   s          r!   _eval_is_imaginaryzAdd._eval_is_imaginary  s    	A!!99YY%'IIaLAaoo-.aoo7NN1??;	r!//++0F0FKK'#	$ DIIrN9yy D!1!9!9::e# $ r,   c                   | j                   du ry g }d}d}d}| j                  D ]  }|j                  r4|j                  r|dz  }!|j                  du r|j	                  |       A y |j
                  r|dz  }U|j                  rct        j                  |j                  v rG|j                  t        j                        \  }}|t        j                  fk(  r|j                  rd} y  y  |t        | j                        k(  ryt        |      dt        | j                        fv ry  | j                  | }|j                  r|s|dk(  ry|dk(  ry|j                  du ryy )NFr   r	   T)rU   r$   r   ri   r9   rD  rf   r   r   rE  r%   r   )	rL   rF  zim_or_zimr?   r   rH  r   s	            r!   _eval_is_zerozAdd._eval_is_zero  s?   %'  	A!!99FAYY%'IIaLaaoo7NN1??;	r!//++0F0F"G#	$ DIIr7q#dii.))DIIrN9971W 99 r,   c                    | j                   D cg c]  }|j                  dus| }}|sy|d   j                  r | j                  |dd   j                  S y c c}w )NTFr   r	   )r$   is_evenis_oddrx   )rL   r   ls      r!   _eval_is_oddzAdd._eval_is_odd  s^    		=1!))t*;Q==Q4;;$4$$ae,444  >s
   AAc                    | j                   D ]P  }|j                  }|r<t        | j                         }|j                  |       t	        d |D              r y y |P y  y)Nc              3  8   K   | ]  }|j                   d u   yw)TNr7  )r   r   s     r!   r"   z*Add._eval_is_irrational.<locals>.<genexpr>  s     =q}},=s   TF)r$   is_irrationalr3   removerg   )rL   ra   r?   otherss       r!   _eval_is_irrationalzAdd._eval_is_irrational  s[     		AAdiia =f==y		 r,   c                |    dx}}| j                   D ])  }|j                  r|r yd}|j                  r|r yd}) y  y)Nr   Fr	   T)r$   is_nonnegativeis_nonpositive)rL   nnnpr?   s       r!   _all_nonneg_or_nonpposzAdd._all_nonneg_or_nonppos  sN    R 	A !! 	 r,   c                &   | j                   rt        | 	         S | j                         \  }}|j                  sgddlm}  ||      }|W||z   }|| k7  r|j                  r|j                  ryt        | j                        dk(  r ||       }||| k7  r|j                  rydx}x}x}}	t               }
| j                  D cg c]  }|j                  r| }}|sy|D ]u  }|j                  }|j                  }|r0|
j                  t        ||j                  f             d|
v rd|
v r y |rd}R|j                  rd}a|j                   rd}p| y d}	w |
rt        |
      dkD  ry |
j#                         S |	ry |s|s|ry|s|ry|s|syy y c c}w Nr	   _monotonic_signTF)r   super_eval_is_extended_positiver   ri   r   rc  r   r{   r%   free_symbolssetr$   r   addr   r~   r5   )rL   r   r?   rc  r   rV   posnonnegnonposunknown_signsaw_INFr$   isposinfinite	__class__s                 r!   re  zAdd._eval_is_extended_positive     >>7577  "1yy2"A}E9!7!7A<U<Ut(()Q.'-A}dq7M7M#/444f4v%996aAII66 	 A**E}}HHeQ-F-F%GHI7?u'7****L'	 * 7|a;;= 3CV $E 7   FFc                6   | j                   s| j                         \  }}|j                  sm|j                  r`ddlm}  ||      }|O||z   }|| k7  r|j                  ryt        | j                        dk(  r ||       }||| k7  r|j                  ryy y y y y y y y Nr	   rb  T)r   r   ri   r{   r   rc  r%   rf  rL   r   r?   rc  r   rV   s         r!   _eval_is_extended_nonnegativez!Add._eval_is_extended_nonnegative4      ~~$$&DAq99!:!:6#A&=AADyQ%>%>#4,,-2+D1=Q$Y1;T;T#' <UY= 3	 ! ";9 r,   c                6   | j                   s| j                         \  }}|j                  sm|j                  r`ddlm}  ||      }|O||z   }|| k7  r|j                  ryt        | j                        dk(  r ||       }||| k7  r|j                  ryy y y y y y y y rt  )r   r   ri   r~   r   rc  r%   rf  ru  s         r!   _eval_is_extended_nonpositivez!Add._eval_is_extended_nonpositiveC  rw  r,   c                &   | j                   rt        | 	         S | j                         \  }}|j                  sgddlm}  ||      }|W||z   }|| k7  r|j                  r|j                  ryt        | j                        dk(  r ||       }||| k7  r|j                  rydx}x}x}}	t               }
| j                  D cg c]  }|j                  r| }}|sy|D ]u  }|j                  }|j                  }|r0|
j                  t        ||j                  f             d|
v rd|
v r y |rd}R|j                  rd}a|j                   rd}p| y d}	w |
rt        |
      dkD  ry |
j#                         S |	ry |s|s|ry|s|ry|s|syy y c c}w ra  )r   rd  _eval_is_extended_negativer   ri   r   rc  r   r~   r%   rf  rg  r$   r   rh  r   r{   r5   )rL   r   r?   rc  r   rV   negrk  rj  rl  rm  r$   isnegro  rp  s                 r!   r{  zAdd._eval_is_extended_negativeR  rq  rr  c           
        |j                   s7|t        j                  u r$| | j                  v r| j	                  | | i      S y | j                         \  }}|j                         \  }}|j                  r?|j                  r3||k(  r| j                  |||       S || k(  r| j                  | ||      S |j                  r|j                  s||k(  r| j                  j                  |      | j                  j                  |      }}t        |      t        |      k  rt        |      }	t        |      }
|
|	k  r9|	|
z
  } | j                  ||| g|D cg c]  }|j                  ||       c} S | j                  j                  |       }t        |      }
|
|	k  r9|	|
z
  } | j                  | ||g|D cg c]  }|j                  ||       c} S y y y c c}w c c}w rG   )r6   r   rz   r$   r   r   re   r   	make_argsr%   rg  _subs)rL   r   new
coeff_self
terms_self	coeff_old	terms_oldargs_old	args_selfself_setold_setret_setrV   s                r!   
_eval_subszAdd._eval_subs  s   zzajj cTTYY%6}}sdSD\22!%!2!2!4
J"//1	9!!i&;&;Y&yyj9*==iZ'yy#z9==!!i&;&;*"&))"5"5# II//
;  H8}s9~-y>h-X%&0G$499S*yj F<C Dqc!2 DF F  99..J h-X%&0G$499cT:y F<C Dqc!2 DF F & . + !E !Es   G
:G!
c                v    | j                   D cg c]  }|j                  r| }} | j                  | S c c}w rG   r$   rh   rx   rL   r?   r$   s      r!   removeOzAdd.removeO  s7    997aAJJ77 t  $'' 8s   66c                |    | j                   D cg c]  }|j                  s| }}|r | j                  | S y c c}w rG   r  r  s      r!   getOzAdd.getO  s?    993a

33$4$$d++  4s   99c                   ddl m} g }t        t        |      r|n|g      }|sdgt	        |      z  }| j
                  D cg c]  }| ||gt        ||       f }}|D ]h  \  }}|D ]   \  }	}
|
j                  |      s|
|k7  sd} n |.||fg}|D ]/  \  }	}
|j                  |
      r|
|k7  r|j                  |	|
f       1 |}j t        |      S c c}w )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   r   N)
sympy.series.orderr   r3   r   r%   r$   r   rZ   r9   r   )rL   symbolspointr   lstr   r   efofr   r\   new_lsts               r!   extract_leading_orderzAdd.extract_leading_order  s   " 	-+g"6wWIFCG$E<@IIFq51S%012FF 	FB 1::b>a2gB zBxjG '1;;q>a2g1v&' C	 Sz Gs   Cc                    | j                   }g g }}|D ]9  }|j                  |      \  }}|j                  |       |j                  |       ;  | 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)
        r^   )r$   as_real_imagr9   r   )	rL   r_   hintssargsre_partim_partr
  rerM  s	            r!   r  zAdd.as_real_imag  sw     		r 	D&&D&1FBNN2NN2	 		7#YTYY%899r,   c           
        ddl m}m} ddlm} ddlm ddlm}m	} ddl
m}	 | j                         }
|
 |d      }
| j                         }|j                  |      r ||      }t        fd| j                   D              rd	d	d
d
d
d
d
d
d
d	} |j"                  di |} |	|      }|j$                  s|j'                  |||      S |j                   D cg c]  }|j(                  s| }}| |d      n|}|j                   D cg c]  }|j'                  |||       }} |d      t*        j,                  }}	 |D ]   } |||      }|r||vr|}|}||v s||z  }" 	 ||j1                  | |            }|j2                  }|*|j5                         j7                         }|j2                  }|d	u r	 |j9                         }|j                  |      rt*        j<                  } |d      }t*        j<                  }|j>                  rT|jA                  |||z   ||      j7                         jC                         j5                         }|dz  }|j>                  rT|j'                  |||      S |t*        jD                  u r|jF                  jI                  |      |
z   S |S c c}w c c}w # t.        $ r |cY S w xY w# t:        $ r t*        j<                  }Y w xY w)Nr   )r   Symbolr   )log)	Piecewisepiecewise_foldr	   )
expand_mulc              3  6   K   | ]  }t        |        y wrG   )rn   )r   r?   r  s     r!   r"   z,Add._eval_as_leading_term.<locals>.<genexpr>  s     5az!S!5s   TF)	r_   r  mul	power_exp
power_basemultinomialbasicforcefactor)r   r   r   r   rR   rB   )%sympy.core.symbolr   r  r  r   &sympy.functions.elementary.exponentialr  $sympy.functions.elementary.piecewiser  r  r   r  r  r  r   rj   r$   expandr6   as_leading_termr   r   r4   	TypeErrorsubsri   trigsimpcancelgetnNotImplementedErrorrv   rh   r   powsimprk   r   r<   )rL   r   r   r   r   r  r   r  r  r  r\   r   logflagsr(   ra   ro  _logxleading_termsminnew_exprr
  orderri   n0resincrr  s                             @r!   _eval_as_leading_termzAdd._eval_as_leading_term  s   3,>R(IIK9aAlln779 %C 549955 $T%e#EETY!H #**(x(C#{{''4'@@#yy:!AMMA::!%f4NRiiX**15t*DXXa!&&X
	% %dAe3.C#HE\$H% <}}UCF3H""?((*113H&&Gd?XXZ vvf~UU(C55D,,''RW4d'KRRT\\^ggi	 ,, &&qt$&??88&&x0144 O] ; Y  	K	 ' UUs<   J-+J-J2J7 J7 >K 7KKK%$K%c                v     | j                   | j                  D cg c]  }|j                          c} S c c}w rG   )r   r$   adjointrL   ra   s     r!   _eval_adjointzAdd._eval_adjoint>  s+    tyy		:1199;:;;:   6c                v     | j                   | j                  D cg c]  }|j                          c} S c c}w rG   )r   r$   	conjugater  s     r!   _eval_conjugatezAdd._eval_conjugateA  +    tyy$))<Q1;;=<==<r  c                v     | j                   | j                  D cg c]  }|j                          c} S c c}w rG   )r   r$   	transposer  s     r!   _eval_transposezAdd._eval_transposeD  r  r  c                   g }d}| j                   D ]q  }|j                         \  }}|j                  st        j                  }|}|xs |t        j
                  u }|j                  |j                  |j                  |f       s |sEt        t        |D cg c]  }|d   	 c}d      }t        t        |D cg c]  }|d   	 c}d      }nPt        t        |D cg c]  }|d   s	|d    c}d      }t        t        |D cg c]  }|d   s	|d    c}d      }||cxk(  rdk(  rn nt        j                  | fS |s9t        |      D ]*  \  }	\  }
}}t        t        |
|z  ||z  z        |      ||	<   , nTt        |      D ]F  \  }	\  }
}}|r"t        t        |
|z  ||z  z        |      ||	<   .t        t        |
|      |      ||	<   H |d   j                  s|d   t        j
                  u r|j!                  d      }nd}t#        |       |r|j%                  d|       t        ||       | j&                  | fS c c}w c c}w c c}w c c}w )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

        Fr   r	   N)r$   rq   re   r   rv   rl   r9   r   r   r   r   r   	enumerater   Rationalr8   r5   r1   r:   rx   )rL   r   r   r?   r   mra   ngcddlcmr    r   r   r
  s                r!   r   zAdd.primitiveG  s1   F  	(A>>#DAq==EE/a///CLL!##qssA'	( $u 5!1 5q9D$u 5!1 5q9D$u =!!1 =qAD$u =!!1 =qAD4155$;#,U#3 L<Aq$&xD470C'DdKaL $-U#3 A<Aq$*8QWtQw4G+H$OE!H*8Aq>4@E!H	A 8qQ->->!>		!AALLAd#%6T%6%6%>>>A !6 5 = =s$   H=
7I

I
%I

I
I
c                H    | j                   | j                  D cg c]  }t        |j                  ||        c} j	                         \  }}|sT|j
                  sH|j                  r<|j                         \  }}||z  }t        d |j                  D              r|}n||z  }|r|j                  r|j                  }g }	d}
|D ]  }t        t              }t        j                  |      D ]y  }|j                  s|j                         \  }}|j                  s0|j
                  s=||j                      j#                  t%        t'        |            |j(                  z         { |s ||fS |
t+        |j-                               }
n#|
t+        |j-                               z  }
|
s ||fS |	j#                  |        |	D ]K  }t        |j-                               D ]  }||
vs|j/                  |        |D ]  }t        ||    ||<    M g }|
D ]H  }t1        t2        |	D cg c]  }||   	 c}d      }|dk7  s+|j#                  |t5        d|      z         J |r,t        | }|D cg c]  }||z  	 }}| |j                   | z  }||fS c c}w c c}w c c}w )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.
        )radicalclearc              3  V   K   | ]!  }|j                         d    j                   # yw)r   N)rq   rt   r  s     r!   r"   z+Add.as_content_primitive.<locals>.<genexpr>  s"     Ca1>>#A&11Cs   ')Nr   r	   )r   r$   r   as_content_primitiver   rt   r6   r   rj   r   r3   ry   r  rr   rs   re   r   r9   r   intr   rg  keysr5   r   r   r  )rL   r  r  r?   conprimr  _pr$   radscommon_qr  	term_radsrH  r   r   r   r   Ggs                       r!   r  zAdd.as_content_primitive  s   ( DII48II ?/0 !,Q-C-C5 .D .* !+  ? @@I	 	TS^^'')FCaBC277CCqt{{99DDH ".'-	--* DByy!~~/1==Q\\%accN11#c!f+qss2BC	D
 !8 Dy7 #"9>>#34H'#inn.>*??H#, Dy+ I&".&  *A!!&&(^ %H,EE!H%  *"AaDz!*	* ! 4AtD%9qad%91=AAvHQN!234 QA+/0RBqD0D0YTYY--DDye ?T &:
 1s    J)J1Jc                N    ddl m} t        t        | j                  |            S )Nr	   )default_sort_keyr.   )sortingr  r   sortedr$   )rL   r  s     r!   _sorted_argszAdd._sorted_args  s    -VDII+;<==r,   c           
     v    ddl m}  | j                  | j                  D cg c]  } ||||       c} S c c}w )Nr   )difference_delta)sympy.series.limitseqr  r   r$   )rL   r   stepddr?   s        r!   _eval_difference_deltazAdd._eval_difference_delta  s0    @tyy499=a2aD>=>>=s   6c                    ddl m} | j                         \  }}|j                         \  }}|t        j
                  k(  st        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)numbersr  r   rq   r   r   AttributeError_mpf_)rL   r  r  restr  	imag_units         r!   _mpc_z	Add._mpc_  se    
 	#))+!..0AOO+ !!cddg$$eGn&:&:;;r,   c                t    t         j                  st        |          S t	        t
        j                  |       S rG   )r   
distributerd  __neg__ry   r   NegativeOne)rL   rp  s    r!   r  zAdd.__neg__  s*     ++7?$$1==$''r,   )r$   zExpr | complexrE   r&   returnr   )r  ztuple[Expr, ...])r   z
list[Expr]r  z#tuple[list[Expr], list[Expr], None])FN)r  ztuple[Number, Expr])r   rC  )r  ztuple[Expr, Expr]rG   )T)FT)Fr   
__module____qualname____doc__	__slots__r6   r   
_args_type__annotations__r   rI   propertyr$   classmethodr   r   r   r   r   r   r   r   r   r   r   r   staticmethodr   r   r   r  r  r  r  _eval_is_real_eval_is_extended_real_eval_is_complex_eval_is_antihermitian_eval_is_finite_eval_is_hermitian_eval_is_integer_eval_is_rational_eval_is_algebraic_eval_is_commutativerA  rI  rN  rS  rY  r_  re  rv  ry  r{  r  r  r  r  r  r  r  r  r  r   r  r  r  r  r  __classcell__)rp  s   @r!   r;   r;   ]   s   Tl IFJ?C 	 
	 
	 P$ P$d " " 
 
/ ! !,#)J : :!? , ,2 ? ?&-:^IP-M9MB<B;O><=>-8'R5 4l((4l#FJ(,
 # #J:.IV<>>N?`FP > >? < <( (r,   r;   rh  )ry   r   r   )r  N)3
__future__r   typingr   r   collectionsr   	functoolsr   operatorr   r  r
   
parametersr   logicr   r   r   	singletonr   
operationsr   r   cacher   intfuncr   r   r(   r   r   r   sympy.utilities.iterablesr   r   sympy.core.numbersr   r  r   r+   r1   r@   r;   rh  r  ry   r   r   r  r  rB   r,   r!   <module>r      sv    " * #     ) 4 4  2     7 )(6 !
-#`^($ ^(@%  3 3 r,   