
    Цi                     &   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  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  SSKJrJr  SSKJr  SSKJ r   S SK!J"r"J#r#  S r$S r%S r& " S S\\5      r'\" S5      r(SSK)J*r*J+r+J,r,  SSKJ-r-  g)    )Tuple)defaultdict)reduce)
attrgetter   )_args_sortkey)global_parameters)_fuzzy_groupfuzzy_or	fuzzy_not)S)AssocOpAssocOpDispatcher)cacheit)equal_valued)ilcmigcd)Expr)UndefinedKind)is_sequencesiftc                     [        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     M/var/www/html/ai-image-ml/venv/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   _addsortr/   !   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appendr/   insertAdd
_from_args)r"   newargscoas       r   _unevaluated_Addr>   &   s    : :DG	
B
HHJ88 KK[[GBNN1 $ W	q">>'""r*   c                     ^  \ rS rSr% SrSr\\S4   \S'   Sr	\r
\S 5       r\S 5       r\S	 5       rS
 r\S 5       rS<S jrS r\S 5       rS=S jrS rS>S jr\S 5       r\S 5       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% r-S& r.S' r/S( r0U 4S) jr1S* r2S+ r3U 4S, jr4S- r5S. r6S/ r7\S?S0 j5       r8S@S1 jr9SAS2 jr:S3 r;S4 r<S5 r=S6 r>SBS7 jr?\S8 5       r@S9 rA\S: 5       rBU 4S; jrCSrDU =rE$ )Cr9   V   a  
Expression representing addition operation for algebraic group.

.. deprecated:: 1.7

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

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

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

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

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

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

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

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

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

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

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

Examples
========

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

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

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

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

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

Note that the printers do not display in args order.

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

See Also
========

MatAdd

 .r"   Tc           	      Z   SSK Jn  SSKJn  SSKJn  Sn[        U5      S:X  aj  Uu  pgUR                  (       a  XvpvUR                  (       a  UR                  (       a  Xg// S4nU(       a$  [        S US    5       5      (       a  U$ / US   S4$ 0 n[        R                  n	/ n
/ nU GHO  nUR                  (       au  UR                  R                  (       a  M2  U
 H  nUR                  U5      (       d  M  Sn  O   Uc  MZ  U/U
 Vs/ s H  oR                  U5      (       a  M  UPM     sn-   n
M  UR                   (       a  U[        R"                  L d"  U	[        R$                  L a,  UR&                  SL a  U(       d  [        R"                  // S4s  $ U	R                   (       d  [)        X5      (       a4  X-  n	U	[        R"                  L a  U(       d  [        R"                  // S4s  $ GME  [)        X5      (       a  UR+                  U	5      n	GMi  [)        X5      (       a  UR-                  U5        GM  [)        X5      (       a  U	(       a  UR+                  U	5      OUn	GM  U[        R$                  L a?  U	R&                  SL a  U(       d  [        R"                  // S4s  $ [        R$                  n	GM  UR.                  (       a  UR1                  UR2                  5        GM;  UR                  (       a  UR5                  5       u  pOUR6                  (       a  UR9                  5       u  nnUR                   (       aJ  UR:                  (       d"  UR                  (       a(  UR<                  (       a  UR-                  UU-  5        GM  [        R>                  UpO[        R>                  nUnX;   aD  X==   U-  ss'   X   [        R"                  L a   U(       d  [        R"                  // S4s  $ GMH  GMK  XU'   GMR     / nSnURA                  5        H  u  pUR                  (       a  M  U[        R>                  L a  UR-                  U5        OUR                  (       a/  URB                  " U4UR2                  -   6 nUR-                  U5        OEUR.                  (       a  UR-                  [E        XSS	95        OUR-                  [E        X5      5        U=(       d    URF                  (       + nM     U	[        RH                  L a9  U Vs/ s H+  nURJ                  (       a  M  URL                  (       a  M)  UPM-     nnOKU	[        RN                  L a8  U Vs/ s H+  nURP                  (       a  M  URL                  (       a  M)  UPM-     nnU	[        R$                  L a1  U Vs/ s H$  oR&                  (       a  URR                  b  M"  UPM&     nnU
(       az  / nU H<  nU
 H  nUR                  U5      (       d  M  Sn  O   Uc  M+  UR-                  U5        M>     UU
-   nU
 H+  nUR                  U	5      (       d  M  [        R                  n	  O   [U        U5        U	[        R                  La  URW                  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)TensExprN   c              3   8   #    U  H  oR                   v   M     g 7fNis_commutative)r   ss     r   r   Add.flatten.<locals>.<genexpr>   s     7A''   FevaluateT),!sympy.calculus.accumulationboundsrC   sympy.matrices.expressionsrD   sympy.tensor.tensorrE   r#   is_Rationalis_Mulallr   r2   is_Orderr&   is_zerocontainsr6   NaNComplexInfinity	is_finite
isinstance__add__r7   r4   r5   r"   as_coeff_Mulis_Powas_base_exp
is_Integeris_negativeOneitems_new_rawargsMulrJ   Infinityis_extended_nonnegativeis_realNegativeInfinityis_extended_nonpositiveis_extended_realr/   r8   )clsseqrC   rD   rE   rvr=   btermscoefforder_factorsextraoo1crK   enewseqnoncommutativecsfnewseq2ts                          r   flattenAdd.flatten   s/   $ 	B90s8q=DA}}1}}88T)B7A777I2a5$& A zz66>>'B{{1~~  ( 9!"!.'F!.2jjnB'F !F J%1+<+<"<u,eEE7B,,??j&D&DJE~e !wD00A++		%(A**QA((,1		%(qa'''??e+EEE7B,,)) 

166" ~~'1 }}1;;ALL$%MMammJJq!t$uua1 EE zA8quu$UEE7B,, .3$ am t KKMDAyyaeea  88 1$-9BMM"%XXMM#aU";< MM#a),+C13C3C/CN+ "0 AJJ!'XA0I0IaQYYaFXFa(((!'XA0I0IaQYYaFXA%%% "( QA010B0B F Q G&Azz!}} 	 ' =NN1%  },F"::e$$FFE # 	 MM!U#eOF!N vt##2t##y'FR Y YQs<   Z#ZZZ1ZZ#*Z#=Z#!Z(Z(c                      SSU R                   4$ )N   r   )__name__)rm   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   )selfkkindsresults       r   r   Add.kind  sK    vAyy!% u:? #F  GFr*   c                     [        U 5      $ rH   )r)   r   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 $ rH   )has_free)xdepss    r   <lambda>"Add.as_coeff_add.<locals>.<lambda>  s    qzz4/@r*   T)binaryr   r   N)r   r"   re   tupleas_coeff_addr   r2   )r   r   l1l2rr   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"   r6   rS   re   r   r2   )r   rationalr   rr   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 UR>                  (       a  [;        U5      S:w  a  [A        U R
                   V	s/ s H  oRC                  5       PM     sn	6 u  nn[        S U 5       5      (       a  SnU H  n	[;        U	5      U:  d  M  [;        U	5      nM!     US:  au  [E        US5      (       dc  SS
KJn  UU* 4nU V	s/ s H  oU;   a  U" U	5      OU	U-  PM     nn	[G        [A        UU5       VVs/ s H  u  nnUU-  PM     snn6 U-  nUU-  U-  $ g g g g g s  sn	f s  sn	f s  snnf )Nr   )pure_complex)is_eqrF   c              3   8   #    U  H  oR                   v   M     g 7frH   )is_infinite)r   _s     r   r   "Add._eval_power.<locals>.<genexpr>  s     &Hi}}irM   Fr   )sqrt)factor_terms)sign)expand_multinomialc              3   8   #    U  H  oR                   v   M     g 7frH   )is_Floatr   s     r   r   r     s     )q!::qrM   )$evalfr   
relationalr   r#   r"   anyrW   r   rc   rr   ImaginaryUnitrl   is_extended_negativer2   is_extended_positiverZ   rS   	is_numberq(sympy.functions.elementary.miscellaneousr   	exprtoolsr   $sympy.functions.elementary.complexesr   functionr   pabs_unevaluated_Mulr6   zipr^   r   r9   )r   rx   r   r   r=   rp   icorirr   r   Dr   r   r   rootrw   mbigbigsaddpows                        r   _eval_powerAdd._eval_power  s   '%tyy>Q3&Hdii&H#H#HyyE!eAquuo&>yy771??++qggaoo.3//A4F4F-- vv-- 000===T^^d#B33!8MQTAqD[)A}};M@#L!%$;<accA#$6UCFNT!WQ__-DDqss8K %L  L L % "W+aoo--1a4!Q$;) )  $ [[SVq[499=9a)9=>DAq)q)))A1v}!!f  7<Q#7#7I#;DBCD!QIa1S58!AD 3q!9"=941a1Q39"=>AF6&=( $87 * )[= E"=s   6M:M,M
c                 |    U R                   " U R                   Vs/ s H  o"R                  U5      PM     sn6 $ s  snf rH   )funcr"   diff)r   rK   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   )r   r   r   r   r   r~   rq   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)r   r&   	repl_dictrr   rq   s        r   _matches_simpleAdd._matches_simple  s9    ((*u:?8##DL)<<r*   c                 &    U R                  XU5      $ rH   )_matches_commutative)r   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 $ rH   )r_   base)r   r   s    r   r   &Add._combine_inverse.<locals>.<lambda>  s    ahh7166R<7r*   c                     U R                   $ rH   )r   )r   s    r   r   r     s    affr*   )sympy.simplify.simplifyr   r   rg   rj   hassymbolr   rd   xreplacereplacer6   )lhsrhsr   infr   repsr   virepseqro   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"   re   r   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        H.  u  p[        U
5      S:X  a	  U
S   XY'   M  U R                  " U
6 XY'   M0     [        [        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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
FrN   r   r   N)	primitiver\   r9   rf   as_numer_denomr   r1   r"   r7   r#   popitemr   _keep_coeffrd   r   iterrange)r   contentr&   ncondconndr|   nididr   r   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 HHJDA1v{!		1	  ,/RXXZ0@+AB+Aa$q'+AByy!#f+.0.q vyk!9Fq56N!JL.0 125v,  4#[%999 5 C0s   
G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rH   )_eval_is_polynomialr   termsymss     r   r   *Add._eval_is_polynomial.<locals>.<genexpr>j  s     Hid++D11i    rU   r"   r   r  s    `r   r  Add._eval_is_polynomiali  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rH   )_eval_is_rational_functionr  s     r   r   1Add._eval_is_rational_function.<locals>.<genexpr>m  s     OYT22488Yr  r  r  s    `r   r  Add._eval_is_rational_functionl  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rH   )is_meromorphic)r   argr=   r   s     r   r   +Add._eval_is_meromorphic.<locals>.<genexpr>p  s     K#//155s   !T
quick_exitr
   r"   )r   r   r=   s    ``r   _eval_is_meromorphicAdd._eval_is_meromorphico  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rH   )_eval_is_algebraic_exprr  s     r   r   .Add._eval_is_algebraic_expr.<locals>.<genexpr>t  s     L)$//55)r  r  r  s    `r   r*  Add._eval_is_algebraic_exprs  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rH   )ri   r   r=   s     r   r   Add.<lambda>.<locals>.<genexpr>x  s     &IqIrM   Tr#  r%  r   s    r   r   Add.<lambda>w  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rH   )rl   r/  s     r   r   r0  z       /Y		YrM   Tr#  r%  r   s    r   r   r1  y      ,/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rH   )
is_complexr/  s     r   r   r0  |       )y!yrM   Tr#  r%  r   s    r   r   r1  {      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rH   )is_antihermitianr/  s     r   r   r0  ~  r4  rM   Tr#  r%  r   s    r   r   r1  }  r5  r*   c                 8    [        S U R                   5       SS9$ )Nc              3   8   #    U  H  oR                   v   M     g 7frH   )r[   r/  s     r   r   r0    s     (iirM   Tr#  r%  r   s    r   r   r1    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rH   )is_hermitianr/  s     r   r   r0         +ArM   Tr#  r%  r   s    r   r   r1        l++'>r*   c                 8    [        S U R                   5       SS9$ )Nc              3   8   #    U  H  oR                   v   M     g 7frH   )
is_integerr/  s     r   r   r0    r9  rM   Tr#  r%  r   s    r   r   r1    r:  r*   c                 8    [        S U R                   5       SS9$ )Nc              3   8   #    U  H  oR                   v   M     g 7frH   is_rationalr/  s     r   r   r0    s     *	1	rM   Tr#  r%  r   s    r   r   r1    s    \*		*t&=r*   c                 8    [        S U R                   5       SS9$ )Nc              3   8   #    U  H  oR                   v   M     g 7frH   )is_algebraicr/  s     r   r   r0    rC  rM   Tr#  r%  r   s    r   r   r1    rD  r*   c                 :    [        S U R                   5       5      $ )Nc              3   8   #    U  H  oR                   v   M     g 7frH   rI   r/  s     r   r   r0    s      5-"+Q)rM   r%  r   s    r   r   r1    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   )r   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"   rl   rW   r7   is_imaginaryr   r   rT   as_coeff_mulr   r   )r   nzim_Ir=   rr   airp   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)rJ   r"   rl   rW   r7   rX  rT   r   r   rY  r#   r   )	r   rZ  zim_or_zimr=   rr   r\  rp   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_oddre   )r   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)TNrJ  )r   r   s     r   r   *Add._eval_is_irrational.<locals>.<genexpr>  s     =f}},fs   TF)r"   is_irrationalr1   removerU   )r   r~   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)r   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   rW   r   r}  r   rh   r#   free_symbolssetr"   r   addr   rk   r3   )r   rw   r=   r}  r   rK   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   rW   rh   r   r}  r#   r  r   rw   r=   r}  r   rK   s         r   _eval_is_extended_nonnegative!Add._eval_is_extended_nonnegative8      ~~$$&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   rW   rk   r   r}  r#   r  r  s         r   _eval_is_extended_nonpositive!Add._eval_is_extended_nonpositiveG  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   rW   r   r}  r   rk   r#   r  r  r"   r   r  r   rh   r3   )r   rw   r=   r}  r   rK   negr  r  r  r  r"   isnegr  r  s                 r   r  Add._eval_is_extended_negativeV  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 rH   )r4   r   rg   r"   r   r   rS   r   	make_argsr#   r  _subs)r   r   new
coeff_self
terms_self	coeff_old	terms_oldargs_old	args_selfself_setold_setret_setrK   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 rH   r"   rV   re   r   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 rH   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   OrderN)
sympy.series.orderr  r1   r   r#   r"   r   rX   r7   r   )r   symbolspointr  lstr|   rn   efofrx   ru   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)
)deep)r"   as_real_imagr7   r   )	r   r  hintssargsre_partim_partr  rerb  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      S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R-                  UT" U5      5      nUR.                  nUc*  UR1                  5       R3                  5       nUR.                  nUS	L a   UR5                  5       nUR                  U5      (       a  [8        R:                  nU" S5      n[8        R:                  nUR<                  (       aV  UR?                  UUU-   X#S9R3                  5       RA                  5       R1                  5       nUS-  nUR<                  (       a  MV  UR'                  XUS9$ U[8        RB                  L a  URD                  RG                  U5      U
-   $ U$ s  snf s  snf ! [*         a    Us $ f = f! [6         a    [8        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rH   )r\   )r   r=   r  s     r   r   ,Add._eval_as_leading_term.<locals>.<genexpr>  s     59az!S!!9s   TF)	r  r  mul	power_exp
power_basemultinomialbasicforcefactor)r   r   r   r   rF   rA   )$sympy.core.symbolr   r  r  r  &sympy.functions.elementary.exponentialr  $sympy.functions.elementary.piecewiser  r  r   r  r  r  r   r   r"   expandr4   as_leading_termr   	TypeErrorsubsrW   trigsimpcancelgetnNotImplementedErrorr   rc   rV   r   powsimprY   r   r:   )r   r   r   r   r   r  r  r  r  r  ru   r   logflagsr&   r~   r  _logxleading_termsminnew_exprr  orderrW   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 1	K K( K%$K%(LLc                 z    U R                   " U R                   Vs/ s H  oR                  5       PM     sn6 $ s  snf rH   )r   r"   adjointr   r~   s     r   _eval_adjointAdd._eval_adjointB  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 rH   )r   r"   	conjugater  s     r   _eval_conjugateAdd._eval_conjugateE  +    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 rH   )r   r"   	transposer  s     r   _eval_transposeAdd._eval_transposeH  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"   r^   rS   r   rc   rZ   r7   r   r   r   r   r   	enumerater  Rationalr6   r3   r/   r8   re   )r   rq   r   r=   rw   r   r~   ngcddlcmr   r   r   r  s                r   r   Add.primitiveK  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)r^   ra   r/  s     r   r   +Add.as_content_primitive.<locals>.<genexpr>  s      C7a>>#A&117s   )+Nr   r   )r   r"   r  as_content_primitiver   ra   r4   r   r   r   r1   rf   r  r_   r`   rS   r   r7   r   intr   r  keysr3   r   r   r  )r   r  r  r=   conprimr
  _pr"   radscommon_qr   	term_radsr\  rp   rx   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"   )r   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"   )r   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   r^   r   r   AttributeError_mpf_)r   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      $ rH   )r	   
distributer~  __neg__rf   r   NegativeOne)r   r  s    r   r,  Add.__neg__  s*     ++7?$$1==$''r*   )FN)r   rW  rH   )T)Nr   )FT)Fr   
__module____qualname____firstlineno____doc__	__slots__tTupler   __annotations__r4   
_args_typeclassmethodr   r   propertyr   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_commutativerT  r]  rc  ri  rq  rx  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r  r  r  r(  r,  __static_attributes____classcell__)r  s   @r   r9   r9   V   s   Tl I
s
FJR$ R$h " " 
 
/ ! !,1)f : :!? , ,2 ? ?&1:fIP-M9MB<B;O><=>-8'R5 4l((4l#FJ(,
 # #J:.IV<>>N?`FP > >? < <( (r*   r9   r  )rf   r  r   )r  N).typingr   r4  collectionsr   	functoolsr   operatorr   r  r   
parametersr	   logicr
   r   r   	singletonr   
operationsr   r   cacher   r#  r   intfuncr   r   r&   r   r   r   sympy.utilities.iterablesr   r   r)   r/   r>   r9   r  r  rf   r  r   r  rA   r*   r   <module>rQ     sk    " #     ) 4 4  2  !    76 !
-#`i($ i(V%  3 3 r*   