
    g                     &   d dl mZ d dlmZ d dlmZ d dlmZ ddl	m
Z
 ddlmZ ddlmZmZmZ dd	lmZ dd
lmZmZ ddlmZ ddlmZ ddlmZmZ ddlmZ ddlm Z  d dl!m"Z"m#Z# d Z$d Z%d Z& G d dee      Z' ed      Z(ddl)m*Z*m+Z+m,Z, ddlm-Z- y)    )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                     t        d | j                  D              }t        | j                        |z
  }||kD  ry||k  ryt        | j	                         |  j	                         k        S )Nc              3   @   K   | ]  }|j                         rd   yw)r   N)could_extract_minus_sign.0is     C/var/www/openai/venv/lib/python3.12/site-packages/sympy/core/add.py	<genexpr>z,_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(      si      )499 ) )M		N]2M}$		& D5"2"2"4455    c                 0    | j                  t               y )Nkey)sortr   )r!   s    r   _addsortr.   !   s    II-I r)   c                  d   t        |       } g }t        j                  }| r^| j                         }|j                  r| j                  |j                         n#|j                  r||z  }n|j                  |       | r^t        |       |r|j                  d|       t        j                  |      S )a  Return a well-formed unevaluated Add: Numbers are collected and
    put in slot 0 and args are sorted. Use this when args have changed
    but you still want to return an unevaluated Add.

    Examples
    ========

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

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

    >>> opts = (Add(x, y, evaluate=False), Add(y, x, evaluate=False))
    >>> a = uAdd(x, y)
    >>> assert a in opts and a == uAdd(x, y)
    >>> uAdd(x + 1, x + 2)
    x + x + 3
    r   )listr   Zeropopis_Addextendr!   	is_Number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                       e Zd ZU dZdZeedf   ed<   dZeZ	e
d        Ze
d        Zed        Zd	 Zed
        Zd;dZd Zed        Zd<dZd Zd=dZed        Zed        Zd Zd Zd Zd Zd Zd Z d Z!d Z"d Z#d Z$d Z%d Z&d Z'd  Z(d! Z)d" Z*d# Z+d$ Z,d% Z-d& Z.d' Z/ fd(Z0d) Z1d* Z2 fd+Z3d, Z4d- Z5d. Z6ed>d/       Z7d?d0Z8d@d1Z9d2 Z:d3 Z;d4 Z<d5 Z=dAd6Z>ed7        Z?d8 Z@ed9        ZA fd:ZB xZCS )Br8   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                 h   ddl m} ddlm} ddlm} d}t        |      dk(  rU|\  }}|j                  r||}}|j                  r|j                  r||gg df}|rt        d |d   D              r|S g |d   dfS i }t        j                  }	g }
g }|D ]  }|j                  r]|j                  j                  r'|
D ]  }|j                  |      sd} n |F|g|
D cg c]  }|j                  |      r| c}z   }
m|j                   r|t        j"                  u s |	t        j$                  u r&|j&                  du r|st        j"                  gg dfc S |	j                   st)        |	|      r/|	|z  }	|	t        j"                  u r|st        j"                  gg dfc S t)        ||      r|j+                  |	      }	+t)        ||      r|j-                  |       Jt)        ||      r|	r|j+                  |	      n|}	m|t        j$                  u r8|	j&                  du r|st        j"                  gg dfc S t        j$                  }	|j.                  r|j1                  |j2                         |j                  r|j5                         \  }}n|j6                  rl|j9                         \  }}|j                   r:|j:                  s|j                  r"|j<                  r|j-                  ||z         et        j>                  |}}nt        j>                  }|}||v r>||xx   |z  cc<   ||   t        j"                  u s|rt        j"                  gg dfc S |||<    g }d}|jA                         D ]  \  }}|j                  r|t        j>                  u r|j-                  |       n|j                  r/ |jB                  |f|j2                  z    }|j-                  |       nE|j.                  r|j-                  tE        ||d	             n|j-                  tE        ||             |xs |jF                   } |	t        jH                  u r*|D cg c]  }|jJ                  r|jL                  r|  }}n;|	t        jN                  u r)|D cg c]  }|jP                  r|jL                  r|  }}|	t        j$                  u r'|D cg c]  }|j&                  r|jR                  | }}|
rhg }|D ]2  }|
D ]  }|j                  |      sd} n |"|j-                  |       4 ||
z   }|
D ]%  }|j                  |	      st        j                  }	 n tU        |       |	t        j                  ur|jW                  d|	       |r||z  }d
}|rg |dfS |g dfS c c}w c c}w c c}w c c}w )a  
        Takes the sequence "seq" of nested Adds and returns a flatten list.

        Returns: (commutative_part, noncommutative_part, order_symbols)

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

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

        See Also
        ========

        sympy.core.mul.Mul.flatten

        r   )AccumBounds)
MatrixExpr)TensExprN   c              3   4   K   | ]  }|j                     y wNis_commutative)r   ss     r   r   zAdd.flatten.<locals>.<genexpr>   s     7Aq''   FevaluateT),!sympy.calculus.accumulationboundsrA   sympy.matrices.expressionsrB   sympy.tensor.tensorrC   r"   is_Rationalis_Mulallr   r1   is_Orderr%   is_zerocontainsr5   NaNComplexInfinity	is_finite
isinstance__add__r6   r3   r4   r!   as_coeff_Mulis_Powas_base_exp
is_Integeris_negativeOneitems_new_rawargsMulrH   Infinityis_extended_nonnegativeis_realNegativeInfinityis_extended_nonpositiveis_extended_realr.   r7   )clsseqrA   rB   rC   rvr<   btermscoefforder_factorsextraoo1crI   enewseqnoncommutativecsfnewseq2ts                          r   flattenzAdd.flatten   s4   $ 	B90s8q=DAq}}!1}}88QT)B7A77I2a5$& A zz66>>'B{{1~  ( 9!"!.'F!.2ajjnB'F !F J%1+<+<"<u,eEE7B,,??j&DQJE~e !wD00A{+		%(Az*QAx(,1		%(qa'''??e+EEE7B,,)) 

166" ~~'1 }}1;;ALL$%MMammJJq!t$uua1 EE EzaA8quu$UEE7B,,am t KKMDAqyyaeea  88 (1$-9BMM"%XXMM#aU";< MM#a),+C13C3C/CN+ "0 AJJ!'XA0I0IQYYaFXa(((!'XA0I0IQYYaFXA%%% "( QA010B0B0N F Q G&Azz!} 	 ' =NN1%  },F"::e$FFE # 	 MM!U#eOF!N vt##2t##y'FR Y YQs6   V 3V V%*V%7V%V*&V*3V*!V/c                      dd| j                   fS )N   r   )__name__)rj   s    r   	class_keyzAdd.class_key  s    !S\\!!r)   c                     t        d      }t        || j                        }t        |      }t	        |      dk7  rt
        }|S |\  }|S )Nkindr   )r   mapr!   	frozensetr"   r   )selfkkindsresults       r   r   zAdd.kind  sM    vAtyy!% u:? #F  GFr)   c                     t        |       S rF   )r(   r   s    r   r   zAdd.could_extract_minus_sign  s    (..r)   c                 <   r8t        | j                  fdd      \  }} | j                  | t        |      fS | j                  d   j	                         \  }}|t
        j                  ur||| j                  dd z   fS t
        j                  | j                  fS )aR  
        Returns a tuple (coeff, args) where self is treated as an Add and coeff
        is the Number term and args is a tuple of all other terms.

        Examples
        ========

        >>> from sympy.abc import x
        >>> (7 + 3*x).as_coeff_add()
        (7, (3*x,))
        >>> (7*x).as_coeff_add()
        (0, (7*x,))
        c                 "     | j                    S rF   )has_free)xdepss    r   <lambda>z"Add.as_coeff_add.<locals>.<lambda>  s    zqzz4/@r)   T)binaryr   r   N)r   r!   rb   tupleas_coeff_addr   r1   )r   r   l1l2ro   notrats    `    r   r   zAdd.as_coeff_add  s     $))%@NFB$4$$b)5944		!113v&499QR=000vvtyy  r)   c                     | j                   d   | j                   dd }}|j                  r|r|j                  r| | j                  | fS t        j
                  | fS )zE
        Efficiently extract the coefficient of a summation.
        r   r   N)r!   r5   rP   rb   r   r1   )r   rationalr   ro   r!   s        r   as_coeff_AddzAdd.as_coeff_Add  sW     iilDIIabMt??8u/@/@+$++T222vvt|r)   c                    ddl m} ddlm} t	        | j
                        dk(  rt        d | j
                  D              r|j                  du r ||t        j                        du r| j
                  \  }}|j                  t        j                        r||}}|j                  t        j                        }|rP|j                  rD|j                  r8|j                  rt        j                  S |j                  rt        j                   S y |j"                  r| j$                  r ||       }|r|\  }}	|j&                  dk(  rddlm}
  |
|dz  |	dz  z         }|j"                  rdd	lm} dd
lm} ddlm}  |
 |||z
  dz              |j8                  z  }| |||z   t;        |	      z   ||	      t        j                  z  z   |j8                  z        z  S |dk(  r,t=        ||	t        j                  z  z
  d|dz  |	dz  z   z        S y y y |j>                  rt;        |      dk7  rtA        | j
                  D 	cg c]  }	|	jC                          c}	 \  }}t        d |D              rd}|D ]  }	t;        |	      |k\  st;        |	      } |dkD  ritE        |d      s\dd
lm} || f}|D 	cg c]  }	|	|v r ||	      n|	|z   }}	tG        tA        ||      D cg c]
  \  }}||z   c}} |z  }||z  |z  S y y y y y c c}	w c c}	w c c}}w )Nr   )pure_complex)is_eqrD   c              3   4   K   | ]  }|j                     y wrF   )is_infinite)r   _s     r   r   z"Add._eval_power.<locals>.<genexpr>  s     &Hiq}}irJ   Fr   )sqrt)factor_terms)sign)expand_multinomialc              3   4   K   | ]  }|j                     y wrF   )is_Floatr   s     r   r   z"Add._eval_power.<locals>.<genexpr>  s     )q!1::qrJ   )$evalfr   
relationalr   r"   r!   anyrT   r   r`   ro   ImaginaryUnitri   is_extended_negativer1   is_extended_positiverW   rP   	is_numberq(sympy.functions.elementary.miscellaneousr   	exprtoolsr   $sympy.functions.elementary.complexesr   functionr   pabs_unevaluated_Mulr5   zipr[   r   r8   )r   ru   r   r   r<   rm   icorirr   r   Dr   r   r   rootrt   mbigbigsaddpows                        r   _eval_powerzAdd._eval_power  s   '%tyy>Q3&Hdii&H#HyyE!eAquuo&>yy1771??+aqAggaoo.3//A4F4F-- vv-- 000==T^^d#B133!8MQTAqD[)A}};M@#L!a%$;<accA#$6UCFNT!WQ__-DDqss8K %L  L L "W+Aaoo--1a4!Q$;) )  % $ [[SVq[499=9a)9=>DAq)q))A1v}!!f  7<Q#7I#;DBCD!QAIa1S58!AD 3q!9"=941a1Q39"=>AF6&=( $87 * )[= E"=s   :K?-LL	
c                 x     | j                   | j                  D cg c]  }|j                  |       c} S c c}w rF   )funcr!   diff)r   rI   r<   s      r   _eval_derivativezAdd._eval_derivative  s1    tyydii8i166!9i8998s   7c           	          | j                   D cg c]  }|j                  ||||       }} | j                  | S c c}w )Nnlogxcdir)r!   nseriesr   )r   r   r   r   r   r{   rn   s          r   _eval_nserieszAdd._eval_nseries  sB    BF))L)Q148)Ltyy%   Ms   <c                 v    | j                         \  }}t        |      dk(  r|d   j                  ||z
  |      S y )Nr   r   )r   r"   matches)r   r%   	repl_dictro   rn   s        r   _matches_simplezAdd._matches_simple  s=    ((*uu:?8##D5L)<<r)   c                 (    | j                  |||      S rF   )_matches_commutative)r   r%   r   olds       r   r   zAdd.matches  s    ((y#>>r)   c                 2   ddl m} t        j                  t        j                  f} | j
                  | s |j
                  | rddlm}  |d      t        j                  t        j                   i}|j                         D ci c]  \  }}||
 }}}| j                  |      |j                  |      z
  }	|	j                        r|	j                  fdd       }	|	j                  |      }
n| |z
  }
 ||
      }|j                  r|S |
S c c}}w )zp
        Returns lhs - rhs, but treats oo like a symbol so oo - oo
        returns 0, instead of a nan.
        r   )signsimpr   )Dummyooc                 <    | j                   xr | j                  u S rF   )r\   base)r   r   s    r   r   z&Add._combine_inverse.<locals>.<lambda>  s    ahh7166R<7r)   c                     | j                   S rF   )r   )r   s    r   r   z&Add._combine_inverse.<locals>.<lambda>  s    affr)   )sympy.simplify.simplifyr   r   rd   rg   hassymbolr   ra   xreplacereplacer5   )lhsrhsr   infr   repsr   virepseqrl   srvr   s               @r   _combine_inversezAdd._combine_inverse  s     	5zz1--.377C=GCGGSM%tB

B""RC)D '+jjl3ldaQTlE3d#cll4&88BvvbzZZ7$& U#BsBrlmms++ 4s   
Dc                 X    | j                   d    | j                  | j                   dd  fS )aZ  Return head and tail of self.

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

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

        >>> from sympy.abc import x, y
        >>> (3*x - 2*y + 5).as_two_terms()
        (5, 3*x - 2*y)
        r   r   N)r!   rb   r   s    r   as_two_termszAdd.as_two_terms"  s/    $ yy|.T..		!">>>r)   c                    | j                         \  }}t        |t              st        ||d      j	                         S |j	                         \  }}t        t              }|j                  D ])  }|j	                         \  }}||   j                  |       + t        |      dk(  rF|j                         \  }	}
 | j                  |
D cg c]  }t        ||       c} t        ||	      fS |j                         D ].  \  }	}
t        |
      dk(  r	|
d   ||	<    | j                  |
 ||	<   0 t        t        |j                                D cg c]  }t        |       c}\  }} | j                  t!        t        |            D cg c]  }t        |d| ||   gz   ||dz   d z     c} t        | }	}
t        ||
      t        ||	      fS c c}w c c}w c c}w )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
        FrK   r   r   N)	primitiverY   r8   rc   as_numer_denomr   r0   r!   r6   r"   popitemr   _keep_coeffra   r   iterrange)r   contentr%   ncondconndry   nididr   r   denomsnumerss                 r   r   zAdd.as_numer_denom6  s   ( ($$wu5DDFF++-
d A%%'FBrFMM" 
 r7a<::<DAq499234!B+dB'!467B47KL L HHJDAq1v{!1!		11	  ,/RXXZ0@+AB+Aa$q'+ABtyy!#f+.0.q vayk!9F1q56N!JL.0 125v,  4#[q%999 5 C0s   GG
"Gc                 @    t        fd| j                  D              S )Nc              3   @   K   | ]  }|j                          y wrF   )_eval_is_polynomialr   termsymss     r   r   z*Add._eval_is_polynomial.<locals>.<genexpr>j  s     Hid4++D1i   rR   r!   r   r   s    `r   r   zAdd._eval_is_polynomiali  s    HdiiHHHr)   c                 @    t        fd| j                  D              S )Nc              3   @   K   | ]  }|j                          y wrF   )_eval_is_rational_functionr   s     r   r   z1Add._eval_is_rational_function.<locals>.<genexpr>m  s     OYT42248Yr   r  r  s    `r   r  zAdd._eval_is_rational_functionl  s    OTYYOOOr)   c                 H    t        fd| j                  D        d      S )Nc              3   B   K   | ]  }|j                          y wrF   )is_meromorphic)r   argr<   r   s     r   r   z+Add._eval_is_meromorphic.<locals>.<genexpr>p  s     K#S//15s   T
quick_exitr
   r!   )r   r   r<   s    ``r   _eval_is_meromorphiczAdd._eval_is_meromorphico  s    KK'+- 	-r)   c                 @    t        fd| j                  D              S )Nc              3   @   K   | ]  }|j                          y wrF   )_eval_is_algebraic_exprr   s     r   r   z.Add._eval_is_algebraic_expr.<locals>.<genexpr>t  s     L)$4//5)r   r  r  s    `r   r  zAdd._eval_is_algebraic_exprs  s    L$))LLLr)   c                 >    t        d | j                  D        d      S )Nc              3   4   K   | ]  }|j                     y wrF   )rf   r   r<   s     r   r   zAdd.<lambda>.<locals>.<genexpr>x  s     &IqIrJ   Tr
  r  r   s    r   r   zAdd.<lambda>w  s    &DII&4"9r)   c                 >    t        d | j                  D        d      S )Nc              3   4   K   | ]  }|j                     y wrF   )ri   r  s     r   r   zAdd.<lambda>.<locals>.<genexpr>z       /Y		YrJ   Tr
  r  r   s    r   r   zAdd.<lambda>y      ,/TYY/D+Br)   c                 >    t        d | j                  D        d      S )Nc              3   4   K   | ]  }|j                     y wrF   )
is_complexr  s     r   r   zAdd.<lambda>.<locals>.<genexpr>|       )y!yrJ   Tr
  r  r   s    r   r   zAdd.<lambda>{      L)tyy)d%<r)   c                 >    t        d | j                  D        d      S )Nc              3   4   K   | ]  }|j                     y wrF   )is_antihermitianr  s     r   r   zAdd.<lambda>.<locals>.<genexpr>~  r  rJ   Tr
  r  r   s    r   r   zAdd.<lambda>}  r  r)   c                 >    t        d | j                  D        d      S )Nc              3   4   K   | ]  }|j                     y wrF   )rX   r  s     r   r   zAdd.<lambda>.<locals>.<genexpr>  s     (iirJ   Tr
  r  r   s    r   r   zAdd.<lambda>  s    <(dii(T$;r)   c                 >    t        d | j                  D        d      S )Nc              3   4   K   | ]  }|j                     y wrF   )is_hermitianr  s     r   r   zAdd.<lambda>.<locals>.<genexpr>       +ArJ   Tr
  r  r   s    r   r   zAdd.<lambda>      l++'>r)   c                 >    t        d | j                  D        d      S )Nc              3   4   K   | ]  }|j                     y wrF   )
is_integerr  s     r   r   zAdd.<lambda>.<locals>.<genexpr>  r  rJ   Tr
  r  r   s    r   r   zAdd.<lambda>  r  r)   c                 >    t        d | j                  D        d      S )Nc              3   4   K   | ]  }|j                     y wrF   is_rationalr  s     r   r   zAdd.<lambda>.<locals>.<genexpr>  s     *	1	rJ   Tr
  r  r   s    r   r   zAdd.<lambda>  s    \*		*t&=r)   c                 >    t        d | j                  D        d      S )Nc              3   4   K   | ]  }|j                     y wrF   )is_algebraicr  s     r   r   zAdd.<lambda>.<locals>.<genexpr>  r%  rJ   Tr
  r  r   s    r   r   zAdd.<lambda>  r&  r)   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wrF   rG   r  s     r   r   zAdd.<lambda>.<locals>.<genexpr>  s      5-"+Q)rJ   r  r   s    r   r   zAdd.<lambda>  s     5-"&))5- )-r)   c                 f    d}| j                   D ]  }|j                  }| y |du s|du r y d}! |S )NFT)r!   r   )r   sawinfr<   ainfs       r   _eval_is_infinitezAdd._eval_is_infinite  sC    A==D|T>  r)   c                    g }g }| j                   D ]  }|j                  r/|j                  r|j                  du r|j                  |       < y |j                  r#|j                  |t
        j                  z         m|j                  rst
        j                  |j                   v rW|j                  t
        j                        \  }}|t
        j                  fk(  r|j                  r|j                  |         y  y   | j                  | }|| k7  r>|j                  r"t         | j                  | j                        S |j                  du ryy y NF)r!   ri   rT   r6   is_imaginaryr   r   rQ   as_coeff_mulr   r   )r   nzim_Ir<   ro   airm   s          r   _eval_is_imaginaryzAdd._eval_is_imaginary  s   A!!99YY%'IIaLAaoo-.aoo7NN1??;	r!//++0F0FKK'# $ DIIrN9yy D!1!9!9::e# $ r)   c                    | j                   du ry g }d}d}d}| j                  D ]  }|j                  r4|j                  r|dz  }!|j                  du r|j	                  |       A y |j
                  r|dz  }U|j                  rct        j                  |j                  v rG|j                  t        j                        \  }}|t        j                  fk(  r|j                  rd} y  y  |t        | j                        k(  ryt        |      dt        | j                        fv ry  | j                  | }|j                  r|s|dk(  ry|dk(  ry|j                  du ryy )NFr   r   T)rH   r!   ri   rT   r6   r9  rQ   r   r   r:  r"   r   )	r   r;  zim_or_zimr<   ro   r=  rm   s	            r   _eval_is_zerozAdd._eval_is_zero  s:   %' A!!99FAYY%'IIaLaaoo7NN1??;	r!//++0F0F"G# $ DIIr7q#dii.))DIIrN9971W 99 r)   c                     | j                   D cg c]  }|j                  dus| }}|sy|d   j                  r | j                  |dd   j                  S y c c}w )NTFr   r   )r!   is_evenis_oddrb   )r   ry   ls      r   _eval_is_oddzAdd._eval_is_odd  s_    		=	1!))t*;Q	=Q4;;$4$$ae,444  >s
   AAc                     | j                   D ]P  }|j                  }|r<t        | j                         }|j                  |       t	        d |D              r y y |P y  y)Nc              3   8   K   | ]  }|j                   d u   yw)TNr,  )r   r   s     r   r   z*Add._eval_is_irrational.<locals>.<genexpr>  s     =fq}},fs   TF)r!   is_irrationalr0   removerR   )r   r{   r<   otherss       r   _eval_is_irrationalzAdd._eval_is_irrational  sV    AAdiia =f==y  r)   c                 |    dx}}| j                   D ])  }|j                  r|r yd}|j                  r|r yd}) y  y)Nr   Fr   T)r!   is_nonnegativeis_nonpositive)r   nnnpr<   s       r   _all_nonneg_or_nonpposzAdd._all_nonneg_or_nonppos  sI    RA !!   r)   c                 &   | j                   rt        | 	         S | j                         \  }}|j                  sgddlm}  ||      }|W||z   }|| k7  r|j                  r|j                  ryt        | j                        dk(  r ||       }||| k7  r|j                  rydx}x}x}}	t               }
| j                  D cg c]  }|j                  r| }}|sy|D ]u  }|j                  }|j                  }|r0|
j                  t        ||j                  f             d|
v rd|
v r y |rd}R|j                  rd}a|j                   rd}p| y d}	w |
rt        |
      dkD  ry |
j#                         S |	ry |s|s|ry|s|ry|s|syy y c c}w Nr   _monotonic_signTF)r   super_eval_is_extended_positiver   rT   r   rX  r   re   r"   free_symbolssetr!   r   addr   rh   r2   )r   rt   r<   rX  r   rI   posnonnegnonposunknown_signsaw_INFr!   isposinfinite	__class__s                 r   rZ  zAdd._eval_is_extended_positive     >>7577  "1yy2"A}E9!7!7A<U<Ut(()Q.'-A}dq7M7M#/444f4v%9969aAII96A**E}}HHeQ-F-F%GHI7?u'7****L' * 7|a;;= 3CV $E 7   FFc                 6   | j                   s| j                         \  }}|j                  sm|j                  r`ddlm}  ||      }|O||z   }|| k7  r|j                  ryt        | j                        dk(  r ||       }||| k7  r|j                  ryy y y y y y y y Nr   rW  T)r   r   rT   re   r   rX  r"   r[  r   rt   r<   rX  r   rI   s         r   _eval_is_extended_nonnegativez!Add._eval_is_extended_nonnegative8      ~~$$&DAq99!:!:6#A&=AADyQ%>%>#4,,-2+D1=Q$Y1;T;T#' <UY= 3	 ! ";9 r)   c                 6   | j                   s| j                         \  }}|j                  sm|j                  r`ddlm}  ||      }|O||z   }|| k7  r|j                  ryt        | j                        dk(  r ||       }||| k7  r|j                  ryy y y y y y y y ri  )r   r   rT   rh   r   rX  r"   r[  rj  s         r   _eval_is_extended_nonpositivez!Add._eval_is_extended_nonpositiveG  rl  r)   c                 &   | j                   rt        | 	         S | j                         \  }}|j                  sgddlm}  ||      }|W||z   }|| k7  r|j                  r|j                  ryt        | j                        dk(  r ||       }||| k7  r|j                  rydx}x}x}}	t               }
| j                  D cg c]  }|j                  r| }}|sy|D ]u  }|j                  }|j                  }|r0|
j                  t        ||j                  f             d|
v rd|
v r y |rd}R|j                  rd}a|j                   rd}p| y d}	w |
rt        |
      dkD  ry |
j#                         S |	ry |s|s|ry|s|ry|s|syy y c c}w rV  )r   rY  _eval_is_extended_negativer   rT   r   rX  r   rh   r"   r[  r\  r!   r   r]  r   re   r2   )r   rt   r<   rX  r   rI   negr`  r_  ra  rb  r!   isnegrd  re  s                 r   rp  zAdd._eval_is_extended_negativeV  rf  rg  c           
         |j                   s7|t        j                  u r$| | j                  v r| j	                  | | i      S y | j                         \  }}|j                         \  }}|j                  r?|j                  r3||k(  r| j                  |||       S || k(  r| j                  | ||      S |j                  r|j                  s||k(  r| j                  j                  |      | j                  j                  |      }}t        |      t        |      k  rt        |      }	t        |      }
|
|	k  r9|	|
z
  } | j                  ||| g|D cg c]  }|j                  ||       c} S | j                  j                  |       }t        |      }
|
|	k  r9|	|
z
  } | j                  | ||g|D cg c]  }|j                  ||       c} S y y y c c}w c c}w rF   )r3   r   rd   r!   r   r   rP   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_setrI   s                r   
_eval_subszAdd._eval_subs  s   zzajj cTTYY%6}}sdSD\22!%!2!2!4
J"//1	9!!i&;&;Y&yyj9*==iZ'yy#z9==!!i&;&;*"&))"5"5# II//
;  H8}s9~-y>h-X%&0G$499S*yj F<C DGqc!2G DF F  99..J h-X%&0G$499cT:y F<C DGqc!2G DF F & . + !E !Es   G
:G!
c                 v    | j                   D cg c]  }|j                  r| }} | j                  | S c c}w rF   r!   rS   rb   r   r<   r!   s      r   removeOzAdd.removeO  s8    9979aAJJ97 t  $'' 8s   66c                 |    | j                   D cg c]  }|j                  s| }}|r | j                  | S y c c}w rF   r  r  s      r   getOzAdd.getO  s@    9939a

93$4$$d++  4s   99c                    ddl m} g }t        t        |      r|n|g      }|sdgt	        |      z  }| j
                  D cg c]  }| ||gt        ||       f }}|D ]h  \  }}|D ]   \  }	}
|
j                  |      s|
|k7  sd} n |.||fg}|D ]/  \  }	}
|j                  |
      r|
|k7  r|j                  |	|
f       1 |}j t        |      S c c}w )a`  
        Returns the leading term and its order.

        Examples
        ========

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

        r   OrderN)
sympy.series.orderr  r0   r   r"   r!   r   rU   r6   r   )r   symbolspointr  lstry   rk   efofru   rr   new_lsts               r   extract_leading_orderzAdd.extract_leading_order  s    " 	-+g"6wWIFCG$E<@IIFIq51S%012IFFB1::b>a2gB  zBxjG1;;q>a2g1v&  C  Sz Gs   Cc                     | j                   }g g }}|D ]9  }|j                  |      \  }}|j                  |       |j                  |       ;  | j                  |  | j                  | fS )a4  
        Return a tuple representing a complex number.

        Examples
        ========

        >>> from sympy import I
        >>> (7 + 9*I).as_real_imag()
        (7, 9)
        >>> ((1 + I)/(1 - I)).as_real_imag()
        (0, 1)
        >>> ((1 + 2*I)*(1 + 3*I)).as_real_imag()
        (-5, 5)
        )deep)r!   as_real_imagr6   r   )	r   r  hintssargsre_partim_partr   rerB  s	            r   r  zAdd.as_real_imag  sr     		rD&&D&1FBNN2NN2  		7#YTYY%899r)   c           
         ddl m}m} ddlm} ddlm ddlm}m	} ddl
m}	 | j                         }
|
 |d      }
| j                         }|j                  |      r ||      }t        fd| j                   D              rd	d	d
d
d
d
d
d
d
d	} |j"                  di |} |	|      }|j$                  s|j'                  |||      S |j                   D cg c]  }|j(                  s| }}| |d      n|}|j                   D cg c]  }|j'                  |||       }} |d      d}}	 |D ]   } |||      }|r||vr|}|}||v s||z  }" 	 ||j-                  | |            }|j.                  }|*|j1                         j3                         }|j.                  }|d	u r	 |j5                         }|j                  |      rt8        j:                  } |d      }t8        j:                  }|j<                  rT|j?                  |||z   ||      j3                         jA                         j1                         }|dz  }|j<                  rT|j'                  |||      S |t8        jB                  u r|jD                  jG                  |      |
z   S |S c c}w c c}w # t*        $ r |cY S w xY w# t6        $ r t8        j:                  }Y w xY w)Nr   )r   Symbolr  )log)	Piecewisepiecewise_foldr   )
expand_mulc              3   6   K   | ]  }t        |        y wrF   )rY   )r   r<   r  s     r   r   z,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   rD   r?   )$sympy.core.symbolr   r  r  r  &sympy.functions.elementary.exponentialr  $sympy.functions.elementary.piecewiser  r  r   r  r  r  r   r   r!   expandr3   as_leading_termr   	TypeErrorsubsrT   trigsimpcancelgetnNotImplementedErrorr   r`   rS   r   powsimprV   r   r9   )r   r   r   r   r   r  r  r  r  r  rr   r   logflagsr%   r{   rd  _logxleading_termsminnew_exprr   orderrT   n0resincrr  s                             @r   _eval_as_leading_termzAdd._eval_as_leading_term  s   3,>R(IIK9aAlln779 %C 549955 $T%e#EETY!H #**(x(C#{{''4'@@#yy:y!AMMAy:!%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W4d'KRRT\\^ggi	 ,, &&qt$&??88&&x0144 O] ; Y  	K	 ' UUs<   J+JJ$3J) J) 0J: )J76J7:KKc                 v     | j                   | j                  D cg c]  }|j                          c} S c c}w rF   )r   r!   adjointr   r{   s     r   _eval_adjointzAdd._eval_adjointB  s/    tyy		:	1199;	:;;:   6c                 v     | j                   | j                  D cg c]  }|j                          c} S c c}w rF   )r   r!   	conjugater  s     r   _eval_conjugatezAdd._eval_conjugateE  /    tyy$))<)Q1;;=)<==<r  c                 v     | j                   | j                  D cg c]  }|j                          c} S c c}w rF   )r   r!   	transposer  s     r   _eval_transposezAdd._eval_transposeH  r  r  c                    g }d}| j                   D ]q  }|j                         \  }}|j                  st        j                  }|}|xs |t        j
                  u }|j                  |j                  |j                  |f       s |sEt        t        |D cg c]  }|d   	 c}d      }t        t        |D cg c]  }|d   	 c}d      }nPt        t        |D cg c]  }|d   s	|d    c}d      }t        t        |D cg c]  }|d   s	|d    c}d      }||cxk(  rdk(  rn nt        j                  | fS |s9t        |      D ]*  \  }	\  }
}}t        t        |
|z  ||z  z        |      ||	<   , nTt        |      D ]F  \  }	\  }
}}|r"t        t        |
|z  ||z  z        |      ||	<   .t        t        |
|      |      ||	<   H |d   j                  s|d   t        j
                  u r|j!                  d      }nd}t#        |       |r|j%                  d|       t        ||       | j&                  | fS c c}w c c}w c c}w c c}w )a  
        Return ``(R, self/R)`` where ``R``` is the Rational GCD of ``self```.

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

        Examples
        ========

        >>> from sympy.abc import x, y

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

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

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

        No subprocessing of term factors is performed:

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

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

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

        See also: primitive() function in polytools.py

        Fr   r   N)r!   r[   rP   r   r`   rW   r6   r   r   r   r   r   	enumerater   Rationalr5   r2   r.   r7   rb   )r   rn   r   r<   rt   r   r{   ngcddlcmr   r   r   r   s                r   r   zAdd.primitiveK  s.   F A>>#DAq==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4155$;#,U#3<Aq$&xD470C'DdKa $4 $-U#3<Aq$*8QWtQw4G+H$OE!H*8Aq>4@E!H	 $4 8qQ->->!>		!AALLAd#%6T%6%6%>>>A !6 5 = =s$   H=
7I

I
%I

I
I
c                 H    | j                   | j                  D cg c]  }t        |j                  ||        c} j	                         \  }}|sT|j
                  sH|j                  r<|j                         \  }}||z  }t        d |j                  D              r|}n||z  }|r|j                  r|j                  }g }	d}
|D ]  }t        t              }t        j                  |      D ]y  }|j                  s|j                         \  }}|j                  s0|j
                  s=||j                      j#                  t%        t'        |            |j(                  z         { |s ||fS |
t+        |j-                               }
n#|
t+        |j-                               z  }
|
s ||fS |	j#                  |        |	D ]K  }t        |j-                               D ]  }||
vs|j/                  |        |D ]  }t        ||    ||<    M g }|
D ]H  }t1        t2        |	D cg c]  }||   	 c}d      }|dk7  s+|j#                  |t5        d|      z         J |r,t        | }|D cg c]  }||z  	 }}| |j                   | z  }||fS c c}w c c}w c c}w )a  Return the tuple (R, self/R) where R is the positive Rational
        extracted from self. If radical is True (default is False) then
        common radicals will be removed and included as a factor of the
        primitive expression.

        Examples
        ========

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

        Radical content can also be factored out of the primitive:

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

        See docstring of Expr.as_content_primitive for more examples.
        )radicalclearc              3   V   K   | ]!  }|j                         d    j                   # yw)r   N)r[   r^   r  s     r   r   z+Add.as_content_primitive.<locals>.<genexpr>  s#     C7a1>>#A&117s   ')Nr   r   )r   r!   r   as_content_primitiver   r^   r3   r   r   r   r0   rc   rt  r\   r]   rP   r   r6   r   intr   r\  keysr2   r   r   r  )r   r  r  r<   conprimr   _pr!   radscommon_qr   	term_radsr=  rm   ru   r   r   Ggs                       r   r  zAdd.as_content_primitive  s   ( DII48II ?4=q !,Q-C-C5 .D .* !+4= ? @@I	 	TS^^'')FCaBC277CCqt{{99DDH'-	--*Byy!~~/1==Q\\%accN11#c!f+qss2BC	 +
 !8 Dy7 #"9>>#34H'#inn.>*??H#, Dy+ I& & A!!&&(^H,EE!H , "AaDz! 	  !AtD%9DqadD%91=AAvHQN!23 " QA+/04RBqD4D0YTYY--DDye ?T &:
 1s    J)J1Jc                 N    ddl m} t        t        | j                  |            S )Nr   )default_sort_keyr+   )sortingr  r   sortedr!   )r   r  s     r   _sorted_argszAdd._sorted_args  s    -VDII+;<==r)   c           
      v    ddl m}  | j                  | j                  D cg c]  } ||||       c} S c c}w )Nr   )difference_delta)sympy.series.limitseqr  r   r!   )r   r   stepddr<   s        r   _eval_difference_deltazAdd._eval_difference_delta  s4    @tyy499=9a2aD>9=>>=s   6c                     ddl m} | j                         \  }}|j                         \  }}|t        j
                  k(  st        d       ||      j                   ||      j                  fS )z;
        Convert self to an mpmath mpc if possible
        r   )Floatz@Cannot convert Add to mpc. Must be of the form Number + Number*I)numbersr  r   r[   r   r   AttributeError_mpf_)r   r  r  restr  	imag_units         r   _mpc_z	Add._mpc_  se    
 	#))+!..0AOO+ !!cddg$$eGn&:&:;;r)   c                 t    t         j                  st        |          S t	        t
        j                  |       S rF   )r	   
distributerY  __neg__rc   r   NegativeOne)r   re  s    r   r  zAdd.__neg__  s*     ++7?$$1==$''r)   )FN)r   r8  rF   )T)Nr   )FT)Dr   
__module____qualname____doc__	__slots__tTupler   __annotations__r3   
_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_commutativer6  r>  rC  rH  rN  rT  rZ  rk  rn  rp  r  r  r  r  r  r  r  r  r  r   r  r  r  r  r  __classcell__)re  s   @r   r8   r8   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)   r8   r]  )rc   r   r   )r  N).typingr   r  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=   r8   r]  r  rc   r   r   r  r?   r)   r   <module>r     sk    " #     ) 4 4  2  !    76 !
-#`i($ i(V%  3 3 r)   