
    Qi                    T   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 dS )    )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
  }||k    rdS ||k     rdS t          |                                 |                                  k               S )Nc              3  B   K   | ]}|                                 d V  dS )r	   N)could_extract_minus_sign.0is     f/var/www/development/aibuddy-work/election-extract/venv/lib/python3.11/site-packages/sympy/core/add.py	<genexpr>z,_could_extract_minus_sign.<locals>.<genexpr>   sF       ) )a%%'') ) ) ) ) ) )    FT)sumargslenboolsort_key)exprnegative_argspositive_argss      r"   _could_extract_minus_signr-      s      ) )49 ) ) ) ) )M	NN]2M}$$u		&	&t D5"2"2"4"44555r$   c                <    |                      t                     d S )Nkey)sortr
   )r&   s    r"   _addsortr2   (   s    II-I     r$   c                 v   t          |           } g }t          j        }| rZ|                                 }|j        r|                     |j                   n"|j        r||z  }n|                    |           | Zt          |           |r|
                    d|           t                              |          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appendr2   insertAdd
_from_args)r&   newargscoas       r"   _unevaluated_AddrA   -   s    : ::DG	
B
 	HHJJ8 	 KK[ 	!GBBNN1  	 W	 q">>'"""r$   c                  V    e Zd ZU dZdZdZeZded<   e	rdddMdZ
edNd            ZedOd            Zed             Zed             Zd Zed             ZdPdQdZd Zed             ZdRdZd  ZdSd!Zed"             Zed#             ZdTd%Zd& Zd' Zd( Z d) Z!d* Z"d+ Z#d, Z$d- Z%d. Z&d/ Z'd0 Z(d1 Z)d2 Z*d3 Z+d4 Z,d5 Z-d6 Z.d7 Z/d8 Z0d9 Z1 fd:Z2d; Z3d< Z4 fd=Z5d> Z6d? Z7d@ Z8edUdA            Z9dVdBZ:dC Z;dD Z<dE Z=dF Z>dG Z?dWdHZ@edI             ZAdJ ZBedK             ZC fdLZD xZES )Xr<   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evaluater&   Expr | complexrF   r(   returnr   c                   d S NrC   )clsrF   r&   s      r"   __new__zAdd.__new__   s    Cr$   tuple[Expr, ...]c                    d S rJ   rC   selfs    r"   r&   zAdd.args   s    Cr$   seq
list[Expr]#tuple[list[Expr], list[Expr], None]c                	   ddl m} ddlm} ddlm}m} d}t          |          dk    rS|\  }}|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 ]wj        r>j        j        rt!          fd|D                       r3fd	|D             }g|z   }Hj        rx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                    |
          }
t+          |          r|                               t+          |          r" ||
                              d
          }
Ft          j        u r+|
j        d
u r|st          j        gg dfc S t          j        }
j        rj        }|                    |           j	        r                                \  }}nqj        r\                                \  }}|j        r/|j        s|j        r!|j         r|                    ||z             t          j!        }}nt          j!        }}||	v r:|	|xx         |z  cc<   |	|         t          j        u r|st          j        gg dfc S r||	|<   yg }d
}|	"                                D ]\  }}|j        r|t          j!        u r|                    |           n|j	        r) |j#        |f|j        z    }|                    |           nP|j        r&|                    tI          ||d
                     n#|                    tI          ||                     |p|j%         }|
t          j&        u rd |D             }n|
t          j'        u rd |D             }|
t          j        u rd |D             }|rdg }|D ]2t!          fd|D                       s|                               3||z   }|D ]%(                    |
          rt          j        }
 n&tS          |           |
t          j        ur|*                    d|
           |r||z  }d}|rg |dfS |g dfS )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  $   K   | ]}|j         V  d S rJ   is_commutative)r    ss     r"   r#   zAdd.flatten.<locals>.<genexpr>   s%      77Aq'777777r$   c              3  B   K   | ]}|                               V  d S rJ   containsr    o1os     r"   r#   zAdd.flatten.<locals>.<genexpr>   s-      >>"r{{1~~>>>>>>r$   c                >    g | ]}                     |          |S rC   r_   ra   s     r"   
<listcomp>zAdd.flatten.<locals>.<listcomp>   s(     R R R1::b>> R R R Rr$   FdeeprE   c                .    g | ]}|j         	|j        |S rC   )is_extended_nonnegativeis_realr    fs     r"   re   zAdd.flatten.<locals>.<listcomp>h  '    XXXA0IXQYXaXXXr$   c                .    g | ]}|j         	|j        |S rC   )is_extended_nonpositiverj   rk   s     r"   re   zAdd.flatten.<locals>.<listcomp>k  rm   r$   c                .    g | ]}|j         r|j        |S rJ   )	is_finiteis_extended_real)r    cs     r"   re   zAdd.flatten.<locals>.<listcomp>v  s7     Q Q QA Q010B0N 0N0N0Nr$   c              3  B   K   | ]}|                               V  d S rJ   r_   )r    rc   ts     r"   r#   zAdd.flatten.<locals>.<genexpr>~  s-      @@Q1::a==@@@@@@r$   T)+!sympy.calculus.accumulationboundsrU   sympy.matrices.expressionsrV   sympy.tensor.tensorrW   rX   r'   is_Rationalis_Mulallr   r5   is_Orderr*   is_zeroanyr9   NaNComplexInfinityrq   
isinstance__add__r:   doitr7   r&   r8   as_coeff_Mulis_Powas_base_exp
is_Integeris_negativeOneitems_new_rawargsMulr\   InfinityNegativeInfinityr`   r2   r;   )rK   rQ   rU   rV   rW   rX   rvr@   btermscoefforder_factorsextrao_argsrs   r]   enewseqnoncommutativecsnewseq2rc   ru   s                        @@r"   flattenzAdd.flatten   sF   $ 	BAAAAA99999999999999s88q==DAq} !1} *8 *QT)B '77A77777 I2a5$& %' f%'"$ S	 S	A z A6> >>>>>>>>>  R R R Rm R R R!"m 3  7JJ%1+<"<"<u,,e,E7B,,,,? 1j&D&D 1QJE~~e~ !wD0000A{++ +		%((Az** 'QAx(( "5))..E.::a'''?e++E+E7B,,,,)  +,6

6"""  ~~''11  }}1; AL $%M67mJJq!t$$$ua1 E EzzaA8qu$$U$E7B,,,,a KKMM 	D 	DDAqy -aea     8 - (1$-9BMM"%%%%X -MM#aU";";";<<<< MM#a)),,,+C13C/CNN AJXXXXXFFa(((XXXXXFA%%%Q Q Q Q QF  	G & &@@@@-@@@@@ &NN1%%%},F"  ::e$$ FEE
 	 MM!U### 	"eOF!N  	$vt##2t##r$   c                    dd| j         fS )N   r	   )__name__)rK   s    r"   	class_keyzAdd.class_key  s    !S\!!r$   c                    t          d          }t          || j                  }t          |          }t	          |          dk    rt
          }n|\  }|S )Nkindr	   )r   mapr&   	frozensetr'   r   )rP   kkindsresults       r"   r   zAdd.kind  sQ    vAty!!%  u::?? #FFGFr$   c                     t          |           S rJ   )r-   rO   s    r"   r   zAdd.could_extract_minus_sign  s    (...r$   c                "   r6t          | j        fdd          \  }} | j        | t          |          fS | j        d                                         \  }}|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 rJ   )has_free)xdepss    r"   <lambda>z"Add.as_coeff_add.<locals>.<lambda>  s    zqz4/@ r$   T)binaryr   r	   N)r   r&   r   tupleas_coeff_addr   r5   )rP   r   l1l2r   notrats    `    r"   r   zAdd.as_coeff_add  s      	5$)%@%@%@%@NNNFB$4$b)59944	!1133v&49QRR=000vty  r$   FNtuple[Number, Expr]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&   r9   ry   r   r   r5   )rP   rationalr   r   r&   s        r"   as_coeff_AddzAdd.as_coeff_Add  sZ     ilDIabbMt? 	38 	3u/@ 	3+$+T222vt|r$   c                   ddl m} ddlm} t	          | j                  dk    rt          d | j        D                       r|j        du r ||t          j	                  du r| j        \  }}|
                    t          j                  r||}}|
                    t          j                  }|r4|j        r-|j        r&|j        rt          j        S |j        rt          j        S d S |j        r| j        r ||           }|r|\  }}	|j        dk    rddlm}
  |
|dz  |	dz  z             }|j        rvdd	lm} dd
lm} ddlm}  |
 |||z
  dz                      |j        z  }| |||z   t;          |	          z   ||	          t          j        z  z   |j        z            z  S d S |dk    r2t=          ||	t          j        z  z
  d|dz  |	dz  z   z            S d S d S d S d S )Nr	   )pure_complex)is_eqrY   c              3  $   K   | ]}|j         V  d S rJ   is_infinite)r    _s     r"   r#   z"Add._eval_power.<locals>.<genexpr>  s$      &H&Hq}&H&H&H&H&H&Hr$   Fr   )sqrt)factor_terms)sign)expand_multinomial)evalfr   
relationalr   r'   r&   r~   r}   r   r   r   ImaginaryUnitrr   is_extended_negativer5   is_extended_positiver   ry   	is_numberq(sympy.functions.elementary.miscellaneousr   	exprtoolsr   $sympy.functions.elementary.complexesr   functionr   pabs_unevaluated_Mul)rP   exptr   r   r@   r   icorirr!   r   Dr   r   r   roots                   r"   _eval_powerzAdd._eval_power  s   ''''''%%%%%%ty>>Q3&H&Hdi&H&H&H#H#H|u$$tQU););u)D)Dy1771?++  aqAggao.. 13/ 1A4F 10 & v0 1 00F 	) 	)d##B )16Q;;MMMMMMQTAqD[))A} O;;;;;;MMMMMM@@@@@@#tLL!a%$;$;<<dfD#$6$6UCFFNTT!WWQ_-DDtv8N %O %O  O OO O RZZ+Aao--1a4!Q$;) ) )#	) 	) 	) 	)) )  Zr$   c                :     | j         fd| j        D              S )Nc                :    g | ]}|                               S rC   )diff)r    r@   r]   s     r"   re   z(Add._eval_derivative.<locals>.<listcomp>  s#    888166!99888r$   funcr&   )rP   r]   s    `r"   _eval_derivativezAdd._eval_derivative  s)    ty8888di88899r$   r   c                J    fd| j         D             } | j        | S )Nc                B    g | ]}|                                S )nlogxcdir)nseries)r    ru   r   r   r   r   s     r"   re   z%Add._eval_nseries.<locals>.<listcomp>  s-    LLLQ1488LLLr$   )r&   r   )rP   r   r   r   r   r   s    ```` r"   _eval_nserieszAdd._eval_nseries  s9    LLLLLLL$)LLLty%  r$   c                    |                                  \  }}t          |          dk    r|d                             ||z
  |          S d S )Nr	   r   )r   r'   matches)rP   r*   	repl_dictr   r   s        r"   _matches_simplezAdd._matches_simple  sI    ((**uu::??8##D5L)<<<r$   c                0    |                      |||          S rJ   )_matches_commutative)rP   r*   r   olds       r"   r   zAdd.matches  s    ((y#>>>r$   c                  
 ddl m} t          j        t          j        f} | j        | s
 |j        | rddlm}  |d          
t          j        
t          j        
 i}d |                                D             }| 	                    |          |	                    |          z
  }|                    
          r|
                    
fdd           }|	                    |          }n| |z
  } ||          }	|	j        r|	n|S )	zp
        Returns lhs - rhs, but treats oo like a symbol so oo - oo
        returns 0, instead of a nan.
        r   )signsimpr	   )Dummyooc                    i | ]\  }}||	S rC   rC   )r    r   vs      r"   
<dictcomp>z(Add._combine_inverse.<locals>.<dictcomp>  s    333daQ333r$   c                $    | j         o| j        u S rJ   )r   base)r   r   s    r"   r   z&Add._combine_inverse.<locals>.<lambda>  s    ah716R< r$   c                    | j         S rJ   )r   )r   s    r"   r   z&Add._combine_inverse.<locals>.<lambda>  s    af r$   )sympy.simplify.simplifyr   r   r   r   hassymbolr   r   xreplacereplacer9   )lhsrhsr   infr   repsirepseqr   srvr   s             @r"   _combine_inversezAdd._combine_inverse  s.    	544444z1-.37C= 	GCGSM 	%%%%%%tB
B"RC)D 43djjll333Ed##cll4&8&88Bvvbzz &ZZ7777$$& & U##BBsBhrllm+ss+r$   c                J    | 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&   r   rO   s    r"   as_two_termszAdd.as_two_terms"  s*    $ y|.T.	!"">>>r$   tuple[Expr, Expr]c                v                                      \  }}t          |t                    s$t          ||d                                          S |                                \  }t          t                    }|j        D ]4}|                                \  }}||                             |           5t          |          dk    r=|
                                \  }}	  j        fd|	D              t          ||          fS  fd|                                D             }
d t          t          |
                                           D             \    j        fdt!          t                              D              t           }}	t          |	          t          ||          fS )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
        FrE   r	   c                0    g | ]}t          |          S rC   )_keep_coeff)r    nincons     r"   re   z&Add.as_numer_denom.<locals>.<listcomp>Y  s#    444B+dB''444r$   c                b    i | ]+\  }}|t          |          d k    r
 j        | n|d         ,S r	   r   )r'   r   )r    dr   rP   s      r"   r   z&Add.as_numer_denom.<locals>.<dictcomp>\  s=    OOODAqq3q66A::)$)Q--1Q4OOOr$   c                ,    g | ]}t          |          S rC   )r4   r   s     r"   re   z&Add.as_numer_denom.<locals>.<listcomp>_  s    CCCa$q''CCCr$   c                b    g | ]+}t          d |         |         gz   |dz   d          z    ,S )Nr	   )r   )r    r!   denomsnumerss     r"   re   z&Add.as_numer_denom.<locals>.<listcomp>`  sR     0 0 0 vayk!9F1q566N!JL 0 0 0r$   )	primitiver   r<   r   as_numer_denomr   r4   r&   r:   r'   popitemr   r  r   zipiterrange)rP   contentr*   dconndrl   r  dir  r   nd2r  r  r  s   `          @@@r"   r  zAdd.as_numer_denom6  s   ( (($$$ 	Gwu555DDFFF++--
d  	 	A%%''FBrFMM" r77a<<::<<DAq494444!44467B47K7KL L POOOBHHJJOOO DC3SYY[[0A0A+BCCCty 0 0 0 0 0!#f++..0 0 0 125v,  4##[q%9%999r$   c                D    t          fd| j        D                       S )Nc              3  B   K   | ]}|                               V  d S rJ   )_eval_is_polynomialr    termsymss     r"   r#   z*Add._eval_is_polynomial.<locals>.<genexpr>f  s1      HHd4++D11HHHHHHr$   r{   r&   rP   r%  s    `r"   r"  zAdd._eval_is_polynomiale  s(    HHHHdiHHHHHHr$   c                D    t          fd| j        D                       S )Nc              3  B   K   | ]}|                               V  d S rJ   )_eval_is_rational_functionr#  s     r"   r#   z1Add._eval_is_rational_function.<locals>.<genexpr>i  s1      OOT422488OOOOOOr$   r&  r'  s    `r"   r*  zAdd._eval_is_rational_functionh  s(    OOOOTYOOOOOOr$   c                L    t          fd| j        D             d          S )Nc              3  D   K   | ]}|                               V  d S rJ   )is_meromorphic)r    argr@   r   s     r"   r#   z+Add._eval_is_meromorphic.<locals>.<genexpr>l  s3      KK#S//155KKKKKKr$   T
quick_exitr   r&   )rP   r   r@   s    ``r"   _eval_is_meromorphiczAdd._eval_is_meromorphick  s:    KKKKKKKK'+- - - 	-r$   c                D    t          fd| j        D                       S )Nc              3  B   K   | ]}|                               V  d S rJ   )_eval_is_algebraic_exprr#  s     r"   r#   z.Add._eval_is_algebraic_expr.<locals>.<genexpr>p  s1      LL$4//55LLLLLLr$   r&  r'  s    `r"   r5  zAdd._eval_is_algebraic_expro  s(    LLLL$)LLLLLLr$   c                B    t          d | j        D             d          S )Nc              3  $   K   | ]}|j         V  d S rJ   )rj   r    r@   s     r"   r#   zAdd.<lambda>.<locals>.<genexpr>t  s$      &&q&&&&&&r$   Tr/  r1  rO   s    r"   r   zAdd.<lambda>s  s*    &&DI&&&4"9 "9 "9 r$   c                B    t          d | j        D             d          S )Nc              3  $   K   | ]}|j         V  d S rJ   )rr   r8  s     r"   r#   zAdd.<lambda>.<locals>.<genexpr>v  %      //	//////r$   Tr/  r1  rO   s    r"   r   zAdd.<lambda>u  -    ,//TY///D+B +B +B r$   c                B    t          d | j        D             d          S )Nc              3  $   K   | ]}|j         V  d S rJ   )
is_complexr8  s     r"   r#   zAdd.<lambda>.<locals>.<genexpr>x  $      ))!))))))r$   Tr/  r1  rO   s    r"   r   zAdd.<lambda>w  *    L))ty)))d%< %< %< r$   c                B    t          d | j        D             d          S )Nc              3  $   K   | ]}|j         V  d S rJ   )is_antihermitianr8  s     r"   r#   zAdd.<lambda>.<locals>.<genexpr>z  r;  r$   Tr/  r1  rO   s    r"   r   zAdd.<lambda>y  r<  r$   c                B    t          d | j        D             d          S )Nc              3  $   K   | ]}|j         V  d S rJ   )rq   r8  s     r"   r#   zAdd.<lambda>.<locals>.<genexpr>|  s$      ((((((((r$   Tr/  r1  rO   s    r"   r   zAdd.<lambda>{  s*    <((di(((T$; $; $; r$   c                B    t          d | j        D             d          S )Nc              3  $   K   | ]}|j         V  d S rJ   )is_hermitianr8  s     r"   r#   zAdd.<lambda>.<locals>.<genexpr>~  $      ++A++++++r$   Tr/  r1  rO   s    r"   r   zAdd.<lambda>}  *    l+++++'> '> '> r$   c                B    t          d | j        D             d          S )Nc              3  $   K   | ]}|j         V  d S rJ   )
is_integerr8  s     r"   r#   zAdd.<lambda>.<locals>.<genexpr>  r@  r$   Tr/  r1  rO   s    r"   r   zAdd.<lambda>  rA  r$   c                B    t          d | j        D             d          S )Nc              3  $   K   | ]}|j         V  d S rJ   is_rationalr8  s     r"   r#   zAdd.<lambda>.<locals>.<genexpr>  s$      **1******r$   Tr/  r1  rO   s    r"   r   zAdd.<lambda>  s*    \**	***t&= &= &= r$   c                B    t          d | j        D             d          S )Nc              3  $   K   | ]}|j         V  d S rJ   )is_algebraicr8  s     r"   r#   zAdd.<lambda>.<locals>.<genexpr>  rJ  r$   Tr/  r1  rO   s    r"   r   zAdd.<lambda>  rK  r$   c                >    t          d | j        D                       S )Nc              3  $   K   | ]}|j         V  d S rJ   r[   r8  s     r"   r#   zAdd.<lambda>.<locals>.<genexpr>  s6       5- 5-5- 5- 5- 5- 5- 5-r$   r1  rO   s    r"   r   zAdd.<lambda>  s.     5- 5-"&)5- 5- 5- )- )- r$   c                P    d}| j         D ]}|j        }| d S |du r	|du r d S d}|S )NFT)r&   r   )rP   sawinfr@   ainfs       r"   _eval_is_infinitezAdd._eval_is_infinite  sO     	 	A=D|ttT>>44r$   c                8   g }g }| j         D ]}|j        r*|j        r|j        du r|                    |           0 d S |j        r#|                    |t
          j        z             ]|j        rgt
          j        |j         v rT|                    t
          j                  \  }}|t
          j        fk    r|j        r|                    |             d S  d S  | j	        | }|| k    r.|j        rt           | j	        | j                  S |j        du rdS d S d S NF)r&   rr   r}   r:   is_imaginaryr   r   rz   as_coeff_mulr   r   )rP   nzim_Ir@   r   air   s          r"   _eval_is_imaginaryzAdd._eval_is_imaginary  sG    	 	A! 9 Y%''IIaLLLLFF 	Aao-.... ao77NN1?;;	r!/+++0F+KK''''FFDIrN99y  D!1!9:::e##u	 9 $#r$   c                \   | j         du rd S g }d}d}d}| j        D ]}|j        r/|j        r|dz  }|j        du r|                    |           5 d S |j        r|dz  }E|j        rSt          j        |j        v r@|	                    t          j                  \  }}|t          j        fk    r
|j        rd} d S  d S |t          | j                  k    rdS t          |          dt          | j                  fv rd S  | j        | }|j        r|s|dk    rdS |dk    rdS |j        du rdS d S )NFr   r	   T)r\   r&   rr   r}   r:   r^  rz   r   r   r_  r'   r   )	rP   r`  zim_or_zimr@   r   rb  r   s	            r"   _eval_is_zerozAdd._eval_is_zero  s   %'' F 	 	A! 9 FAAY%''IIaLLLLFF 	a ao77NN1?;;	r!/+++0F+"GGFFDI4r77q#di..)))4DIrN9 	! !7741WW 595 r$   c                x    d | j         D             }|sdS |d         j        r | j        |dd           j        S d S )Nc                $    g | ]}|j         d u|S T)is_evenrk   s     r"   re   z$Add._eval_is_odd.<locals>.<listcomp>  s$    ===1!)t*;*;Q*;*;*;r$   Fr   r	   )r&   is_oddr   rl  )rP   ls     r"   _eval_is_oddzAdd._eval_is_odd  sW    ==	=== 	5Q4; 	5$4$ae,44	5 	5r$   c                    | j         D ]X}|j        }|rHt          | j                   }|                    |           t	          d |D                       r dS  d S | d S YdS )Nc              3  (   K   | ]}|j         d u V  dS )TNrQ  )r    r   s     r"   r#   z*Add._eval_is_irrational.<locals>.<genexpr>  s)      ==q},======r$   TF)r&   is_irrationalr4   remover{   )rP   ru   r@   otherss       r"   _eval_is_irrationalzAdd._eval_is_irrational  s     		 		AA dia   ==f=====  44tty ur$   c                b    dx}}| j         D ]"}|j        r|r dS d}|j        r|r dS d}  d S dS )Nr   Fr	   T)r&   is_nonnegativeis_nonpositive)rP   nnnpr@   s       r"   _all_nonneg_or_nonpposzAdd._all_nonneg_or_nonppos  sj    R 	 	A 	 ! 55!  ! 554r$   c                   | j         r t                                                      S |                                 \  }}|j        sbddlm}  ||          }|O||z   }|| k    r|j        r	|j        rdS t          | j
                  dk    r ||           }||| k    r	|j        rdS dx}x}x}}	t                      }
d | j        D             }|sdS |D ]f}|j        }|j        }|r4|
                    t          ||j        f                     d|
v rd|
v r d S |rd}K|j        rd}U|j        rd}_| d S d}	g|
r)t          |
          dk    rd S |
                                S |	rd S |s|s|rdS |s|rdS |s|sdS d S d S )Nr	   _monotonic_signTFc                     g | ]}|j         	|S rC   r}   r8  s     r"   re   z2Add._eval_is_extended_positive.<locals>.<listcomp>      666aAI6666r$   )r   super_eval_is_extended_positiver   r}   r   r~  r   ri   r'   free_symbolssetr&   r   addr   ro   r6   )rP   rs   r@   r~  r   r]   posnonnegnonposunknown_signsaw_INFr&   isposinfinite	__class__s                 r"   r  zAdd._eval_is_extended_positive  F   > 	87755777  ""1y 
	$222222""A}E99!79A<U94t())Q..'--A}dq7M#t/444f4v%%6649666 	5 	  	 A*E}H HeQ-F%GHHIII7??u'7'7FF * * LL 	7||a;;==  	F 	 	3 	4 	C 	4 	V 	5	 	 	 	r$   c                0   | j         s|                                 \  }}|j        sd|j        r_ddlm}  ||          }|N||z   }|| k    r	|j        rdS t          | j                  dk    r$ ||           }||| k    r|j        rdS d S d S d S d S d S d S d S d S Nr	   r}  T)r   r   r}   ri   r   r~  r'   r  rP   rs   r@   r~  r   r]   s         r"   _eval_is_extended_nonnegativez!Add._eval_is_extended_nonnegative4      ~ 	($$&&DAq9 
(!: 
(666666#OA&&=AADyyQ%>y#t4,--22+OD11=Q$YY1;TY#'4	( 	(
( 
( 
( 
( != 32(=YYYYr$   c                0   | j         s|                                 \  }}|j        sd|j        r_ddlm}  ||          }|N||z   }|| k    r	|j        rdS t          | j                  dk    r$ ||           }||| k    r|j        rdS d S d S d S d S d S d S d S d S r  )r   r   r}   ro   r   r~  r'   r  r  s         r"   _eval_is_extended_nonpositivez!Add._eval_is_extended_nonpositiveC  r  r$   c                   | j         r t                                                      S |                                 \  }}|j        sbddlm}  ||          }|O||z   }|| k    r|j        r	|j        rdS t          | j
                  dk    r ||           }||| k    r	|j        rdS dx}x}x}}	t                      }
d | j        D             }|sdS |D ]f}|j        }|j        }|r4|
                    t          ||j        f                     d|
v rd|
v r d S |rd}K|j        rd}U|j        rd}_| d S d}	g|
r)t          |
          dk    rd S |
                                S |	rd S |s|s|rdS |s|rdS |s|sdS d S d S )Nr	   r}  TFc                     g | ]}|j         	|S rC   r  r8  s     r"   re   z2Add._eval_is_extended_negative.<locals>.<listcomp>c  r  r$   )r   r  _eval_is_extended_negativer   r}   r   r~  r   ro   r'   r  r  r&   r   r  r   ri   r6   )rP   rs   r@   r~  r   r]   negr  r  r  r  r&   isnegr  r  s                 r"   r  zAdd._eval_is_extended_negativeR  r  r$   c                |   j         s3t          j        u r# | j        v r|                       i          S d S |                                 \  }}                                \  }}|j        rD|j        r=||k    r|                     ||           S || k    r|                      ||          S |j        r|j        s||k    r| j                            |          | j                            |          }}t          |          t          |          k     rt          |          }	t          |          }
|
|	k     r#|	|
z
  } | j        || gfd|D             R  S | j                            |           }t          |          }
|
|	k     r'|	|
z
  } | j         ||gfd|D             R  S d S d S d S )Nc                <    g | ]}|                               S rC   _subsr    r]   newr   s     r"   re   z"Add._eval_subs.<locals>.<listcomp>  '     D D Dqc!2!2 D D Dr$   c                <    g | ]}|                               S rC   r  r  s     r"   re   z"Add._eval_subs.<locals>.<listcomp>  r  r$   )r7   r   r   r&   r   r   ry   r   	make_argsr'   r  )rP   r   r  
coeff_self
terms_self	coeff_old	terms_oldargs_old	args_selfself_setold_setret_sets    ``         r"   
_eval_subszAdd._eval_subs  sK   z 	aj  cTTY%6%6}}sdSD\2224!%!2!2!4!4
J"//11	9! 	>i&; 	>Y&&yyj9*===iZ''yy#z9===! 	Fi&; 	F**"&)"5"5# # I//
;;  H8}}s9~~--y>>h--X%%&0G$49S*yj F D D D D DG D D DF F F F  9..J   h--X%%&0G$49cT:y F D D D D DG D D DF F F F .- +* &%r$   c                8    d | j         D             } | j        | S )Nc                     g | ]}|j         	|S rC   r|   r8  s     r"   re   zAdd.removeO.<locals>.<listcomp>  s    777aAJ7777r$   r  rP   r&   s     r"   removeOzAdd.removeO  s'    7749777 t $''r$   c                @    d | j         D             }|r
 | j        | S d S )Nc                     g | ]}|j         	|S rC   r  r8  s     r"   re   zAdd.getO.<locals>.<listcomp>  s    333a
3333r$   r  r  s     r"   getOzAdd.getO  s9    3349333 	,$4$d++	, 	,r$   c                  
 ddl m
 g }t          t                    rng          sdgt	                    z  
fd| j        D             }|D ]q\  }}|D ]$\  }}|                    |          r
||k    rd} n%|/||fg}	|D ]8\  }}|                    |          r||k    r!|	                    ||f           9|	}rt          |          S )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   c           
     B    g | ]}| |gt                    R  fS rC   )r  )r    rl   r   pointsymbolss     r"   re   z-Add.extract_leading_order.<locals>.<listcomp>  s:    FFFq551S%001112FFFr$   N)	sympy.series.orderr   r4   r   r'   r&   r`   r:   r   )rP   r  r  lstrQ   efofr   rc   new_lstr   s    ``       @r"   extract_leading_orderzAdd.extract_leading_order  s3   " 	-,,,,,+g"6"6EwwWIFF 	%CG$EFFFFFFDIFFF 	 	FB  1::b>> a2ggBEzBxjG ' '1;;q>> a2gg1v&&&&CCSzzr$   c                    | j         }g g }}|D ]E}|                    |          \  }}|                    |           |                    |           F | 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)
        rf   )r&   as_real_imagr:   r   )	rP   rg   hintssargsre_partim_partr$  rerg  s	            r"   r  zAdd.as_real_imag  s     	r 	 	D&&D&11FBNN2NN2	7#YTY%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}	 |                                 }
|
 |d          }
|                                 }|                    |          r ||          }t          fd| j        D                       rd	d	d
d
d
d
d
d
d
d	} |j        di |} |	|          }|j        s|                    |          S d |j        D             }| |d          n|fd|j        D             } |d          t(          j        }}	 |D ]"} ||          }|r||vr|}|}||v r||z  }#n# t,          $ r |cY S w xY w||                                         }|j        }|-|                                                                }|j        }|d	u r	 |                                }n# t8          $ r t(          j        }Y nw xY w|                    |          rt(          j        } |d          }t(          j        }|j        r^|                    ||z   |                                                                                                           }|dz  }|j        ^|                    |          S |t(          j!        u r|j"        #                    |          |
z   S |S )Nr   )r   Symbolr   )log)	Piecewisepiecewise_foldr	   )
expand_mulc              3  8   K   | ]}t          |          V  d S rJ   )r   )r    r@   r  s     r"   r#   z,Add._eval_as_leading_term.<locals>.<genexpr>  s-      55az!S!!555555r$   TF)	rg   r  mul	power_exp
power_basemultinomialbasicforcefactorr   r   c                     g | ]}|j         	|S rC   r   r    ru   s     r"   re   z-Add._eval_as_leading_term.<locals>.<listcomp>  s    :::!AM:A:::r$   r   c                @    g | ]}|                                S )r  )as_leading_term)r    ru   _logxr   r   s     r"   re   z-Add._eval_as_leading_term.<locals>.<listcomp>  s.    XXX**15t*DDXXXr$   r   rY   rC   )$sympy.core.symbolr   r  r  r   &sympy.functions.elementary.exponentialr  $sympy.functions.elementary.piecewiser  r  r   r  r  r  r   r~   r&   expandr7   r  r   r5   	TypeErrorsubsr}   trigsimpcancelgetnNotImplementedErrorr   r|   r   powsimpr   r   r=   )rP   r   r   r   r   r  r   r  r  r  rc   r   logflagsr*   r  leading_termsminnew_exprr$  orderr}   n0resincrr  r  s    ` `                    @@r"   _eval_as_leading_termzAdd._eval_as_leading_term  s   33333333,,,,,,>>>>>>RRRRRRRR((((((IIKK9aAllnn779 	& .%%C 55554955555 	) $T%e#EETY! !H #*((x((Cz#{ 	A''4'@@@::ty:::!%f4XXXXXXdiXXXa!&X
	% % %dA %e3..C#HHE\\$H%  	 	 	KKK	 <}}UCCFF33H"?((**1133H&Gd??XXZZ&   Uvvf~~ U%((C5D, ''RW4d'KKRRTT\\^^ggii	 ,  &&qt$&???8&&x00144 Os$   ,%E E! E! G G.-G.c                4     | j         d | j        D              S )Nc                6    g | ]}|                                 S rC   )adjointr  s     r"   re   z%Add._eval_adjoint.<locals>.<listcomp>?  s     :::1199;;:::r$   r   rO   s    r"   _eval_adjointzAdd._eval_adjoint>  s"    ty::	:::;;r$   c                4     | j         d | j        D              S )Nc                6    g | ]}|                                 S rC   )	conjugater  s     r"   re   z'Add._eval_conjugate.<locals>.<listcomp>B       <<<Q1;;==<<<r$   r   rO   s    r"   _eval_conjugatezAdd._eval_conjugateA  "    ty<<$)<<<==r$   c                4     | j         d | j        D              S )Nc                6    g | ]}|                                 S rC   )	transposer  s     r"   re   z'Add._eval_transpose.<locals>.<listcomp>E  r  r$   r   rO   s    r"   _eval_transposezAdd._eval_transposeD  r  r$   c                f   g }d}| j         D ]`}|                                \  }}|j        st          j        }|}|p|t          j        u }|                    |j        |j        |f           a|sAt          t          d |D             d          }t          t          d |D             d          }n@t          t          d |D             d          }t          t          d |D             d          }||cxk    rdk    rn nt          j        | fS |sCt          |          D ]2\  }\  }	}
}t          t          |	|z  ||
z  z            |          ||<   3nft          |          D ]V\  }\  }	}
}|
r*t          t          |	|z  ||
z  z            |          ||<   5t          t          |	|
          |          ||<   W|d         j        s|d         t          j        u r|                    d          }nd}t#          |           |r|                    d|           t          ||           | j        | fS )	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

        Fc                    g | ]
}|d          S r   rC   r  s     r"   re   z!Add.primitive.<locals>.<listcomp>u       5 5 5!1 5 5 5r$   r   c                    g | ]
}|d          S r	   rC   r  s     r"   re   z!Add.primitive.<locals>.<listcomp>v  r  r$   r	   c                .    g | ]}|d          
|d         S r  rC   r  s     r"   re   z!Add.primitive.<locals>.<listcomp>x  %     = = =!! =1 = = =r$   c                .    g | ]}|d          
|d          S r  rC   r  s     r"   re   z!Add.primitive.<locals>.<listcomp>y  r  r$   N)r&   r   ry   r   r   r   r:   r   r   r   r   r   	enumerater  Rationalr9   r6   r2   r;   r   )rP   r   r   r@   rs   mngcddlcmr!   r   r   r$  s               r"   r  zAdd.primitiveG  s   F  	( 	(A>>##DAq= E/a//CLL!#qsA'''' 	B$ 5 5u 5 5 5q99D$ 5 5u 5 5 5q99DD$ = =u = = =qAAD$ = =u = = =qAAD415$; 	A#,U#3#3 L L<Aq$&xD470C'D'DdKKaL $-U#3#3 A A<Aq$ A*8QWtQw4G+H+H$OOE!HH*8Aq>>4@@E!HH 8 	qQ->!>!>		!AAA 	LLAd##%6T%6%>>>r$   c           	         | j         fd| j        D                                              \  }}sP|j        sI|j        rB|                                \  }}||z  }t          d |j        D                       r|}n||z  }r|j        r|j        }g }d}	|D ]}
t          t                    }t          j
        |
          D ]p}|j        rg|                                \  }}|j        rI|j        rB||j                                     t!          t#          |                    |j        z             q|s n7|	"t'          |                                          }	n(|	t'          |                                          z  }	|	s n|                    |           |D ]V}t          |                                          D ]|	vr|                               |D ]t          |          |<   Wg |	D ]Pt-          t.          fd|D             d          }|dk    r&                    |t1          d          z             Qr$t           fd|D             } |j         | z  }||fS )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.
        c                L    g | ] }t          |                                !S ))radicalclear)r  as_content_primitive)r    r@   r  r  s     r"   re   z,Add.as_content_primitive.<locals>.<listcomp>  sK      ?  ?  ?/0 !,Q-C-C5 .D .* .* !+  ?  ?  ?r$   c              3  T   K   | ]#}|                                 d          j        V  $dS )r   N)r   r   r8  s     r"   r#   z+Add.as_content_primitive.<locals>.<genexpr>  s4      CCa1>>##A&1CCCCCCr$   Nc                     g | ]
}|         S rC   rC   )r    r   r   s     r"   re   z,Add.as_content_primitive.<locals>.<listcomp>  s    %9%9%9qad%9%9%9r$   r   r	   c                    g | ]}|z  S rC   rC   )r    rb  Gs     r"   re   z,Add.as_content_primitive.<locals>.<listcomp>  s    000RBqD000r$   )r   r&   r  r   r7   r  r~   r   r4   r   r  r   r   ry   r   r:   r   intr   r  keysr6   r   r   r  )rP   r  r  conprimr  _pr&   radscommon_qr	  	term_radsrb  r   r   r   gr  r   s    ``              @@r"   r  zAdd.as_content_primitive  s   ( DI  ?  ?  ?  ?  ?48I ?  ?  ? @@I	 	T 	S^ 	 	''))FCaBCC27CCCCC q '	.t{ '	.9DDH ". ".'--	-** D DBy D!~~//1= DQ\ D%acN11#c!ff++qs2BCCC  E#"9>>#3#344HH'#inn.>.>*?*??H# I&&&&  * *A!!&&((^^ % %H,,EE!HHH * *"AaDz!* ! 4 4At%9%9%9%9D%9%9%91==AAvvHQNN!2333 .QA00004000DYTY--DDyr$   c                T    ddl m} t          t          | j        |                    S )Nr	   )default_sort_keyr/   )sortingr  r   sortedr&   )rP   r  s     r"   _sorted_argszAdd._sorted_args  s2    ------VDI+;<<<===r$   c                N    ddl m  | j        fd| j        D              S )Nr   )difference_deltac                *    g | ]} |          S rC   rC   )r    r@   ddr   steps     r"   re   z.Add._eval_difference_delta.<locals>.<listcomp>  s%    ===a22aD>>===r$   )sympy.series.limitseqr$  r   r&   )rP   r   r'  r&  s    ``@r"   _eval_difference_deltazAdd._eval_difference_delta  sC    @@@@@@ty======49===>>r$   c                    ddl m} |                                 \  }}|                                \  }}|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_)rP   r+  r  restr  	imag_units         r"   _mpc_z	Add._mpc_  s    
 	#"""""))++!..00AO++ !!cdddg$eeGnn&:;;r$   c                    t           j        s t                                                      S t	          t
          j        |           S rJ   )r   
distributer  __neg__r   r   NegativeOne)rP   r  s    r"   r4  zAdd.__neg__  s4     + 	%77??$$$1=$'''r$   )r&   rG   rF   r(   rH   r   )rH   rM   )rQ   rR   rH   rS   )FN)rH   r   r   r]  )rH   r  rJ   rk  )FT)Fr   
__module____qualname____doc__	__slots__r7   r   
_args_type__annotations__r   rL   propertyr&   classmethodr   r   r   r   r   r   r   r   r   r   r   r   staticmethodr  r  r  r"  r*  r2  r5  _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_commutativer[  rc  rh  ro  ru  r{  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r"  r)  r1  r4  __classcell__)r  s   @r"   r<   r<   ]   s        T Tl IFJ ?C 	 	 	 	 	 	 
	 	 	 
	 P$ P$ P$ [P$d " " [" 
 
 X
/ / / ! ! W!,    #) #) #)J : : W:! ! ! !  ? ? ? ? , , \,2 ? ? W?&-: -: -: -:^I I IP P P- - -M M M9 9MB B< <B B; ;O> >< <= => >- -    8' ' 'R5 5 5     4 4 4 4 4l( ( (( ( (4 4 4 4 4l#F #F #FJ( ( (, , ,
 # # # W#J: : : :.I I IV< < <> > >> > >N? N? N?`F F F FP > > X>? ? ? < < X<( ( ( ( ( ( ( ( (r$   r<   r  )r   r  r   )r  N)3
__future__r   typingr   r   collectionsr   	functoolsr   operatorr   r  r
   
parametersr   logicr   r   r   	singletonr   
operationsr   r   cacher   intfuncr   r   r*   r   r   r   sympy.utilities.iterablesr   r   sympy.core.numbersr   r  r   r-   r2   rA   r<   r  r  r   r  r   r,  r  rC   r$   r"   <module>rW     s   " " " " " " * * * * * * * * # # # # # #                         ) ) ) ) ) ) 4 4 4 4 4 4 4 4 4 4       2 2 2 2 2 2 2 2                           7 7 7 7 7 7 7 7  )))))))((((((6 6 6 ! ! !
-# -# -#`^( ^( ^( ^( ^($ ^( ^( ^(@%  3 3 3 3 3 3 3 3 3 3        r$   