Ë
    O/æj‘ª  ã                   ó&  — 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     úQ/root/repos/pocs/video-evals/.venv/lib/python3.12/site-packages/sympy/core/add.pyú	<genexpr>z,_could_extract_minus_sign.<locals>.<genexpr>   s#   è ø€ ò )˜aØ×%Ñ%Ô'ô ñ )ùs   ‚FT)ÚsumÚargsÚlenÚboolÚsort_key)ÚexprÚnegative_argsÚpositive_argss      r   Ú_could_extract_minus_signr(      si   € ô ñ ) 4§9¡9ô )ó )€Mä˜Ÿ	™	“N ]Ñ2€MØ�}Ò$ØØ	˜Ò	&Øô �—‘“ D 5×"2Ñ"2Ó"4Ñ4Ó5Ð5ó    c                 ó0   — | j                  t        ¬«       y )N©Úkey)Úsortr   )r!   s    r   Ú_addsortr.   !   s   € à‡I�I”-€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Ù
Ø�H‰H‹JˆØ�8Š8ð �K‰K˜Ÿ™ÕØ�[Š[Ø�!‰G‰Bà�N‰N˜1Ôò ô ˆ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¨A�q×'Õ'Ñ7ùó   ‚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µ   sR  € õ$ 	BÝ9Ý0ØˆÜˆs‹8�qŠ=Ø‰DˆAˆqØ�}Š}Ø˜!�1�Ø�}Š}Ø—8’8Ø˜Q˜  TÐ)�BÙÜÑ7°°A±Ô7Ô7Ø�IØ˜2˜a™5 $�Ð&àˆô —‘ˆàˆàˆàó V	ˆAð �zŠzØ—6‘6—>’>ØØ'ò �BØ—{‘{ 1•~Ø ˜Ùðð �9ØØ!" Ø!.ö'FØ°a·j±jÀµn’Bò'Fñ !F�àð —’ØœŸ™‘J %¬1×+<Ñ+<Ñ"<ØŸ™ uÑ,±eäŸE™E˜7 B¨Ð,Ò,Ø—?’?¤j°¸Ô&DØ˜Q‘J�EØ¤§¡‘~©eä !§¡˜w¨¨DÐ0Ò0Ùä˜A˜{Ô+ØŸ	™	 %Ó(�Ùä˜A˜zÔ*à—‘˜Q”Ùä˜A˜xÔ(Ù,1˜Ÿ	™	 %Ô(°q�Ùà”a×'Ñ'Ñ'Ø—?‘? eÑ+±EäŸE™E˜7 B¨Ð,Ò,Ü×)Ñ)�Ùð —’à—
‘
˜1Ÿ6™6Ô"Ùð —’Ø—~‘~Ó'‘�‘1ð —’Ø—}‘}“‘��1Ø—;’; A§L¢LØ$%§M¢M°a·m²mØ—J‘J˜q !™tÔ$ÙÜ—u‘u˜a�1‘ô —E‘E�Ø�ð �E‰zØ�a“˜A‘“Ø˜‘8œqŸu™uÓ$«UäŸE™E˜7 B¨Ð,Ò,à��a“ðmV	ðt ˆØˆØ—K‘K“Mò 	D‰DˆAˆqà�yŠyØà”a—e‘e‘Ø—‘˜aÕ ð —8’8ð (˜Ÿ™¨1¨$°·±©-Ð9�BØ—M‘M "Õ%Ø—X’Xà—M‘M¤# a¨°UÔ";Õ<ð —M‘M¤# a¨£)Ô,à+ÒC°1×3CÑ3CÐ/C‰Nð+	Dð0 ”A—J‘JÑØ!'ÖX˜A°×0IÓ0IÈQÏYËY’aÐXˆFÑXà”a×(Ñ(Ñ(Ø!'ÖX˜A°×0IÓ0IÈQÏYËY’aÐXˆFÐXà”A×%Ñ%Ñ%ð "(ö Q˜A°·²Ø01×0BÑ0BÐ0Nò ð QˆFð Qñ ØˆGØò &�Ø&ò �Aà—z‘z !•}Ø ˜Ùð	ð ‘=Ø—N‘N 1Õ%ð&ð ˜}Ñ,ˆFà"ò �Ø—:‘:˜eÕ$ÜŸF™F�EÙðô 	�Ôð œŸ™ÑØ�M‰M˜!˜UÔ#áØ�e‰OˆFØ!ˆNñ Ø�v˜tÐ#Ð#à˜2˜tÐ#Ð#ùò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ÓˆÜ�A�t—y‘yÓ!ˆÜ˜%Ó ˆÜˆu‹:˜Š?ô #ˆFð ˆð ‰GˆFØˆ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   ø€ ¨z¨q¯z©z¸4Ð/@€ 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Ž   ø€ ñ Ü˜$Ÿ)™)Ó%@ÈÔN‰FˆB�Ø$�4×$Ñ$ bÐ)¬5°«9Ð4Ð4ØŸ	™	 !™×1Ñ1Ó3‰ˆˆvØœŸ™ÑØ˜& 4§9¡9¨Q¨R =Ñ0Ð0Ð0Ü�v‰v�t—y‘yÐ Ð 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   € ð —i‘i ‘l D§I¡I¨a¨b Mˆtˆà�?Š?¡8¨u×/@Ò/@ØÐ+˜$×+Ñ+¨TÐ2Ð2Ð2Ü�v‰v�tˆ|Ðr)   c                 ó  — ddl m} ddlm} t	        | j
                  «      dk(  rçt        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(  r—ddlm}
  |
|dz  |	dz  z   «      }|j"                  r¦d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>                  råt;        |«      dk7  rÖtA        | j
                  D �	cg c]  }	|	jC                  «       ‘Œ c}	Ž \  }}t        d„ |D «       «      r’d}|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   è ø€ Ò&H¸ q§}¥}Ñ&HùrJ   Fr   )Úsqrt)Úfactor_terms)Úsign)Úexpand_multinomialéÿÿÿÿc              3   ó4   K  — | ]  }|j                   –— Œ y ­wrF   )Úis_Floatr   s     r   r   z"Add._eval_power.<locals>.<genexpr>ê  s   è ø€ Ò) !�1—:•:Ñ)ùrJ   )$Ú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È  € Ý'Ý%Üˆt�y‰y‹>˜QÒ¤3Ñ&H¸d¿i¹iÔ&HÔ#HØ�y‰y˜EÑ!¡e¨A¬q¯u©u£o¸Ñ&>à—y‘y‘��1Ø—7‘7œ1Ÿ?™?Ô+Ø˜a�q�AØ—g‘gœaŸo™oÓ.�Ù˜3×/Ò/°A×4FÒ4FØ×-Ò-Ü Ÿv™v˜Ø×-Ò-Ü ×0Ñ0Ð0ØØ�=Š=˜TŸ^š^Ù˜dÓ#ˆBÙØ‘��1Ø—3‘3˜!’8ÝMÙ˜Q ™T A q¡D™[Ó)�AØ—}’}Ý;ÝMÝ@á#¡L°!°a±%¸±Ó$;Ó<¸a¿c¹cÑA˜Ø#Ñ$6à ™U¤C¨£F™N©T°!«W´Q·_±_Ñ-DÑDÀqÇsÁsñ8Kó %Lñ  Lð Lð ˜"’WÜ+Ø˜AœaŸo™oÑ-Ñ-Ø˜1˜a™4 ! Q¡$™;™ó)ð )ð ð %ð ð$ �[Š[œS ›V qš[ä°4·9±9Ö=¨a˜Ÿ™Õ)Ò=Ð>‰DˆAˆqÜÑ) qÔ)Ô)Ø�Øò %�AÜ˜1“v “}Ü! !›f™ð%ð ˜’7¤<°°QÔ#7ÝIØ # ˜;�DØBCÖD¸Q A¨¡I™˜aœ°1°S±5Ñ8ÐD�AÐDÜ ´3°q¸!³9×"=©4¨1¨a 1 Q£3Ó"=Ð>ÀÑA�FØ ™6 &™=Ð(ð $8�7ð *ð )ˆ[ùâ=ùò 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ö  s-   € àˆt�y‰y¨d¯i©iÖ8¨˜1Ÿ6™6 !�9Ò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ú  sA   € ØBFÇ)Á)ÖL¸Q�—‘˜1 ¨°4�Õ8ÐLˆÐLØˆt�y‰y˜%Ð Ð ùò 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×#Ñ# D¨5¡L°)Ó<Ð<Ø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
                  |Ž r°d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   ø€ ˜aŸh™hÒ7¨1¯6©6°R¨<€ r)   c                 ó   — | j                   S rF   )rØ   )rŽ   s    r   r�   z&Add._combine_inverse.<locals>.<lambda>  s
   € ˜aŸf™f€ r)   )Ú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Ü�z‰zœ1×-Ñ-Ð.ˆØˆ3�7‰7�C‰=˜G˜CŸG™G S™MÝ%Ù�t“ˆBä—
‘
˜BÜ×"Ñ" R Cð)ˆDð '+§j¡j£l×3™d˜a �Q˜‘TÐ3ˆEÑ3Ø—‘˜dÓ# c§l¡l°4Ó&8Ñ8ˆBØ�v‰v�bŒzØ—Z‘ZÛ7Ù$ó&�ð —‘˜UÓ#‰Bà�s‘ˆBÙ�r‹lˆØ—m’mˆsÐ+¨Ð+ùó 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/   € ð$ �y‰y˜‰|Ð.˜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Ø×%Ñ%Ó'‰FˆB�Øˆr‰F�M‰M˜"Õð	ô
 ˆr‹7�aŠ<Ø—:‘:“<‰DˆAˆqØ�4—9‘9Ø23Ö4¨B”+˜d BÕ'Ò4ð6Ü7BÀ4ÈÓ7KðLð Lð —H‘H“Jò 	&‰DˆAˆqÜ�1‹v˜Š{Ø˜!™��1’à!˜Ÿ	™	 1˜��1’ð		&ô ,/´°R·X±X³ZÓ0@Ð+AÖB aœ$˜q�'ÒB‰ˆ�Øˆt�y‰yÜ!¤# f£+Ó.ö0Øô  ¨¨ ¨v°a©y¨kÑ!9¸FÀ1ÀqÁ5À6¸NÑ!JÒLò 0ð 1Ü25°v°,ð ˆô ˜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   øè ø€ ÒH°d�4×+Ñ+¨D×1ÑHùó   ƒ©rR   r!   ©r…   rÿ   s    `r   rü   zAdd._eval_is_polynomiali  s   ø€ ÜÓH¸d¿i¹iÔ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   øè ø€ ÒO¸T�4×2Ñ2°4×8ÑOùr   r  r  s    `r   r  zAdd._eval_is_rational_functionl  s   ø€ ÜÓOÀTÇYÁYÔ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ÑKù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ÑLù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   è ø€ Ò&�qˆ��Ñ&ùrJ   Tr
  r  rŠ   s    r   r�   zAdd.<lambda>w  s   € ¤Ù&˜DŸI™IÔ&°4ô"9€ r)   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  ó   è ø€ Ò/ ˆ×	Õ	Ñ/ùrJ   Tr
  r  rŠ   s    r   r�   zAdd.<lambda>y  ó   € ¬,Ù/ T§Y¡YÔ/¸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>|  ó   è ø€ Ò)˜!ˆ��Ñ)ùrJ   Tr
  r  rŠ   s    r   r�   zAdd.<lambda>{  ó   € ¤LÙ)˜tŸy™yÔ)°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   è ø€ Ò(˜ˆ��Ñ(ùrJ   Tr
  r  rŠ   s    r   r�   zAdd.<lambda>  s   € ¤<Ù(˜dŸi™iÔ(°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-Øˆ×Õñ5-ù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Œ  sH   € ØˆØ—‘ò 	ˆAØ—=‘=ˆDØˆ|ÙØ˜’à˜T‘>ÙØ‘ð	ð ˆr)   c                 ó¦  — g }g }| j                   D ]ì  }|j                  r/|j                  rŒ|j                  du r|j                  |«       Œ< y |j                  r#|j                  |t
        j                  z  «       Œm|j                  rst
        j                  |j                   v rW|j                  t
        j                  «      \  }}|t
        j                  fk(  r|j                  r|j                  | «       Œê y  y   | j                  |Ž }|| k7  r>|j                  r"t         | j                  |Ž j                  «      S |j                  du ryy y ©NF)r!   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Ø×!Ò!Ø—9’9ØØ—Y‘Y %Ñ'Ø—I‘I˜a•LáØ—’Ø—‘˜AœaŸo™oÑ-Õ.Ø—’œaŸo™o°·±Ñ7ØŸN™N¬1¯?©?Ó;‘	��rØœ!Ÿ/™/Ð+Ò+°×0FÒ0FØ—K‘K  Õ'ááð#	ð$ ˆD�I‰I�rˆNˆØ�Š9Ø�yŠyÜ   §¡¨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Ø×!Ò!Ø—9’9Ø˜‘F‘AØ—Y‘Y %Ñ'Ø—I‘I˜a•LáØ—’Ø�a‘‘Ø—’œaŸo™o°·±Ñ7ØŸN™N¬1¯?©?Ó;‘	��rØœ!Ÿ/™/Ð+Ò+°×0FÒ0FØ"‘Gááð#	ð$ ”�D—I‘I“ÒØÜˆr‹7�qœ#˜dŸi™i›.Ð)Ñ)ØØˆD�I‰I�rˆNˆØ�9Š9ÙØ˜’7ØØ˜1’WØ Ø�9‰9˜ÑØð 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Ð=ˆÐ=ÙØØˆQ‰4�;Š;Ø$�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   è ø€ Ò=°�q—}‘}¨Ô,Ñ=ùs   ‚TF)r!   Úis_irrationalr0   ÚremoverR   )r…   r{   r<   Úotherss       r   Ú_eval_is_irrationalzAdd._eval_is_irrationalå  s[   € Ø—‘ò 		ˆAØ—‘ˆAÙÜ˜dŸi™i›�Ø—‘˜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ò  sN   € ØˆˆˆRØ—‘ò 	ˆAØ×ÒÙÙ Ø‘Ø×!Ò!ÙÙ Ø‘áð	ð r)   c                 ó&  •— | j                   rt        ‰| �	  «       S | j                  «       \  }}|j                  sgddlm}  ||«      }|�W||z   }|| k7  r|j                  r|j                  ryt        | j                  «      dk(  r || «      }|�|| k7  r|j                  rydx}x}x}}	t        «       }
| j                  D �cg c]  }|j                  rŒ|‘Œ }}|sy|D ]u  }|j                  }|j                  }|r0|
j                  t        ||j                  f«      «       d|
v rd|
v r y |rd}ŒR|j                  rd}Œa|j                   rd}Œp|€ y d}	Œw |
rt        |
«      dkD  ry |
j#                  «       S |	ry |s|s|ry|s|ry|s|syy y c c}w ©Nr   ©Ú_monotonic_signTF)r­   ÚsuperÚ_eval_is_extended_positiver™   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Ø�yŠyÝ2Ù Ó"ˆAØˆ}Ø˜‘E�Ø˜’9 ×!7Ò!7¸A×<UÒ<UØÜ�t×(Ñ(Ó)¨QÒ.Ù'¨Ó-�AØ�}¨¨dª°q×7MÒ7MØ#Ø/4Ð4ˆÐ4ˆfÐ4�v Ü“%ˆØŸ9™9Ö6�a¨A¯I«I’Ð6ˆÐ6ÙØØò 	 ˆAØ×*Ñ*ˆEØ—}‘}ˆHÙØ—‘œH e¨Q×-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  óª   € Ø�~Š~Ø×$Ñ$Ó&‰DˆAˆqØ—9’9 ×!:Ò!:Ý6Ù# AÓ&�Ø�=Ø˜A™�AØ˜D’y Q×%>Ò%>Ø#Ü˜4×,Ñ,Ó-°Ò2Ù+¨DÓ1˜Ø˜=¨Q°$ªY¸1×;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  rºt        |«      }	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ó  € Ø�zŠzØ”a—j‘jÑ  c T¨T¯Y©YÑ%6à—}‘} s d¨S¨D \Ó2Ð2Øà!%×!2Ñ!2Ó!4Ñˆ
�JØ"×/Ñ/Ó1Ñˆ	�9à×!Ò! i×&;Ò&;Ø˜YÒ&Ø—y‘y  j°9°*Ó=Ð=Ø˜i˜ZÒ'Ø—y‘y #  z°9Ó=Ð=à×!Ò! i×&;Ò&;Ø Ó*Ø"&§)¡)×"5Ñ"5Øó#Ø ŸI™I×/Ñ/°
Ó;ð  ˆHä�8‹}œs 9›~Ò-Ü˜y›>�Ü˜h›-�à˜XÒ%Ø&¨Ñ0�GØ$˜4Ÿ9™9 S¨*°y°jð FØ<CÖ D°q §¡¨¨cÕ!2Ò DòFð Fð  Ÿ9™9×.Ñ.Ø�Jó �ä˜h›-�Ø˜XÒ%Ø&¨Ñ0�GØ$˜4Ÿ9™9 c T¨:°yð FØ<CÖ D°q §¡¨¨cÕ!2Ò 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±  s7   € ØŸ9™9Ö7�a¨A¯J«J’Ð7ˆÐ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?   € ØŸ9™9Ö3�a¨¯
«
’Ð3ˆÐ3ÙØ$�4×$Ñ$ dÐ+Ð+ð ùò 4s   �9¡9c                 ó¸  — ddl m} g }t        t        |«      r|n|g«      }|sdgt	        |«      z  }| j
                  D �cg c]  }| ||gt        ||«      ¢­Ž f‘Œ }}|D ]h  \  }}|D ]   \  }	}
|
j                  |«      sŒ|
|k7  sŒd} n |€Œ.||fg}|D ]/  \  }	}
|j                  |
«      r|
|k7  rŒ|j                  |	|
f«       Œ1 |}Œj t        |«      S c c}w )a`  
        Returns the leading term and its order.

        Examples
        ========

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

        r   ©Ú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Ô"6‘w¸W¸IÓFˆÙØ�Cœ˜G›Ñ$ˆEØ<@¿I¹IÖF°q�‘5˜Ð1œS ¨%Ó0Ò1Ò2ÐFˆÐFØò 	‰FˆB�Øò ‘��1Ø—:‘:˜b•> a¨2£gØ�BÙðð ˆzØØ˜B�x�jˆGØò '‘��1Ø—;‘;˜q”> a¨2¢gØØ—‘  1˜vÕ&ð'ð ‰Cð	ô �S‹zÐùò 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à  sw   € ð —	‘	ˆØ˜r�ˆØò 	ˆDØ×&Ñ&¨DÐ&Ó1‰FˆB�Ø�N‰N˜2ÔØ�N‰N˜2Õð	ð �—	‘	˜7Ð# Y T§Y¡Y°Ð%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   øè ø€ Ò5 aŒz˜!˜S×!Ñ5ùs   ƒ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Ý(à�I‰I‹KˆØˆ9Ù�a“ˆAØ�l‰l‹nˆà�7‰7�9ÔÙ  Ó%ˆCô Ó5¨4¯9©9Ô5Ô5Ø $¨T¸%ÈeØ#°EÀEÐTYØñ!ˆHð �#—*‘*Ñ(˜xÑ(ˆCÙ˜#‹ˆà�{Š{Ø×'Ñ'¨°¸4Ð'Ó@Ð@à#Ÿy™yÖ:˜!¨A¯M«M’AÐ:ˆÐ:à!% ‘�f”°4ˆØNRÏiÉiÖXÈ˜×*Ñ*¨1°5¸tÐ*ÕDÐXˆÐXá˜a› !ˆXˆð
	Ø%ò %�Ù˜d A›�Ù˜e¨3Ñ.Ø�CØ#‘HØ˜E’\Ø Ñ$‘Hñ%ð ˆ<Ø—}‘} U©C°«FÓ3ˆHà×"Ñ"ˆØˆ?Ø×(Ñ(Ó*×1Ñ1Ó3ˆHØ×&Ñ&ˆGØ�d‰?ðØ—X‘X“Z�ð �v‰v�fŒ~Ü—U‘U�Ù˜“(ˆCÜ—5‘5ˆDØ—,’,Ø×'Ñ'¨¨R°©W¸4ÀdÐ'ÓK×RÑRÓT×\Ñ\Ó^×gÑgÓi�Ø˜‘	�ð —,“,ð ×&Ñ& q¨t¸$Ð&Ó?Ð?àœŸ™ÑØ—8‘8×&Ñ& xÓ0°1Ñ4Ð4ð ˆOùò] ;ùò Yøô ò 	ØŠKð	ûô 'ò Ü—U‘U“ðú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+   € Øˆt�y‰y°·	±	Ö:¨1˜1Ÿ9™9�;Ò:Ð;Ð;ùÒ:ó   ›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  ó+   € Øˆt�y‰y°$·)±)Ö<¨Q˜1Ÿ;™;�=Ò<Ð=Ð=ùÒ<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  s1  € ðF ˆØˆØ—‘ò 	(ˆAØ—>‘>Ó#‰DˆAˆqØ—=’=Ü—E‘E�Ø�ØÒ/˜œa×/Ñ/Ð/ˆCØ�L‰L˜!Ÿ#™#˜qŸs™s A˜Õ'ð	(ñ Üœ$¨uÖ 5¨!  1£Ò 5°qÓ9ˆDÜœ$¨uÖ 5¨!  1£Ò 5°qÓ9‰Däœ$¨uÖ =¨!¸¸!»  1£Ò =¸qÓAˆDÜœ$¨uÖ =¨!¸¸!»  1£Ò =¸qÓAˆDà�4Ô˜1ÕÜ—5‘5˜$�;ÐÙÜ#,¨UÓ#3ò L‘�‘<�A�q˜$Ü&¤x°°D±¸4À¹7Ñ0CÓ'DÀdÓK��a’ñLô $-¨UÓ#3ò A‘�‘<�A�q˜$ÙÜ*¬8°Q¸±W¸tÀQ¹wÑ4GÓ+HÈ$ÓO�E˜!’Hä*¬8°A°q«>¸4Ó@�E˜!’Hð	Að �‰8×Ò  q¡¬Q×->Ñ->Ñ!>Ø—	‘	˜!“‰AàˆAÜ�ŒÙØ�L‰L˜˜AÔÜ˜˜dÓ#Ð%6 T×%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"   è ø€ ÒC°a�1—>‘>Ó# AÑ&×1Õ1ÑCùs   ‚')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¦  € ð( �D—I‘IØ48·I±Iö ?Ø/0ô !,¨Q×-CÑ-CØ 5ð .Dó .*ò !+ò  ?ð @ß@IÁ	Ãñ 	ˆˆTá˜SŸ^š^°·²Ø×'Ñ'Ó)‰FˆC�Ø�a‘ˆBÜÑC¸2¿7¹7ÔCÔCØ‘à�q‘�Ú�t—{“{à—9‘9ˆDØˆDØˆHØò ".�Ü'¬Ó-�	ÜŸ-™-¨Ó*ò D�BØ—y“yØ!Ÿ~™~Ó/™˜˜1ØŸ=›=¨Q¯\«\Ø% a§c¡c™N×1Ñ1´#´c¸!³f³+¸q¿s¹sÑ2BÕCð	Dñ
 !Øð8 �DˆyÐð7 Ð#Ü" 9§>¡>Ó#3Ó4‘Hà'¬#¨i¯n©nÓ.>Ó*?Ñ?�HÙ#Øð, �DˆyÐð+ —‘˜IÕ&ð".ð& ò *�AÜ! !§&¡&£(›^ò %˜Ø HÒ,ØŸE™E !�Hð%ð ò *˜Ü" A a¡D˜z˜˜!šñ*ð	*ð �Ø!ò 4�AÜœt°DÖ%9¨q a¨£dÒ%9¸1Ó=�AØ˜A“vØŸ™ ¤H¨Q°£NÑ!2Õ3ð4ñ Ü˜Q˜�AØ+/Ö0 R˜B˜q›DÐ0�DÐ0Ø˜Y˜TŸY™Y¨Ð-Ñ-�Dà�DˆyÐùò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   € å-Ü”V˜DŸI™IÐ+;Ô<Ó=Ð=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è  s0   € Ý@Øˆt�y‰y°4·9±9Ö=¨a™2˜a  D�>Ò=Ð>Ð>ùÒ=s   ¡6c                 óÞ   — ddl m} | j                  «       \  }}|j                  «       \  }}|t        j
                  k(  st        d«      ‚ ||«      j                   ||«      j                  fS )z;
        Convert self to an mpmath mpc if possible
        r   )ÚFloatz@Cannot convert Add to mpc. Must be of the form Number + Number*I)Únumbersrê  r™   r[   r   rª   ÚAttributeErrorÚ_mpf_)r…   rê  r—  Úrestr˜  Ú	imag_units         r   Ú_mpc_z	Add._mpc_ì  se   € õ
 	#Ø×)Ñ)Ó+‰ˆ�Ø!×.Ñ.Ó0Ñˆ�ØœAŸO™OÒ+ô !Ð!cÓdÐdá�g“×$Ñ$¡e¨G£n×&:Ñ&:Ð;Ð;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ñ9€Mñ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)   