Ë
    7^(h�©  ã                  óF  — d dl mZ d dlmZmZ d dlmZ d dlmZ d dl	m
Z
 ddlmZ ddlmZ dd	lmZmZmZ dd
lmZ ddlmZmZ ddlmZ ddlmZmZ ddlmZ ddlm Z  d dl!m"Z"m#Z# erd dl$m%Z% d dl&m'Z' d„ Z(d„ Z)d„ Z* G d„ dee«      Z+ ed«      Z,ddl-m.Z.m/Z/m0Z0 ddl1m2Z2 y)é    )Úannotations)ÚTYPE_CHECKINGÚClassVar)Údefaultdict)Úreduce)Ú
attrgetteré   )Ú_args_sortkey)Úglobal_parameters)Ú_fuzzy_groupÚfuzzy_orÚ	fuzzy_not)ÚS)ÚAssocOpÚAssocOpDispatcher)Úcacheit)ÚilcmÚigcd)ÚExpr)ÚUndefinedKind)Úis_sequenceÚsift)ÚNumber©ÚOrderc                óØ   — t        d„ | j                  D «       «      }t        | j                  «      |z
  }||kD  ry||k  ryt        | j	                  «       |  j	                  «       k  «      S )Nc              3  ó@   K  — | ]  }|j                  «       rd –— Œ y­w)r	   N)Úcould_extract_minus_sign)Ú.0Úis     úL/var/www/skyplay_api_hub/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!   Ú_addsortr1   (   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Úappendr1   Ú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dZeZded<   e	rddœd>d„Z
ed?d„«       Zed@d	„«       Zed
„ «       Zed„ «       Zd„ Zed„ «       ZdAdBd„Zd„ Zed„ «       ZdCd„Zd„ ZdDd„Zed„ «       Zed„ «       ZdEd„Zd„ Zd„ Zd„ Z d„ Z!d„ Z"d„ Z#d„ Z$d„ Z%d„ Z&d „ Z'd!„ Z(d"„ Z)d#„ Z*d$„ Z+d%„ Z,d&„ Z-d'„ Z.d(„ Z/d)„ Z0d*„ Z1ˆ fd+„Z2d,„ Z3d-„ Z4ˆ fd.„Z5d/„ Z6d0„ Z7d1„ Z8edFd2„«       Z9dGd3„Z:d4„ Z;d5„ Z<d6„ Z=d7„ Z>d8„ Z?dHd9„Z@ed:„ «       ZAd;„ ZBed<„ «       ZCˆ fd=„ZDˆ xZES )Ir;   a¬	  
    Expression representing addition operation for algebraic group.

    .. deprecated:: 1.7

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

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

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

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

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

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

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

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

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

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

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

    Examples
    ========

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

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

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

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

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

    Note that the printers do not display in args order.

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

    See Also
    ========

    MatAdd

    © TzClassVar[Expr]Úidentity©Úevaluatec                ó   — y ©NrB   )ÚclsrE   r$   s      r!   Ú__new__zAdd.__new__¾   s   € Ør,   c                 ó   — y rG   rB   ©Úselfs    r!   r$   zAdd.argsÁ   s   € àr,   c                óV  ‡‡— ddl m} ddlm} ddlm}m} d}t        |«      dk(  rU|\  }}|j                  r||}}|j                  r|j                  r||gg df}|rt        d„ |d   D «       «      r|S g |d   dfS i }	t        j                  }
g }g }|D �]Í  Š‰j                  rT‰j                  j                  rŒ't!        ˆfd„|D «       «      rŒ<|D �cg c]  }‰j#                  |«      rŒ|‘Œ }}‰g|z   }Œd‰j$                  r“‰t        j&                  u s |
t        j(                  u r&‰j*                  d	u r|st        j&                  gg dfc S |
j$                  st-        |
|«      r/|
‰z  }
|
t        j&                  u r|st        j&                  gg dfc S �Œt-        ‰|«      r‰j/                  |
«      }
�Œ"t-        ‰|«      r|j1                  ‰«       �ŒAt-        ‰|«      r |‰|
«      j3                  d	¬
«      }
�Œh‰t        j(                  u r8|
j*                  d	u r|st        j&                  gg dfc S t        j(                  }
�Œ²‰j4                  r‰j6                  }|j9                  |«       �ŒÝ‰j                  r‰j;                  «       \  }}nŠ‰j<                  rl‰j?                  «       \  }}|j$                  r:|j@                  s|j                  r"|jB                  r|j1                  ||z  «       �Œbt        jD                  ‰}}nt        jD                  }‰}||	v r>|	|xx   |z  cc<   |	|   t        j&                  u s�Œ¯|r�Œ³t        j&                  gg dfc S ||	|<   �ŒÐ g }d	}|	jG                  «       D ]Ç  \  }}|j                  rŒ|t        jD                  u r|j1                  |«       n€|j                  r/ |jH                  |f|j6                  z   Ž }|j1                  |«       nE|j4                  r|j1                  tK        ||d	¬«      «       n|j1                  tK        ||«      «       |xs |jL                   }ŒÉ |
t        jN                  u r*|D �cg c]  }|jP                  rŒ|jR                  rŒ|‘Œ  }}n;|
t        jT                  u r)|D �cg c]  }|jV                  rŒ|jR                  rŒ|‘Œ  }}|
t        j(                  u r'|D �cg c]  }|j*                  r|jX                  €|‘Œ }}|r^g }|D ](  Št!        ˆfd„|D «       «      rŒ|j1                  ‰«       Œ* ||z   }|D ]%  Š‰j#                  |
«      sŒt        j                  }
 n t[        |«       |
t        j                  ur|j]                  d|
«       |r||z  }d}|rg |dfS |g dfS c c}w c c}w c c}w c c}w )a…  
        Takes the sequence "seq" of nested Adds and returns a flatten list.

        Returns: (commutative_part, noncommutative_part, order_symbols)

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

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

        See Also
        ========

        sympy.core.mul.Mul.flatten

        r   )ÚAccumBounds)Ú
MatrixExpr)ÚTensExprÚTensAddNé   c              3  ó4   K  — | ]  }|j                   –— Œ y ­wrG   ©Úis_commutative)r   Úss     r!   r"   zAdd.flatten.<locals>.<genexpr>ã   s   è ø€ Ò7¨A�q×'Õ'Ñ7ùó   ‚c              3  ó@   •K  — | ]  }|j                  ‰«      –— Œ y ­wrG   ©Úcontains)r   Úo1Úos     €r!   r"   zAdd.flatten.<locals>.<genexpr>ù   s   øè ø€ Ò>¨"�r—{‘{ 1—~Ñ>ùó   ƒF©ÚdeeprD   c              3  ó@   •K  — | ]  }|j                  ‰«      –— Œ y ­wrG   rY   )r   r\   Úts     €r!   r"   zAdd.flatten.<locals>.<genexpr>~  s   øè ø€ Ò@¨Q˜1Ÿ:™: aŸ=Ñ@ùr]   T)/Ú!sympy.calculus.accumulationboundsrN   Úsympy.matrices.expressionsrO   Úsympy.tensor.tensorrP   rQ   r%   Úis_RationalÚis_MulÚallr   r4   Úis_Orderr(   Úis_zeroÚanyrZ   r8   ÚNaNÚComplexInfinityÚ	is_finiteÚ
isinstanceÚ__add__r9   Údoitr6   r$   r7   Úas_coeff_MulÚis_PowÚas_base_expÚ
is_IntegerÚis_negativeÚOneÚitemsÚ_new_rawargsÚMulrU   ÚInfinityÚis_extended_nonnegativeÚis_realÚNegativeInfinityÚis_extended_nonpositiveÚis_extended_realr1   r:   )rH   ÚseqrN   rO   rP   rQ   Úrvr?   ÚbÚtermsÚcoeffÚorder_factorsÚextrar[   Úo_argsÚcrV   ÚeÚnewseqÚnoncommutativeÚcsÚfÚnewseq2r\   ra   s                          @@r!   ÚflattenzAdd.flattenÅ   s)  ù€ õ$ 	BÝ9ß9ØˆÜˆs‹8�qŠ=Ø‰DˆAˆqØ�}Š}Ø˜!�1�Ø�}Š}Ø—8’8Ø˜Q˜  TÐ)�BÙÜÑ7°°A±Ô7Ô7Ø�IØ˜2˜a™5 $�Ð&ð %'ˆô —f‘fˆà%'ˆà"$ˆàó S	ˆAð �zŠzØ—6‘6—>’>ØÜÓ>°Ô>Ô>ØØ.;Ö R¨À1Ç:Á:ÈbÅ>¢Ð R�Ð RØ!"  mÑ 3�Øð —’ØœŸ™‘J %¬1×+<Ñ+<Ñ"<ØŸ™ uÑ,±eäŸE™E˜7 B¨Ð,Ò,Ø—?’?¤j°¸Ô&DØ˜Q‘J�EØ¤§¡‘~©eä !§¡˜w¨¨DÐ0Ò0Ùä˜A˜{Ô+ØŸ	™	 %Ó(�Ùä˜A˜zÔ*à—‘˜Q”Ùä˜A˜xÔ(Ù  5Ó)×.Ñ.°EÐ.Ó:�Ùà”a×'Ñ'Ñ'Ø—?‘? eÑ+±EäŸE™E˜7 B¨Ð,Ò,Ü×)Ñ)�Ùð —’à+,¯6©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“ðgS	ðn ˆØˆØ—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ð1	Dð6 ”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Øò &�äÓ@°-Ô@Õ@Ø—N‘N 1Õ%ð&ð ˜}Ñ,ˆFà"ò �Ø—:‘:˜eÕ$ÜŸF™F�EÙðô 	�Ôð œŸ™ÑØ�M‰M˜!˜UÔ#áØ�e‰OˆFØ!ˆNñ Ø�v˜tÐ#Ð#à˜2˜tÐ#Ð#ùòw !SùòZ Yùò YùòQs6   ÃVÃ+VÑVÑ+VÑ8VÒV!Ò'V!Ò4V!Ó!V&c                ó    — dd| j                   fS )Né   r	   )Ú__name__)rH   s    r!   Ú	class_keyzAdd.class_key˜  s   € à�!�S—\‘\Ð!Ð!r,   c                ó’   — t        d«      }t        || j                  «      }t        |«      }t	        |«      dk7  rt
        }|S |\  }|S )NÚkindr	   )r   Úmapr$   Ú	frozensetr%   r   )rL   ÚkÚkindsÚresults       r!   r•   zAdd.kindœ  sM   € ä�vÓˆÜ�A�t—y‘yÓ!ˆÜ˜%Ó ˆÜˆu‹:˜Š?ô #ˆFð ˆð ‰GˆFØˆr,   c                ó   — t        | «      S rG   )r+   rK   s    r!   r   zAdd.could_extract_minus_sign©  s   € Ü(¨Ó.Ð.r,   c                ó<  ‡— ‰r8t        | j                  ˆfd„d¬«      \  }} | j                  |Ž t        |«      fS | j                  d   j	                  «       \  }}|t
        j                  ur||| j                  dd z   fS t
        j                  | j                  fS )aR  
        Returns a tuple (coeff, args) where self is treated as an Add and coeff
        is the Number term and args is a tuple of all other terms.

        Examples
        ========

        >>> from sympy.abc import x
        >>> (7 + 3*x).as_coeff_add()
        (7, (3*x,))
        >>> (7*x).as_coeff_add()
        (0, (7*x,))
        c                ó"   •—  | j                   ‰Ž S rG   )Úhas_free)ÚxÚdepss    €r!   ú<lambda>z"Add.as_coeff_add.<locals>.<lambda>¼  s   ø€ ¨z¨q¯z©z¸4Ð/@€ r,   T)Úbinaryr   r	   N)r   r$   rx   ÚtupleÚas_coeff_addr   r4   )rL   r    Úl1Úl2r„   Únotrats    `    r!   r¤   zAdd.as_coeff_add¬  sŽ   ø€ ñ Ü˜$Ÿ)™)Ó%@ÈÔ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$   r8   re   rx   r   r4   )rL   Úrationalr    r„   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"                  rtdd	lm} dd
lm} ddlm}  |
 |||z
  dz  «      «      |j8                  z  }| |||z   t;        |	«      z   ||	«      t        j                  z  z   |j8                  z  «      z  S y |dk(  r,t=        ||	t        j                  z  z
  d|dz  |	dz  z   z  «      S y y y y )Nr	   )Úpure_complex)Úis_eqrR   c              3  ó4   K  — | ]  }|j                   –— Œ y ­wrG   )Úis_infinite)r   Ú_s     r!   r"   z"Add._eval_power.<locals>.<genexpr>Ô  s   è ø€ Ò&H¸ q§}¥}Ñ&HùrW   Fr   )Úsqrt)Úfactor_terms)Úsign)Úexpand_multinomialéÿÿÿÿ)Úevalfr¬   Ú
relationalr­   r%   r$   rj   ri   r   rv   r„   ÚImaginaryUnitr   Úis_extended_negativer4   Úis_extended_positiverl   re   Ú	is_numberÚqÚ(sympy.functions.elementary.miscellaneousr±   Ú	exprtoolsr²   Ú$sympy.functions.elementary.complexesr³   Úfunctionr´   ÚpÚabsÚ_unevaluated_Mul)rL   Úexptr¬   r­   r?   r‚   ÚicoÚriÚrr    r±   ÚDr²   r³   r´   Úroots                   r!   Ú_eval_powerzAdd._eval_powerÑ  sË  € Ý'Ý%Üˆt�y‰y‹>˜QÒ¤3Ñ&H¸d¿i¹iÔ&HÔ#HØ�|‰|˜uÑ$©¨t´Q·U±UÓ);¸uÑ)Dà—y‘y‘��1Ø—7‘7œ1Ÿ?™?Ô+Ø˜a�q�AØ—g‘gœaŸo™oÓ.�Ù˜3×/Ò/°A×4FÒ4FØ×0Ò0Ü Ÿv™v˜Ø×0Ò0Ü ×0Ñ0Ð0ØØ×Ò §¢Ù˜dÓ#ˆBÙØ‘��1Ø—6‘6˜Q’;ÝMÙ˜Q ™T A q¡D™[Ó)�AØ—}’}Ý;ÝMÝ@á#¡L°!°a±%¸±Ó$;Ó<¸d¿f¹fÑD˜Ø#Ñ$6à ™U¤C¨£F™N©T°!«W´Q·_±_Ñ-DÑDÀtÇvÁvñ8Nó %Oñ  Oð Oð %ð ˜R’ZÜ+Ø˜AœaŸo™oÑ-Ñ-Ø˜1˜a™4 ! Q¡$™;™ó)ð )ð  ð ð !/Ðr,   c                óx   —  | j                   | j                  D �cg c]  }|j                  |«      ‘Œ c}Ž S c c}w rG   )Úfuncr$   Údiff)rL   rV   r?   s      r!   Ú_eval_derivativezAdd._eval_derivativeö  s-   € àˆ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Ì   )rL   rŸ   rÑ   rÒ   rÓ   ra   rƒ   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)rL   r(   Ú	repl_dictr„   rƒ   s        r!   Ú_matches_simplezAdd._matches_simpleþ  s=   € à×(Ñ(Ó*‰ˆˆuÜˆu‹:˜Š?Ø˜‘8×#Ñ# D¨5¡L°)Ó<Ð<Ør,   c                ó(   — | j                  |||«      S rG   )Ú_matches_commutative)rL   r(   rØ   Úolds       r!   r×   zAdd.matches  s   € Ø×(Ñ(¨¨y¸#Ó>Ð>r,   c                ó2  ‡— ddl m} t        j                  t        j                  f} | j
                  |Ž s |j
                  |Ž 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 rG   )rr   Ú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 rG   )râ   )rŸ   s    r!   r¡   z&Add._combine_inverse.<locals>.<lambda>  s
   € ˜aŸf™f€ r,   )Úsympy.simplify.simplifyrÞ   r   rz   r}   ÚhasÚsymbolrß   rw   ÚxreplaceÚreplacer8   )ÚlhsÚrhsrÞ   Úinfrß   Úrepsr˜   ÚvÚirepsÚeqr�   Úsrvrà   s               @r!   Ú_combine_inversezAdd._combine_inverse  sô   ø€ õ 	5Ü�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$   rx   rK   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 �	�
ci c](  \  }	}
|	t        |
«      dkD  r | j                  |
Ž n|
d   “Œ* }}	}
t        t        |j                  «       «      Ž D �cg c]  }t        |«      ‘Œ c}\  }} | j                  t!        t        |«      «      D �cg c]  }t        |d| ||   gz   ||dz   d z   Ž ‘Œ c}Ž t        |Ž }	}
t        ||
«      t        ||	«      fS c c}w c c}
}	w c c}w c c}w )a~  
        Decomposes an expression to its numerator part and its
        denominator part.

        Examples
        ========

        >>> from sympy.abc import x, y, z
        >>> (x*y/z).as_numer_denom()
        (x*y, z)
        >>> (x*(y + 1)/y**7).as_numer_denom()
        (x*(y + 1), y**7)

        See Also
        ========

        sympy.core.expr.Expr.as_numer_denom
        FrD   r	   r   N)Ú	primitivern   r;   ry   Úas_numer_denomr   r3   r$   r9   r%   ÚpopitemrÌ   Ú_keep_coeffrw   ÚzipÚiterÚrange)rL   Úcontentr(   ÚnconÚdconÚndr�   ÚniÚdiÚdrÑ   Únd2r    ÚdenomsÚnumerss                  r!   rö   zAdd.as_numer_denom6  sÙ  € ð( Ÿ™Ó(‰ˆ�Ü˜$¤Ô$Ü�w ¨uÔ5×DÑDÓFÐFØ×+Ñ+Ó-‰
ˆˆdô œÓˆØ—‘ò 	ˆAØ×%Ñ%Ó'‰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ð EGÇHÁHÃJ×O¹D¸A¸qˆq¤3 q£6¨A¢:�)�$—)‘)˜Q‘-°1°Q±4Ñ7ÐOˆÑOô ,/´°S·Y±Y³[Ó0AÐ+BÖC aœ$˜q�'ÒC‰ˆ�Øˆ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ùó Pùò Dùò0s   ÃGÄ-GÅGÆ"G"c                ó@   ‡— t        ˆfd„| j                  D «       «      S )Nc              3  ó@   •K  — | ]  }|j                  ‰«      –— Œ y ­wrG   )Ú_eval_is_polynomial©r   ÚtermÚsymss     €r!   r"   z*Add._eval_is_polynomial.<locals>.<genexpr>f  s   øè ø€ ÒH°d�4×+Ñ+¨D×1ÑHùr]   ©rg   r$   ©rL   r  s    `r!   r  zAdd._eval_is_polynomiale  s   ø€ ÜÓH¸d¿i¹iÔHÓHÐHr,   c                ó@   ‡— t        ˆfd„| j                  D «       «      S )Nc              3  ó@   •K  — | ]  }|j                  ‰«      –— Œ y ­wrG   )Ú_eval_is_rational_functionr	  s     €r!   r"   z1Add._eval_is_rational_function.<locals>.<genexpr>i  s   øè ø€ ÒO¸T�4×2Ñ2°4×8ÑOùr]   r  r  s    `r!   r  zAdd._eval_is_rational_functionh  s   ø€ ÜÓOÀTÇYÁYÔOÓOÐOr,   c                óH   ‡‡— t        ˆˆfd„| j                  D «       d¬«      S )Nc              3  óB   •K  — | ]  }|j                  ‰‰«      –— Œ y ­wrG   )Úis_meromorphic)r   Úargr?   rŸ   s     €€r!   r"   z+Add._eval_is_meromorphic.<locals>.<genexpr>l  s   øè ø€ ÒK¸#˜S×/Ñ/°°1×5ÑKùs   ƒT©Ú
quick_exit©r   r$   )rL   rŸ   r?   s    ``r!   Ú_eval_is_meromorphiczAdd._eval_is_meromorphick  s   ù€ ÜÔKÀÇÁÔKØ'+ô-ð 	-r,   c                ó@   ‡— t        ˆfd„| j                  D «       «      S )Nc              3  ó@   •K  — | ]  }|j                  ‰«      –— Œ y ­wrG   )Ú_eval_is_algebraic_exprr	  s     €r!   r"   z.Add._eval_is_algebraic_expr.<locals>.<genexpr>p  s   øè ø€ ÒL¸$�4×/Ñ/°×5ÑLùr]   r  r  s    `r!   r  zAdd._eval_is_algebraic_expro  s   ø€ ÜÓLÀ$Ç)Á)ÔLÓLÐLr,   c                ó>   — t        d„ | j                  D «       d¬«      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrG   )r|   ©r   r?   s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>t  s   è ø€ Ò&�qˆ��Ñ&ùrW   Tr  r  rK   s    r!   r¡   zAdd.<lambda>s  s   € ¤Ù&˜DŸI™IÔ&°4ô"9€ r,   c                ó>   — t        d„ | j                  D «       d¬«      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrG   )r   r  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>v  ó   è ø€ Ò/ ˆ×	Õ	Ñ/ùrW   Tr  r  rK   s    r!   r¡   zAdd.<lambda>u  ó   € ¬,Ù/ T§Y¡YÔ/¸Dô+B€ r,   c                ó>   — t        d„ | j                  D «       d¬«      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrG   )Ú
is_complexr  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>x  ó   è ø€ Ò)˜!ˆ��Ñ)ùrW   Tr  r  rK   s    r!   r¡   zAdd.<lambda>w  ó   € ¤LÙ)˜tŸy™yÔ)°dô%<€ r,   c                ó>   — t        d„ | j                  D «       d¬«      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrG   )Úis_antihermitianr  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>z  r!  rW   Tr  r  rK   s    r!   r¡   zAdd.<lambda>y  r"  r,   c                ó>   — t        d„ | j                  D «       d¬«      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrG   )rm   r  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>|  s   è ø€ Ò(˜ˆ��Ñ(ùrW   Tr  r  rK   s    r!   r¡   zAdd.<lambda>{  s   € ¤<Ù(˜dŸi™iÔ(°Tô$;€ r,   c                ó>   — t        d„ | j                  D «       d¬«      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrG   )Úis_hermitianr  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>~  ó   è ø€ Ò+˜Aˆ��Ñ+ùrW   Tr  r  rK   s    r!   r¡   zAdd.<lambda>}  ó   € ¤lÙ+ §¡Ô+¸ô'>€ r,   c                ó>   — t        d„ | j                  D «       d¬«      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrG   )Ú
is_integerr  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>€  r&  rW   Tr  r  rK   s    r!   r¡   zAdd.<lambda>  r'  r,   c                ó>   — t        d„ | j                  D «       d¬«      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrG   ©Úis_rationalr  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>‚  s   è ø€ Ò*˜1ˆ��Ñ*ùrW   Tr  r  rK   s    r!   r¡   zAdd.<lambda>�  s   € ¤\Ù* §	¡	Ô*°tô&=€ r,   c                ó>   — t        d„ | j                  D «       d¬«      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrG   )Úis_algebraicr  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>„  r0  rW   Tr  r  rK   s    r!   r¡   zAdd.<lambda>ƒ  r1  r,   c                ó:   — t        d„ | j                  D «       «      S )Nc              3  ó4   K  — | ]  }|j                   –— Œ y ­wrG   rT   r  s     r!   r"   zAdd.<lambda>.<locals>.<genexpr>…  s   è ø€ ò 5-Øˆ×Õñ5-ùrW   r  rK   s    r!   r¡   zAdd.<lambda>…  s   € ¬ñ 5-Ø"&§)¡)ô5-ó )-€ r,   c                óf   — d}| j                   D ]  }|j                  }|€ y |du sŒ|du r y d}Œ! |S )NFT)r$   r¯   )rL   Úsawinfr?   Úainfs       r!   Ú_eval_is_infinitezAdd._eval_is_infiniteˆ  sH   € ØˆØ—‘ò 	ˆAØ—=‘=ˆDØˆ|ÙØ˜’à˜T‘>ÙØ‘ð	ð ˆr,   c                ó¦  — g }g }| j                   D ]ì  }|j                  r/|j                  rŒ|j                  du r|j                  |«       Œ< y |j                  r#|j                  |t
        j                  z  «       Œm|j                  rst
        j                  |j                   v rW|j                  t
        j                  «      \  }}|t
        j                  fk(  r|j                  r|j                  | «       Œê y  y   | j                  |Ž }|| k7  r>|j                  r"t         | j                  |Ž j                  «      S |j                  du ryy y ©NF)r$   r   ri   r9   Úis_imaginaryr   r¸   rf   Úas_coeff_mulrÌ   r   )rL   ÚnzÚim_Ir?   r„   Úair‚   s          r!   Ú_eval_is_imaginaryzAdd._eval_is_imaginary•  s  € ØˆØˆØ—‘ò 	ˆAØ×!Ò!Ø—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)rU   r$   r   ri   r9   rD  rf   r   r¸   rE  r%   rÌ   )	rL   rF  ÚzÚim_or_zÚimr?   r„   rH  r‚   s	            r!   Ú_eval_is_zerozAdd._eval_is_zero±  s?  € Ø×Ñ %Ñ'ð ØˆØˆØˆØˆØ—‘ò 	ˆAØ×!Ò!Ø—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_oddrx   )rL   r�   Ú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)TNr7  )r   rŸ   s     r!   r"   z*Add._eval_is_irrational.<locals>.<genexpr>ç  s   è ø€ Ò=°�q—}‘}¨Ô,Ñ=ùs   ‚TF)r$   Úis_irrationalr3   Úremoverg   )rL   ra   r?   Úotherss       r!   Ú_eval_is_irrationalzAdd._eval_is_irrationalá  s[   € Ø—‘ò 		ˆAØ—‘ˆAÙÜ˜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)rL   ÚnnÚnpr?   s       r!   Ú_all_nonneg_or_nonpposzAdd._all_nonneg_or_nonpposî  sN   € ØˆˆˆRØ—‘ò 	ˆAØ×ÒÙÙ Ø‘Ø×!Ò!ÙÙ Ø‘áð	ð r,   c                ó&  •— | j                   rt        ‰| �	  «       S | j                  «       \  }}|j                  sgddlm}  ||«      }|�W||z   }|| k7  r|j                  r|j                  ryt        | j                  «      dk(  r || «      }|�|| k7  r|j                  rydx}x}x}}	t        «       }
| j                  D �cg c]  }|j                  rŒ|‘Œ }}|sy|D ]u  }|j                  }|j                  }|r0|
j                  t        ||j                  f«      «       d|
v rd|
v r y |rd}ŒR|j                  rd}Œa|j                   rd}Œp|€ y d}	Œw |
rt        |
«      dkD  ry |
j#                  «       S |	ry |s|s|ry|s|ry|s|syy y c c}w ©Nr	   ©Ú_monotonic_signTF)r»   ÚsuperÚ_eval_is_extended_positiverª   ri   r¾   rc  rº   r{   r%   Úfree_symbolsÚsetr$   r¯   Úaddr   r~   r5   )rL   rˆ   r?   rc  rí   rV   ÚposÚnonnegÚnonposÚunknown_signÚsaw_INFr$   ÚisposÚinfiniteÚ	__class__s                 €r!   re  zAdd._eval_is_extended_positiveþ  ó²  ø€ Ø�>Š>Ü‘7Ñ5Ó7Ð7Ø× Ñ Ó"‰ˆˆ1Ø�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	   rb  T)r»   rª   ri   r{   r¾   rc  r%   rf  ©rL   rˆ   r?   rc  rí   rV   s         r!   Ú_eval_is_extended_nonnegativez!Add._eval_is_extended_nonnegative4  óª   € Ø�~Š~Ø×$Ñ$Ó&‰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 rt  )r»   rª   ri   r~   r¾   rc  r%   rf  ru  s         r!   Ú_eval_is_extended_nonpositivez!Add._eval_is_extended_nonpositiveC  rw  r,   c                ó&  •— | j                   rt        ‰| �	  «       S | j                  «       \  }}|j                  sgddlm}  ||«      }|�W||z   }|| k7  r|j                  r|j                  ryt        | j                  «      dk(  r || «      }|�|| k7  r|j                  rydx}x}x}}	t        «       }
| j                  D �cg c]  }|j                  rŒ|‘Œ }}|sy|D ]u  }|j                  }|j                  }|r0|
j                  t        ||j                  f«      «       d|
v rd|
v r y |rd}ŒR|j                  rd}Œa|j                   rd}Œp|€ y d}	Œw |
rt        |
«      dkD  ry |
j#                  «       S |	ry |s|s|ry|s|ry|s|syy y c c}w ra  )r»   rd  Ú_eval_is_extended_negativerª   ri   r¾   rc  r¹   r~   r%   rf  rg  r$   r¯   rh  r   r{   r5   )rL   rˆ   r?   rc  rí   rV   Únegrk  rj  rl  rm  r$   Úisnegro  rp  s                 €r!   r{  zAdd._eval_is_extended_negativeR  rq  rr  c           
     óÌ  — |j                   s7|t        j                  u r$| | j                  v r| j	                  | | i«      S y | j                  «       \  }}|j                  «       \  }}|j                  r?|j                  r3||k(  r| j                  ||| «      S || k(  r| j                  | ||«      S |j                  r|j                  s||k(  �r| j                  j                  |«      | j                  j                  |«      }}t        |«      t        |«      k  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 rG   )r6   r   rz   r$   rç   rª   re   rÌ   Ú	make_argsr%   rg  Ú_subs)rL   rÜ   ÚnewÚ
coeff_selfÚ
terms_selfÚ	coeff_oldÚ	terms_oldÚargs_oldÚ	args_selfÚself_setÚold_setÚret_setrV   s                r!   Ú
_eval_subszAdd._eval_subsˆ  só  € Ø�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 rG   ©r$   rh   rx   ©rL   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 rG   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   r   N)
Úsympy.series.orderr   r3   r   r%   r$   rù   rZ   r9   r£   )rL   ÚsymbolsÚpointr   Úlstr�   r€   ÚefÚofr‰   r\   Únew_lsts               r!   Úextract_leading_orderzAdd.extract_leading_order¶  s  € õ" 	-ØˆÜ¤+¨gÔ"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)
        r^   )r$   Úas_real_imagr9   rÌ   )	rL   r_   ÚhintsÚsargsÚre_partÚim_partr
  ÚrerM  s	            r!   rœ  zAdd.as_real_imagÜ  sw   € ð —	‘	ˆØ˜r�ˆØò 	ˆDØ×&Ñ&¨DÐ&Ó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«      t*        j,                  }}	 |D ]   } |||«      }|r||vr|}|}Œ||v sŒ||z  }Œ" 	 |€|j1                  | ‰|«      «      }|j2                  }|€*|j5                  «       j7                  «       }|j2                  }|d	u r¾	 |j9                  «       }|j                  |«      rt*        j<                  } |d«      }t*        j<                  }|j>                  rT|jA                  |||z   ||¬«      j7                  «       jC                  «       j5                  «       }|dz  }|j>                  rŒT|j'                  |||¬«      S |t*        jD                  u r|jF                  jI                  |«      |
z   S |S c c}w c c}w # t.        $ r |cY S w xY w# t:        $ r t*        j<                  }Y �Œw xY w)Nr   )rß   ÚSymbolr   )Úlog)Ú	PiecewiseÚpiecewise_foldr	   )Ú
expand_mulc              3  ó6   •K  — | ]  }t        |‰«      –— Œ y ­wrG   )rn   )r   r?   r¤  s     €r!   r"   z,Add._eval_as_leading_term.<locals>.<genexpr>  s   øè ø€ Ò5 aŒz˜!˜S×!Ñ5ùs   ƒTF)	r_   r¤  ÚmulÚ	power_expÚ
power_baseÚmultinomialÚbasicÚforceÚfactor)rÒ   rÓ   rÒ   rÐ   rR   rB   )%Úsympy.core.symbolrß   r£  r“  r   Ú&sympy.functions.elementary.exponentialr¤  Ú$sympy.functions.elementary.piecewiser¥  r¦  rÀ   r§  r‘  r�  rå   rj   r$   Úexpandr6   Úas_leading_termr¯   r   r4   Ú	TypeErrorÚsubsri   ÚtrigsimpÚcancelÚgetnÚNotImplementedErrorrv   rh   rÕ   Úpowsimprk   rÌ   r<   )rL   rŸ   rÒ   rÓ   rß   r£  r   r¥  r¦  r§  r\   rÜ   Úlogflagsr(   ra   ro  Ú_logxÚleading_termsÚminÚnew_exprr
  Úorderri   Ún0ÚresÚincrr¤  s                             @r!   Ú_eval_as_leading_termzAdd._eval_as_leading_termó  sÃ  ø€ ß3Ý,Ý>ßRÝ(à�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-ÄJ2ÅJ7 ÅJ7 Æ>K Ê7KËKËK%Ë$K%c                óv   —  | j                   | j                  D �cg c]  }|j                  «       ‘Œ c}Ž S c c}w rG   )rÌ   r$   Úadjoint©rL   ra   s     r!   Ú_eval_adjointzAdd._eval_adjoint>  s+   € Øˆt�y‰y°·	±	Ö:¨1˜1Ÿ9™9�;Ò:Ð;Ð;ùÒ:ó   ›6c                óv   —  | j                   | j                  D �cg c]  }|j                  «       ‘Œ c}Ž S c c}w rG   )rÌ   r$   Ú	conjugaterÈ  s     r!   Ú_eval_conjugatezAdd._eval_conjugateA  ó+   € Øˆt�y‰y°$·)±)Ö<¨Q˜1Ÿ;™;�=Ò<Ð=Ð=ùÒ<rÊ  c                óv   —  | j                   | j                  D �cg c]  }|j                  «       ‘Œ c}Ž S c c}w rG   )rÌ   r$   Ú	transposerÈ  s     r!   Ú_eval_transposezAdd._eval_transposeD  rÎ  rÊ  c                ó¢  — g }d}| j                   D ]q  }|j                  «       \  }}|j                  st        j                  }|}|xs |t        j
                  u }|j                  |j                  |j                  |f«       Œs |sEt        t        |D �cg c]  }|d   ‘Œ	 c}d«      }t        t        |D �cg c]  }|d   ‘Œ	 c}d«      }nPt        t        |D �cg c]  }|d   sŒ	|d   ‘Œ c}d«      }t        t        |D �cg c]  }|d   sŒ	|d   ‘Œ c}d«      }||cxk(  rdk(  rn nt        j                  | fS |s9t        |«      D ]*  \  }	\  }
}}t        t        |
|z  ||z  z  «      |«      ||	<   Œ, nTt        |«      D ]F  \  }	\  }
}}|r"t        t        |
|z  ||z  z  «      |«      ||	<   Œ.t        t        |
|«      |«      ||	<   ŒH |d   j                  s|d   t        j
                  u r|j!                  d«      }nd}t#        |«       |r|j%                  d|«       t        ||«       | j&                  |Ž fS c c}w c c}w c c}w c c}w )a  
        Return ``(R, self/R)`` where ``R``` is the Rational GCD of ``self```.

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

        Examples
        ========

        >>> from sympy.abc import x, y

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

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

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

        No subprocessing of term factors is performed:

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

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

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

        See also: primitive() function in polytools.py

        Fr   r	   N)r$   rq   re   r   rv   rl   r9   rÁ   r¼   r   r   r   Ú	enumeraterø   ÚRationalr8   r5   r1   r:   rx   )rL   rƒ   rë   r?   rˆ   Úmra   ÚngcdÚdlcmr    rÁ   r¼   r
  s                r!   rõ   zAdd.primitiveG  s1  € ðF ˆØˆØ—‘ò 	(ˆAØ—>‘>Ó#‰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)rq   rt   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õ   rt   r6   rö   rj   r   r3   ry   r  rr   rs   re   r¼   r9   rÂ   ÚintrÁ   rg  Úkeysr5   r   r   rÔ  )rL   rÙ  rÚ  r?   ÚconÚprimr  Ú_pr$   ÚradsÚcommon_qrÕ  Ú	term_radsrH  r‚   r‰   rÇ   r¼   ÚGÚgs                       r!   rÜ  zAdd.as_content_primitive—  s¦  € ð( �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$   )rL   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$   )rL   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ª   rq   r   r¸   ÚAttributeErrorÚ_mpf_)rL   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 rG   )r   Ú
distributerd  Ú__neg__ry   r   ÚNegativeOne)rL   rp  s    €r!   rü  zAdd.__neg__ø  s*   ø€ Ü ×+Ò+Ü‘7‘?Ó$Ð$Ü”1—=‘= $Ó'Ð'r,   )r$   zExpr | complexrE   r&   Úreturnr   )rþ  ztuple[Expr, ...])r€   z
list[Expr]rþ  z#tuple[list[Expr], list[Expr], None])FN)rþ  ztuple[Number, Expr])r   rC  )rþ  ztuple[Expr, Expr]rG   )T)FT)Fr’   Ú
__module__Ú__qualname__Ú__doc__Ú	__slots__r6   r   Ú
_args_typeÚ__annotations__r   rI   Úpropertyr$   Úclassmethodr�   r“   r•   r   r   r¤   rª   rÊ   rÎ   rÕ   rÙ   r×   Ústaticmethodrñ   ró   rö   r  r  r  r  Ú_eval_is_realÚ_eval_is_extended_realÚ_eval_is_complexÚ_eval_is_antihermitianÚ_eval_is_finiteÚ_eval_is_hermitianÚ_eval_is_integerÚ_eval_is_rationalÚ_eval_is_algebraicÚ_eval_is_commutativerA  rI  rN  rS  rY  r_  re  rv  ry  r{  r‹  r�  r‘  rš  rœ  rÅ  rÉ  rÍ  rÑ  rõ   rÜ  rë  rñ  rù  rü  Ú__classcell__)rp  s   @r!   r;   r;   ]   s  ø… ñTðl €Ià€Fà€JàÓáà?Cõ 	ð 
ò	ó 
ð	ð òP$ó ðP$ðd ñ"ó ð"ð ñ
ó ð
ò/ð ñ!ó ð!ô,ò#)ðJ ñ:ó ð:ó!òó?ð ñ,ó ð,ð2 ñ?ó ð?ó&-:ò^IòPò-òMñ9€MñBÐñ<ÐñBÐñ;€Oñ>Ðñ<Ðñ=Ðñ>Ðñ-Ðòòò8'òR5òòô 4òl(ò(ô4òl#FòJ(ò,ð
 ò#ó ð#óJ:ò.IòV<ò>ò>òN?ó`FðP ñ>ó ð>ò?ð ñ<ó ð<÷(ð (r,   r;   rh  )ry   rø   rÃ   )rÔ  N)3Ú
__future__r   Útypingr   r   Úcollectionsr   Ú	functoolsr   Úoperatorr   r­  r
   Ú
parametersr   Úlogicr   r   r   Ú	singletonr   Ú
operationsr   r   Úcacher   Úintfuncr   r   r(   r   r•   r   Úsympy.utilities.iterablesr   r   Úsympy.core.numbersr   r“  r   r+   r1   r@   r;   rh  r©  ry   rø   rÃ   rô  rÔ  rB   r,   r!   ú<module>r      sv   ðÝ "ç *Ý #Ý Ý Ý  Ý )ß 4Ñ 4Ý ß 2Ý ß Ý Ý ß 7ñ Ý)Ý(ò6ò !ò
-#ô`^(ˆ$�ô ^(ñ@% ˜Ó€ç 3Ñ 3Þ r,   