gdZddlmZddlmZmZddlmZddlm Z ddl m Z ddl m Z ddlmZdd lmZmZmZmZmZdd lmZdd lmZmZdd lmZdd lmZddlmZddl m!Z!m"Z"ddl#m$Z$ddl%m&Z&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,ddl-m!Z.edZ/dZ0dZ1de de.e e2ffdZ3de de.e effdZ4GddZ5Gdd Z6d(d!Z7d)d"Z8d#Z9d*d$Z:d+d&Z;d'Z>> from sympy.core.exprtools import _monotonic_sign as F >>> from sympy import Dummy >>> nn = Dummy(integer=True, nonnegative=True) >>> p = Dummy(integer=True, positive=True) >>> p2 = Dummy(integer=True, positive=True) >>> F(nn + 1) 1 >>> F(p - 1) _nneg >>> F(nn*p + 1) 1 >>> F(p2*p + 1) 2 >>> F(nn - 1) # could be negative, zero or positive Nr Fr) real_roots)roots)PolynomialErrorc3<K|]}|z jywr%)is_nonpositive.0rx0s r* z"_monotonic_sign..s ,G9EAR//posTr"nneg) nonnegativeneg)negativenpos) nonpositivec3<K|]}|z jywr%)is_nonnegativer8s r*r<z"_monotonic_sign..s .G9EAR//r=c3bK|]'}|js|jj)ywr%)is_Powexp is_Integerr9ps r*r<z"_monotonic_sign..s!GlahhAEE$$ls//c3:K|]}|jr|ywr%) is_numberrKs r*r<z"_monotonic_sign..s>l!++1ls)3is_extended_real is_Symbol_monotonic_signis_Addas_numer_denomrNis_primeis_oddr is_composite is_positiveis_even is_integerrOne_epsis_extended_negative NegativeOneis_zerois_extended_nonpositiveis_extended_nonnegativeZero free_symbolslen is_polynomialsympy.polys.polytoolsr3sympy.polys.polyrootsr4sympy.polys.polyerrorsr5popdiffNotImplementedErrorsubsrFallrr7 is_negative as_coeff_Addis_MulrH is_rationalatomsrr make_argsanylistxreplace)selfrvsfreer3r4r5xd currentrootsr:yndenvcaairepsrLr)r;s @r*rQrQ sJ    dU #Zr(bS( ;;4..03==  ::xxqz!qz! ^^xxqz!qz! ]]yy::&"1:%"1:%uu   # #yyr{"}}$u 9911Q5N5N66M   D 4yA~     8 3 > A #BdTE]"VV~IIaL;;#%LV'1!} IIa$##,G9E,G)G''AMM() 1V5QU;VV#(T#BB''AMM() 1V5QU;VV#(T#BB%%#.G9E.G+G''AMM#(#>>#(T#BB''AMM#(#>>#(T#BB&#&&(DAqC{{%a([["1%1)!,CCOOscE== 66%% T::]] 66%% T::    DAq A ?? !1 q{{ AHH GaggclGG!--AmmA&<<GAA-a0DGAw)RWWT]"' >aggcl>>ADTDTXYXhXh'DA#A&9AQ%5%5TD5!   1 A} U  774# #  774# #!/  e,-@AV38A;'U;a!BTBT;'U 'UVs$-Y;;Z3Z(#Z('Z32Z3exprreturnc|j\}}|jrP|jr<|js t |t d|j }|j}||fS|d}}||fS|jd\}}|tjurt ||d}}||fS|tjur>> from sympy.core.exprtools import decompose_power >>> from sympy.abc import x, y >>> from sympy import exp >>> decompose_power(x) (x, 1) >>> decompose_power(x**2) (x, 2) >>> decompose_power(exp(2*y/3)) (exp(y/3), 2) rT)rational) as_base_expr( is_RationalrJrr qrL as_coeff_Mulrr]rZr)rbaserIetails r*decompose_powerrs&  "ID# }} ??>>4!SUU!34A 7NA!D 7N$$d$3 T !-- $or!D 7N x355148D$osuu!D 7NA!D 7Nr,c^|jx}\}}|jr|St|S)a Decompose power into symbolic base and rational exponent; if the exponent is not a Rational, then separate only the integer coefficient. Examples ======== >>> from sympy.core.exprtools import decompose_power_rat >>> from sympy.abc import x >>> from sympy import sqrt, exp >>> decompose_power_rat(sqrt(x)) (x, 1/2) >>> decompose_power_rat(exp(-3*x/2)) (exp(x/2), -3) )rrr)r_rrIs r*decompose_power_ratrs1&$$&&A c1:_T%::r,ceZdZdZdZddZdZdZedZ edZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZdZdZdZdZy)Factorsz0Efficient representation of ``f_1*f_2*...*f_n``.)factorsgensNc t|ttfr t|}t|tr|j j }n|dtjfvri}n|tjus|dk(r"tjtji}nvt|tr|}i}|dkr$tj|tj<| }|tjur&|js|js|tjurtj||<n|jr]|jdk7r&tj|t!|j<tj|t!|j"<n~t%d|zt|t&r |j(s|tji}n@t|t*r|j-\}}|j/t0}t3|D]}|j5t0t7t9j:|j=}t?|jAD]}t|tBst|t r%t!|jt!|j"} }||vr||ntj||z||<| |vr|| ntj||z || <|jE||r.|jGt0tj|z|t0<|rtj|t9|ddi<n|j }|D cgc]} | t0us| dvs| } } | rwtj} | D](} tI|| s| | |jE| zz} *| tjur'| jJr | j(n| gD]} | tjurtj|| <*| t0urtj|t0<J| jLrE|jG| jNtj| jPz|| jN<tS| drtj|| <tS| dr6tj|| <tj|tj<t%d | z||_tU|d d}| tWd tY||_-ycc} w) aInitialize Factors from dict or expr. Examples ======== >>> from sympy.core.exprtools import Factors >>> from sympy.abc import x >>> from sympy import I >>> e = 2*x**3 >>> Factors(e) Factors({2: 1, x: 3}) >>> Factors(e.as_powers_dict()) Factors({2: 1, x: 3}) >>> f = _ >>> f.factors # underlying dictionary {2: 1, x: 3} >>> f.gens # base of each factor frozenset({2, x}) >>> Factors(0) Factors({0: 1}) >>> Factors(I) Factors({I: 1}) Notes ===== Although a dictionary can be passed, only minimal checking is performed: powers of -1 and I are made canonical. Nrrz'Expected Float|Rational|Integer, not %sevaluateF)rrrzunexpected factor in i1: %skeyszexpecting Expr or dictionary).r&rr'rrrcopyrZrarr]is_FloatrJInfinityrrLr r ValueErrorrargsrargs_cnccountrrangeremovedictr _from_argsas_powers_dictrtrr rhgetr+rorHrrIrgetattr TypeError frozensetr)rvrr~rncr)rfrLrkhandlei1rrs r*__init__zFactors.__init__!s> g E2 3jG gw 'oo**,G quu %G  'Q,vvquuoG  (AG1u)* &B~::ajj!"GAJ]]ssax01 -,-MMGGACCL)$%NQR%RSS  ' &G  &$$&EAr A1X 3>>!,;;=>G',,.)a*:a3I"133<qA01W '!*!&>UJ!VGAJ01W '!*!&>UJ!VGAJKKN * $[[AFF3a7 45EER0%01llnG")CAAFa7laFCUUA$WQZ0 !W[[^++B QUU?(* RWWt; -)*GAJ!V)*GAJXX.5kk!&&!&&.IAEE.QGAFFO)!Q/)*GAJ)!R0*+%%GQBK56UUGAMM2",-JQ-N"OO< w- <:; ;df% 7Ds U U ctt|jj}|Dcgc]}|j|}}t ||fScc}wr%)tuplerrrhash)rvrrvaluess r*__hash__zFactors.__hash__sNWT\\..012+/04a$,,q/40T6N##1sAc ddjt|jjDcgc] \}}|d|c}}zScc}}w)Nz Factors({%s}), z: )joinrritems)rvrrs r*__repr__zFactors.__repr__sO+24<<3E3E3G+H I+H41aA +H I"KK K IsA c^|j}t|dk(xrtj|vS)zj >>> from sympy.core.exprtools import Factors >>> Factors(0).is_zero True r)rrcrra)rvrs r*r^zFactors.is_zeros( LL1v{*qvv{*r,c|j S)zi >>> from sympy.core.exprtools import Factors >>> Factors(1).is_one True )rrvs r*is_onezFactors.is_ones<<r,c8g}|jjD]t\}}|dk7rYt|tr4|j \}}t ||}|j ||zO|j ||zd|j |vt|S)zReturn the underlying expression. Examples ======== >>> from sympy.core.exprtools import Factors >>> from sympy.abc import x, y >>> Factors((x*y**2).as_powers_dict()).as_expr() x*y**2 r)rrr&r rrappendr)rvrfactorrIbrs r*as_exprzFactors.as_exprs<<--/KFCaxc7+!--/DAq#C+AKK1%KK , F#0Dzr,cDt|ts t|}td||fDrttjSt |j }|j jD]\}}||vr|||z}|s||=|||<t|S)aReturn Factors of ``self * other``. Examples ======== >>> from sympy.core.exprtools import Factors >>> from sympy.abc import x, y, z >>> a = Factors((x*y**2).as_powers_dict()) >>> b = Factors((x*y/z).as_powers_dict()) >>> a.mul(b) Factors({x: 2, y: 3, z: -1}) >>> a*b Factors({x: 2, y: 3, z: -1}) c34K|]}|jywr%r^r9rs r*r<zFactors.mul..s0-Qqyy-)r&rrsrrarrrrvotherrrrIs r*mulz Factors.muls%)ENE 04-0 0166? "t||$ ==..0KFC fo+!GFO1wr,ct|tsit|}|jr#tttjfS|jr#ttjtfSt |j }t |j }|j jD]\}} |j |}||z }|s||=||=$t|r|dkDr |||<||==||=| ||<G|j|}||r |||<||=e||=||=l|j\} } | rY|j\} } | | z } | dkDr||xx| zcc<| }n,| dkr ||xx| zcc<||xx| zcc<| | z }n| ||<| }|r|||<||=t|t|fS#t$rY wxYw)aLReturn ``self`` and ``other`` with ``gcd`` removed from each. The only differences between this and method ``div`` is that this is 1) optimized for the case when there are few factors in common and 2) this does not raise an error if ``other`` is zero. See Also ======== div r) r&rr^rrarrrKeyErrorr+extract_additivelyrn)rvr self_factors other_factorsrself_exp other_exprIr:scsaocoaris r*normalzFactors.normals%)ENE}} 7166?33||33DLL) U]]+ $ 2 2 4 FH !MM&1 Y&C (!&)37+.L(%f-$V,-0DM&)// :=/0 V,)&1(0)&1%224FB!*!7!7!9B!Bw!8(0B60(*I!AX(0B60)&1R71(*T I35L0(*I 09 f-)&1[!5^|$gm&<<>> from sympy.core.exprtools import Factors >>> from sympy.abc import x, y, z >>> from sympy import S >>> a = Factors((x*y**2).as_powers_dict()) >>> a.div(a) (Factors({}), Factors({})) >>> a.div(x*z) (Factors({y: 2}), Factors({z: 1})) The ``/`` operator only gives ``quo``: >>> a/x Factors({y: 2}) Factors treats its factors as though they are all in the numerator, so if you violate this assumption the results will be correct but will not strictly correspond to the numerator and denominator of the ratio: >>> a.div(x/z) (Factors({y: 2}), Factors({z: -1})) Factors is also naive about bases: it does not attempt any denesting of Rational-base terms, for example the following does not become 2**(2*x)/2. >>> Factors(2**(2*x + 2)).div(S(8)) (Factors({2: 2*x + 2}), Factors({8: 1})) factor_terms can clean up such Rational-bases powers: >>> from sympy import factor_terms >>> n, d = Factors(2**(2*x + 2)).div(S(8)) >>> n.as_expr()/d.as_expr() 2**(2*x + 2)/8 >>> factor_terms(_) 2**(2*x)/2 r) rrr&rr^ZeroDivisionErrorrrarr+rrn)rvrquoremrrIr{r:rrrrrris r*divz Factors.div,s\ %rS%)ENE}}''||33 ==..0KFC}K#%Q<AvKAv*+CK "CF 66s;A}*+CK #F $' !$V!9!9!;B%.%;%;%=FB#%7D#ax #F r 1 ,. !% #F r 1 ,.I .0F ,. $*3CK#)#44#4CKW1Zs|WS\))r,c*|j|dS)aYReturn numerator Factor of ``self / other``. Examples ======== >>> from sympy.core.exprtools import Factors >>> from sympy.abc import x, y, z >>> a = Factors((x*y**2).as_powers_dict()) >>> b = Factors((x*y/z).as_powers_dict()) >>> a.quo(b) # same as a/b Factors({y: 1}) rrrvrs r*rz Factors.quosxxq!!r,c*|j|dS)awReturn denominator Factors of ``self / other``. Examples ======== >>> from sympy.core.exprtools import Factors >>> from sympy.abc import x, y, z >>> a = Factors((x*y**2).as_powers_dict()) >>> b = Factors((x*y/z).as_powers_dict()) >>> a.rem(b) Factors({z: -1}) >>> a.rem(a) Factors({}) rrrs r*rz Factors.remsxxq!!r,c(t|tr'|j}|jr t |}t|t r>|dk\r9i}|r*|j jD] \}}||z||<t|Std|z)aReturn self raised to a non-negative integer power. Examples ======== >>> from sympy.core.exprtools import Factors >>> from sympy.abc import x, y >>> a = Factors((x*y**2).as_powers_dict()) >>> a**2 Factors({x: 2, y: 4}) rz%expected non-negative integer, got %s) r&rrrJintrrrrrs r*powz Factors.pows eW %MMOEE  eZ (UaZG#'<<#5#5#7KFC&)%iGFO$87# #DuLM Mr,ct|ts,t|}|jrt|jSi}|jj D]i\}}t |t |}}||jvs+||j|z j }|dk(r|||<R|dk(sX|j|||<kt|S)aReturn Factors of ``gcd(self, other)``. The keys are the intersection of factors with the minimum exponent for each factor. Examples ======== >>> from sympy.core.exprtools import Factors >>> from sympy.abc import x, y, z >>> a = Factors((x*y**2).as_powers_dict()) >>> b = Factors((x*y/z).as_powers_dict()) >>> a.gcd(b) Factors({x: 1, y: 1}) TF)r&rr^rrr rm)rvrrrrIlts r*gcdz Factors.gcds%)ENE}}t||,,<<--/KFC!&/73>:&)GFO5[&+mmF&;GFO0wr,cFt|ts8t|}td||fDrttjSt |j }|j jD]\}}||vrt|||}|||<t|S)aReturn Factors of ``lcm(self, other)`` which are the union of factors with the maximum exponent for each factor. Examples ======== >>> from sympy.core.exprtools import Factors >>> from sympy.abc import x, y, z >>> a = Factors((x*y**2).as_powers_dict()) >>> b = Factors((x*y/z).as_powers_dict()) >>> a.lcm(b) Factors({x: 1, y: 2, z: -1}) c34K|]}|jywr%rrs r*r<zFactors.lcm..s4m199mr) r&rrsrrarrrmaxrs r*lcmz Factors.lcms%)ENE4tUm44qvv&t||$ ==..0KFC #wv/!GFO 1 wr,c$|j|Sr%)rrs r*__mul__zFactors.__mul__ xxr,c$|j|Sr%rrs r* __divmod__zFactors.__divmod__rr,c$|j|Sr%)rrs r* __truediv__zFactors.__truediv__rr,c$|j|Sr%)rrs r*__mod__zFactors.__mod__rr,c$|j|Sr%)rrs r*__pow__zFactors.__pow__rr,cjt|ts t|}|j|jk(Sr%)r&rrrs r*__eq__zFactors.__eq__s(%)ENE||u}},,r,c||k( Sr%rs r*__ne__zFactors.__ne__!5=  r,r%)__name__ __module__ __qualname____doc__ __slots__rrrpropertyr^rrrrrrrrrrrrrrrrrrr,r*rrs:#Il&\$ K++  4 BD=Ld*L """N8 B <- !r,rcpeZdZdZdZddZdZdZdZdZ d Z d Z d Z d Z d ZdZdZdZdZdZy)Termz5Efficient representation of ``coeff*(numer/denom)``. coeffnumerdenomNc|||js td|j\}}tttt}}|D]X}t |\}}|j r|j\} }|| |zz}|dkDr||xx|z cc<K||xx| z cc<Zt|}t|}n|}| t}| t}||_ ||_ ||_ y)Nzcommutative expression expectedr) is_commutativer as_coeff_mulr!rrrR primitiverrrr) rvtermrrrrrrrIconts r*rz Term.__init__*s =U]&&.577"..0NE7&s+[-=5E!+F3 c;;!%!1JD$T3Y&E7$K3&K$KC4'K"ENEENEE} }    r,cZt|j|j|jfSr%)rrrrrs r*rz Term.__hash__Ns TZZTZZ899r,cVd|jd|jd|jdS)NzTerm(r)rrs r*rz Term.__repr__Qs%)ZZTZZHHr,c|j|jj|jjz zSr%)rrrrrs r*rz Term.as_exprTs0zz4::--/ 0B0B0DDEEr,c |j|jz}|jj|j}|jj|j}|j |\}}t |||Sr%)rrrrrr)rvrrrrs r*rzTerm.mulWsa 5;;& u{{+ u{{+||E* uE5%((r,c^td|jz |j|jS)Nr)rrrrrs r*invzTerm.inv`s!AdjjL$**djj99r,c@|j|jSr%)rrrs r*rzTerm.quocsxx $$r,c|dkr |jj| St|j|z|jj||j j|S)Nr)rrrrrrrs r*rzTerm.powfsX 1988:>>5&) ) e+ u- u-/ /r,ct|jj|j|jj|j|jj|jSr%)rrrrrrs r*rzTerm.gcdnJDJJNN5;;/JJNN5;;/JJNN5;;/1 1r,ct|jj|j|jj|j|jj|jSr%)rrrrrrs r*rzTerm.lcmsrr,cPt|tr|j|StSr%)r&rrNotImplementedrs r*rz Term.__mul__x eT "88E? "! !r,cPt|tr|j|StSr%)r&rrrrs r*rzTerm.__truediv__~rr,cPt|tr|j|StSr%)r&rrrrs r*rz Term.__pow__s eZ (88E? "! !r,c|j|jk(xr4|j|jk(xr|j|jk(Sr%rrs r*rz Term.__eq__sA ekk)* ekk)* ekk) +r,c||k( Sr%rrs r*rz Term.__ne__rr,)NN)rrrrrrrrrrrrrrrrrrrrrr,r*rr%sX?+I"H:IF):%/1 1 " " " + !r,rc t|tr%t|tstj|}t t t|Dcgc]}|s| c}}t|dk(r/tjtjtjfSt|dk(rK|dj}|djj}|djj}nO|d}|ddD]}|j!|}t#|D]\}}|j%|||<|r|dj}|ddD]}|j'|j}g} |D]b}|jj)|j%|j}| j+|j|jzdn@|Dcgc]}|j} }ttjj}|j}t| }|j}|s$|j,r|j/\} }|| z}|||fScc}wcc}w)aHelper function for :func:`gcd_terms`. Parameters ========== isprimitive : boolean, optional If ``isprimitive`` is True then the call to primitive for an Add will be skipped. This is useful when the content has already been extracted. fraction : boolean, optional If ``fraction`` is True then the expression will appear over a common denominator, the lcm of all term denominators. rrN)r&rrrrrrtmaprrcrrarZrrrrr enumeraterrrrrRr ) terms isprimitivefractiontrrrr r)numers_conts r* _gcd_termsr+s % 5%(@ e$ Tu2u!Au23 4E  5zQvvqvvquu$$ 5zQQx~~a&&(a&&(Qx!"ID88D>D!'GAtxx~E!H( !HNNEab  $**-"F uyy'<= djj89,115aaiik5F1K%%E||~V   5<<( u    W3@2s I0I0!I5cJd}t|t}|xs7t|t xr$t|txrt|t  }|r|rt |j}n t|}||\}}t|\}} } | j|} |j\} } sh| j\} }| jsIsG| jr;| j\}}| |z }td|jDr|} ||z} t!| | | z| z St|ts|S|j"r|S|j$rA|j'\} }t!| t)|Dcgc]}t+|c}Sfdt|t r-t |jDcgc]\}}||fc}}S|j,|jDcgc] }| c}Scc}wcc}}wcc}w)aCompute the GCD of ``terms`` and put them together. Parameters ========== terms : Expr Can be an expression or a non-Basic sequence of expressions which will be handled as though they are terms from a sum. isprimitive : bool, optional If ``isprimitive`` is True the _gcd_terms will not run the primitive method on the terms. clear : bool, optional It controls the removal of integers from the denominator of an Add expression. When True (default), all numerical denominator will be cleared; when False the denominators will be cleared only if all terms had numerical denominators other than 1. fraction : bool, optional When True (default), will put the expression over a common denominator. Examples ======== >>> from sympy import gcd_terms >>> from sympy.abc import x, y >>> gcd_terms((x + 1)**2*y + (x + 1)*y**2) y*(x + 1)*(x + y + 1) >>> gcd_terms(x/2 + 1) (x + 2)/2 >>> gcd_terms(x/2 + 1, clear=False) x/2 + 1 >>> gcd_terms(x/2 + y/2, clear=False) (x + y)/2 >>> gcd_terms(x/2 + 1/x) (x**2 + 2)/(2*x) >>> gcd_terms(x/2 + 1/x, fraction=False) (x + 2/x)/2 >>> gcd_terms(x/2 + 1/x, fraction=False, clear=False) x/2 + 1/x >>> gcd_terms(x/2/y + 1/x/y) (x**2 + 2)/(2*x*y) >>> gcd_terms(x/2/y + 1/x/y, clear=False) (x**2/2 + 1)/(x*y) >>> gcd_terms(x/2/y + 1/x/y, clear=False, fraction=False) (x/2 + 1/x)/y The ``clear`` flag was ignored in this case because the returned expression was a rational expression, not a simple sum. See Also ======== factor_terms, sympy.polys.polytools.terms_gcd cB|Dcgc]"}|jr|gfn|j$}}g}t|D]Q\}\}}|rBt|}t }|j ||f|j |t|||<M|||<S|t |fScc}w)zpreplace nc portions of each term with a unique Dummy symbols and return the replacements to restore them)r rr$rrrr)r%rrrr)rrr{s r*maskzgcd_terms..masksHMMu!1++B=uM#D/JAw2"XG QG$ q'QQ*T$ZNs'B)includec3VK|]!}|jdj#ywrN)rrJr9rs r*r<zgcd_terms..4s*.!,A~~'*55!,s'))clearc4t|tspt|tr;|js|S|j|jDcgc] }| c}St ||Dcgc] }| c}St |Scc}wcc}wr%)r&rrrfunctype gcd_terms)rr)r3r'rr&s r*rzgcd_terms..handleEs!T"!U#vvHqvv166:6aq 6:;;47q1q!F1Iq12 2K99 ;1s B,B)r&rrr setrrtrr r+rurrJrRrSrsris_Atomror rr7r5)r%r&r3r'r.isaddaddlikerrrrrrr_coeffr~r{_numerrr)rrrs ``` @r*r7r7sz uc "E$:eU33$E3'$ ud ##  $EENE5k t'{HEeUt$**,w**,IAv<<%,,'')1q.!'.."EfHE5'%-"5UCC eU #  }}  ||$$&41c$%.aeX$N$#(* *:%<Aq&)n<== 5::5::6:aq :6 77$=6sHH H c z|j}|dk(rtjS|j}|Dchc]}|jd}}t |fi|}|j |\}}t|tr*||jdg|z|j|g|zS||j|g|zScc}w)aReturn Sum or Integral object with factors that are not in the wrt variables removed. In cases where there are additive terms in the function of the object that are independent, the object will be separated into two objects. Examples ======== >>> from sympy import Sum, factor_terms >>> from sympy.abc import x, y >>> factor_terms(Sum(x + y, (x, 1, 3))) y*Sum(1, (x, 1, 3)) + Sum(x, (x, 1, 3)) >>> factor_terms(Sum(x*y, (x, 1, 3))) y*Sum(x, (x, 1, 3)) Notes ===== If a function in the summand or integrand is replaced with a symbol, then this simplification should not be done or else an incorrect result will be obtained when the symbol is replaced with an expression that depends on the variables of summation/integration: >>> eq = Sum(y, (x, 1, 3)) >>> factor_terms(eq).subs(y, x).doit() 3*x >>> eq.subs(y, x).doit() 6 rr) functionrralimitsr factor_termsas_independentr&rr5)rkwargsresultr@r)wrtrr{s r*_factor_sum_intrFTs>]]F {vv [[F% %f166!9fC % V&v&A 1  S !DAq!S9499Q(((9499Q+@+@@@9499Q(((( &sB8cDfdt|}|S)aRemove common factors from terms in all arguments without changing the underlying structure of the expr. No expansion or simplification (and no processing of non-commutatives) is performed. Parameters ========== radical: bool, optional If radical=True then a radical common to all terms will be factored out of any Add sub-expressions of the expr. clear : bool, optional If clear=False (default) then coefficients will not be separated from a single Add if they can be distributed to leave one or more terms with integer coefficients. fraction : bool, optional If fraction=True (default is False) then a common denominator will be constructed for the expression. sign : bool, optional If sign=True (default) then even if the only factor in common is a -1, it will be factored out of the expression. Examples ======== >>> from sympy import factor_terms, Symbol >>> from sympy.abc import x, y >>> factor_terms(x + x*(2 + 4*y)**3) x*(8*(2*y + 1)**3 + 1) >>> A = Symbol('A', commutative=False) >>> factor_terms(x*A + x*A + x*y*A) x*(y*A + 2*A) When ``clear`` is False, a rational will only be factored out of an Add expression if all terms of the Add have coefficients that are fractions: >>> factor_terms(x/2 + 1, clear=False) x/2 + 1 >>> factor_terms(x/2 + 1, clear=True) (x + 2)/2 If a -1 is all that can be factored out, to *not* factor it out, the flag ``sign`` must be False: >>> factor_terms(-x - y) -(x + y) >>> factor_terms(-x - y, sign=False) -x - y >>> factor_terms(-2*x - 2*y, sign=False) -2*(x + y) See Also ======== gcd_terms, sympy.polys.polytools.terms_gcd cddlm}ddlm}t |}t |t r |jr)|r%t||Dcgc] }| c}S|S|js|js|s t|dsA|j}t|Dcgc] }| c}}||k(r|S|j|St |||frt|S|j!\}}|j"rt%j&|D cgc] } |  } } t)d| Ds| }| D cgc]} | } } i} t+| D]P\}} | j-\} } | j.s&| t1| jk7s.do..s4+ )1~~'*CCBG4O )s.0T)r&r3r')r3rL)sympy.concrete.summationsrIsympy.integrals.integralsrJrr&rr9r6rH is_Functionhasattrrrr5rFas_content_primitiverRrrrrsr$rrorrrr7rur)rrIrJ is_iterabler)rnewargsrrLr list_argsspecialrrrwr3dor'rKrLs r*rXzfactor_terms..dos616tn $&$,,!tDz$"7$Q2a5$"788K ;;$**74#<99DD1DqRUD12G$ 499g& & dS(O ,"4u!. .++G5+Ia 88(+ a(89(81A(8I9+ )++u)23AaR 3G!),1}}188S!&&\ 1#(7IaL,-GIaL) - y)A! !#$,8G#4 VV!"(A"Q%(*A qD 9 S#8 2: 4 )sH0H5H: H? Ir )rrKr3r'rLrXs ````@r*rArAs#z00b 4=D d8Or,Nc&xsdfd}|fd}|}|jr|igfSg}t}t}t|t}t |D]\} t fd|Dr|j +jr8jr"|j|j fjrsjrjr|j|j t|dk(r)|s'|j|j|fn6t|dk(r(|s&|j|j|ft|t}|D]/} |d } |j| | f|j| 1|j!|}t#|}|j%t||D cic]\} } | |  c} } |fScc} } w) a Return ``eq`` with non-commutative objects replaced with Dummy symbols. A dictionary that can be used to restore the original values is returned: if it is None, the expression is noncommutative and cannot be made commutative. The third value returned is a list of any non-commutative symbols that appear in the returned equation. Explanation =========== All non-commutative objects other than Symbols are replaced with a non-commutative Symbol. Identical objects will be identified by identical symbols. If there is only 1 non-commutative object in an expression it will be replaced with a commutative symbol. Otherwise, the non-commutative entities are retained and the calling routine should handle replacements in this case since some care must be taken to keep track of the ordering of symbols when they occur within Muls. Parameters ========== name : str ``name``, if given, is the name that will be used with numbered Dummy variables that will replace the non-commutative objects and is mainly used for doctesting purposes. Examples ======== >>> from sympy.physics.secondquant import Commutator, NO, F, Fd >>> from sympy import symbols >>> from sympy.core.exprtools import _mask_nc >>> from sympy.abc import x, y >>> A, B, C = symbols('A,B,C', commutative=False) One nc-symbol: >>> _mask_nc(A**2 - x**2, 'd') (_d0**2 - x**2, {_d0: A}, []) Multiple nc-symbols: >>> _mask_nc(A**2 - B**2, 'd') (A**2 - B**2, {}, [A, B]) An nc-object with nc-symbols but no others outside of it: >>> _mask_nc(1 + x*Commutator(A, B), 'd') (_d0*x + 1, {_d0: Commutator(A, B)}, []) >>> _mask_nc(NO(Fd(x)*F(y)), 'd') (_d0, {_d0: NO(CreateFermion(x)*AnnihilateFermion(y))}, []) Multiple nc-objects: >>> eq = x*Commutator(A, B) + x*Commutator(A, C)*Commutator(A, B) >>> _mask_nc(eq, 'd') (x*_d0 + x*_d1*_d0, {_d0: Commutator(A, B), _d1: Commutator(A, C)}, [_d0, _d1]) Multiple nc-objects and nc-symbols: >>> eq = A*Commutator(A, B) + B*Commutator(A, C) >>> _mask_nc(eq, 'd') (A*_d0 + B*_d1, {_d0: Commutator(A, B), _d1: Commutator(A, C)}, [_d0, _d1, A, B]) r.c3>Kd} t|z|dz }w)Nrr)str)r)names r*numbered_namesz _mask_nc..numbered_names=s+ Q-  FAsc:ddlm}|tg|i|S)Nrr)symbolrnext)rrCrnamess r*rz_mask_nc..DummyEs!T%[242622r,)rc3.K|] }|dk(ywr1r)r9r:rs r*r<z_mask_nc..Ss&#QqAaDy#srkeyF) commutative)r r8rrr$rsskip is_symboladdrRrorHrcrrhsortedrkrtsort)eqr\r]rrrepnc_objnc_symspotr)r~rrrrras ` @@r*_mask_ncrpsH >6D  E3 D 2rz C UFeG T(8 9C#1 &#& & HHJ!!{{ A hh!((ahh 1   6{a FJJL%'*+ W 6 GKKM57+,F 0 1F  u % Ar7 B 99S>D7mG LL%L& 3'341a!Q$3' 00's: H c  t|}t|tr |js|S|js0|j |jDcgc] }t |c}S|j |jDcgc] }t|c}}ddlm }m }t|\}}}|r||j|Stj|Dcgc]}|j}}t j"x}x} x} } d} t%|D]X\}}|dk(rt'j(|d}$|dr ||t'j(|d}It j"}Z|t j"urd} |j+\}} | t j"ur[t%|D]M\}\} }t-t'jt'j(t-| | z } | ||d<Ot%|D]$\}\} }| r | d|z | d<nd|z g} | ||d<&t%|D]\}}|dk(r |ddd}nt/|d}|r&|ddsn|dddj1\}}d}|j2ro|D]A}|dsnc|ddj1\}}|j2r||k(r t5||}An*dx}} ||z} || z}|D]}||ddz|dd<n-|rn(d} t7}t'|} |D] }|d|d|d<t%|D]\}}|dk(r |ddd}nt9||d}|r&|ddsn|dddj1\}}d}|j2ro|D]A}|dsnc|ddj1\}}|j2r||k(r t5||}An*dx}} ||z} || z}|D]}|dd|z|dd<n<|rn7d} t7|}t'|} |D]}|ddt7|d|z |d<| r+t|D cgc]\} }t'| t'|zc}} }n|}ddlm}t?|t@ Dcgc]}|tCf}}|Dcgc] \}}||f }}}|jEt|j|\}} }|||}|j| j|}|jFrtI|| | z|z| zS|jJrd }!g}"g}#|jD]f}$|$jLr|"jO|$!|$j1\}}|j2r|#jQ|g|zV|#jO|$h| t'|"z| z}%|!||z }&tS|#t7|#D])}'|%t'|'z| z}|!||&k(stI||cStI|| | z|z| zScc}wcc}wcc}wcc}} wcc}wcc}}w) aReturn the factored form of ``expr`` while handling non-commutative expressions. Examples ======== >>> from sympy import factor_nc, Symbol >>> from sympy.abc import x >>> A = Symbol('A', commutative=False) >>> B = Symbol('B', commutative=False) >>> factor_nc((x**2 + 2*A*x + A**2).expand()) (x + A)**2 >>> factor_nc(((x + A)*(x + B)).expand()) (x + A)*(x + B) r)rrFTrNr)powsimprcc 2|jdddddddS)zCExpand with the minimal set of hints necessary to check the result.TF)deepr power_exp power_basebasic multinomiallog)expand)rs r* _pemexpandzfactor_nc.._pemexpands){{$$$Et#PPr,)*r r&rrrRr5 factor_ncr rerrrprkrrrrrrZr$rrrrtrrrJminrcrsympy.simplify.powsimprrrirrreverserHrror rextendr)(rrr)rrrl nc_symbolsrrglr:hitccrr~rrokr(btetillennrmidrrrep1rrunrep1new_midr2r{cfacncfacrpre_midtargetrxs( r*r|r|rsd 4=D dD ! ;;tyy;A9Q<;<< 499DII>Iq'*I> ?D1$TND#z d|  %%&)mmD&9:&9 &9:AAdODAqAvNN1Q4(13>>!A$/0EE $ AEE>C>>#DAq~"+D/JAwAcmmCNN48,DQ,FGHB!#DGAJ#2(o 7BqE!GBqEA#BQ .dODAqAvaDG!!QqT*AwqzAwqz!}0021<<! t!!"1a!4!4!6B==R1W #Ar A!"$(SqDU!%A&(1ajAaDG"&9$<Cq6DQAtDE{!dODAqAvaDG!!QqT*AwqzAwqz"~1131<<! t!!"1b!5!5!7B==R1W #Ar A!"$(SqDU!%A'(tBx{AaDH"&9$<Cq6DQAt-S1Y-.! =fb"Rb)=>CC2'-Z=M&NO&NEG &NO%)*TTQ1a&T*!#((4.1Q&/*,,r"''/ >>q!A#g+a-0 0 >> PDE\\##KKN==?DAq|| aSU+ Q"T l1nGQ'Fs5z2S!W_Q&b>V+&q"--3 1ac#gai((w<>;B>P*s$X2X7X<Y Y-Y )FT)FTT)FFFTr%)=rrhrrrrpowerrrwrrrr?r r numbersr r rrr singletonrsortingrrr_r traversalr coreerrorsr containersrrsympy.external.gmpyrsympy.utilities.iterablesrrrrr collectionsr!typingtTupler[r+rQrrrrrr+r7rFrArpr|rr,r*rs?!&??.)0#*++$" d=v$r)$)6$)#4)X;d;vdHn'=;.F!F!Rk!k!\>B}8@-)`ody1xo)r,