
    MZdz2                    v   d dl mZ d dlmZ d dlmZmZ d dlm	Z	 d dl
Z
ddlmZ ddlmZ dd	lmZ dd
lmZmZ ddlmZ ddlmZ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!  G d d      Z" eejF                        Z$d Z%d Z& G d dee      Z' ed      Z(ddZ)d dZ*d Z+ddl,m-Z- ddl.m/Z/ ddl0m1Z1m2Z2 y)!    )Tuple)defaultdict)
cmp_to_keyreduce)productN   )sympify)Basic)S)AssocOpAssocOpDispatcher)cacheit)	fuzzy_not_fuzzy_group)Expr)global_parameters)KindDispatcher	bottom_up)siftc                        e Zd ZdZdZdZdZdZy)	NC_MarkerFN)__name__
__module____qualname__is_Orderis_Mul	is_Numberis_Polyis_commutative     0/usr/lib/python3/dist-packages/sympy/core/mul.pyr   r      s    HFIGNr"   r   c                 0    | j                  t               y )Nkey)sort_args_sortkeyargss    r#   _mulsortr+   !   s    II-I r"   c                  2   t        |       } g }g }t        j                  }| r| j                         }|j                  rK|j                         \  }}| j                  |       |rH|j                  t        j                  |             n#|j                  r||z  }n|j                  |       | rt        |       |t        j                  ur|j                  d|       |r$|j                  t        j                  |             t        j                  |      S )a   Return a well-formed unevaluated Mul: Numbers are collected and
    put in slot 0, any arguments that are Muls will be flattened, and args
    are sorted. Use this when args have changed but you still want to return
    an unevaluated Mul.

    Examples
    ========

    >>> from sympy.core.mul import _unevaluated_Mul as uMul
    >>> from sympy import S, sqrt, Mul
    >>> from sympy.abc import x
    >>> a = uMul(*[S(3.0), x, S(2)])
    >>> a.args[0]
    6.00000000000000
    >>> a.args[1]
    x

    Two unevaluated Muls with the same arguments will
    always compare as equal during testing:

    >>> m = uMul(sqrt(2), sqrt(3))
    >>> m == uMul(sqrt(3), sqrt(2))
    True
    >>> u = Mul(sqrt(3), sqrt(2), evaluate=False)
    >>> m == uMul(u)
    True
    >>> m == Mul(*m.args)
    False

    r   )listr   Onepopr   args_cncextendappendMul
_from_argsr   r+   insert)r*   newargsncargscoacncs          r#   _unevaluated_Mulr<   &   s    > :DGF	
B
HHJ88JJLEArKKNcnnR01[[!GBNN1  W	q"s~~f-.>>'""r"   c                       e Zd ZU dZdZee   ed<   dZeZ	 e
dd      Zed        Zd Zd	 Zed
        Zd Zed        Zd Zed        Zed        Zeddd       ZdHdZdIdZed        Zd Zed        Ze fd       Zd Z d Z!dJdZ"ed        Z#edKd       Z$ed        Z%ed        Z&ed        Z'ed         Z(ed!        Z)d" Z*d# Z+d$ Z,d% Z-d& Z.d' Z/d( Z0d) Z1d* Z2d+ Z3d, Z4d- Z5d. Z6d/ Z7d0 Z8d1 Z9d2 Z:d3 Z;d4 Z<d5 Z=d6 Z>d7 Z?d8 Z@d9 ZAd: ZBd; ZCd< ZDd= ZEd> ZFd? ZGdLd@ZHdMdAZIdB ZJdC ZKdD ZLdNdEZMdKdFZNedG        ZO xZPS )Or3   aB  
    Expression representing multiplication operation for algebraic field.

    .. 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 ``Mul()`` must be ``Expr``. Infix operator ``*``
    on most scalar objects in SymPy calls this class.

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

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

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

    2. Identity removing
        ``Mul(x, 1, y)`` -> ``Mul(x, y)``

    3. Exponent collecting by ``.as_base_exp()``
        ``Mul(x, x**2)`` -> ``Pow(x, 3)``

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

    Since multiplication can be vector space operation, arguments may
    have the different :obj:`sympy.core.kind.Kind()`. Kind of the
    resulting object is automatically inferred.

    Examples
    ========

    >>> from sympy import Mul
    >>> from sympy.abc import x, y
    >>> Mul(x, 1)
    x
    >>> Mul(x, x)
    x**2

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

    >>> Mul(1, 2, evaluate=False)
    1*2
    >>> Mul(x, x, evaluate=False)
    x*x

    ``Mul()`` also represents the general structure of multiplication
    operation.

    >>> from sympy import MatrixSymbol
    >>> A = MatrixSymbol('A', 2,2)
    >>> expr = Mul(x,y).subs({y:A})
    >>> expr
    x*A
    >>> type(expr)
    <class 'sympy.matrices.expressions.matmul.MatMul'>

    See Also
    ========

    MatMul

    r!   r*   TMul_kind_dispatcher)commutativec                 F    d | j                   D        } | j                  | S )Nc              3   4   K   | ]  }|j                     y wN)kind.0r9   s     r#   	<genexpr>zMul.kind.<locals>.<genexpr>   s     /QVV/   )r*   _kind_dispatcher)self	arg_kindss     r#   rC   zMul.kind   s#    /TYY/	$t$$i00r"   c                 b    | |  k(  ry| j                   d   }|j                  xr |j                  S )NFr   )r*   r   is_extended_negative)rI   r:   s     r#   could_extract_minus_signzMul.could_extract_minus_sign   s0    TE?IIaL{{5q555r"   c                 H   | j                         \  }}|d   t        j                  ur| }|t        j                  urJ|d   j                  r5t        |      }|t        j                  u r
|d    |d<   n|dxx   |z  cc<   n|f|z   }| j                  || j                        S Nr   )	as_coeff_mulr   ComplexInfinityr.   r   r-   NegativeOner4   r    )rI   r:   r*   s      r#   __neg__zMul.__neg__   s    ##%47!+++AAEE>Aw  Dz%#AwhDGGqLGtd{tT%8%899r"   c           
        "6 ddl m} ddlm6 d}t	        |      dk(  r|\  }""j
                  r	"|c}"|"g}|t        j                  usJ |j                  s|j
                  r"j                         \  }""j                  r|t        j                  ur/||z  }|t        j                  u r"}n | ||z  "d      }|gg df}nLt        j                  r<"j                  r0t        "j                  D cg c]  }t!        ||       c} }	|	gg df}|r|S g }
g }g }t        j                  }g }g }t        j"                  }i }d}|D ]  }|j$                  r|j'                  |      \  }}|j(                  r~|j                  r|j+                  |j                         nU|j                  D ]1  }|j                  r|j-                  |       !|j-                  |       3 |j-                  t.               |j0                  r|t        j2                  u s|t        j4                  u r"|j                  rt        j2                  gg dfc S |j0                  st7        ||      r-||z  }|t        j2                  u rt        j2                  gg dfc S Gt7        ||      r|j9                  |      }f|t        j4                  u r*|st        j2                  gg dfc S t        j4                  }|t        j:                  u r|t        j<                  z  }|j                  r|j?                         \  "}|j@                  rԉ"j0                  r|j
                  r|jB                  r|tE        "|      z  }*|jF                  r|j-                  tE        "|             S"jF                  r||z  }" ""t        j                  ur!|jI                  "g       j-                  |       "jJ                  s|jL                  r|j-                  "|f       |j-                  "|f       |t.        ur|j-                  |       |s|jO                  d      }|s|j-                  |       )|jO                         }|j?                         \  }}|j?                         \  }}||z   }||k(  rB|j                  s6||z  }|j                  r|j-                  |       |jQ                  d|       n|j+                  ||g       |r d } ||      } ||      }tS        d      D ]e  }g }d} |D ]   \  "}|j                  rr"j                  s"j(                  rYtU        "fd	t        j4                  t        jV                  t        jX                  fD              rt        j2                  gg dfc c S |t        j                  u r"j0                  r|"z  }"}!|t        j                  ur@tE        "|      }!|!j@                  r("j@                  s"}|!j?                         \  "}"|k7  rd
} |
j-                  !       |j-                  "|f       # | r6t	        |D "ch c]  \  }"}|"	 c}}"      t	        |      k7  rg }
 ||      }f n i }#|D ]&  \  "}|#jI                  |g       j-                  "       ( |#j[                         D ]  \  }" | " |#|<    |
j+                  |#j[                         D "cg c]  \  }}"|s	tE        |"|       c}"}       i }$|j[                         D ],  \  "}|$jI                  t        | g       j-                  "       . ~g }%|$j[                         D ]  \  }" | " "|j\                  dk(  r|tE        "|      z  }*|j^                  |j\                  kD  rHta        |j^                  |j\                        \  }&}'|tE        "|&      z  }tc        |'|j\                        }|%j-                  "|f        ~$te        tf              }(d}|t	        |%      k  r|%|   \  }})g }*tS        |dz   t	        |%            D ]  }+|%|+   \  },}-|ji                  |,      }.|.t        j                  us/|)|-z   }|j\                  dk(  r|tE        |.|      z  }nt|j^                  |j\                  kD  rHta        |j^                  |j\                        \  }&}'|tE        |.|&      z  }tc        |'|j\                        }|*j-                  |.|f       |,|.z  |-f|%|+<   ||.z  }|t        j                  u s n |t        j                  ur{tE        ||)      }/|/j0                  r||/z  }n]tj        jm                  |/      D ]E  }/|/j0                  r||/z  }|/j@                  sJ |/j                  \  }})|(|)   j-                  |       G |%j+                  |*       |dz  }|t	        |%      k  r|(j[                         D ]  \  }" | " |(|<    |r|jo                         \  }!}ta        |!|      \  }0}!|0dz  r| }|dk(  r |
j-                  t        j:                         nk|!ritc        |!|      }|(j[                         D ]  \  }"||k(  s"jJ                  s" |(|<    n, |
j-                  tE        t        jp                  |d             |
j+                  |(j[                         D "cg c]  \  }}"tE        |"|       c}"}       |t        jV                  t        jX                  fv r d }1 |1|
d      \  }
}2 |1||2      \  }}2||2z  }|t        j4                  u ra|
D 3cg c]%  }3ts        |3j                        r|3jt                  |3' }
}3|D 3cg c]%  }3ts        |3j                        r|3jt                  |3' }}3nR|j                  rFtU        6fd|D              r|g||fS tU        d |
D              rt        j2                  gg |fS |gg |fS g }4|
D ]%  }|j0                  r||z  }|4j-                  |       ' |4}
tw        |
       |t        j                  ur|
jQ                  d|       t        j                  ri|sgt	        |
      dk(  rY|
d   j0                  rJ|
d   jx                  r;|
d   j                  r,|
d   }t        |
d   j                  D 5cg c]  }5||5z  	 c}5 g}
|
||fS c c}w c c}}"w c c}"}w c c}"}w c c}3w c c}3w c c}5w )a.  Return commutative, noncommutative and order arguments by
        combining related terms.

        Notes
        =====
            * In an expression like ``a*b*c``, Python process this through SymPy
              as ``Mul(Mul(a, b), c)``. This can have undesirable consequences.

              -  Sometimes terms are not combined as one would like:
                 {c.f. https://github.com/sympy/sympy/issues/4596}

                >>> from sympy import Mul, sqrt
                >>> from sympy.abc import x, y, z
                >>> 2*(x + 1) # this is the 2-arg Mul behavior
                2*x + 2
                >>> y*(x + 1)*2
                2*y*(x + 1)
                >>> 2*(x + 1)*y # 2-arg result will be obtained first
                y*(2*x + 2)
                >>> Mul(2, x + 1, y) # all 3 args simultaneously processed
                2*y*(x + 1)
                >>> 2*((x + 1)*y) # parentheses can control this behavior
                2*y*(x + 1)

                Powers with compound bases may not find a single base to
                combine with unless all arguments are processed at once.
                Post-processing may be necessary in such cases.
                {c.f. https://github.com/sympy/sympy/issues/5728}

                >>> a = sqrt(x*sqrt(y))
                >>> a**3
                (x*sqrt(y))**(3/2)
                >>> Mul(a,a,a)
                (x*sqrt(y))**(3/2)
                >>> a*a*a
                x*sqrt(y)*sqrt(x*sqrt(y))
                >>> _.subs(a.base, z).subs(z, a.base)
                (x*sqrt(y))**(3/2)

              -  If more than two terms are being multiplied then all the
                 previous terms will be re-processed for each new argument.
                 So if each of ``a``, ``b`` and ``c`` were :class:`Mul`
                 expression, then ``a*b*c`` (or building up the product
                 with ``*=``) will process all the arguments of ``a`` and
                 ``b`` twice: once when ``a*b`` is computed and again when
                 ``c`` is multiplied.

                 Using ``Mul(a, b, c)`` will process all arguments once.

            * The results of Mul are cached according to arguments, so flatten
              will only be called once for ``Mul(a, b, c)``. If you can
              structure a calculation so the arguments are most likely to be
              repeats then this can save time in computing the answer. For
              example, say you had a Mul, M, that you wished to divide by ``d[i]``
              and multiply by ``n[i]`` and you suspect there are many repeats
              in ``n``. It would be better to compute ``M*n[i]/d[i]`` rather
              than ``M/d[i]*n[i]`` since every time n[i] is a repeat, the
              product, ``M*n[i]`` will be returned without flattening -- the
              cached value will be returned. If you divide by the ``d[i]``
              first (and those are more unique than the ``n[i]``) then that will
              create a new Mul, ``M/d[i]`` the args of which will be traversed
              again when it is multiplied by ``n[i]``.

              {c.f. https://github.com/sympy/sympy/issues/5706}

              This consideration is moot if the cache is turned off.

            NB
            --
              The validity of the above notes depends on the implementation
              details of Mul and flatten which may change at any time. Therefore,
              you should only consider them when your code is highly performance
              sensitive.

              Removal of 1 from the sequence is already handled by AssocOp.__new__.
        r   )AccumBounds)
MatrixExprN   Fevaluatec           
         i }| D ]L  \  }}|j                         }|j                  |i       j                  |d   g       j                  |d          N |j                         D ](  \  }}|j                         D ]  \  }}t	        | ||<    * g }|j                         D ]<  \  }}|j                  |j                         D 	
cg c]  \  }	}
||
|	z  f c}
}	       > |S c c}
}	w Nr   r   )as_coeff_Mul
setdefaultr2   itemsAddr1   )c_powerscommon_bber8   ddilinew_c_powerstr:   s              r#   _gatherzMul.flatten.<locals>._gather  s    H  -1^^%##Ar*55qE2%vbe}- !( %1ggi %FBHAbE%% L ( F1##!'')$D$!Qa1X$DEF %Es   C"c              3   :   K   | ]  }|j                   v   y wrB   r)   )rE   inftyrb   s     r#   rF   zMul.flatten.<locals>.<genexpr>  s!      6;! 7<qvvo 6;s   Tr   c                 |    g }| D ]2  }|j                   r|j                  r|dz  }"|j                  |       4 ||fS N)is_extended_positiverL   r2   )c_part
coeff_sign
new_c_partrh   s       r#   _handle_for_ooz#Mul.flatten.<locals>._handle_for_oo  sS    
 )A-- --"b(
 %%a() ":--r"   c              3   6   K   | ]  }t        |        y wrB   )
isinstance)rE   r:   rV   s     r#   rF   zMul.flatten.<locals>.<genexpr>  s     >:a,>s   c              3   :   K   | ]  }|j                   d k(    ywFN	is_finite)rE   r:   s     r#   rF   zMul.flatten.<locals>.<genexpr>  s     8A1;;%'8   )=!sympy.calculus.accumulationboundsrU   sympy.matrices.expressionsrV   lenis_Rationalr   r.   is_zeror\   is_Addr   
distributer    r_   r*   _keep_coeffZeror   as_expr_variablesr   r1   r2   r   r   NaNrQ   ru   __mul__ImaginaryUnitHalfas_base_expis_Pow
is_IntegerPowis_negativer]   is_positive
is_integerr/   r5   rangeanyInfinityNegativeInfinityr^   qpdivmodRationalr   r-   gcdr3   	make_argsas_numer_denomrR   r   is_extended_realr+   ry   )7clsseqrU   rvr9   rararbbinewbrp   nc_partnc_seqcoeffr`   num_expneg1epnum_ratorder_symbolsor   rc   o1b1e1b2e2new_expo12ri   irg   changedr   rb   inv_exp_dictcomb_enum_rate_ieppneweigrowjbjejgobjnrs   rq   r:   _newfrV   s7                                     `                   @r#   flattenzMul.flatten   s   ^ 	B9s8q=DAq}}!1!fAEE>!>99~~'188~qS;"#C"%ac1u"=C!UB_*55!:J:J"!&&$IB[B%7$IJ"VR-	       u	0Azz#$#6#6}#E = xx##JJqvv& VV -++JJqM"MM!,	- JJy) :!*;*;!;		EE7B,,__
5+(FQJE~ !wD00A{+		%(a'''EE7B,,))aoo%!! }}1 88{{
 == || %Q 2 (!" #

3q!9 5 (!" %
%&B ~ ( 3 3Ar : A A! D$]]all#NNAq62$A'
 I%MM!$ 

1A"q)  !B^^-FB]]_FB 2gG
 Rx Gm --JJsO$"MM!S1  Aw/7 uu	0H	  8$ '"0 q $	ALG  ,199AHH# 6;&'&7&7&'&8&8&:6; 3; !"wD00:{{
 AAEE>Aq	A xx }}17&*Ga ##QF+1,6 3". 0!QA 0 1474EF "<0I$	P  	5DAq##Ar*11!4	5 &&( 	&DAq!1gLO	&\-?-?-AGTQQs1ayGH NN$ 	5DAqc1gr*11!4	5 LLN 		#DAqQAssaxQ"ssQSSy acc*RQ$R%NNAq6"		#  4 #g,QZFBD1q5#g,/  BFF2JAEE> RAssaxQ*339&,QSS!##&6GC!SC[0E (QSS 1AQF+"$Q$GAJABQUU{)* "bk==SLE  #}}S1 0==!SLE#&::-:%(XXFB HOOB/0 NN4 FAO #g,T JJL 	DAq1gDG	 ((*DAq!Q<DAq1uAvaoo. !A JJL MDAqEzamm#$"QM MM#ammUU"KL 	TZZ\:TQs1ay:; QZZ!3!344	. "0!:FJ"0*"EGZZE A%%% "( QA	!))0D010B0B0N  QF Q") SQ)AII2F232D2D2P  SG S ]] >g>>w66888wM117B--  	A{{
A		
  	 MM!U# ((S[A=Mq	##q	(;(;q	@P@P1IEVAY^^<E!G<=>Fw--G %Jd 0  HD ;2QSD =s0   4s#s(2
s.
=s.
#s4
*s:	*s?tc           
         | j                  d      \  }}|j                  rDt        |D cg c]  }t        ||d       c} t        t        j	                  |      |d      z  S |j
                  r|j                  dk(  r| j                  r| j                         d   }|j
                  rddl	m
} t        |dz        j                         \  }} ||d      \  }}	|	rb ||d      \  }}	|	rTddlm}
 t        |      |z  }t!        ||j"                  z  d |
|      t$        j&                  z  z   |j"                  z        S t        | |d      }|j
                  s|j(                  r|j+                         S |S c c}w )	NF)split_1rX   rW   r   )integer_nthrootr   sign)r0   r   r3   r   r4   r~   r   is_imaginaryas_real_imagpowerr   absr   $sympy.functions.elementary.complexesr   r	   r<   r   r   r   is_Float_eval_expand_power_base)rI   rc   cargsr;   rb   r9   r   r   rd   rh   r   r   r   s                r#   _eval_powerzMul._eval_power  sI    MM%M0	r<<EBqQE2BCCNN2&E:; ;==QSSAX  %%'*==6qs8224DAq*1a0DAq.q!41Q '
1A#3AqssFQaAX=X[\[^[^<^#__a%(==AJJ,,..+ Cs   E9c                      dd| j                   fS )N   r   )r   r   s    r#   	class_keyzMul.class_key  s    !S\\!!r"   c                 .   | j                         \  }}|t        j                  u r=|j                  rt	        j
                  ||       }n/|j                  |      }||}| }nt	        j
                  | |      }|j                  r|j                         S |S rB   )r\   r   rR   r   r   _eval_evalf	is_numberexpand)rI   precr:   mr   mnews         r#   r   zMul._eval_evalf  s      "1xx))!T22}}T*#AR$$T40B<<99;	r"   c                     ddl m} | j                         \  }}|t        j                  urt        d       |d      j                   ||      j                  fS )z;
        Convert self to an mpmath mpc if possible
        r   )Floatz7Cannot convert Mul to mpc. Must be of the form Number*Ir   )numbersr   r\   r   r   AttributeError_mpf_)rI   r   im_part	imag_units       r#   _mpc_z	Mul._mpc_  sQ    
 	#!..0AOO+ !!Z[[ag 4 455r"   c                     | j                   }t        |      dk(  rt        j                  | fS t        |      dk(  r|S |d    | j                  |dd  fS )ao  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_mul() which gives the head and a tuple containing
          the arguments of the tail when treated as a Mul.
        - if you want the coefficient when self is treated as an Add
          then use self.as_coeff_add()[0]

        Examples
        ========

        >>> from sympy.abc import x, y
        >>> (3*x*y).as_two_terms()
        (3, x*y)
        r   rW   r   N)r*   r}   r   r.   _new_rawargs)rI   r*   s     r#   as_two_termszMul.as_two_terms  s[    * yyt9>55$;Y!^K 7-D--tABx888r"   )rationalc                `   r8t        | j                  fdd      \  }} | j                  | t        |      fS | j                  }|d   j                  rG|r|d   j
                  r
|d   |dd  fS |d   j                  rt        j                  |d    f|dd  z   fS t        j                  |fS )Nc                 "     | j                    S rB   )has)xdepss    r#   <lambda>z"Mul.as_coeff_mul.<locals>.<lambda>0  s    uquud| r"   T)binaryr   r   )
r   r*   r   tupler   r~   rL   r   rR   r.   )rI   r   r   kwargsl1l2r*   s     `    r#   rP   zMul.as_coeff_mul-  s    $))%;DIFB$4$$b)5944yy7tAw22AwQR((a--}}QxkDH&<<<uud{r"   c                 B   | j                   d   | j                   dd }}|j                  rd|r|j                  r&t        |      dk(  r||d   fS | | j                  | fS |j
                  r$t        j                   | j                  | f|z    fS t        j                  | fS )zC
        Efficiently extract the coefficient of a product.
        r   r   N)	r*   r   r~   r}   r   rL   r   rR   r.   )rI   r   r   r*   s       r#   r\   zMul.as_coeff_Mul:  s     iilDIIabMt??u00t9> $q'>) "3$"3"3T":::++}}&7d&7&7E6)d:J&LLLuud{r"   c                    ddl m}m}m} g }g }g }t        j
                  }	| j                  D ]  }
|
j                         \  }}|j                  r|j                  |       4|j                  r#|j                  |t        j                  z         c|
j                  ro|r|
j                         nd }t        |      D ])  \  }}||k(  s|j                   ||      dz         ||=   |
j                  r|	|
z  }	|j                  |
       |j                  |
         | j                  | }|j!                  d      |k(  ry t#        |      dz  r ||j%                  d            }nt        j&                  } | j                  ||z    }| ||      z  | ||      z  }}|	dk(  rY|dk(  r3|j                  r|t        j&                  fS t        j&                  ||z  fS |t        j&                  u r||fS | |z  ||z  fS ddlm}  ||	d      j                         \  }}|t        j&                  u r||z  ||z  z
  ||z  ||z  z   fS | |z  ||z  }}||z  ||z  z
  ||z  ||z  z   fS )	Nr   )AbsimrerW   ignorer   )
expand_mulF)deep)r   r   r   r   r   r.   r*   r   r   r2   r   r    	conjugate	enumerater   funcgetr}   r/   r   functionr   )rI   r   hintsr   r   r   othercoeffrcoeffiaddtermsr9   r   r   aconjr   r   imcorecor   addreaddims                        r#   r   zMul.as_real_imagJ  sM   DD55 	 A>>#DAqyya a/0!!).D%e, 	(DAqEzc!fai0!!H		( xx AQQ)	 * DIIu99X!#v;?fjjm$D 66Dtyy6F?,RU
DAJ1q=Av<< !&&>)FFDI..qvv~1vE!GT!V$$(!(7DDFu166>eGag%qw5'89957DFqAeGag%qw5'899r"   c           	      :   t        |       }|dk(  r| d   j                  S g }t        j                  | d|dz         }t        j                  | |dz  d       }|D cg c]  }|D ]  }t        ||        }}}t	        | }t	        j
                  |      S c c}}w )zk
        Helper function for _eval_expand_mul.

        sums must be a list of instances of Basic.
        r   r   NrW   )r}   r*   r3   _expandsumsr_   r   )sumsLtermsleftrightr9   rb   addeds           r#   r  zMul._expandsums  s     I67<<tEQT{+QTU,$(8q%8QQ888U}}U## 9s   Bc                    ddl m} | } ||      \  }}|j                  r3||fD cg c]"  }|j                  r |j                  di |n|$ c}\  }}||z  }|j                  s|S g g d}	}}|j                  D ]Z  }
|
j
                  r|j                  |
       d}	#|
j                  r|j                  |
       A|j                  t        |
             \ |	s|S  | j                  | }|r|j                  dd      }| j                  j                  |      }g }|D ]_  }| j                  ||      }|j                  r.t        d |j                  D              r|r|j                         }|j                  |       a t        | S |S c c}w )Nr   fractionFTr   c              3   4   K   | ]  }|j                     y wrB   )r   rD   s     r#   rF   z'Mul._eval_expand_mul.<locals>.<genexpr>  s     'AQ'ArG   r!   )sympy.simplify.radsimpr  r   _eval_expand_mulr*   r   r2   r    r
   r   r  r  r   r_   )rI   r  r  exprr   rd   r   plainr  rewritefactorr   r  r*   termrh   s                   r#   r  zMul._eval_expand_mul  s}   3 ~188Q! 4588&A&&//B !DAqs{{K!2uWtii 	/F}}F#((LL(KKf.	/ KDIIu%Eyy/		--d3! #D		%.AxxC'A!&&'A$Ad..0KKN	#
 Dz!A!s   'Fc           
      0   t        | j                        }g }t        t        |            D ]T  }||   j	                  |      }|s|j                  t        d |d | |gz   ||dz   d  z   t        j                               V t        j                  |      S )Nc                     | |z  S rB   r!   )r   ys     r#   r   z&Mul._eval_derivative.<locals>.<lambda>  s
    1 r"   r   )r-   r*   r   r}   diffr2   r   r   r.   r_   fromiter)rI   sr*   r  r   rd   s         r#   _eval_derivativezMul._eval_derivative  s    DIIs4y! 	_AQQA V$4tBQx1#~QQRUV7TWXW\W\]^	_ ||E""r"   c                 H   ddl m} ddlm}m}m} t        |||f      st        | !  ||      S ddl	m
} | j                  }t        |      }	t        |t        |f      rkg }
ddlm}  ||	|      D ]O  \  }}t!        t#        ||      D cg c]  \  }}|j%                  ||f       c}} }|
j'                  ||z         Q t)        |
 S ddlm} ddlm} dd	lm}  |d
|	z  |      }|t7        |      z
  } ||      }|t9        t;        ||            z   ||      z  t!        t=        |	dz
        D cg c]  }||   j%                  |||   f       c} z  |d   j%                  | |d|      f      z  |D cg c]  }|d|f	 c}}} ||g| S c c}}w c c}w c c}w )Nr   )AppliedUndef)SymbolsymbolsDummy)Integerr   )!multinomial_coefficients_iterator)Sum)	factorial)Maxzk1:%ir   rn   )r  r(  symbolr)  r*  r+  ru   super_eval_derivative_n_timesr   r,  r*   r}   intsympy.ntheory.multinomialr-  r3   zipr#  r2   r_   sympy.concrete.summationsr.  (sympy.functions.combinatorial.factorialsr/  (sympy.functions.elementary.miscellaneousr0  sumprodmapr   )rI   r%  r   r(  r)  r*  r+  r,  r*   r   r  r-  kvalsr:   kargr   r.  r/  r0  klastnfactrh   rc   l	__class__s                            r#   r3  zMul._eval_derivative_n_times  s   *22!lF34 73Aq99$yyIa#w(ES=aC $qUD9IJvq##((Aq6*JKQU#$ ;1F@!/CJ!$s9e,--i.>>uQqSzB!$q',,58}-BCDHMM1c!Um,-. !&&1aAY&	 
 1zqz K C&s   
F4 F
;Fc                     ddl m} | j                  d   }t        | j                  dd   }|j	                  |||z          ||||      z   ||||      |z  z   S )Nr   )difference_deltar   )sympy.series.limitseqrE  r*   r3   subs)rI   r   stepddarg0rests         r#   _eval_difference_deltazMul._eval_difference_delta  sc    @yy|DIIabM"		!QX&D!T)::Ra=N>  	r"   c                     | j                         \  }}t        j                  |      }t        |      dk(  r1| j                  j                  ||      }|d   j                  ||      S y r[   )r\   r3   r   r}   rC  _combine_inversematches)rI   r  	repl_dictr   r  newexprs         r#   _matches_simplezMul._matches_simple  s]    ((*ue$u:?nn55dEBG8##GY77r"   c                    t        |      }| j                  r|j                  r| j                  |||      S | j                  |j                  ury | j                         \  }}|j                         \  }}||fD cg c]	  }|xs dg c}\  }}t	        | }	t	        | }
|	j                  |
||      }|s||k7  ry t        j                  |      }t        j                  |      }t        j                  |||      }|xs d S c c}w Nr   )r	   r    _matches_commutativer0   r3   rO  _matches_expand_pows_matches_noncomm)rI   r  rP  oldc1nc1c2nc2r:   comm_mul_selfcomm_mul_exprs              r#   rO  zMul.matches  s   t}4#6#6,,T9cBB  (;(;; --/C--/C%'H-q!(s(-B RR!))-CH	 R2X &&s+&&s+((c9=	 D ) .s   <Dc                     g }| D ]X  }|j                   r9|j                  dkD  r*|j                  |j                  g|j                  z         H|j	                  |       Z |S rO   )r   expr1   baser2   )arg_listnew_argsr?  s      r#   rV  zMul._matches_expand_pows  sU     	%Czzcggk
SWW 45$		%
 r"   c                    |i }n|j                         }g }d}|\  }}i }|t        |      k  r|t        |       k  r| |   }|j                  rt        j	                  ||       t        j                  ||| |      }	|	r'|	\  }
}|j                  |
       |r|D ]
  }||   ||<    |sy|j                         }|\  }}|t        |      k  r|t        |       k  r|S )zNon-commutative multiplication matcher.

        `nodes` is a list of symbols within the matcher multiplication
        expression, while `targets` is a list of arguments in the
        multiplication expression being matched against.
        N)r   r   )copyr}   is_Wildr3   _matches_add_wildcard_matches_new_statesr1   r/   )nodestargetsrP  agendastatenode_ind
target_indwildcard_dictnodestates_matches
new_statesnew_matchesmatchs                r#   rW  zMul._matches_noncomm$  s     I!(I $*3w<'Hs5z,A?D||))-? 44]E5:GEN*8'
Kj)!, >+6u+=	%(>

',$*% 3w<'Hs5z,A( r"   c                 D    |\  }}|| v r| |   \  }}||f| |<   y ||f| |<   y rB   r!   )
dictionaryrl  rm  rn  beginends         r#   rg  zMul._matches_add_wildcardO  s@    $*z!#H-JE3$):#6Jx $.
#;Jx r"   c                    |\  }}||   }||   }|t        |      dz
  k\  r|t        |      dz
  k  ry |j                  rt        j                  | |||      }|rt        j	                  | ||      }	|	D ]>  }
| |
   \  }}| |   \  }}|||dz    }|||dz    }t        ||      D ]  \  }}||k7  s  y  @ ||dz   fg}|t        |      dz
  k  r|j                  |dz   |dz   f       ||fS y |t        |      dz
  k\  r|t        |      dz
  k  ry |j                  |      }|r|dz   |dz   fg|fS ||k(  r|dz   |dz   fgd fS y rT  )r}   rf  r3   _matches_match_wilds_matches_get_other_nodesr6  r2   rO  )rv  rl  ri  rj  rm  rn  rp  targetmatch_attemptother_node_indsindother_begin	other_end
curr_begincurr_endother_targetscurrent_targetscurrr  	new_states                       r#   rh  zMul._matches_new_statesX  s   $*X$ W))hUa.G<<44Z5:GEM #&">">z?Dh#P* 	(C-7_*K+5h+?(J$+K	A$FM&-jA&FO'*?M'J (e5=#'(	( '
Q78	c%j1n,$$hlJN%CD -/// 8 3u:>)j3w<!;K.K LL0M!AzA~67FF!AzA~67==r"   c                     ||   }| |   \  }}|||dz    }t        |      dkD  rt        | n|d   }|j                  |      S )z@Determine matches of a wildcard with sub-expression in `target`.r   r   )r}   r3   rO  )	rv  wildcard_indri  rj  wildcardrw  rx  r  mults	            r#   rz  zMul._matches_match_wilds  sV     &-
scAg&!%j1nsE{%(%%r"   c                 H    ||   }| D cg c]  }||   |k(  s| c}S c c}w )z8Find other wildcards that may have already been matched.r!   )rv  ri  rm  ind_noder  s        r#   r{  zMul._matches_get_other_nodes  s,     ?)DU3Z8-CDDDs   c                    ddl m} ddlm} | |k(  rt        j
                  S d } || |      s	 |||       rt        j
                  S t        d | |fD              rO |d      }t        j                  |i}|t        j                  i}| j                  |      j                         }|j                  |      j                         }	t        |	      }
t        |	j                               D ]:  }||v s||xx   |	j                  |      z  cc<   ||   r*|j                  |       < t        |	      |
k7  rvt        |j                         D cg c]
  \  }}||z   c}} j                  |      } t        |	j                         D cg c]
  \  }}||z   c}} j                  |      }| |z  } ||      }|j                   r|S |S c c}}w c c}}w )z
        Returns lhs/rhs, but treats arguments like symbols, so things
        like oo/oo return 1 (instead of a nan) and ``I`` behaves like
        a symbol instead of sqrt(-1).
        r   )signsimpr   )r+  c                     | j                   r=|j                  r1| j                  d      |j                         j                  d      k(  S y)Nr   F)r   is_comparable__add__evalf)rB  r   s     r#   checkz#Mul._combine_inverse.<locals>.check  s8    zzaoo yy|qwwy'8'8';;;r"   c              3   P   K   | ]  }|j                   xs |j                     y wrB   )r   r   rE   r   s     r#   rF   z'Mul._combine_inverse.<locals>.<genexpr>  s      8qxx#188#8   $&I)sympy.simplify.simplifyr  r1  r+  r   r.   r   r   xreplaceas_powers_dictr}   r   keysr/   r3   r^   r   )lhsrhsr  r+  r  rd   _ii_r9   rb   blenr   r>  vr   srvs                   r#   rN  zMul._combine_inverse  s    	5!#:55L	 c?eCo55L8c3Z88 c
A//1%BQ__%BR //1AR //1Aq6DAFFHo "7bEQUU2Y&ER5b		"
 1v~QWWY7TQAqD78AA"EQWWY7TQAqD78AA"EWrlmms++	 87s   G
G
c                     t        t              }| j                  D ]5  }|j                         j	                         D ]  \  }}||xx   |z  cc<    7 |S rB   )r   r4  r*   r  r^   )rI   rd   r  rb   rc   s        r#   r  zMul.as_powers_dict  sX    II 	D++-335 1!		 r"   c           	          t        t        | j                  D cg c]  }|j                          c}       \  }} | j                  |  | j                  | fS c c}w rB   )r-   r6  r*   r   r   )rI   r   numersdenomss       r#   r   zMul.as_numer_denom  sV     c		#J1A$4$4$6#JKLtyy&!9499f#555 $Ks   Ac                    d }g }d}| j                   D ]Z  }|j                         \  }}|j                  s|dz  }||}n||k7  s|dkD  r| t        j                  fc S |j                  |       \  | j                  | |fS )Nr   r   )r*   r   r    r   r.   r2   r   )rI   r   basesr;   r   rb   rc   s          r#   r   zMul.as_base_exp  s     	A==?DAq##azbBFQUU{"LLO	 tyy% "$$r"   c                 @    t        fd| j                  D              S )Nc              3   @   K   | ]  }|j                          y wrB   )_eval_is_polynomialrE   r  symss     r#   rF   z*Mul._eval_is_polynomial.<locals>.<genexpr>  s     Hd4++D1H   allr*   rI   r  s    `r#   r  zMul._eval_is_polynomial  s    HdiiHHHr"   c                 @    t        fd| j                  D              S )Nc              3   @   K   | ]  }|j                          y wrB   )_eval_is_rational_functionr  s     r#   rF   z1Mul._eval_is_rational_function.<locals>.<genexpr>  s     OT42248Or  r  r  s    `r#   r  zMul._eval_is_rational_function  s    OTYYOOOr"   c                 H    t        fd| j                  D        d      S )Nc              3   B   K   | ]  }|j                          y wrB   )is_meromorphic)rE   r?  r9   r   s     r#   rF   z+Mul._eval_is_meromorphic.<locals>.<genexpr>  s     K#S//15Ks   T
quick_exitr   r*   )rI   r   r9   s    ``r#   _eval_is_meromorphiczMul._eval_is_meromorphic  s    KK'+- 	-r"   c                 @    t        fd| j                  D              S )Nc              3   @   K   | ]  }|j                          y wrB   )_eval_is_algebraic_exprr  s     r#   rF   z.Mul._eval_is_algebraic_expr.<locals>.<genexpr>  s     L$4//5Lr  r  r  s    `r#   r  zMul._eval_is_algebraic_expr  s    L$))LLLr"   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wrB   )r    rD   s     r#   rF   zMul.<lambda>.<locals>.<genexpr>  s      5-5-rG   r  rI   s    r#   r   zMul.<lambda>  s     5-"&))5- )- r"   c                     t        d | j                  D              }|du r:t        d | j                  D              rt        d | j                  D              ry y|S )Nc              3   4   K   | ]  }|j                     y wrB   )
is_complexrD   s     r#   rF   z'Mul._eval_is_complex.<locals>.<genexpr>  s     <QALL<rG   Fc              3   4   K   | ]  }|j                     y wrB   )is_infiniterD   s     r#   rF   z'Mul._eval_is_complex.<locals>.<genexpr>  s     4Q1==4rG   c              3   8   K   | ]  }|j                   d u  ywrw   r   rD   s     r#   rF   z'Mul._eval_is_complex.<locals>.<genexpr>  s     A!qyy-A   )r   r*   r   )rI   comps     r#   _eval_is_complexzMul._eval_is_complex  sL    <$))<<5=4$))44AtyyAAr"   c                     dx}}| j                   D ]^  }|j                  r	|dur yd}|j                  r	|dur yd}-|du r|j                  |dur yd }|du sJ|j                  W|dur yd }` ||fS )NF)NNT)r*   r   r  )rI   	seen_zeroseen_infiniter9   s       r#   _eval_is_zero_infinite_helperz!Mul._eval_is_zero_infinite_helper  s    X %*)	M 	)Ayy -% 	E)% $%!))*;$E1) $I E)amm.C -)$(M#	)& -''r"   c                 F    | j                         \  }}|du ry|du r|du ryy NFTr  rI   r  r  s      r#   _eval_is_zerozMul._eval_is_zero@  s7     $(#E#E#G 	=$=E#9r"   c                 F    | j                         \  }}|du r|du ry|du ryy )NTFr  r  s      r#   _eval_is_infinitezMul._eval_is_infiniteL  s7     $(#E#E#G 	=D Y%%7e#r"   c                     t        d | j                  D        d      }|r|S |du rt        d | j                  D              ryy y )Nc              3   4   K   | ]  }|j                     y wrB   )is_rationalrD   s     r#   rF   z(Mul._eval_is_rational.<locals>.<genexpr>\  s     ;A!--;rG   Tr  Fc              3   8   K   | ]  }|j                   d u   ywrw   r  rD   s     r#   rF   z(Mul._eval_is_rational.<locals>.<genexpr>a       9!199%9r  r   r*   r  rI   r   s     r#   _eval_is_rationalzMul._eval_is_rational[  sF    ;;MH%Z9tyy99 : r"   c                     t        d | j                  D        d      }|r|S |du rt        d | j                  D              ryy y )Nc              3   4   K   | ]  }|j                     y wrB   )is_algebraicrD   s     r#   rF   z)Mul._eval_is_algebraic.<locals>.<genexpr>e  s     <Q!..<rG   Tr  Fc              3   8   K   | ]  }|j                   d u   ywrw   r  rD   s     r#   rF   z)Mul._eval_is_algebraic.<locals>.<genexpr>j  r  r  r  r  s     r#   _eval_is_algebraiczMul._eval_is_algebraicd  sF    <$))<NH%Z9tyy99 : r"   c                    ddl m} | j                         }|du ryg }g }d}| j                  D ]W  }d}|j                  r.t        |      t        j                  us.|j                  |       @|j                  rd|j                         \  }}	t        |      t        j                  ur|j                  |       |	t        j                  us|j                  |	       |j                  r|j                         \  }
}|
j                  r|j                  sdx}}|j                  r?|j                  |t        j                  u rdnt        |t        j                                6|s|j"                  rJ |j$                  rJ  y  y  y  |s|syd }d }d }d	d
lm |s|rt+        fd|D              ry|ry  ||      r	 ||      ry ||      r|dgk(  ry ||      r! ||      rt-        |ddid	z
  j"                  ryt/        |      d	k(  rn|d   }	|	j0                  r]|	j2                  rQt5        |D cg c]!  }|j2                  r|j                         d	   # c}  ||	j6                        z
  j8                  ryt/        |      d	k(  rq|d   }|j0                  r_|j2                  rRt5        |D cg c]!  }|j2                  r|j                         d	   # c}  ||j6                        z
  j"                  ryy y y y c c}w c c}w )Nr   trailingFTrW   c                 &    t        d | D              S )Nc              3   4   K   | ]  }|j                     y wrB   )is_oddr  s     r#   rF   z9Mul._eval_is_integer.<locals>.<lambda>.<locals>.<genexpr>  s     3Aqxx3rG   r  r   s    r#   r   z&Mul._eval_is_integer.<locals>.<lambda>  s    3333 r"   c                 &    t        d | D              S )Nc              3   4   K   | ]  }|j                     y wrB   is_evenr  s     r#   rF   z9Mul._eval_is_integer.<locals>.<lambda>.<locals>.<genexpr>       5a		5rG   r  r  s    r#   r   z&Mul._eval_is_integer.<locals>.<lambda>      C5155 r"   c                 &    t        d | D              S )Nc              3   4   K   | ]  }|j                     y wrB   r  r  s     r#   rF   z9Mul._eval_is_integer.<locals>.<lambda>.<locals>.<genexpr>  r  rG   )r   r  s    r#   r   z&Mul._eval_is_integer.<locals>.<lambda>  r  r"   r   )is_gtc              3   L   K   | ]  } |t         j                          y wrB   )r   r.   )rE   _r  s     r#   rF   z'Mul._eval_is_integer.<locals>.<genexpr>  s       37$%a37   !$rY   )sympy.ntheory.factor_r  r  r*   r   r   r   r.   r2   r~   r   r   r   r   r   r   rR   r   r   
relationalr  r  r3   r}   r   r  r_   r   is_nonnegative)rI   r  r  
numeratorsdenominatorsunknownr9   hitr   rd   rb   rc   alloddallevenanyevenr   r  s                   @r#   _eval_is_integerzMul._eval_is_integerp  s   2,,.%
 	AC||q6&%%a('')1q6&%%a(AEE> ''*}}1||1<<$((C'== ''Q!&&[Aq}}-/ }},, yy(= 9	< G355%ls 37)537 07JGL$9Z \aS%8Z VL &L959A=+|!QA||		 "1&'ii --/!, 1 24<QSSMB(.)  z?a1A||		 $3()		 --/!, 3 46>qssmD%+& !& !*|  	13s   7&K?3&Lc                 z    t        d | j                  D              }|xr t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wrB   )is_polarrE   r?  s     r#   rF   z%Mul._eval_is_polar.<locals>.<genexpr>  s     ::rG   c              3   P   K   | ]  }|j                   xs |j                     y wrB   )r  r   r  s     r#   rF   z%Mul._eval_is_polar.<locals>.<genexpr>  s      EC//Er  )r   r*   r  )rI   	has_polars     r#   _eval_is_polarzMul._eval_is_polar  s7    :		::	 FE499EE	Fr"   c                 $    | j                  d      S NT)_eval_real_imagr  s    r#   _eval_is_extended_realzMul._eval_is_extended_real  s    ##D))r"   c                    d}d }| j                   D ]  }|j                  xs |j                  du r|j                  du r y|j                  r| }?|j                  r;|rN|j
                  }|s|du r|}c|sft        d | j                   D              r y y |j                  du r|r y |}|j                  du r|r y |} y  |r&|j                  du r|r|S |j                  du r|s|S y y |du r|S |r|S y )NFc              3   4   K   | ]  }|j                     y wrB   rx   rD   s     r#   rF   z&Mul._eval_real_imag.<locals>.<genexpr>  s     >qq{{>rG   T)r*   r  r  r   r   r   r  )rI   realzerot_not_re_imrh   zs         r#   r  zMul._eval_real_imag  s    	A-%7A<N<NRW<Wx##		A >DII>>#'##u,5(1	4 ++u4K''50K  1 U]KK r"   c                 ^    t        d | j                  D              r| j                  d      S y )Nc              3   T   K   | ]   }|j                   d u xr |j                   " ywrw   )r   ry   rD   s     r#   rF   z)Mul._eval_is_imaginary.<locals>.<genexpr>  s%     EaqyyE!1akk1Es   &(F)r  r*   r  r  s    r#   _eval_is_imaginaryzMul._eval_is_imaginary  s+    E499EE''.. Fr"   c                 $    | j                  d      S r  _eval_herm_antihermr  s    r#   _eval_is_hermitianzMul._eval_is_hermitian  s    ''--r"   c                 $    | j                  d      S NFr  r  s    r#   _eval_is_antihermitianzMul._eval_is_antihermitian  s    ''..r"   c                     | j                   D ]:  }|j                  |j                   y |j                  r*|j                  r| }: y  |dur|S | j                         }|ry|du r|S y r  )r*   is_hermitianis_antihermitianr  )rI   hermrh   r   s       r#   r  zMul._eval_herm_antiherm  s     	A~~%););)C~~##x	 uK$$&K r"   c                     | j                   D ]P  }|j                  }|r<t        | j                         }|j                  |       t	        d |D              r y y |P y  t	        d | j                   D              ryy )Nc              3   f   K   | ])  }|j                   xr t        |j                        d u  + yw)TN)r  r   r   rE   r   s     r#   rF   z*Mul._eval_is_irrational.<locals>.<genexpr>  s'     XA>)AII*>4GXs   /1Tc              3   4   K   | ]  }|j                     y wrB   )is_realr%  s     r#   rF   z*Mul._eval_is_irrational.<locals>.<genexpr>  s     ,Qqyy,rG   F)r*   is_irrationalr-   remover  )rI   rh   r9   otherss       r#   _eval_is_irrationalzMul._eval_is_irrational  ss     		AAdiia XQWXXy		 ,$)),, -r"   c                 $    | j                  d      S )a  Return True if self is positive, False if not, and None if it
        cannot be determined.

        Explanation
        ===========

        This algorithm is non-recursive and works by keeping track of the
        sign which changes when a negative or nonpositive is encountered.
        Whether a nonpositive or nonnegative is seen is also tracked since
        the presence of these makes it impossible to return True, but
        possible to return False if the end result is nonpositive. e.g.

            pos * neg * nonpositive -> pos or zero -> None is returned
            pos * neg * nonnegative -> neg or zero -> False is returned
        r   _eval_pos_negr  s    r#   _eval_is_extended_positivezMul._eval_is_extended_positive  s      !!!$$r"   c                    dx}}| j                   D ]  }|j                  r|j                  r| } |j                  r t	        d | j                   D              r y y |j
                  r| }d}^|j                  rd}m|j                  du r
| }|r y d}|j                  du r|r y d} y  |dk(  r	|du r|du ry|dk  ryy )NFc              3   4   K   | ]  }|j                     y wrB   rx   rD   s     r#   rF   z$Mul._eval_pos_neg.<locals>.<genexpr>7  s     6qq{{6rG   Tr   r   )	r*   ro   rL   r   r  is_extended_nonpositiveis_extended_nonnegativer   r   )rI   r   saw_NONsaw_NOTrh   s        r#   r.  zMul._eval_pos_neg/  s    !!' 	A%%''u6DII66 **u** %'u%'7	8 19E)g.>!8 r"   c                 $    | j                  d      S rm   r-  r  s    r#   _eval_is_extended_negativezMul._eval_is_extended_negativeR  s    !!"%%r"   c                 <   | j                         }|dur|S ddlm}  ||       \  }}|j                  rw|j                  rkddlm} t        t        j                  |      D cg c]!  }|j                  r|j                         d   # c}  ||j                        z
  j                  ryy d\  }}| j                  D ]X  }	t        |	      t        j                   u r|	j                  r y|du rn%|dk7  r||	z   j"                  rd}n|	j                  d }|	}Z |S c c}w )NTr   r  r  r   F)Tr   )r  r  r  r   r  r  r  r_   r3   r   r   r   r   r*   r   r   r.   r  )
rI   r   r  r   rd   r  r   r   accrh   s
             r#   _eval_is_oddzMul._eval_is_oddU  s   **,
T!3~1<<AII6 MM!$3Q()		 mmoa( 3 46>qssmD!k" 3 	A1vyyEzsQw.."C	 %3s   "&Dc                 8   ddl m}  ||       \  }}|j                  rx|j                  rkddlm} t        t        j                  |      D cg c]!  }|j                  r|j                         d   # c}  ||j                        z
  j                  ryy y y c c}w )Nr   r  r  r   F)r  r  r   r  r  r  r_   r3   r   r   r   r  )rI   r  r   rd   r  r   s         r#   _eval_is_evenzMul._eval_is_event  s    3~1<<AII 7MM!$3Q()		 mmoa( 3 46>qssmD$n% % &<
3s   &Bc                     d}| j                   D ]1  }|j                  r|j                  s y|dz
  j                  s-|dz  }3 |dkD  ryy)z
        Here we count the number of arguments that have a minimum value
        greater than two.
        If there are more than one of such a symbol then the result is composite.
        Else, the result cannot be determined.
        r   Nr   T)r*   r   r   )rI   number_of_argsr?  s      r#   _eval_is_compositezMul._eval_is_composite  sU     99 	$CNNsA""!#		$ A r"   c           	      <  ()*+, ddl m, ddlm} ddlm+ ddlm} |j                  sy |j                  d   j                  rR|j                  d   dk  r@| j                  d   j                  r'| j                  d   dk  r| j                  | |       S y d ((+fd}(fd}d	 }d } ||       \  }	}
| }|
t        j                  urJ|	j                  ||      |
j                  ||      z  }|j                  s|j                  ||      S || k7  r|}|j                  d   }|j                  d   }d }|j                  r#|j                  r||k7  r |j                  |      }n|j                  r|S  ||      \  )} ||      \  *}|rf|j                  rZt!        |      d
k7  rLt         |t!        |      |            })j#                  |       |)v r)|xx   |z  cc<   n|)|<   |||z  z  }nd
}d}t%        |      t%        |      kD  rd}nt%        *      t%        )      kD  rd}nt|D ch c]  }|d   	 c}j'                  |D ch c]  }|d   	 c}      rd}n>t)        *      j'                  t)        )            rd}nt+        )*,fd*D              rd}|s|S *sd }nKg }*j-                         D ]+  \  }})|   }|j/                   |||             |d   r)|c S  t1        |      }|s(d }t3        t%        |            D ]  } |||    ||<    nRd}t%        |      }|xs t        j4                  }g }d}|r||z   t%        |      k  rd}g }t3        |      D ]  }|||z      d   ||   d   k7  r nx|dk(  r(|j/                   ||||z      d
   ||   d
                nX||d
z
  k(  r(|j/                   ||||z      d
   ||   d
                n(|||z      d
   ||   d
   k7  r n|j/                  d
       |d
z  } t1        |      } | r|d
k(  r@|rt1        ||       } t7        ||        |||   d   ||   d
   | |d   d
   z  z
        z  ||<   nd
}  |||   d   ||   d
   | |d   d
   z  z
        }!|}"||z   d
z
  }#||#   d   ||#   d
   | |d   d
   z  z
  f}$|$d
   r4||z   t%        |      k  r|!|"z  |$g||||z    n! ||$ }$|!|"z  |$z  g||||z    n|!|"z  g||||z    || z  }|| z  }d}|s|j/                  |       |d
z  }|r||z   t%        |      k  r|s|S |j9                  t3        |t%        |                   |D ]  } |||    j;                  ||      ||<    ||}%n||}%nt1        ||      }%g }&)D ]X  }|*v r')|   *|   |%z  z
  }'|&j/                   |||'             .|&j/                   ||j;                  ||      )|                Z |r|st7        ||      g|&z   }&| |j<                  |& z   |j<                  | z  S c c}w c c}w )Nr   r   )multiplicity)	powdenestr  c                     ddl m} | j                  st        | |      r| j	                         S | t
        j                  fS )Nr   )r`  )&sympy.functions.elementary.exponentialr`  r   ru   r   r   r.   )r9   r`  s     r#   base_expz Mul._eval_subs.<locals>.base_exp  s1     Cxx:a-}}&aee8Or"   c                 N   t        t              g }}t        j                  |       D ]x  } 	|      } |      \  }}|t        j
                  ur$|j                         \  }}t        |||z        }|}|j                  r||xx   |z  cc<   f|j                  ||g       z ||fS )zbreak up powers of eq when treated as a Mul:
                   b**(Rational*e) -> b**e, Rational
                commutatives come back as a dictionary {b**e: Rational}
                noncommutatives come back as a list [(b**e, Rational)]
            )
r   r4  r3   r   r   r.   rP   r   r    r2   )
eqr:   r;   r9   rb   rc   r8   r  rE  rB  s
           r#   breakupzMul._eval_subs.<locals>.breakup  s     #3'Q]]2& 
&aL!!AAEE>nn.GRAqtAA##aDAIDIIq!f%
& r7Nr"   c                 8     |       \  } }t        | ||z        S )z
            Put rational back with exponent; in general this is not ok, but
            since we took it from the exponent for analysis, it's ok to put
            it back.
            r   )rb   r8   rc   rE  s      r#   rejoinzMul._eval_subs.<locals>.rejoin  s"     a[FQq!B$<r"   c                     |j                   | j                   z  r| j                   |j                   z  st        | |z        S y)zif b divides a in an extractive way (like 1/4 divides 1/2
            but not vice versa, and 2/5 does not divide 1/3) then return
            the integer number of times it divides, else return 0.
            r   )r   r4  )r9   rb   s     r#   ndivzMul._eval_subs.<locals>.ndiv  s1    
 339ACC!##I1Q3xr"   r   TFc              3   L   K   | ]  } |          |         k7    y wrB   r!   )rE   rb   r:   old_cr   s     r#   rF   z!Mul._eval_subs.<locals>.<genexpr>  s&     =!adtE!H~-=r  rn   )r   r   r  rA  sympy.simplify.powsimprB  r  r  r   r*   r   _subsr   r.   r~   extract_multiplicativelyr   r/   r}   
differencesetr   r^   r2   minr   r   r   r1   rG  r   )-rI   rX  newrA  r  rH  rK  rM  r   r   rd   self2co_selfco_oldco_xmulr;   old_ncr  co_residualokr   cdidratrb   old_ec_encdidtakelimitfailedr  r   ndorB  midirr   domargsrc   rE  r:   rO  rB  r   s-                                           @@@@@r#   
_eval_subszMul._eval_subs  s   =643zz 88A;  SXXa[1_yy|%%99Q<!#::sdSD11		*	 	 ~1AEE>GGC%aggc3&77E<<{{3,,} **Q-!'"5"5  !::6BI %.B!#, w**s6{a/?\#f+w78DEE'N{&	T!	 &	!&$,.KK v;R BZ#a& B"#qad#..b/A!/ABBZ""3q6*B=u==BIDC#kkm 
Ed

4U+,2wI	
 s8DE3r7^ '11' Ev;D&AJJEFAAHB/ t 3#A!a%y|vay|3a

41q5	!fQil#CDdQh

41q5	!fQil#CDAE115

1FA3# c(C19#&)$n$'SM&Aq$&qE!Hs6!9Q</?$?3A %ABqE #$C !'r!uQxAqC$*1IaL=1 21 !2A
 #&C "#TAB!#BBrF1I!'A9/ -/ !0A t#$t8c"g#567eQZBqTN(.
A67eAgYBqTN
 34C%1QX" MM!$QC AHB/H I eAs2w/0 :A"BqEN//S9BqE:
 <B]BUD!B 	=AEz aD58B;&VAq\*VAFF3$4ad;<	=  d^$u,E:5::u--jejj"o==U $/As   )XXc                 P    ddl m} ddlm} ddlm} d }g }		 | j                  D ]@  }
|
j                  |      \  }}|j                  |      s|	j                  |
|f       <t         t        d |	D              }g }|	D ]f  \  }
} |||z
  |j                  r|ndz         }|
j                  ||||      }|j                         }|||k  r|||z
  z  }|j                  |       h 	 t(        j*                  }|D cg c]  }t5        j6                  |       }}t9        | D ]O  }|D cg c]  } |||       }}t;        | \  }}t        |      }||z
  j<                  s?|t?        | ||z  z  z  }Q  fd | jA                  |      r=ddl!m"} ddl#m$} 	   | |      |k\  s || |       |||      k7  r| |||z  |      z  }|S || k7  rc| |z
  jK                  |d      t(        j*                  k(  r.|dkD  r)| jM                  |||      }|t(        j*                  k(  r|S | |||z  |      z  }|S # t        t        t         t"        |f$ r t%        t        d	 |	D                    }|j&                  rt(        j*                  }| j                  D 
cg c]   }
|
j                  | |||z
        ||      " nc c}
w }}
dd
lm}  | | j0                  | j3                         dd      }|j                  |      r| |||z  |      z  }|cY S w xY wc c}w c c}w # |$ r Y \w xY w)Nr   )	PoleErrorr   )ceiling)Orderc                     | j                  |      }|d   j                  |      r	 | j                  |      }|S |S # t        $ r | t        j
                  fcY S w xY wrO   )as_coeff_exponentr   leadterm
ValueErrorr   r   )r  r   lts      r#   	coeff_expz$Mul._eval_nseries.<locals>.coeff_exp  s^    ''*B!uyy|(q)B I2I " (<'(s   < AAc              3   F   K   | ]  }|d    j                   s|d      ywr   Nr   rE   rh   s     r#   rF   z$Mul._eval_nseries.<locals>.<genexpr>  s     :a1Q4>>QqT:   !
!)r   logxcdirc              3   F   K   | ]  }|d    j                   s|d      ywrw  rx  ry  s     r#   rF   z$Mul._eval_nseries.<locals>.<genexpr>  s     Ba1Q4>>QqTBrz  )powsimpr`  T)combiner   c           	         | u rt         j                  S | j                  rt         j                  S | j                  rt        fd| j                  D              S | j                  r't        | j                  D cg c]  } |       c} S | j                  r  | j                        | j                  z  S t         j                  S c c}w )Nc              3   0   K   | ]  } |        y wrB   r!   )rE   r9   
max_degreer   s     r#   rF   z8Mul._eval_nseries.<locals>.max_degree.<locals>.<genexpr>  s     <:a+<s   )r   r.   is_Atomr   r   maxr*   r   r_   r   ra  r`  )rc   r   r9   r  s    ` r#   r  z%Mul._eval_nseries.<locals>.max_degree  s    Avuuyyvvxx<QVV<<<xxqvv>!Z1->??xx!!&&!,QUU2266M ?s   =C)PolynomialError)degreer{  r|  )'r  rm  #sympy.functions.elementary.integersrn  sympy.series.orderro  r*   rr  r   r2   rs  r:  r   nseriesgetnNotImplementedError	TypeErrorr   r	   r  r   r   rP  r~  r   r   r_   r   r   r6  r   r3   is_polynomialsympy.polys.polyerrorsr  sympy.polys.polytoolsr  rG  _eval_as_leading_term)!rI   r   r   r{  r|  rm  rn  ro  ru  ordsrh   r   r`  n0facsr   n1r%  nsr~  resr  ords2facr  ords3coeffspowersr   r  r  rt  r  s!                                   @r#   _eval_nserieszMul._eval_nseries  s!   '?,	 	YY %ZZ]
syy|KKC)$$% :4::BD 1QVAKKqQ?@IIa2DtI<VVX>BwR"WA( ff59:6v&::E? 	/C478DYtQ'8E8 %[NFFKE	&&sF|QX..	/	 a >4dA&!+vdA&a./P5Aq>)C 
$;s
  A&!&&0QU//4/H<J5Aq>!C
g /NIV 		B4BBCB  VVQUQZQZ[AAIIa71R4=t$IG[[D[6)$))T*113UNCwwu~uQT1~%J		 ; 92 # s>   CH2 =L*L.L 2AL%J76ALLL%$L%c           
      ~     | j                   | j                  D cg c]  }|j                  |||       c} S c c}w )Nr  )r   r*   as_leading_term)rI   r   r{  r|  rh   s        r#   r  zMul._eval_as_leading_term  s7    tyytyyY!1,,QT,EYZZYs   :c                 v     | j                   | j                  D cg c]  }|j                          c} S c c}w rB   )r   r*   r   rI   rh   s     r#   _eval_conjugatezMul._eval_conjugate  s+    tyy$))<Q1;;=<==<s   6c                      | j                   | j                  d d d   D cg c]  }|j                          c} S c c}w rm   )r   r*   	transposer  s     r#   _eval_transposezMul._eval_transpose  s3    tyy$))DbD/BQ1;;=BCCB   <c                      | j                   | j                  d d d   D cg c]  }|j                          c} S c c}w rm   )r   r*   adjointr  s     r#   _eval_adjointzMul._eval_adjoint  s3    tyy		$B$@1199;@AA@r  c                     t         j                  }g }| j                  D ]A  }|j                  ||      \  }}||z  }|t         j                  us1|j	                  |       C | | j
                  | fS )aU  Return the tuple (R, self/R) where R is the positive Rational
        extracted from self.

        Examples
        ========

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

        See docstring of Expr.as_content_primitive for more examples.
        )radicalclear)r   r.   r*   as_content_primitiver2   r   )rI   r  r  coefr*   r9   r:   r   s           r#   r  zMul.as_content_primitive  su     uu 	A))')GDAqAID~A		 YTYY%%%r"   c                 ^    | j                         \  }}|j                  fd       ||z   S )a  Transform an expression into an ordered list of factors.

        Examples
        ========

        >>> from sympy import sin, cos
        >>> from sympy.abc import x, y

        >>> (2*x*y*sin(x)*cos(x)).as_ordered_factors()
        [2, x, y, sin(x), cos(x)]

        c                 (    | j                        S )N)order)sort_key)r  r  s    r#   r   z(Mul.as_ordered_factors.<locals>.<lambda>&  s    DMMM$> r"   r%   )r0   r'   )rI   r  cpartncparts    `  r#   as_ordered_factorszMul.as_ordered_factors  s-     v

>
?v~r"   c                 4    t        | j                               S rB   )r   r  r  s    r#   _sorted_argszMul._sorted_args)  s    T,,.//r"   )F)Tr  rB   )r   rO   )FT)Qr   r   r   __doc__	__slots__tTupler   __annotations__r   
_args_typer   rH   propertyrC   rM   rS   classmethodr   r   r   r   r   r   r   rP   r\   r   staticmethodr  r  r&  r3  rL  rR  rO  rV  rW  rg  rh  rz  r{  rN  r  r   r   r  r  r  r  _eval_is_commutativer  r  r  r  r  r  r  r
  r  r  r  r  r  r  r+  r/  r.  r7  r:  r<  r?  rk  r  r  r  r  r  r  r  r  __classcell__)rC  s   @r#   r3   r3   \   s   DJ I
,FJ%&;N1 16: F. F.P: " "  6 6 9 9< +/ 
 
 5:n $ $$(T 	# 	#  >!@   ( (T < < 2 2h & & E E
 ', ',R6%IP-M-A(F

M!^F
*(T/./(%$!F&>"F>PVp[>DB&4" 0 0r"   r3   mulc                 8    t        t        j                  | |      S )a  Return product of elements of a. Start with int 1 so if only
       ints are included then an int result is returned.

    Examples
    ========

    >>> from sympy import prod, S
    >>> prod(range(3))
    0
    >>> type(_) is int
    True
    >>> prod([S(2), 3])
    6
    >>> _.is_Integer
    True

    You can start the product at something other than 1:

    >>> prod([1, 2], 3)
    6

    )r   operatorr  )r9   starts     r#   r;  r;  0  s    . (,,5))r"   c           
         | j                   s|j                   r| |} }n| |z  S |t        j                  u r| S | t        j                  u r|S | t        j                  u r|s| S |j                  r|s| j
                  r| j                  dk7  r|j                  D cg c]  }|j                          }}|D cg c]  \  }}t        ||       |f }}}t        d |D              rCt        j                  |D cg c]$  }t        j                  |d   dk(  r|dd n|      & c}      S t        | |d      S |j                  rrt        |j                        }|d   j                   r'|dxx   | z  cc<   |d   dk(  r$|j!                  d       n|j#                  d|        t        j                  |      S | |z  }|j                   r#|j                   st        j                  | |f      }|S c c}w c c}}w c c}w )a  Return ``coeff*factors`` unevaluated if necessary.

    If ``clear`` is False, do not keep the coefficient as a factor
    if it can be distributed on a single factor such that one or
    more terms will still have integer coefficients.

    If ``sign`` is True, allow a coefficient of -1 to remain factored out.

    Examples
    ========

    >>> from sympy.core.mul import _keep_coeff
    >>> from sympy.abc import x, y
    >>> from sympy import S

    >>> _keep_coeff(S.Half, x + 2)
    (x + 2)/2
    >>> _keep_coeff(S.Half, x + 2, clear=False)
    x/2 + 1
    >>> _keep_coeff(S.Half, (x + 2)*y, clear=False)
    y*(x + 2)/2
    >>> _keep_coeff(S(-1), x + y)
    -x - y
    >>> _keep_coeff(S(-1), x + y, sign=True)
    -(x + y)
    r   c              3   :   K   | ]  \  }}|j                     y wrB   )r   )rE   r:   r  s      r#   rF   z_keep_coeff.<locals>.<genexpr>t  s     1DAq1<<1rz   r   NFrX   )r   r   r.   rR   r   r~   r   r*   r\   r   r   r_   r4   r3   r   r-   r/   r5   )	r   factorsr  r   r   r*   r:   r   rj  s	            r#   r   r   J  s   6 ??"GUG= !%%~	!--	x	**uww!|.5ll;ANN$;D;;?@41a[E*A.@D@1D11~~8<'>34 (+~~qTQYAabEA(/ '> ? ?5'E22	W\\"8!HHQx1}		!LLE"~~e$$'M;;w00w/0A' <@'>s   G)7G.7)G4c                      d }t        | |      S )Nc                     | j                   rN| j                         \  }}|j                  r/|j                  r#t	        |j
                  D cg c]  }||z  	 c} S | S c c}w rB   )r   r\   r   r   _unevaluated_Addr*   )rc   r:   r   ris       r#   ri  zexpand_2arg.<locals>.do  sO    88>>#DAq{{qxx')@2!B$)@AA *As   Ar   )rc   ri  s     r#   expand_2argr    s     Qr"   )r   rJ  )r_   r  )r   )TF)3typingr   r  collectionsr   	functoolsr   r   	itertoolsr   r  r	   basicr
   	singletonr   
operationsr   r   cacher   logicr   r   r  r   
parametersr   rC   r   	traversalr   sympy.utilities.iterablesr   r   comparer(   r+   r<   r3   r  r;  r   r  r   r   r   r   addr_   r  r!   r"   r#   <module>r     s    " # (      2  *  )     *  5==)!
3#lO0$ O0b> *4;z   & &r"   