~9\c@ sdZddlmZmZddlmZddlmZmZm Z m Z ddl m Z m Z ddlmZddlmZmZddlmZdd lmZdd lmZmZmZmZdd lmZdd lmZdd l m!Z!ddl"m#Z#m$Z$ddl%m&Z&ddl'm(Z(m)Z)m*Z*m+Z+ddl,m-Z-ede.Z/dZ0dZ1dZ2dZ3de4fdYZ5de4fdYZ6e7e.dZ8e7e.e.dZ9e7e7e7e.dZ:e;dZ<dZ=d S(!s9Tools for manipulating of large commutative expressions. i(tprint_functiontdivision(tAdd(titerablet is_sequencet SYMPY_INTStrange(tMult _keep_coeff(tPow(tBasictpreorder_traversal(tExpr(tsympify(tRationaltIntegertNumbertI(tS(tDummy(tNonCommutativeExpression(tTupletDict(tdefault_sort_key(t common_prefixt common_suffixt variationstordered(t defaultdicttpositivecC st|ttfp|jS(N(t isinstanceRtfloatt is_Number(ti((s3lib/python2.7/site-packages/sympy/core/exprtools.pyt _isnumbersc s |js dS| jr9t| }|dkr4|S| S|j rW|jdjrW|}|jr|jrxt dSt dSn|j r|jrt dSt dSn|j r|j r|jt krt dSt dSq1|jrt jStSn4|jr1|j rt dS|jr)t jSt Sn|jsL|jsL|jrSt jSdS|j}t|dkr|jrdd lm}dd lm}dd lm}|j }t|tkst krt jndk r|j!|}|jrg} nUy||} WnB|t"fk rlg|||D]} | jrN| ^qN} nX|j#|} |jr7t$fd | Dr7| jr|j r| r| j r| St%d dt&St%ddt&Sn| jr|jr| r!| jr| St%ddt&St%ddt&Sqq|jrt$fd| Dr| jr|jr| rt%d dt&St%ddt&Sn| jr|j r| rt%ddt&St%ddt&Sqqqn|j\} }d} | jr t|} n-|js8t| dk r8t|} q8n| dk r| j sV| jr| | }|j ryt%d dt&S|jrt%ddt&S|jrt%ddt&S|jrt%ddt&SndS|j'\}}d}|js|j\} }| jp|jsdS|j(s)|j)r|j*rt$d|j+t,Dr|j sc|jrt d}xt-j.|D]p}|jr||9}qni}x5|jD]*}t|||<||dkrdSqW||j#|9}qWqn|rt/d|j+t,D r|js1|jrt0|j}i}xJ|D]B}t|}|dkrodS|p|jrtnt ||>> from sympy.core.exprtools import _monotonic_sign as F >>> from sympy import Dummy, S >>> 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 Niiii iii(t real_roots(troots(tPolynomialErrorc3 s|]}|kVqdS(N((t.0tr(tx0(s3lib/python2.7/site-packages/sympy/core/exprtools.pys stposRtnnegt nonnegativetnegtnegativetnpost nonpositivec3 s|]}|kVqdS(N((R&R'(R((s3lib/python2.7/site-packages/sympy/core/exprtools.pys scs s$|]}|jr|jjVqdS(N(tis_Powtexpt is_Integer(R&tp((s3lib/python2.7/site-packages/sympy/core/exprtools.pys scs s|]}|js|VqdS(N(t is_number(R&R3((s3lib/python2.7/site-packages/sympy/core/exprtools.pys si(2tis_realt is_Symbolt_monotonic_signtNonetis_Addtas_numer_denomR4tis_primetis_oddRt is_compositet is_positivetis_eventFalset is_integertOnet_epst is_negativet NegativeOnetis_zerotis_nonpositivetis_nonnegativetZerot free_symbolstlent is_polynomialtsympy.polys.polytoolsR#tsympy.polys.polyrootsR$tsympy.polys.polyerrorsR%tpoptdifftNotImplementedErrortsubstallRtTruet as_coeff_Addtis_MulR0t is_rationaltatomsR Rt make_argstanytlisttxreplace(tselftrvtstfreeR#R$R%txtdt currentrootsR'tytntdentvtctataitrepsR3R!((R(s3lib/python2.7/site-packages/sympy/core/exprtools.pyR7s%                            /%%            2   $  cC s|j\}}|jrg|jrW|jsKt|td|j}n|j}q|d}}n|jdt \}}|t j krt||d}}nS|t j k rt td|j|}t|||j}}n |d}}||fS(s3 Decompose power into symbolic base and integer exponent. This is strictly only valid if the exponent from which the integer is extracted is itself an integer or the base is positive. These conditions are assumed and not checked here. Examples ======== >>> from sympy.core.exprtools import decompose_power >>> from sympy.abc import x, y >>> decompose_power(x) (x, 1) >>> decompose_power(x**2) (x, 2) >>> decompose_power(x**(2*y)) (x**y, 2) >>> decompose_power(x**(2*y/3)) (x**(y/3), 2) itrationali(t as_base_expR t is_RationalR2R RtqR3t as_coeff_MulRURRERBR(texprtbaseR1ttail((s3lib/python2.7/site-packages/sympy/core/exprtools.pytdecompose_powers     cC s|j\}}|jr7|js|d}}qn|jdt\}}|tjkrwt||d}}nS|tjk rt t d|j |}t|||j }}n |d}}||fS(sD Decompose power into symbolic base and rational exponent. iRmi( RnR RoRqRURRER RBRRRpR3(RrRsR1Rt((s3lib/python2.7/site-packages/sympy/core/exprtools.pytdecompose_power_rats   tFactorscB seZdZddgZddZdZdZedZ edZ dZ d Z d Z d Zd Zd ZdZdZdZdZdZdZeZdZdZdZdZRS(s0Efficient representation of ``f_1*f_2*...*f_n``.tfactorstgensc C sLt|ttfr$t|}nt|trE|jj}n|d ks`|tjkrii}n|tj ks|dkritjtj 6}nft|t r{|}i}|dkrtj|tj <| }n|tjk r|j s |j s |tjkrtj||>> 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. iis'Expected Float|Rational|Integer, not %stevaluateisunexpected factor in i1: %stkeyssexpecting Expr or dictionaryN(ii(+RRRRRwRxtcopyR8RBRIRREtis_FloatR2tInfinityRoR3RRpt ValueErrorR targsR targs_cnctcountRRtremovetdictRt _from_argstas_powers_dictR@tappendR"RPRWR0R1tgetattrt TypeErrort frozensetRy( R^RxRfRitncR!t_thandletkti1RjR{((s3lib/python2.7/site-packages/sympy/core/exprtools.pyt__init__$s   !     "      cC sKtt|jj}g|D]}|j|^q"}t||fS(N(ttupleRRxR{thash(R^R{Rtvalues((s3lib/python2.7/site-packages/sympy/core/exprtools.pyt__hash__s cC sCddjgt|jjD]\}}d||f^qS(Ns Factors({%s})s, s%s: %s(tjoinRRxtitems(R^RRh((s3lib/python2.7/site-packages/sympy/core/exprtools.pyt__repr__s cC s(|j}t|dko'tj|kS(sj >>> from sympy.core.exprtools import Factors >>> Factors(0).is_zero True i(RxRKRRI(R^tf((s3lib/python2.7/site-packages/sympy/core/exprtools.pyRFs cC s|j S(si >>> from sympy.core.exprtools import Factors >>> Factors(1).is_one True (Rx(R^((s3lib/python2.7/site-packages/sympy/core/exprtools.pytis_onescC sg}x|jjD]\}}|dkr|j\}}t|trgtt||}n+t|trt||}n ||9}|j||q|j|qWt |S(sReturn 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 i( RxRRnRtintRRRRR(R^RtfactorR1tbte((s3lib/python2.7/site-packages/sympy/core/exprtools.pytas_exprs   cC st|tst|}ntd||fDrGttjSt|j}xW|jjD]F\}}||kr|||}|s||=qfqn|||>> 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}) cs s|]}|jVqdS(N(RF(R&R((s3lib/python2.7/site-packages/sympy/core/exprtools.pys s(RRwR[RRIRRxR(R^totherRxRR1((s3lib/python2.7/site-packages/sympy/core/exprtools.pytmuls   cC s?t|ts\t|}|jr:tttjfS|jr\ttjtfSnt|j}t|j}x|jjD]\}}y|j|}Wntk rqnX||}|s||=||=qt |r |dkr |||<||=q%||=| ||>> 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.core.exprtools 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 iN(RRxRRwRFtZeroDivisionErrorRRIRR"RR8RVtAssertionError(R^RtquotremRR1RcR'RRRRRRQ((s3lib/python2.7/site-packages/sympy/core/exprtools.pytdiv0sT.                      cC s|j|dS(sYReturn 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}) i(R(R^R((s3lib/python2.7/site-packages/sympy/core/exprtools.pyRs cC s|j|dS(swReturn 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({}) i(R(R^R((s3lib/python2.7/site-packages/sympy/core/exprtools.pyRscC st|tr6|j}|jr6t|}q6nt|tr|dkri}|rx.|jjD]\}}||||>> 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}) is%expected non-negative integer, got %sN( RRwRR2RRRxRR(R^RRxRR1((s3lib/python2.7/site-packages/sympy/core/exprtools.pytpows    cC st|ts4t|}|jr4t|jSni}x|jjD]\}}t|t|}}||jkrJ||j|j}|tkr|||>> 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}) ( RRwRFRxRR RDRUR@(R^RRxRR1tlt((s3lib/python2.7/site-packages/sympy/core/exprtools.pytgcds     cC st|tsGt|}td||fDrGttjSnt|j}xI|jjD]8\}}||krt|||}n|||>> 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}) cs s|]}|jVqdS(N(RF(R&R((s3lib/python2.7/site-packages/sympy/core/exprtools.pys s( RRwR[RRIRRxRtmax(R^RRxRR1((s3lib/python2.7/site-packages/sympy/core/exprtools.pytlcms  cC s |j|S(N(R(R^R((s3lib/python2.7/site-packages/sympy/core/exprtools.pyt__mul__scC s |j|S(N(R(R^R((s3lib/python2.7/site-packages/sympy/core/exprtools.pyt __divmod__scC s |j|S(N(R(R^R((s3lib/python2.7/site-packages/sympy/core/exprtools.pyt__div__scC s |j|S(N(R(R^R((s3lib/python2.7/site-packages/sympy/core/exprtools.pyt__mod__scC s |j|S(N(R(R^R((s3lib/python2.7/site-packages/sympy/core/exprtools.pyt__pow__scC s.t|tst|}n|j|jkS(N(RRwRx(R^R((s3lib/python2.7/site-packages/sympy/core/exprtools.pyt__eq__"scC s ||k S(N((R^R((s3lib/python2.7/site-packages/sympy/core/exprtools.pyt__ne__'sN(t__name__t __module__t__doc__t __slots__R8RRRtpropertyRFRRRRRRRRRRRRRt __truediv__RRRR(((s3lib/python2.7/site-packages/sympy/core/exprtools.pyRws0  m     ! F f    !       tTermcB seZdZdddgZdddZdZdZdZdZ d Z d Z d Z d Z d ZdZdZeZdZdZdZRS(s5Efficient representation of ``coeff*(numer/denom)``. tcoefftnumertdenomc C sJ|dkr|dkr|js0tdn|j\}}tttt}}x||D]t}t|\}}|jr|j\} }|| |9}n|dkr||c|7}|j j|j|j}| j|j |jqtWn4g|D]}|j^q} tt dj }|j}t| }|j}| r@|jr@|j\} }|| 9}n|||fS(sCHelper function for :func:`gcd_terms`. If ``isprimitive`` is True then the call to primitive for an Add will be skipped. This is useful when the content has already been extrated. If ``fraction`` is True then the expression will appear over a common denominator, the lcm of all term denominators. ii(RR RRRZR\tmapRRKRRIRBRRRRRt enumerateRRRRR9R( ttermst isprimitivetfractionttRRRRR!tnumerst_cont((s3lib/python2.7/site-packages/sympy/core/exprtools.pyt _gcd_termss> .    !    c  s[d}t|t}|pMt|t oMt|dtoMt|t }|rc|rnt|j}n t|}||\}}t |\}} } | j |} |j \} } sH| j \} }| j rH rH| j rH| j\}}| |}td|jDrE|} ||} qEqHnt| | | | dSt|tsv|S|jr|S|jr|j\} }t| tg|D]}t|^qdSfdt|tr2tg|jD]\}}||f^q S|jg|jD]}|^qBS(s.Compute the GCD of ``terms`` and put them together. ``terms`` can be an expression or a non-Basic sequence of expressions which will be handled as though they are terms from a sum. If ``isprimitive`` is True the _gcd_terms will not run the primitive method on the terms. ``clear`` 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``, when True (default), will put the expression over a common denominator. Examples ======== >>> from sympy.core 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 cS sg|D]'}|jr"|gfn |j^q}g}xxt|D]j\}\}}|rt|}t}|j||f|j|t|||/stclearc st|tspt|trG|jg|jD]}|^q.St|g|D]}|^qWSt|S(N(RR R tfuncRttypet gcd_terms(RjR!(RRRR(s3lib/python2.7/site-packages/sympy/core/exprtools.pyR@s ))(RRR RtsetRR\RR RR]RqR2R9R:R[Rtis_AtomRWRRRR(RRRRRtisaddtaddlikeRlRRRRRxRit_coeffRfRct_numerRR!RRh((RRRRs3lib/python2.7/site-packages/sympy/core/exprtools.pyRsF5       /2c s1fdt|}|S(sTRemove 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. If radical=True then a radical common to all terms will be factored out of any Add sub-expressions of the expr. 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. If fraction=True (default is False) then a common denominator will be constructed for the expression. 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 c  sddlm}ddlm}t|}t|t sE|jrx|rtt|g|D]}|^q[S|S|j s|j s|st |d r|j }t g|D]}|^q}||kr|S|j|St||r||ddddS|jdd\}}|jrOgtj|D]} | ^qS} td | Dr| }g| D] } | ^q} ni} xht| D]Z\}} | j\} } | jr| t| j krt| |<| | | |sR(tsympy.concrete.summationsRtsympy.simplify.simplifyRRRR RRR0t is_FunctionthasattrRRRtas_content_primitiveR9RRZRTRRnRWRRRRRUR]R(RrRRt is_iterableR!RtnewargsRR3Rjt list_argstspecialRRR_(RtdoRRR(s3lib/python2.7/site-packages/sympy/core/exprtools.pyRsN ) %  " (     ((R (RrRRRR((RRRRRs3lib/python2.7/site-packages/sympy/core/exprtools.pyt factor_termsMs5/ c  s'p dfd}|fd}|}|jrO|igfSg}t}t}t|dt}xt|D]\} tfd|Dr|jqjsjr|j|jqj pj pj s|j|jqqqWt |dkr[| r[|j |j|fn8t |dkr| r|j |j|fnt|dt}x=|D]5} |dt} |j | | f|j| qW|j|}t|}|jdt|d |D|fS( s 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. ``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. Notes ===== 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. Examples ======== >>> from sympy.physics.secondquant import Commutator, NO, F, Fd >>> from sympy import symbols, Mul >>> 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]) If there is an object that: - doesn't contain nc-symbols - but has arguments which derive from Basic, not Expr - and doesn't define an _eval_is_commutative routine then it will give False (or None?) for the is_commutative test. Such objects are also removed by this routine: >>> from sympy import Basic >>> eq = (1 + Mul(Basic(), Basic(), evaluate=False)) >>> eq.is_commutative False >>> _mask_nc(eq, 'd') (_d0**2 + 1, {_d0: Basic()}, []) Rc3 s0d}x#tr+t|V|d7}q WdS(Nii(RUtstr(R!(tname(s3lib/python2.7/site-packages/sympy/core/exprtools.pytnumbered_namess c s&ddlm}|t||S(Ni(R(tsympyRtnext(RtkwargsR(tnames(s3lib/python2.7/site-packages/sympy/core/exprtools.pyRsR{c3 s|]}|dkVqdS(iN((R&R'(Rj(s3lib/python2.7/site-packages/sympy/core/exprtools.pys sitkeyt commutativecS si|]\}}||qS(((R&RRh((s3lib/python2.7/site-packages/sympy/core/exprtools.pys 9s (RRR RRR[tskipt is_symboltaddR9RWR0RKRRPtsortedR@RSR\tsort( teqRRRRrtreptnc_objtnc_symstpotR!RfR((RjRRs3lib/python2.7/site-packages/sympy/core/exprtools.pyt_mask_ncsDO              c(C sddlm}ddlm}m}d}t|}t|t sU|j rY|S|j s|j g|jD]}t |^qrSt |\}}}|r||j |Sgtj|D]}|j^q}tj} } } } t} xnt|D]`\}}|dkr7tj|d} q |dr`|| tj|d} q tj} q W| tjk rEt} | j\} } | tjk rxYt|D]H\}\}}ttjtjt|| }|||dt|D]0\}}|dt|d| ||d>> from sympy.core.exprtools import factor_nc >>> from sympy import 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) i(tpowsimp(RRcS s4|jdtdtdtdtdtdtdtS(sCExpand with the minimal set of hints necessary to check the result.tdeepRt power_expt power_basetbasict multinomialtlog(texpandRUR@(Rr((s3lib/python2.7/site-packages/sympy/core/exprtools.pyt _pemexpandPsiiRN(+RRt sympy.polysRRR RR RR9Rt factor_ncRRSRRZRRRBR@RRRRURqR\RRnR2tminRKRRRRtreverseR0RRWRRtextendR((RrRRRRRjRt nc_symbolsRRitgtlR'thitR!tccRRfRRtokRtbttettiltlennRtmidtrep1RRhtunrep1tnew_midtr2tcfactncfacRtpre_midttargetR`((s3lib/python2.7/site-packages/sympy/core/exprtools.pyR<s   )(   (       &          &   (8.%     N(>Rt __future__RRtsympy.core.addRtsympy.core.compatibilityRRRRtsympy.core.mulRRtsympy.core.powerR tsympy.core.basicR R tsympy.core.exprR tsympy.core.sympifyR tsympy.core.numbersRRRRtsympy.core.singletonRtsympy.core.symbolRtsympy.core.coreerrorsRtsympy.core.containersRRtsympy.utilitiesRtsympy.utilities.iterablesRRRRt collectionsRRURCR"R7RuRvtobjectRwRR@RRRR8RR(((s3lib/python2.7/site-packages/sympy/core/exprtools.pyts<"""  1 p<vh