
    \h                    P   S SK Jr  S SKJrJr  S SKJr  S SKJr  S SK	J
r
  SSKJr  SSKJr  SS	KJrJrJr  SS
KJr  SSKJrJr  SSKJr  SSKJrJr  SSKJr  SSKJ r   S SK!J"r"J#r#  \(       a  S SK$J%r%  S SK&J'r'  S r(S r)S r* " S S\\5      r+\" S5      r,SSK-J.r.J/r/J0r0  SSK1J2r2  g)    )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                    [        S U R                   5       5      n[        U R                  5      U-
  nX!:  a  gX!:  a  g[        U R	                  5       U * R	                  5       :  5      $ )Nc              3  T   #    U  H  nUR                  5       (       d  M  S v   M      g7f)r	   N)could_extract_minus_sign).0is     F/var/www/auris/envauris/lib/python3.13/site-packages/sympy/core/add.py	<genexpr>,_could_extract_minus_sign.<locals>.<genexpr>   s#      )9a%%' 9s   (	(FT)sumargslenboolsort_key)exprnegative_argspositive_argss      r!   _could_extract_minus_signr,      se      )499 ) )M		N]2M$		& D5"2"2"4455    c                *    U R                  [        S9  g )Nkey)sortr
   )r%   s    r!   _addsortr2   (   s    II-I r-   c                    [        U 5      n / n[        R                  nU (       am  U R                  5       nUR                  (       a  U R                  UR                  5        O'UR                  (       a  X#-  nOUR                  U5        U (       a  Mm  [        U5        U(       a  UR                  SU5        [        R                  U5      $ )aA  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appendr2   insertAdd
_from_args)r%   newargscoas       r!   _unevaluated_AddrA   -   s    : :DG	
B
HHJ88 KK[[GBNN1 $ W	q">>'""r-   c                  D  ^  \ rS rSr% SrSrSr\rS\	S'   \
(       a  SS.S?S jjr\S@S	 j5       r\SAS
 j5       r\S 5       r\S 5       rS r\S 5       rSBSCS jjrS r\S 5       rSDS jrS rSES jr\S 5       r\S 5       rSFS jrS rS r S r!S r"S r#S r$S r%S r&S  r'S! r(S" r)S# r*S$ r+S% r,S& r-S' r.S( r/S) r0S* r1S+ r2U 4S, jr3S- r4S. r5U 4S/ jr6S0 r7S1 r8S2 r9\SGS3 j5       r:SHS4 jr;S5 r<S6 r=S7 r>S8 r?S9 r@SIS: jrA\S; 5       rBS< rC\S= 5       rDU 4S> jrESrFU =rG$ )Jr<   ]   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                   g NrD   )clsrG   r%   s      r!   __new__Add.__new__   s    r-   c                    g rI   rD   selfs    r!   r%   Add.args   s    r-   c           	     J  ^^ SSK Jn  SSKJn  SSKJnJn  Sn[        U5      S:X  aj  Uu  pxUR                  (       a  XpUR                  (       a  UR                  (       a  Xx// S4nU(       a$  [        S US    5       5      (       a  U$ / US   S4$ 0 n	[        R                  n
/ n/ nU GHL  mTR                  (       ak  TR                  R                  (       a  M2  [!        U4S jU 5       5      (       a  MN  U Vs/ s H  nTR#                  U5      (       a  M  UPM     nnT/U-   nM  TR$                  (       a  T[        R&                  L d"  U
[        R(                  L a,  TR*                  S	L a  U(       d  [        R&                  // S4s  $ U
R$                  (       d  [-        X5      (       a5  U
T-  n
U
[        R&                  L a  U(       d  [        R&                  // S4s  $ GM<  [-        TU5      (       a  TR/                  U
5      n
GMa  [-        TU5      (       a  UR1                  T5        GM  [-        TU5      (       a  U" TU
5      R3                  S	S
9n
GM  T[        R(                  L a?  U
R*                  S	L a  U(       d  [        R&                  // S4s  $ [        R(                  n
GM  TR4                  (       a   TR6                  nUR9                  U5        GM3  TR                  (       a  TR;                  5       u  nnOTR<                  (       a  TR?                  5       u  nnUR$                  (       aJ  UR@                  (       d"  UR                  (       a(  URB                  (       a  UR1                  UU-  5        GM  [        RD                  TnnO[        RD                  nTnUU	;   aF  U	U==   U-  ss'   U	U   [        R&                  L a   U(       d  [        R&                  // S4s  $ GME  GMH  XU'   GMO     / nS	nU	RG                  5        H  u  nnUR                  (       a  M  U[        RD                  L a  UR1                  U5        OUR                  (       a/  URH                  " U4UR6                  -   6 nUR1                  U5        OGUR4                  (       a  UR1                  [K        UUS	S95        OUR1                  [K        UU5      5        U=(       d    URL                  (       + nM     U
[        RN                  L a9  U Vs/ s H+  nURP                  (       a  M  URR                  (       a  M)  UPM-     nnOKU
[        RT                  L a8  U Vs/ s H+  nURV                  (       a  M  URR                  (       a  M)  UPM-     nnU
[        R(                  L a1  U Vs/ s H$  oR*                  (       a  URX                  b  M"  UPM&     nnU(       an  / nU H0  m[!        U4S jU 5       5      (       a  M  UR1                  T5        M2     UU-   nU H+  mTR#                  U
5      (       d  M  [        R                  n
  O   [[        U5        U
[        R                  La  UR]                  SU
5        U(       a  UU-  nSnU(       a  / US4$ U/ S4$ s  snf s  snf s  snf s  snf )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  8   #    U  H  oR                   v   M     g 7frI   is_commutative)r   ss     r!   r"   Add.flatten.<locals>.<genexpr>   s     7A''   c              3  D   >#    U  H  oR                  T5      v   M     g 7frI   contains)r   o1os     r!   r"   r[      s     >"{{1~~    FdeeprF   c              3  D   >#    U  H  oR                  T5      v   M     g 7frI   r^   )r   ra   ts     r!   r"   r[   ~  s     @-Q::a==-rb   T)/!sympy.calculus.accumulationboundsrR   sympy.matrices.expressionsrS   sympy.tensor.tensorrT   rU   r&   is_Rationalis_Mulallr   r5   is_Orderr)   is_zeroanyr_   r9   NaNComplexInfinity	is_finite
isinstance__add__r:   doitr7   r%   r8   as_coeff_Mulis_Powas_base_exp
is_Integeris_negativeOneitems_new_rawargsMulrY   Infinityis_extended_nonnegativeis_realNegativeInfinityis_extended_nonpositiveis_extended_realr2   r;   )rJ   seqrR   rS   rT   rU   rvr@   btermscoefforder_factorsextrar`   o_argscrZ   enewseqnoncommutativecsfnewseq2ra   rf   s                          @@r!   flattenAdd.flatten   s)   $ 	B99s8q=DA}}1}}88T)B7A777I2a5$& %' ff%'"$A zz66>>>>>>.; Rm1::b>m R!"m 3 J%1+<+<"<u,eEE7B,,??j&D&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1 EE EzaA8quu$UEE7B,, .3$ ag n KKMDAqyyaeea  88 1$-9BMM"%XXMM#aU";< MM#a),+C13C3C/CN1 "6 AJJ!'XA0I0IaQYYaFXFa(((!'XA0I0IaQYYaFXA%%% "( QA010B0B F Q G@-@@@NN1%  },F"::e$$FFE # 	 MM!U#eOF!N vt##2t##w !SZ Y YQs<   <ZZ	Z"Z5ZZ.ZZ !Z Z c                     SSU R                   4$ )N   r	   )__name__)rJ   s    r!   	class_keyAdd.class_key  s    !S\\!!r-   c                    [        S5      n[        XR                  5      n[        U5      n[	        U5      S:w  a  [
        nU$ Uu  nU$ )Nkindr	   )r   mapr%   	frozensetr&   r   )rO   kkindsresults       r!   r   Add.kind  sK    vAyy!% u:? #F  GFr-   c                    [        U 5      $ rI   )r,   rN   s    r!   r   Add.could_extract_minus_sign  s    (..r-   c                >  ^ T(       a5  [        U R                  U4S jSS9u  p#U R                  " U6 [        U5      4$ U R                  S   R	                  5       u  pEU[
        R                  La  XEU R                  SS -   4$ [
        R                  U R                  4$ )a  
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                "   > U R                   " T6 $ rI   )has_free)xdepss    r!   <lambda>"Add.as_coeff_add.<locals>.<lambda>  s    qzz4/@r-   T)binaryr   r	   N)r   r%   r}   tupleas_coeff_addr   r5   )rO   r   l1l2r   notrats    `    r!   r   Add.as_coeff_add  s     $))%@NFB$$b)5944		!113499QR=000vvtyy  r-   c                    U R                   S   U R                   SS pCUR                  (       a  U(       a  UR                  (       a  X0R                  " U6 4$ [        R
                  U 4$ )z5
Efficiently extract the coefficient of a summation.
r   r	   N)r%   r9   rj   r}   r   r5   )rO   rationalr   r   r%   s        r!   as_coeff_AddAdd.as_coeff_Add  sP     iilDIIabMt??8u/@/@++T222vvt|r-   c                   SSK Jn  SSKJn  [	        U R
                  5      S:X  Ga	  [        S U R
                   5       5      (       a  UR                  SL a  U" U[        R                  5      SL a  U R
                  u  pEUR                  [        R                  5      (       a  XTpTUR                  [        R                  5      nU(       ad  UR                  (       aS  UR                  (       aB  UR                  (       a  [        R                  $ UR                  (       a  [        R                   $ g UR"                  (       Ga  U R$                  (       a  U" U 5      nU(       a  Uu  pUR&                  S:X  a  SSKJn
  U
" US-  U	S-  -   5      nUR"                  (       aq  SS	KJn  SS
KJn  SSKJn  U
" U" X-
  S-  5      5      UR8                  -  nX" X-   [;        U	5      -  U" U	5      [        R                  -  -   UR8                  -  5      -  $ g US:X  a+  [=        X[        R                  -  -
  SUS-  U	S-  -   -  5      $ g g g g )Nr	   )pure_complex)is_eqrV   c              3  8   #    U  H  oR                   v   M     g 7frI   )is_infinite)r   _s     r!   r"   "Add._eval_power.<locals>.<genexpr>  s     &Hi}}ir\   Fr   )sqrt)factor_terms)sign)expand_multinomial)evalfr   
relationalr   r&   r%   ro   rn   r   r{   r   ImaginaryUnitr   is_extended_negativer5   is_extended_positiverq   rj   	is_numberq(sympy.functions.elementary.miscellaneousr   	exprtoolsr   $sympy.functions.elementary.complexesr   functionr   pabs_unevaluated_Mul)rO   exptr   r   r@   r   icorirr    r   Dr   r   r   roots                   r!   _eval_powerAdd._eval_power  s   '%tyy>Q3&Hdii&H#H#H||u$tQUU);u)Dyy771??++qggaoo.3//A4F4F00 vv00 000d#B66Q;MQTAqD[)A}};M@#L!%$;<dffD#$6UCFNT!WQ__-DDtvv8N %O  O O % RZ+aoo--1a4!Q$;) )    !/r-   c                |    U R                   " U R                   Vs/ s H  o"R                  U5      PM     sn6 $ s  snf rI   )funcr%   diff)rO   rZ   r@   s      r!   _eval_derivativeAdd._eval_derivative  s-    yydii8i66!9i8998s   9c           
     |    U R                    Vs/ s H  oUR                  XX4S9PM     nnU R                  " U6 $ s  snf )Nnlogxcdir)r%   nseriesr   )rO   r   r   r   r   rf   r   s          r!   _eval_nseriesAdd._eval_nseries  s:    BF))L)Q18)Lyy%   Ms   9c                t    U R                  5       u  p4[        U5      S:X  a  US   R                  X-
  U5      $ g )Nr	   r   )r   r&   matches)rO   r)   	repl_dictr   r   s        r!   _matches_simpleAdd._matches_simple  s9    ((*u:?8##DL)<<r-   c                &    U R                  XU5      $ rI   )_matches_commutative)rO   r)   r   olds       r!   r   Add.matches  s    ((#>>r-   c                \  ^ SSK Jn  [        R                  [        R                  4nU R
                  " U6 (       d  UR
                  " U6 (       a  SSKJn  U" S5      m[        R                  T[        R                  T* 0nUR                  5        VVs0 s H  u  pgXv_M	     nnnU R                  U5      UR                  U5      -
  n	U	R                  T5      (       a  U	R                  U4S jS 5      n	U	R                  U5      n
OX-
  n
U" U
5      nUR                  (       a  U$ U
$ s  snnf )zX
Returns lhs - rhs, but treats oo like a symbol so oo - oo
returns 0, instead of a nan.
r   )signsimpr	   )Dummyooc                F   > U R                   =(       a    U R                  TL $ rI   )rw   base)r   r   s    r!   r   &Add._combine_inverse.<locals>.<lambda>  s    ahh7166R<7r-   c                    U R                   $ rI   )r   )r   s    r!   r   r     s    affr-   )sympy.simplify.simplifyr   r   r   r   hassymbolr   r|   xreplacereplacer9   )lhsrhsr   infr   repsr   virepseqr   srvr   s               @r!   _combine_inverseAdd._combine_inverse  s     	5zz1--.77C=CGGSM%tB

B""RC)D '+jjl3ldaQTlE3d#cll4&88BvvbzzZZ7$& U#BBrlmms++ 4s   D(c                X    U R                   S   U R                  " U R                   SS 6 4$ )a  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}   rN   s    r!   as_two_termsAdd.as_two_terms"  s,    $ yy|T..		!">>>r-   c                   U R                  5       u  p[        U[        5      (       d  [        XSS9R	                  5       $ UR	                  5       u  p4[        [        5      nUR                   H(  nUR	                  5       u  pxXX   R                  U5        M*     [        U5      S:X  aF  UR                  5       u  pU R                  " U
 Vs/ s H  n[        X75      PM     sn6 [        XI5      4$ UR                  5        V	V
s0 s H)  u  pU	[        U
5      S:  a  U R                  " U
6 OU
S   _M+     nn	n
[        [        UR                  5       5      6  Vs/ s H  n[        U5      PM     snu  pU R                  " [!        [        U5      5       Vs/ s H  n[        USU X   /-   XS-   S -   6 PM     sn6 [        U6 p[        X:5      [        XI5      4$ s  snf s  sn
n	f s  snf s  snf )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	   r   N)	primitivers   r<   r~   as_numer_denomr   r4   r%   r:   r&   popitemr   _keep_coeffr|   zipiterrange)rO   contentr)   ncondconndr   nididr   nd2r    denomsnumerss                  r!   r  Add.as_numer_denom6  s   ( ($$$wu5DDFF++-
 A%%'FBFMM" 
 r7a<::<DA99234!B+d'!467B47KL L EGHHJOJDAq3q6A:$))Q-1Q47JO ,/SYY[0A+BC+Ba$q'+BCyy!#f+.0.q vyk!9Fq56N!JL.0 125v,  4#[%999 5 P D0s   
G0GG #G%c                B   ^ [        U4S jU R                   5       5      $ )Nc              3  D   >#    U  H  oR                  T5      v   M     g 7frI   )_eval_is_polynomialr   termsymss     r!   r"   *Add._eval_is_polynomial.<locals>.<genexpr>f  s     Hid++D11irb   rl   r%   rO   r!  s    `r!   r  Add._eval_is_polynomiale  s    HdiiHHHr-   c                B   ^ [        U4S jU R                   5       5      $ )Nc              3  D   >#    U  H  oR                  T5      v   M     g 7frI   )_eval_is_rational_functionr  s     r!   r"   1Add._eval_is_rational_function.<locals>.<genexpr>i  s     OYT22488Yrb   r#  r$  s    `r!   r(  Add._eval_is_rational_functionh  s    OTYYOOOr-   c                D   ^^ [        UU4S jU R                   5       SS9$ )Nc              3  F   >#    U  H  oR                  TT5      v   M     g 7frI   )is_meromorphic)r   argr@   r   s     r!   r"   +Add._eval_is_meromorphic.<locals>.<genexpr>l  s     K#//155s   !T
quick_exitr   r%   )rO   r   r@   s    ``r!   _eval_is_meromorphicAdd._eval_is_meromorphick  s    KK'+- 	-r-   c                B   ^ [        U4S jU R                   5       5      $ )Nc              3  D   >#    U  H  oR                  T5      v   M     g 7frI   )_eval_is_algebraic_exprr  s     r!   r"   .Add._eval_is_algebraic_expr.<locals>.<genexpr>p  s     L)$//55)rb   r#  r$  s    `r!   r7  Add._eval_is_algebraic_expro  s    L$))LLLr-   c                8    [        S U R                   5       SS9$ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   )r   r   r@   s     r!   r"   Add.<lambda>.<locals>.<genexpr>t  s     &IqIr\   Tr0  r2  rN   s    r!   r   Add.<lambda>s  s    &DII&4"9r-   c                8    [        S U R                   5       SS9$ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   )r   r<  s     r!   r"   r=  v       /Y		Yr\   Tr0  r2  rN   s    r!   r   r>  u      ,/TYY/D+Br-   c                8    [        S U R                   5       SS9$ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   )
is_complexr<  s     r!   r"   r=  x       )y!yr\   Tr0  r2  rN   s    r!   r   r>  w      L)tyy)d%<r-   c                8    [        S U R                   5       SS9$ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   )is_antihermitianr<  s     r!   r"   r=  z  rA  r\   Tr0  r2  rN   s    r!   r   r>  y  rB  r-   c                8    [        S U R                   5       SS9$ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   )rr   r<  s     r!   r"   r=  |  s     (iir\   Tr0  r2  rN   s    r!   r   r>  {  s    <(dii(T$;r-   c                8    [        S U R                   5       SS9$ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   )is_hermitianr<  s     r!   r"   r=  ~       +Ar\   Tr0  r2  rN   s    r!   r   r>  }      l++'>r-   c                8    [        S U R                   5       SS9$ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   )
is_integerr<  s     r!   r"   r=    rF  r\   Tr0  r2  rN   s    r!   r   r>    rG  r-   c                8    [        S U R                   5       SS9$ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   is_rationalr<  s     r!   r"   r=    s     *	1	r\   Tr0  r2  rN   s    r!   r   r>    s    \*		*t&=r-   c                8    [        S U R                   5       SS9$ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   )is_algebraicr<  s     r!   r"   r=    rP  r\   Tr0  r2  rN   s    r!   r   r>    rQ  r-   c                :    [        S U R                   5       5      $ )Nc              3  8   #    U  H  oR                   v   M     g 7frI   rX   r<  s     r!   r"   r=    s      5-"+Q)r\   r2  rN   s    r!   r   r>    s     5-"&))5- )-r-   c                r    SnU R                    H$  nUR                  nUc    g USL d  M  USL a    g SnM&     U$ )NFT)r%   r   )rO   sawinfr@   ainfs       r!   _eval_is_infiniteAdd._eval_is_infinite  sC    A==D|T>  r-   c                   / n/ nU R                    GH  nUR                  (       a7  UR                  (       a  M(  UR                  SL a  UR                  U5        MJ    g UR                  (       a$  UR                  U[
        R                  -  5        M  UR                  (       a|  [
        R                  UR                   ;   a^  UR                  [
        R                  5      u  pEU[
        R                  4:X  a&  UR                  (       a  UR                  U* 5        GM    g   g    U R                  " U6 nX`:w  aD  UR                  (       a"  [        U R                  " U6 R                  5      $ UR                  SL a  gg g NF)r%   r   rn   r:   is_imaginaryr   r   rk   as_coeff_mulr   r   )rO   nzim_Ir@   r   air   s          r!   _eval_is_imaginaryAdd._eval_is_imaginary  s   A!!99YY%'IIaLAaoo-.aoo7NN1??;	!//++0F0FKK'# $ IIrN9yy D!1!9!9::e# $ r-   c                $   U R                   SL a  g / nSnSnSnU R                   H  nUR                  (       a<  UR                  (       a  US-  nM,  UR                  SL a  UR	                  U5        MN    g UR
                  (       a  US-  nMh  UR                  (       ak  [        R                  UR                  ;   aM  UR                  [        R                  5      u  pgU[        R                  4:X  a  UR                  (       a  SnM    g   g    U[        U R                  5      :X  a  g[        U5      S[        U R                  5      4;   a  g U R                  " U6 nUR                  (       a  U(       d  US:X  a  gUS:X  a  gUR                  SL a  gg )NFr   r	   T)rY   r%   r   rn   r:   re  rk   r   r   rf  r&   r   )	rO   rg  zim_or_zimr@   r   ri  r   s	            r!   _eval_is_zeroAdd._eval_is_zero  s6   %' A!!99FAYY%'IIaLaaoo7NN1??;	!//++0F0F"G# $ DIIr7q#dii.))IIrN9971W 99 r-   c                    U R                    Vs/ s H  oR                  SLd  M  UPM     nnU(       d  gUS   R                  (       a  U R                  " USS  6 R                  $ g s  snf )NTFr   r	   )r%   is_evenis_oddr}   )rO   r   ls      r!   _eval_is_oddAdd._eval_is_odd  s[    		=	1))t*;Q	=Q4;;$$ae,444  >s
   A&A&c                    U R                    H\  nUR                  nU(       aA  [        U R                   5      nUR                  U5        [	        S U 5       5      (       a    g  g Ub  M\    g    g)Nc              3  <   #    U  H  oR                   S L v   M     g7f)TNrW  )r   r   s     r!   r"   *Add._eval_is_irrational.<locals>.<genexpr>  s     =f}},fs   TF)r%   is_irrationalr4   removerl   )rO   rf   r@   otherss       r!   _eval_is_irrationalAdd._eval_is_irrational  sY    AAdiia =f===y  r-   c                    S=pU R                    H?  nUR                  (       a  U(       a    gSnM!  UR                  (       a  U(       a    gSnM?    g    g)Nr   Fr	   T)r%   is_nonnegativeis_nonpositive)rO   nnnpr@   s       r!   _all_nonneg_or_nonpposAdd._all_nonneg_or_nonppos  sG    A !!   r-   c                  > U R                   (       a  [        TU ]	  5       $ U R                  5       u  pUR                  (       dx  SSKJn  U" U5      nUbg  XA-   nXP:w  a#  UR                  (       a  UR                  (       a  g[        U R                  5      S:X  a"  U" U 5      nUb  X@:w  a  UR                  (       a  gS=n=n=p[        5       n
U R                   Vs/ s H  o"R                  (       a  M  UPM     nnU(       d  gU H  nUR                  nUR                  nU(       a3  U
R                  [        XR                  45      5        SU
;   a  SU
;   a    g U(       a  SnM`  UR                  (       a  SnMu  UR                   (       a  SnM  Uc    g Sn	M     U
(       a   [        U
5      S:  a  g U
R#                  5       $ U	(       a  g U(       d  U(       d  U(       a  gU(       d  U(       a  gU(       d	  U(       d  gg g s  snf Nr	   _monotonic_signTF)r   super_eval_is_extended_positiver   rn   r   r  r   r   r&   free_symbolssetr%   r   addr   r   r6   )rO   r   r@   r  r   rZ   posnonnegnonposunknown_signsaw_INFr%   isposinfinite	__class__s                 r!   r  Add._eval_is_extended_positive     >>7577  "yy2"A}E9!7!7A<U<Ut(()Q.'-A}q7M7M#/444f4v%9969aII96A**E}}HHe-F-F%GHI7?u'7****L' * 7|a;;= 3CV $E 7   G?3G?c                j   U R                   (       d  U R                  5       u  pUR                  (       d~  UR                  (       al  SSKJn  U" U5      nUbZ  XA-   nXP:w  a  UR                  (       a  g[        U R                  5      S:X  a%  U" U 5      nUb  X@:w  a  UR                  (       a  gg g g g g g g g Nr	   r  T)r   r   rn   r   r   r  r&   r  rO   r   r@   r  r   rZ   s         r!   _eval_is_extended_nonnegative!Add._eval_is_extended_nonnegative4      ~~$$&DA99!:!:6#A&=AyQ%>%>#4,,-2+D1=QY1;T;T#' <UY= 3	 ! ";9 r-   c                j   U R                   (       d  U R                  5       u  pUR                  (       d~  UR                  (       al  SSKJn  U" U5      nUbZ  XA-   nXP:w  a  UR                  (       a  g[        U R                  5      S:X  a%  U" U 5      nUb  X@:w  a  UR                  (       a  gg g g g g g g g r  )r   r   rn   r   r   r  r&   r  r  s         r!   _eval_is_extended_nonpositive!Add._eval_is_extended_nonpositiveC  r  r-   c                  > U R                   (       a  [        TU ]	  5       $ U R                  5       u  pUR                  (       dx  SSKJn  U" U5      nUbg  XA-   nXP:w  a#  UR                  (       a  UR                  (       a  g[        U R                  5      S:X  a"  U" U 5      nUb  X@:w  a  UR                  (       a  gS=n=n=p[        5       n
U R                   Vs/ s H  o"R                  (       a  M  UPM     nnU(       d  gU H  nUR                  nUR                  nU(       a3  U
R                  [        XR                  45      5        SU
;   a  SU
;   a    g U(       a  SnM`  UR                  (       a  SnMu  UR                   (       a  SnM  Uc    g Sn	M     U
(       a   [        U
5      S:  a  g U
R#                  5       $ U	(       a  g U(       d  U(       d  U(       a  gU(       d  U(       a  gU(       d	  U(       d  gg g s  snf r  )r   r  _eval_is_extended_negativer   rn   r   r  r   r   r&   r  r  r%   r   r  r   r   r6   )rO   r   r@   r  r   rZ   negr  r  r  r  r%   isnegr  r  s                 r!   r  Add._eval_is_extended_negativeR  r  r  c           
        UR                   (       d:  U[        R                  L a&  U* U R                  ;   a  U R	                  U* U* 05      $ g U R                  5       u  p4UR                  5       u  pVUR                  (       aB  UR                  (       a1  XF:X  a  U R                  X#U* 5      $ XF* :X  a  U R                  U* X55      $ UR                  (       a  UR                  (       d  X5:X  Ga  U R                  R                  U5      U R                  R                  U5      p[        U5      [        U5      :  a  [        U5      n	[        U5      n
X:  a8  X-
  nU R                  " X#U* /U Vs/ s H  oR                  X5      PM     snQ76 $ U R                  R                  U* 5      n[        U5      n
X:  a8  X-
  nU R                  " U* X5/U Vs/ s H  oR                  X5      PM     snQ76 $ g g g s  snf s  snf rI   )r7   r   r   r%   r   r   rj   r   	make_argsr&   r  _subs)rO   r   new
coeff_self
terms_self	coeff_old	terms_oldargs_old	args_selfself_setold_setret_setrZ   s                r!   
_eval_subsAdd._eval_subs  s   zzajj cTTYY%6}}sdSD\22!%!2!2!4
"//1	!!i&;&;&yy9*==Z'yy#z==!!i&;&;*"&))"5"5# II//
;  8}s9~-y>h-%&0G99Syj F<C DGq!2G DF F  99..J h-%&0G99cT: F<C DGq!2G DF F & . + !E !Es   +G2
G7
c                    U R                    Vs/ s H  oR                  (       a  M  UPM     nnU R                  " U6 $ s  snf rI   r%   rm   r}   rO   r@   r%   s      r!   removeOAdd.removeO  s4    9979aJJ97  $'' 8s   >>c                    U R                    Vs/ s H  oR                  (       d  M  UPM     nnU(       a  U R                  " U6 $ g s  snf rI   r  r  s      r!   getOAdd.getO  s<    9939a

93$$d++  4s
   AAc                   SSK Jn  / n[        [        U5      (       a  UOU/5      nU(       d  S/[	        U5      -  nU R
                   Vs/ s H  oUU" U/[        X5      Q76 4PM     nnU Hv  u  pxU H&  u  pU
R                  U5      (       d  M  X:w  d  M$  Sn  O   Uc  M6  Xx4/nU H4  u  pUR                  U
5      (       a  X:w  a  M"  UR                  X45        M6     UnMx     [        U5      $ s  snf )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   r4   r   r&   r%   r  r_   r:   r   )rO   symbolspointr   lstr   r   efofr   ra   new_lsts               r!   extract_leading_orderAdd.extract_leading_order  s    " 	-+g"6"6wWIFCG$E<@IIFIq51S012IFFB::b>>agB  zxjG;;q>>agv&  C  Sz Gs   C1c                    U R                   n/ / pTU H6  nUR                  US9u  pxUR                  U5        UR                  U5        M8     U R                  " U6 U R                  " U6 4$ )z
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)
rc   )r%   as_real_imagr:   r   )	rO   rd   hintssargsre_partim_partr   rero  s	            r!   r  Add.as_real_imag  sj     		rD&&D&1FBNN2NN2  		7#TYY%899r-   c           
     .  ^ SSK JnJn  SSKJn  SSKJm  SSKJnJ	n  SSK
Jn	  U R                  5       n
U
c  U" S5      n
U R                  5       nUR                  U5      (       a  U" U5      n[        U4S jU R                    5       5      (       a  S	S	S
S
S
S
S
S
S
S.	nUR"                  " S0 UD6nU	" U5      nUR$                  (       d  UR'                  XUS9$ UR                    Vs/ s H  oR(                  (       d  M  UPM     nnUc  U" S5      OUnUR                    Vs/ s H  oR'                  UUUS9PM     nnU" S5      [*        R,                  nn U H,  nU" UU5      nU(       a  UU;  a  UnUnM  UU;   d  M'  UU-  nM.     Uc  UR1                  UT" U5      5      nUR2                  nUc*  UR5                  5       R7                  5       nUR2                  nUS	L a   UR9                  5       nUR                  U5      (       a  [*        R<                  nU" S5      n[*        R<                  nUR>                  (       aV  URA                  UUU-   X#S9R7                  5       RC                  5       R5                  5       nUS-  nUR>                  (       a  MV  UR'                  XUS9$ U[*        RD                  L a  URF                  RI                  U5      U
-   $ U$ s  snf s  snf ! [.         a    Us $ f = f! [:         a    [*        R<                  n GN!f = f)Nr   )r   Symbolr   )log)	Piecewisepiecewise_foldr	   )
expand_mulc              3  <   >#    U  H  n[        UT5      v   M     g 7frI   )rs   )r   r@   r  s     r!   r"   ,Add._eval_as_leading_term.<locals>.<genexpr>  s     59az!S!!9s   TF)	rd   r  mul	power_exp
power_basemultinomialbasicforcefactor)r   r   r   r   rV   rD   )%sympy.core.symbolr   r  r  r   &sympy.functions.elementary.exponentialr  $sympy.functions.elementary.piecewiser  r  r   r  r  r  r   ro   r%   expandr7   as_leading_termr   r   r5   	TypeErrorsubsrn   trigsimpcancelgetnNotImplementedErrorr{   rm   r   powsimprp   r   r=   )rO   r   r   r   r   r  r   r  r  r  ra   r   logflagsr)   rf   r  _logxleading_termsminnew_exprr   orderrn   n0resincrr  s                             @r!   _eval_as_leading_termAdd._eval_as_leading_term  s   3,>R(IIK9aAlln779 %C 5499555 $T%e#EETY!H **(x(C#{{''4'@@#yy:y!MMAy:!%f4NRiiXi**15t*DiXa!&&X
	%dAe3.C#HE\$H & <}}UCF3H""?((*113H&&Gd?XXZ vvf~~UU(C55D,,''RW4'KRRT\\^ggi	 ,,, &&q$&??88&&x0144 O] ; Y  	K	 ' UUs<   &K>K!K%K$ ?	K$ "K6 $K32K36LLc                z    U R                   " U R                   Vs/ s H  oR                  5       PM     sn6 $ s  snf rI   )r   r%   adjointrO   rf   s     r!   _eval_adjointAdd._eval_adjoint>  s+    yy		:	199;	:;;:   8c                z    U R                   " U R                   Vs/ s H  oR                  5       PM     sn6 $ s  snf rI   )r   r%   	conjugater  s     r!   _eval_conjugateAdd._eval_conjugateA  +    yy$))<)Q;;=)<==<r  c                z    U R                   " U R                   Vs/ s H  oR                  5       PM     sn6 $ s  snf rI   )r   r%   	transposer  s     r!   _eval_transposeAdd._eval_transposeD  r  r  c                
   / nSnU R                    H{  nUR                  5       u  pEUR                  (       d  [        R                  nUnU=(       d    U[        R
                  L nUR                  UR                  UR                  U45        M}     U(       dI  [        [        U Vs/ s H  ofS   PM	     snS5      n[        [        U Vs/ s H  ofS   PM	     snS5      nO`[        [        U Vs/ s H  ofS   (       d  M  US   PM     snS5      n[        [        U Vs/ s H  ofS   (       d  M  US   PM     snS5      nXxs=:X  a  S:X  a  O  O[        R                  U 4$ U(       d7  [        U5       H'  u  n	u  pn[        [        X-  X-  -  5      U5      X'   M)     OV[        U5       HG  u  n	u  pnU(       a   [        [        X-  X-  -  5      U5      X'   M0  [        [        X5      U5      X'   MI     US   R                  (       d  US   [        R
                  L a  UR!                  S5      nOSn[#        U5        U(       a  UR%                  SU5        [        Xx5      U R&                  " U6 4$ s  snf s  snf s  snf s  snf )aw  
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%   rv   rj   r   r{   rq   r:   r   r   r   r   r   	enumerater  Rationalr9   r6   r2   r;   r}   )rO   r   r   r@   r   mrf   ngcddlcmr    r   r   r   s                r!   r
  Add.primitiveG  s   F A>>#DA==EE/a///CLL!##qssA'  $u 5u!1u 5q9D$u 5u!1u 5q9D$u =u!!1u =qAD$u =u!!1u =qAD155$;#,U#3<A$&x470C'DdK $4 $-U#3<A$*8QWtw4G+H$OEH*8A>4@EH	 $4 8qQ->->!>		!AALLA#T%6%6%>>>A !6 5 = =s$   %I1
	I6
.I;
?	I;
J 
/	J 
c                   U R                   " U R                   Vs/ s H  n[        UR                  XS96 PM     sn6 R	                  5       u  pEU(       d`  UR
                  (       dO  UR                  (       a>  UR                  5       u  pFXV-  n[        S UR                   5       5      (       a  UnOXF-  nU(       Ga$  UR                  (       Ga  UR                  n/ n	Sn
U GH  n[        [        5      n[        R                  " U5       H  nUR                  (       d  M  UR                  5       u  pUR                  (       d  M;  UR
                  (       d  MN  XR                      R#                  [%        ['        U5      5      UR(                  -  5        M     U(       d    XE4$ U
c  [+        UR-                  5       5      n
O'U
[+        UR-                  5       5      -  n
U
(       d    XE4$ U	R#                  U5        GM     U	 HS  n[        UR-                  5       5       H  nUU
;  d  M  UR/                  U5        M     U H  n[        UU   6 UU'   M     MU     / nU
 HN  n[1        [2        U	 Vs/ s H  nUU   PM
     snS5      nUS:w  d  M0  UR#                  U[5        SU5      -  5        MP     U(       a.  [        U6 nU Vs/ s H  oU-  PM	     nnUUR                   " U6 -  nXE4$ s  snf s  snf s  snf )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  Z   #    U  H!  oR                  5       S    R                  v   M#     g7f)r   N)rv   ry   r<  s     r!   r"   +Add.as_content_primitive.<locals>.<genexpr>  s      C7a>>#A&117s   )+Nr   r	   )r   r%   r  as_content_primitiver
  ry   r7   r  ro   r   r4   r~   r  rw   rx   rj   r   r:   r   intr   r  keysr6   r   r   r	  )rO   r  r  r@   conprimr  _pr%   radscommon_qr
  	term_radsri  r   r   r   r   Ggs                       r!   r  Add.as_content_primitive  s   ( II48II ?4=q !,Q-C-C .D .* !+4= ? @@I	 	S^^'')FCBC277CCCt{{{99DDH'-	--*Byyy!~~/===Q\\\%ccN11#c!f+qss2BC	 +
 !8 y7 #"9>>#34H'#inn.>*??H#, y+ I& & A!!&&(^H,EE!H , "AaDz! 	  !AtD%9DqadD%91=AAvHQN!23 " QA+/04RqD4D0TYY--Dye ?T &:
 1s   K$+K)?K.c                H    SSK Jn  [        [        U R                  US95      $ )Nr	   )default_sort_keyr/   )sortingr   r   sortedr%   )rO   r   s     r!   _sorted_argsAdd._sorted_args  s    -VDII+;<==r-   c           
     x    SSK Jn  U R                  " U R                   Vs/ s H  oC" XAU5      PM     sn6 $ s  snf )Nr   )difference_delta)sympy.series.limitseqr&  r   r%   )rO   r   stepddr@   s        r!   _eval_difference_deltaAdd._eval_difference_delta  s0    @yy499=9a2aD>9=>>=s   7c                    SSK Jn  U R                  5       u  p#UR                  5       u  pEU[        R
                  :X  d  [        S5      eU" U5      R                  U" U5      R                  4$ )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   rv   r   r   AttributeError_mpf_)rO   r-  r  restr  	imag_units         r!   _mpc_	Add._mpc_  sa    
 	#))+!..0AOO+ !!cddg$$eGn&:&:;;r-   c                ~   > [         R                  (       d  [        TU ]  5       $ [	        [
        R                  U 5      $ rI   )r   
distributer  __neg__r~   r   NegativeOne)rO   r  s    r!   r7  Add.__neg__  s*     ++7?$$1==$''r-   )r%   zExpr | complexrG   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   rd  )r:  ztuple[Expr, Expr]rI   )T)FT)Hr   
__module____qualname____firstlineno____doc__	__slots__r7   r   
_args_type__annotations__r   rK   propertyr%   classmethodr   r   r   r   r   r   r   r   r   r   r   r   staticmethodr  r  r  r  r(  r3  r7  _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  rj  rp  rv  r~  r  r  r  r  r  r  r  r  r  r  r  r  r   r  r
  r  r#  r*  r3  r7  __static_attributes____classcell__)r  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<   r  )r~   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,   r2   rA   r<   r  r  r~   r  r   r.  r	  rD   r-   r!   <module>r^     sv    " * #     ) 4 4  2     7 )(6 !
-#`^($ ^(@%  3 3 r-   