~9\c @ sdZddlmZmZddlmZmZmZmZm Z m Z m Z m Z m Z ddlmZddlmZmZmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd l m!Z!dd l"m#Z$ddl%m&Z&ddl'm(Z(m)Z)m*Z*ddl+m,Z,ddl-m.Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAddlBmCZCmDZDmEZEmFZFmGZGmHZHddlImJZJddlKmLZLddlMmNZNmOZOmPZPmQZQddl"ZRddlSZSddlTmUZUePdefdYZVePdeVfdYZWePd ZXd!ZYePd"ZZd#Z[d$Z\ePd%d&Z]ePd'Z^ePd(Z_ePd)Z`ePd*ZaePd+ZbePd,ZcePd-ZdePd.ZeePd/ZfePd0ZgePd1ZhePd2ZiePd3ZjePd4ZkePd5ZlePd6ZmePd7ZnePd8ZoePd9ZpePd:ZqePd;ZrePesd<ZtePd=ZuePesd>ZvePd?ZwePd@ZxePdAZyePdBZzePdCZ{ePdDZ|ePdEZ}ePdFZ~ePdGZePdHZePdIZePdJZdKZdLZdMZdNZdOZdPZdQZdRZePdSZePdTZePdUZePdVZePeeseseseeedWZePeseseedXZePesesdYZePedZZePd[d\ed]ZePd^ZePd_ZePd`ZePdaZePdbZ.ePdcZePddefdeYZePdfZdS(gs8User-friendly public interface to polynomial functions. i(tprint_functiontdivision( tStBasictExprtItIntegertAddtMultDummytTuple(tpreorder_traversal(titerabletrangetordered(t _sympifyit(t Derivative(t _keep_coeff(t Relational(tSymbol(tsympify(t BooleanAtom(t polyoptions(tconstruct_domain(tFFtQQtZZ(t matrix_fglm(tgroebner(tMonomial(t monomial_key(tDMP( tOperationNotSupportedt DomainErrortCoercionFailedtUnificationFailedtGeneratorsNeededtPolynomialErrortMultivariatePolynomialErrortExactQuotientFailedtPolificationFailedtComputationFailedtGeneratorsError(tbasic_from_dictt _sort_genst _unify_genst _dict_reordert_dict_from_exprt_parallel_dict_from_expr(ttogether(tdup_isolate_real_roots_list(tgrouptsifttpublict filldedentN(t NoConvergencetPolycB seZdZddgZeZeZdZdZe dZ e dZ e dZ e dZ e d Ze d Ze d Ze d Ze d ZdZdZedZedZedZedZedZedZedZedZdZdZdddZ!dZ"dZ#dZ$dZ%dZ&d Z'dd!Z(d"Z)d#Z*d$Z+d%Z,d&Z-d'Z.dd(Z/dd)Z0dd*Z1dd+Z2dd,Z3d-Z4d.Z5d/Z6d0Z7d1Z8e9e9d2Z:e9d3Z;d4Z<d5Z=d6Z>e9d7Z?d8Z@d9ZAd:ZBd;ZCd<ZDd=ZEd>ZFd?ZGd@ZHdAZIdBZJdCZKdDZLdEZMdFZNdGZOdHZPdIZQedJZRedKZSedLZTedMZUdNZVdOdPZWdQZXdRZYdSZZdTZ[ddUZ\dVZ]ddWZ^dXZ_dYZ`dZe9d[Zadd\Zbdd]Zcdd^Zddd_Zed`ZfdaZge9dbZhdcZiddZjdeZkekZldedfZmdgZnedhZoediZpedjZqdkZrdlZse9dmZtdnZuddoZvddpZwdqZxdrZydsZzdtZ{eduZ|dvZ}dwZ~dxZdyZdzZd{Zed|Zd}Zd~ZdZdZe9dZe9dZdZdZe9ddde9e9dZdde9e9dZdddZedZeedZeedZddedZdZdZe9dZedZedZedZedZedZedZedZedZedZedZedZedZedZedZdZdZededZededZededZededZededZededZededZededZededZededZededZededZededZededZededZeZeZededZededZdZeZe9dZe9dZdZRS(s Generic class for representing and operating on polynomial expressions. Subclasses Expr class. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y Create a univariate polynomial: >>> Poly(x*(x**2 + x - 1)**2) Poly(x**5 + 2*x**4 - x**3 - 2*x**2 + x, x, domain='ZZ') Create a univariate polynomial with specific domain: >>> from sympy import sqrt >>> Poly(x**2 + 2*x + sqrt(3), domain='R') Poly(1.0*x**2 + 2.0*x + 1.73205080756888, x, domain='RR') Create a multivariate polynomial: >>> Poly(y*x**2 + x*y + 1) Poly(x**2*y + x*y + 1, x, y, domain='ZZ') Create a univariate polynomial, where y is a constant: >>> Poly(y*x**2 + x*y + 1,x) Poly(y*x**2 + y*x + 1, x, domain='ZZ[y]') You can evaluate the above polynomial as a function of y: >>> Poly(y*x**2 + x*y + 1,x).eval(2) 6*y + 1 See Also ======== sympy.core.expr.Expr treptgensgn$@cO stj||}d|kr-tdnt|dtrwt|tr^|j||S|jt ||Sn5t |}|j r|j ||S|j ||SdS(s:Create a new polynomial instance out of something useful. torders&'order' keyword is not implemented yettexcludeN(toptionst build_optionstNotImplementedErrorR tstrt isinstancetdictt _from_dictt _from_listtlistRtis_Polyt _from_polyt _from_expr(tclsR9R:targstopt((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__new__ks   cG syt|ts"td|n2|jt|dkrTtd||fntj|}||_||_|S(s:Construct :class:`Poly` instance from raw representation. s%invalid polynomial representation: %sisinvalid arguments: %s, %s( RARR%tlevtlenRRLR9R:(RIR9R:tobj((s4lib/python2.7/site-packages/sympy/polys/polytools.pytnews  cO s"tj||}|j||S(s(Construct a polynomial from a ``dict``. (R=R>RC(RIR9R:RJRK((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt from_dictscO s"tj||}|j||S(s(Construct a polynomial from a ``list``. (R=R>RD(RIR9R:RJRK((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt from_listscO s"tj||}|j||S(s*Construct a polynomial from a polynomial. (R=R>RG(RIR9R:RJRK((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt from_polyscO s"tj||}|j||S(s+Construct a polynomial from an expression. (R=R>RH(RIR9R:RJRK((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt from_exprscC s|j}|stdnt|d}|j}|dkr^t|d|\}}n0x-|jD]\}}|j|||>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(x**2 + 1).free_symbols {x} >>> Poly(x**2 + y).free_symbols {x, y} >>> Poly(x**2 + y, x).free_symbols {x, y} >>> Poly(x**2 + y, x, z).free_symbols {x, y} (R_R:R RNtmonomst free_symbolstfree_symbols_in_domain(RetsymbolsR:tiRZ((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRjs    cC sw|jjt}}|jrCxQ|jD]}||jO}q)Wn0|jrsx$|jD]}||jO}qYWn|S(sj Free symbols of the domain of ``self``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 1).free_symbols_in_domain set() >>> Poly(x**2 + y).free_symbols_in_domain set() >>> Poly(x**2 + y, x).free_symbols_in_domain {y} (R9tdomR_t is_CompositeRlRjtis_EXtcoeffs(ReRURltgenR[((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRks  cC s |jfS(s Don't mess up with the core. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).args (x**2 + 1,) (R`(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRJ2scC s |jdS(s Return the principal generator. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).gen x i(R:(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRrCscC s |jS(s#Get the ground domain of ``self``. (t get_domain(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRUTscC s.|j|jj|jj|jj|jS(s3Return zero polynomial with ``self``'s properties. (RPR9tzeroRMRnR:(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRtYscC s.|j|jj|jj|jj|jS(s2Return one polynomial with ``self``'s properties. (RPR9toneRMRnR:(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRu^scC s.|j|jj|jj|jj|jS(s3Return unit polynomial with ``self``'s properties. (RPR9tunitRMRnR:(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRvcscC s1|j|\}}}}||||fS(s Make ``f`` and ``g`` belong to the same domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f, g = Poly(x/2 + 1), Poly(2*x + 1) >>> f Poly(1/2*x + 1, x, domain='QQ') >>> g Poly(2*x + 1, x, domain='ZZ') >>> F, G = f.unify(g) >>> F Poly(1/2*x + 1, x, domain='QQ') >>> G Poly(2*x + 1, x, domain='QQ') (t_unify(tftgt_tpertFtG((s4lib/python2.7/site-packages/sympy/polys/polytools.pytunifyhsc  st|}|js}y;|jj|j|j|jj|jjj|fSWq}tk rytd||fq}Xnt|jt rFt|jt rFt |j |j }|jjj |jj|t |d}}|j |krt|jj|j |\}}|jj|krXg|D]}|j||jj^q1}nt ttt||||}n|jj|}|j |kr1t|jj|j |\} } |jj|krg| D]}|j||jj^q} nt ttt| | ||} q\|jj|} ntd||f|j||dfd} || || fS(Nscan't unify %s with %sic sH|dk r8|| ||d}|s8|j|Snj||S(Ni(RVtto_sympyRP(R9RnR:tremove(RI(s4lib/python2.7/site-packages/sympy/polys/polytools.pyR{s  (RRFR9RnR{t from_sympyR"R#RARR-R:R~RNR.tto_dictRXRBREtzipR]RV( RxRyR:RnRMtf_monomstf_coeffstcR|tg_monomstg_coeffsR}R{((RIs4lib/python2.7/site-packages/sympy/polys/polytools.pyRws6  ; $/!.*!.*  cC si|dkr|j}n|dk rV|| ||d}|sV|jjj|Sn|jj||S(sb Create a Poly out of the given representation. Examples ======== >>> from sympy import Poly, ZZ >>> from sympy.abc import x, y >>> from sympy.polys.polyclasses import DMP >>> a = Poly(x**2 + 1) >>> a.per(DMP([ZZ(1), ZZ(1)], ZZ), gens=[y]) Poly(y + 1, y, domain='ZZ') iN(RVR:R9RnRR]RP(RxR9R:R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR{s   cC s8tj|ji|d6}|j|jj|jS(s Set the ground domain of ``f``. RU(R=R>R:R{R9RXRU(RxRURK((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRbscC s |jjS(s Get the ground domain of ``f``. (R9Rn(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRsscC s%tjj|}|jt|S(s Set the modulus of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(5*x**2 + 2*x - 1, x).set_modulus(2) Poly(x**2 + 1, x, modulus=2) (R=tModulust preprocessRbR(Rxtmodulus((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt set_modulusscC s5|j}|jr%t|jStddS(s Get the modulus of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, modulus=2).get_modulus() 2 s$not a polynomial over a Galois fieldN(Rstis_FiniteFieldRtcharacteristicR%(RxRU((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt get_moduluss  cC si||jkrS|jr(|j||Sy|j||SWqStk rOqSXn|jj||S(s)Internal implementation of :func:`subs`. (R:t is_numbertevaltreplaceR%R`tsubs(RxtoldRP((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt _eval_subss  cC sq|jj\}}g}x@tt|jD])}||kr1|j|j|q1q1W|j|d|S(s  Remove unnecessary generators from ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import a, b, c, d, x >>> Poly(a + x, a, b, c, d, x).exclude() Poly(a + x, a, x, domain='ZZ') R:(R9R<R RNR:tappendR{(RxtJRPR:tj((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR<s  cG s|dkr7|jr(|j|}}q7tdn||ksR||jkrV|S||jkr||jkr|j}|j s||jkrt|j}|||j |<|j |j d|Sntd|||fdS(s Replace ``x`` with ``y`` in generators list. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 1, x).replace(x, y) Poly(y**2 + 1, y, domain='ZZ') s(syntax supported only in univariate caseR:scan't replace %s with %s in %sN( RVt is_univariateRrR%R:RsRoRlREtindexR{R9(Rxtxtyt_ignoreRnR:((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR's    cO stjd|}|s0t|jd|}n*t|jt|krZtdntttt |j j |j|}|j t ||j jt|dd|S(s Efficiently apply new order of generators. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + x*y**2, x, y).reorder(y, x) Poly(y**2*x + x**2, y, x, domain='ZZ') RKs7generators list can differ only up to order of elementsiR:((R=tOptionsR,R:R_R%RBRERR.R9RR{RRnRN(RxR:RJRKR9((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRaJs 0cC s|jdt}|j|}i}xU|jD]G\}}td|| Drmtd|n||||>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(y**2 + y*z**2, x, y, z).ltrim(y) Poly(y**2 + y*z**2, y, z, domain='ZZ') >>> Poly(z, x, y, z).ltrim(-1) Poly(z, z, domain='ZZ') tnativecs s|] }|VqdS(N((t.0Rm((s4lib/python2.7/site-packages/sympy/polys/polytools.pys ~sscan't left trim %si( tas_dictRct _gen_to_levelRWtanyR%R:RPRRQRNR9Rn(RxRrR9RttermsRZR[R:((s4lib/python2.7/site-packages/sympy/polys/polytools.pytltrimds cG st}x[|D]S}y|jj|}Wn'tk rUtd||fqX|j|qWxG|jD]9}x0t|D]"\}}||kr|rtSqWqtWt S(sJ Return ``True`` if ``Poly(f, *gens)`` retains ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(x*y + 1, x, y, z).has_only_gens(x, y) True >>> Poly(x*y + z, x, y, z).has_only_gens(x, y) False s%s doesn't have %s as generator( R_R:Rt ValueErrorR*taddRit enumeratetFalseRc(RxR:tindicesRrRRZRmtelt((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt has_only_genss    cC s@t|jdr$|jj}nt|d|j|S(s Make the ground domain a ring. Examples ======== >>> from sympy import Poly, QQ >>> from sympy.abc import x >>> Poly(x**2 + 1, domain=QQ).to_ring() Poly(x**2 + 1, x, domain='ZZ') tto_ring(thasattrR9RR R{(Rxtresult((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC s@t|jdr$|jj}nt|d|j|S(s Make the ground domain a field. Examples ======== >>> from sympy import Poly, ZZ >>> from sympy.abc import x >>> Poly(x**2 + 1, x, domain=ZZ).to_field() Poly(x**2 + 1, x, domain='QQ') Rd(RR9RdR R{(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRdscC s@t|jdr$|jj}nt|d|j|S(s Make the ground domain exact. Examples ======== >>> from sympy import Poly, RR >>> from sympy.abc import x >>> Poly(x**2 + 1.0, x, domain=RR).to_exact() Poly(x**2 + 1, x, domain='QQ') tto_exact(RR9RR R{(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC sOt|jdtd|d|jjp*d\}}|j||jd|S(s Recalculate the ground domain of a polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**2 + 1, x, domain='QQ[y]') >>> f Poly(x**2 + 1, x, domain='QQ[y]') >>> f.retract() Poly(x**2 + 1, x, domain='ZZ') >>> f.retract(field=True) Poly(x**2 + 1, x, domain='QQ') RtR^t compositeRUN(RRRcRURoRVRQR:(RxR^RnR9((s4lib/python2.7/site-packages/sympy/polys/polytools.pytretracts!cC s|dkr#d||}}}n|j|}t|t|}}t|jdrx|jj|||}nt|d|j|S(s1Take a continuous subsequence of terms of ``f``. itsliceN(RVRtintRR9RR R{(RxRtmtnRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs cC s5g|jjd|D]}|jjj|^qS(sQ Returns all non-zero coefficients from ``f`` in lex order. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x + 3, x).coeffs() [1, 2, 3] See Also ======== all_coeffs coeff_monomial nth R;(R9RqRnR(RxR;R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRqscC s|jjd|S(sU Returns all non-zero monomials from ``f`` in lex order. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x*y**2 + x*y + 3*y, x, y).monoms() [(2, 0), (1, 2), (1, 1), (0, 1)] See Also ======== all_monoms R;(R9Ri(RxR;((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRi'scC sAg|jjd|D]'\}}||jjj|f^qS(sc Returns all non-zero terms from ``f`` in lex order. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x*y**2 + x*y + 3*y, x, y).terms() [((2, 0), 1), ((1, 2), 2), ((1, 1), 1), ((0, 1), 3)] See Also ======== all_terms R;(R9RRnR(RxR;RR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR;scC s/g|jjD]}|jjj|^qS(s Returns all coefficients from a univariate polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x - 1, x).all_coeffs() [1, 0, 2, -1] (R9t all_coeffsRnR(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyROscC s |jjS(s? Returns all monomials from a univariate polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x - 1, x).all_monoms() [(3,), (2,), (1,), (0,)] See Also ======== all_terms (R9t all_monoms(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR_scC s;g|jjD]'\}}||jjj|f^qS(s Returns all terms from a univariate polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x - 1, x).all_terms() [((3,), 1), ((2,), 0), ((1,), 2), ((0,), -1)] (R9t all_termsRnR(RxRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRsscO si}x|jD]q\}}|||}t|trL|\}}n|}|r||krq|||>> from sympy import Poly >>> from sympy.abc import x >>> def func(k, coeff): ... k = k[0] ... return coeff//10**(2-k) >>> Poly(x**2 + 20*x + 400).termwise(func) Poly(x**2 + 2*x + 4, x, domain='ZZ') s%s monomial was generated twice(RRAttupleR%RQR:(RxtfuncR:RJRRZR[R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyttermwises  cC st|jS(s Returns the number of non-zero terms in ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 2*x - 1).length() 3 (RNR(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pytlengthscC s0|r|jjd|S|jjd|SdS(s Switch to a ``dict`` representation. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x*y**2 - y, x, y).as_dict() {(0, 1): -1, (1, 2): 2, (2, 0): 1} RtN(R9Rt to_sympy_dict(RxRRt((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC s$|r|jjS|jjSdS(s%Switch to a ``list`` representation. N(R9tto_listt to_sympy_list(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pytas_lists cG s|s|j}nt|dkrt|dtr|d}t|j}xd|jD]S\}}y|j|}Wn'tk rtd||fq]X|||>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2 + 2*x*y**2 - y, x, y) >>> f.as_expr() x**2 + 2*x*y**2 - y >>> f.as_expr({x: 5}) 10*y**2 - y + 25 >>> f.as_expr(5, 6) 379 iis%s doesn't have %s as generator( R:RNRARBRERWRRR*R+R9R(RxR:tmappingRrtvalueR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR`s %  cC s@t|jdr$|jj}nt|d|j|S(s Convert algebraic coefficients to rationals. Examples ======== >>> from sympy import Poly, I >>> from sympy.abc import x >>> Poly(x**2 + I*x + 1, x, extension=I).lift() Poly(x**4 + 3*x**2 + 1, x, domain='QQ') tlift(RR9RR R{(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC sLt|jdr*|jj\}}nt|d||j|fS(s+ Reduce degree of ``f`` by mapping ``x_i**m`` to ``y_i``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**6*y**2 + x**3 + 1, x, y).deflate() ((3, 2), Poly(x**2*y + x + 1, x, y, domain='ZZ')) tdeflate(RR9RR R{(RxRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR scC s|jj}|jr|S|js5td|nt|jdr_|jjd|}nt|d|r|j|j }n|j |j}|j ||S(s Inject ground domain generators into ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2*y + x*y**3 + x*y + 1, x) >>> f.inject() Poly(x**2*y + x*y**3 + x*y + 1, x, y, domain='ZZ') >>> f.inject(front=True) Poly(y**3*x + y*x**2 + y*x + 1, y, x, domain='ZZ') scan't inject generators over %stinjecttfront( R9Rnt is_NumericalRFR!RRR RlR:RP(RxRRnRR:((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR!s   cG s|jj}|js(td|nt|}|j| |kr^|j|t}}n8|j| |kr|j| t}}n td|j |}t |jdr|jj |d|}nt |d|j ||S(s Eject selected generators into the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2*y + x*y**3 + x*y + 1, x, y) >>> f.eject(x) Poly(x*y**3 + (x**2 + x)*y + 1, y, domain='ZZ[x]') >>> f.eject(y) Poly(y*x**2 + (y**3 + y)*x + 1, x, domain='ZZ[y]') scan't eject generators over %ss'can only eject front or back generatorstejectR(R9RnRR!RNR:RcRR?RRRR RP(RxR:Rntkt_gensRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRFs    cC sLt|jdr*|jj\}}nt|d||j|fS(s Remove GCD of terms from the polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**6*y**2 + x**3*y, x, y).terms_gcd() ((3, 1), Poly(x**3*y + 1, x, y, domain='ZZ')) t terms_gcd(RR9RR R{(RxRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRpscC sCt|jdr'|jj|}nt|d|j|S(s Add an element of the ground domain to ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 1).add_ground(2) Poly(x + 3, x, domain='ZZ') t add_ground(RR9RR R{(RxR[R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC sCt|jdr'|jj|}nt|d|j|S(s Subtract an element of the ground domain from ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 1).sub_ground(2) Poly(x - 1, x, domain='ZZ') t sub_ground(RR9RR R{(RxR[R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC sCt|jdr'|jj|}nt|d|j|S(s Multiply ``f`` by a an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 1).mul_ground(2) Poly(2*x + 2, x, domain='ZZ') t mul_ground(RR9RR R{(RxR[R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC sCt|jdr'|jj|}nt|d|j|S(sO Quotient of ``f`` by a an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x + 4).quo_ground(2) Poly(x + 2, x, domain='ZZ') >>> Poly(2*x + 3).quo_ground(2) Poly(x + 1, x, domain='ZZ') t quo_ground(RR9RR R{(RxR[R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC sCt|jdr'|jj|}nt|d|j|S(s Exact quotient of ``f`` by a an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x + 4).exquo_ground(2) Poly(x + 2, x, domain='ZZ') >>> Poly(2*x + 3).exquo_ground(2) Traceback (most recent call last): ... ExactQuotientFailed: 2 does not divide 3 in ZZ t exquo_ground(RR9RR R{(RxR[R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC s@t|jdr$|jj}nt|d|j|S(s Make all coefficients in ``f`` positive. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).abs() Poly(x**2 + 1, x, domain='ZZ') tabs(RR9RR R{(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC s@t|jdr$|jj}nt|d|j|S(s4 Negate all coefficients in ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).neg() Poly(-x**2 + 1, x, domain='ZZ') >>> -Poly(x**2 - 1, x) Poly(-x**2 + 1, x, domain='ZZ') tneg(RR9RR R{(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR scC szt|}|js"|j|S|j|\}}}}t|jdra|j|}nt|d||S(s[ Add two polynomials ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).add(Poly(x - 2, x)) Poly(x**2 + x - 1, x, domain='ZZ') >>> Poly(x**2 + 1, x) + Poly(x - 2, x) Poly(x**2 + x - 1, x, domain='ZZ') R(RRFRRwRR9RR (RxRyRzR{R|R}R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR#s   cC szt|}|js"|j|S|j|\}}}}t|jdra|j|}nt|d||S(s` Subtract two polynomials ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).sub(Poly(x - 2, x)) Poly(x**2 - x + 3, x, domain='ZZ') >>> Poly(x**2 + 1, x) - Poly(x - 2, x) Poly(x**2 - x + 3, x, domain='ZZ') tsub(RRFRRwRR9RR (RxRyRzR{R|R}R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRBs   cC szt|}|js"|j|S|j|\}}}}t|jdra|j|}nt|d||S(sp Multiply two polynomials ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).mul(Poly(x - 2, x)) Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ') >>> Poly(x**2 + 1, x)*Poly(x - 2, x) Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ') tmul(RRFRRwRR9RR (RxRyRzR{R|R}R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRas   cC s@t|jdr$|jj}nt|d|j|S(s3 Square a polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x - 2, x).sqr() Poly(x**2 - 4*x + 4, x, domain='ZZ') >>> Poly(x - 2, x)**2 Poly(x**2 - 4*x + 4, x, domain='ZZ') tsqr(RR9RR R{(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC sOt|}t|jdr3|jj|}nt|d|j|S(sX Raise ``f`` to a non-negative power ``n``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x - 2, x).pow(3) Poly(x**3 - 6*x**2 + 12*x - 8, x, domain='ZZ') >>> Poly(x - 2, x)**3 Poly(x**3 - 6*x**2 + 12*x - 8, x, domain='ZZ') tpow(RRR9RR R{(RxRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs  cC sj|j|\}}}}t|jdrE|j|\}}nt|d||||fS(s# Polynomial pseudo-division of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).pdiv(Poly(2*x - 4, x)) (Poly(2*x + 4, x, domain='ZZ'), Poly(20, x, domain='ZZ')) tpdiv(RwRR9RR (RxRyRzR{R|R}tqtr((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs cC sX|j|\}}}}t|jdr?|j|}nt|d||S(sN Polynomial pseudo-remainder of ``f`` by ``g``. Caveat: The function prem(f, g, x) can be safely used to compute in Z[x] _only_ subresultant polynomial remainder sequences (prs's). To safely compute Euclidean and Sturmian prs's in Z[x] employ anyone of the corresponding functions found in the module sympy.polys.subresultants_qq_zz. The functions in the module with suffix _pg compute prs's in Z[x] employing rem(f, g, x), whereas the functions with suffix _amv compute prs's in Z[x] employing rem_z(f, g, x). The function rem_z(f, g, x) differs from prem(f, g, x) in that to compute the remainder polynomials in Z[x] it premultiplies the divident times the absolute value of the leading coefficient of the divisor raised to the power degree(f, x) - degree(g, x) + 1. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).prem(Poly(2*x - 4, x)) Poly(20, x, domain='ZZ') tprem(RwRR9RR (RxRyRzR{R|R}R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs cC sX|j|\}}}}t|jdr?|j|}nt|d||S(s Polynomial pseudo-quotient of ``f`` by ``g``. See the Caveat note in the function prem(f, g). Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).pquo(Poly(2*x - 4, x)) Poly(2*x + 4, x, domain='ZZ') >>> Poly(x**2 - 1, x).pquo(Poly(2*x - 2, x)) Poly(2*x + 2, x, domain='ZZ') tpquo(RwRR9RR (RxRyRzR{R|R}R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs cC s|j|\}}}}t|jdrwy|j|}Wqtk rs}|j|j|jqXnt|d||S(s Polynomial exact pseudo-quotient of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).pexquo(Poly(2*x - 2, x)) Poly(2*x + 2, x, domain='ZZ') >>> Poly(x**2 + 1, x).pexquo(Poly(2*x - 4, x)) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 tpexquo(RwRR9RR'RPR`R (RxRyRzR{R|R}Rtexc((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR s%c C s|j|\}}}}t}|r\|jr\|j r\|j|j}}t}nt|jdr|j|\}} nt |d|ry|j | j } } Wnt k rqX| | }} n|||| fS(s Polynomial division with remainder of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).div(Poly(2*x - 4, x)) (Poly(1/2*x + 1, x, domain='QQ'), Poly(5, x, domain='QQ')) >>> Poly(x**2 + 1, x).div(Poly(2*x - 4, x), auto=False) (Poly(0, x, domain='ZZ'), Poly(x**2 + 1, x, domain='ZZ')) tdiv( RwRtis_Ringtis_FieldRdRcRR9RR RR"( RxRytautoRnR{R|R}RRRtQtR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR+s  c C s|j|\}}}}t}|r\|jr\|j r\|j|j}}t}nt|jdr|j|}nt |d|ry|j }Wqt k rqXn||S(so Computes the polynomial remainder of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).rem(Poly(2*x - 4, x)) Poly(5, x, domain='ZZ') >>> Poly(x**2 + 1, x).rem(Poly(2*x - 4, x), auto=False) Poly(x**2 + 1, x, domain='ZZ') trem( RwRRRRdRcRR9RR RR"( RxRyRRnR{R|R}RR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRRs  c C s|j|\}}}}t}|r\|jr\|j r\|j|j}}t}nt|jdr|j|}nt |d|ry|j }Wqt k rqXn||S(sa Computes polynomial quotient of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).quo(Poly(2*x - 4, x)) Poly(1/2*x + 1, x, domain='QQ') >>> Poly(x**2 - 1, x).quo(Poly(x - 1, x)) Poly(x + 1, x, domain='ZZ') tquo( RwRRRRdRcRR9RR RR"( RxRyRRnR{R|R}RR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRws  c C s|j|\}}}}t}|r\|jr\|j r\|j|j}}t}nt|jdry|j|}Wqt k r} | j |j |j qXnt |d|ry|j }Wqtk rqXn||S(s Computes polynomial exact quotient of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).exquo(Poly(x - 1, x)) Poly(x + 1, x, domain='ZZ') >>> Poly(x**2 + 1, x).exquo(Poly(2*x - 4, x)) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 texquo(RwRRRRdRcRR9RR'RPR`R RR"( RxRyRRnR{R|R}RRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs" % cC st|trrt|j}| |ko6|knrV|dkrO||S|Sqtd|||fn>y|jjt|SWn!tk rtd|nXdS(s3Returns level associated with the given generator. is -%s <= gen < %s expected, got %ss"a valid generator expected, got %sN(RARRNR:R%RRR(RxRrR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs  icC sD|j|}t|jdr1|jj|St|ddS(su Returns degree of ``f`` in ``x_j``. The degree of 0 is negative infinity. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + y*x + 1, x, y).degree() 2 >>> Poly(x**2 + y*x + y, x, y).degree(y) 1 >>> Poly(0, x).degree() -oo tdegreeN(RRR9RR (RxRrR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC s2t|jdr|jjSt|ddS(s Returns a list of degrees of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + y*x + 1, x, y).degree_list() (2, 1) t degree_listN(RR9RR (Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs cC s2t|jdr|jjSt|ddS(s Returns the total degree of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + y*x + 1, x, y).total_degree() 2 >>> Poly(x + y**5, x, y).total_degree() 5 t total_degreeN(RR9RR (Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs cC st|ts(tdt|n||jkrU|jj|}|j}nt|j}|j|f}t|jdr|j |jj |d|St |ddS(s Returns the homogeneous polynomial of ``f``. A homogeneous polynomial is a polynomial whose all monomials with non-zero coefficients have the same total degree. If you only want to check if a polynomial is homogeneous, then use :func:`Poly.is_homogeneous`. If you want not only to check if a polynomial is homogeneous but also compute its homogeneous order, then use :func:`Poly.homogeneous_order`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> f = Poly(x**5 + 2*x**2*y**2 + 9*x*y**3) >>> f.homogenize(z) Poly(x**5 + 2*x**2*y**2*z + 9*x*y**3*z, x, y, z, domain='ZZ') s``Symbol`` expected, got %st homogenizeR:thomogeneous_orderN( RARt TypeErrorttypeR:RRNRR9R{RR (RxtsRmR:((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs cC s2t|jdr|jjSt|ddS(s- Returns the homogeneous order of ``f``. A homogeneous polynomial is a polynomial whose all monomials with non-zero coefficients have the same total degree. This degree is the homogeneous order of ``f``. If you only want to check if a polynomial is homogeneous, then use :func:`Poly.is_homogeneous`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**5 + 2*x**3*y**2 + 9*x*y**4) >>> f.homogeneous_order() 5 RN(RR9RR (Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR?s cC sc|dk r|j|dSt|jdrA|jj}nt|d|jjj|S(s Returns the leading coefficient of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(4*x**3 + 2*x**2 + 3*x, x).LC() 4 itLCN(RVRqRR9RR RnR(RxR;R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRXs  cC sFt|jdr$|jj}nt|d|jjj|S(s Returns the trailing coefficient of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x**2 + 3*x, x).TC() 0 tTC(RR9RR RnR(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRpscC s6t|jdr#|j|dSt|ddS(s Returns the last non-zero coefficient of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x**2 + 3*x, x).EC() 3 RqitECN(RR9RqR (RxR;((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC s|jt||jjS(sE Returns the coefficient of ``monom`` in ``f`` if there, else None. Examples ======== >>> from sympy import Poly, exp >>> from sympy.abc import x, y >>> p = Poly(24*x*y*exp(8) + 23*x, x, y) >>> p.coeff_monomial(x) 23 >>> p.coeff_monomial(y) 0 >>> p.coeff_monomial(x*y) 24*exp(8) Note that ``Expr.coeff()`` behaves differently, collecting terms if possible; the Poly must be converted to an Expr to use that method, however: >>> p.as_expr().coeff(x) 24*y*exp(8) + 23 >>> p.as_expr().coeff(y) 24*x*exp(8) >>> p.as_expr().coeff(x*y) 24*exp(8) See Also ======== nth: more efficient query using exponents of the monomial's generators (tnthRR:t exponents(RxRZ((s4lib/python2.7/site-packages/sympy/polys/polytools.pytcoeff_monomials#cG st|jdr`t|t|jkr<tdn|jjttt|}nt |d|jj j |S(s. Returns the ``n``-th coefficient of ``f`` where ``N`` are the exponents of the generators in the term of interest. Examples ======== >>> from sympy import Poly, sqrt >>> from sympy.abc import x, y >>> Poly(x**3 + 2*x**2 + 3*x, x).nth(2) 2 >>> Poly(x**3 + 2*x*y**2 + y**2, x, y).nth(1, 2) 2 >>> Poly(4*sqrt(x)*y) Poly(4*y*(sqrt(x)), y, sqrt(x), domain='ZZ') >>> _.nth(1, 1) 4 See Also ======== coeff_monomial Rs,exponent of each generator must be specified( RR9RNR:RRRER\RR RnR(RxtNR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs $icC stddS(NsyEither convert to Expr with `as_expr` method to use Expr's coeff method or else use the `coeff_monomial` method of Polys.(R?(RxRRtright((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR[scC st|j|d|jS(s Returns the leading monomial of ``f``. The Leading monomial signifies the monomial having the highest power of the principal generator in the expression f. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).LM() x**2*y**0 i(RRiR:(RxR;((s4lib/python2.7/site-packages/sympy/polys/polytools.pytLMscC st|j|d|jS(s Returns the last non-zero monomial of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).EM() x**0*y**1 i(RRiR:(RxR;((s4lib/python2.7/site-packages/sympy/polys/polytools.pytEMscC s/|j|d\}}t||j|fS(s Returns the leading term of ``f``. The Leading term signifies the term having the highest power of the principal generator in the expression f along with its coefficient. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).LT() (x**2*y**0, 4) i(RRR:(RxR;RZR[((s4lib/python2.7/site-packages/sympy/polys/polytools.pytLTscC s/|j|d\}}t||j|fS(s Returns the last non-zero term of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).ET() (x**0*y**1, 3) i(RRR:(RxR;RZR[((s4lib/python2.7/site-packages/sympy/polys/polytools.pytET$scC sFt|jdr$|jj}nt|d|jjj|S(s Returns maximum norm of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(-x**2 + 2*x - 3, x).max_norm() 3 tmax_norm(RR9RR RnR(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR5scC sFt|jdr$|jj}nt|d|jjj|S(s Returns l1 norm of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(-x**2 + 2*x - 3, x).l1_norm() 6 tl1_norm(RR9RR RnR(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRJscC s|}|jjjs"tj|fS|j}|jrL|jjj}nt|jdrv|jj \}}nt |d|j ||j |}}| s|j r||fS||j fSdS(s Clear denominators, but keep the ground domain. Examples ======== >>> from sympy import Poly, S, QQ >>> from sympy.abc import x >>> f = Poly(x/2 + S(1)/3, x, domain=QQ) >>> f.clear_denoms() (6, Poly(3*x + 2, x, domain='QQ')) >>> f.clear_denoms(convert=True) (6, Poly(3*x + 2, x, domain='ZZ')) t clear_denomsN(R9RnRRtOneRsthas_assoc_Ringtget_ringRRR RR{R(ReRXRxRnR[R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR_s    cC s|}|j|\}}}}||}||}|joH|jsU||fS|jdt\}}|jdt\}}|j|}|j|}||fS(s Clear denominators in a rational function ``f/g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2/y + 1, x) >>> g = Poly(x**3 + y, x) >>> p, q = f.rat_clear_denoms(g) >>> p Poly(x**2 + y, x, domain='ZZ[y]') >>> q Poly(y*x**3 + y**2, x, domain='ZZ[y]') RX(RwRRRRcR(ReRyRxRnR{tatb((s4lib/python2.7/site-packages/sympy/polys/polytools.pytrat_clear_denomss   cO s|}|jdtr6|jjjr6|j}nt|jdr|sj|j|jjddS|j}x]|D]U}t |t kr|\}}n |d}}|jt ||j |}qzW|j|St |ddS(s Computes indefinite integral of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x + 1, x).integrate() Poly(1/3*x**3 + x**2 + x, x, domain='QQ') >>> Poly(x*y**2 + x, x, y).integrate((0, 1), (1, 0)) Poly(1/2*x**2*y**2 + 1/2*x**2, x, y, domain='QQ') Rt integrateRiN(tgetRcR9RnRRdRR{RRRRRR (RetspecsRJRxR9tspecRrR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs!   % cO s|jdts"t|||St|jdr|sV|j|jjddS|j}x]|D]U}t|tkr|\}}n |d}}|jt ||j |}qfW|j|St |ddS(sX Computes partial derivative of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x + 1, x).diff() Poly(2*x + 2, x, domain='ZZ') >>> Poly(x*y**2 + x, x, y).diff((0, 0), (1, 1)) Poly(2*x*y, x, y, domain='ZZ') tevaluatetdiffRiN( RRcRRR9R{R RRRRR (RxRtkwargsR9RRrR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR s   % c C s|}|dkrt|trZ|}x,|jD]\}}|j||}q4W|St|ttfr|}t|t|jkrt dnx2t |j|D]\}}|j||}qW|Sd|} }n|j |} t |j dst|dny|j j|| } Wntk r|sitd||j jfqt|g\} \}|jj| |j} |j| }| j|| }|j j|| } nX|j| d| S(s Evaluate ``f`` at ``a`` in the given variable. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(x**2 + 2*x + 3, x).eval(2) 11 >>> Poly(2*x*y + 3*x + y + 2, x, y).eval(x, 2) Poly(5*y + 8, y, domain='ZZ') >>> f = Poly(2*x*y + 3*x + y + 2*z, x, y, z) >>> f.eval({x: 2}) Poly(5*y + 2*z + 6, y, z, domain='ZZ') >>> f.eval({x: 2, y: 5}) Poly(2*z + 31, z, domain='ZZ') >>> f.eval({x: 2, y: 5, z: 7}) 45 >>> f.eval((2, 5)) Poly(2*z + 31, z, domain='ZZ') >>> f(2, 5) Poly(2*z + 31, z, domain='ZZ') stoo many values providediRscan't evaluate at %s in %sRN(RVRARBRWRRRERNR:RRRRR9R R"R!RnRRstunify_with_symbolsRbRXR{( ReRRRRxRRrRtvaluesRRta_domaint new_domain((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs:  cG s |j|S(sz Evaluate ``f`` at the give values. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> f = Poly(2*x*y + 3*x + y + 2*z, x, y, z) >>> f(2) Poly(5*y + 2*z + 6, y, z, domain='ZZ') >>> f(2, 5) Poly(2*z + 31, z, domain='ZZ') >>> f(2, 5, 7) 45 (R(RxR ((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__call__H sc C s|j|\}}}}|rF|jrF|j|j}}nt|jdrp|j|\}}nt|d||||fS(s Half extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15 >>> g = x**3 + x**2 - 4*x - 4 >>> Poly(f).half_gcdex(Poly(g)) (Poly(-1/5*x + 3/5, x, domain='QQ'), Poly(x + 1, x, domain='QQ')) t half_gcdex(RwRRdRR9RR ( RxRyRRnR{R|R}Rth((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR^ sc C s|j|\}}}}|rF|jrF|j|j}}nt|jdrs|j|\}}} nt|d|||||| fS(s Extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15 >>> g = x**3 + x**2 - 4*x - 4 >>> Poly(f).gcdex(Poly(g)) (Poly(-1/5*x + 3/5, x, domain='QQ'), Poly(1/5*x**2 - 6/5*x + 2, x, domain='QQ'), Poly(x + 1, x, domain='QQ')) tgcdex(RwRRdRR9RR ( RxRyRRnR{R|R}RttR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR} scC s|j|\}}}}|rF|jrF|j|j}}nt|jdrj|j|}nt|d||S(s Invert ``f`` modulo ``g`` when possible. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).invert(Poly(2*x - 1, x)) Poly(-4/3, x, domain='QQ') >>> Poly(x**2 - 1, x).invert(Poly(x - 1, x)) Traceback (most recent call last): ... NotInvertible: zero divisor tinvert(RwRRdRR9RR (RxRyRRnR{R|R}R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR scC sIt|jdr-|jjt|}nt|d|j|S(sc Compute ``f**(-1)`` mod ``x**n``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(1, x).revert(2) Poly(1, x, domain='ZZ') >>> Poly(1 + x, x).revert(1) Poly(1, x, domain='ZZ') >>> Poly(x**2 - 1, x).revert(1) Traceback (most recent call last): ... NotReversible: only unity is reversible in a ring >>> Poly(1/x, x).revert(1) Traceback (most recent call last): ... PolynomialError: 1/x contains an element of the generators set trevert(RR9RRR R{(RxRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR scC sa|j|\}}}}t|jdr?|j|}nt|dtt||S(sd Computes the subresultant PRS of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).subresultants(Poly(x**2 - 1, x)) [Poly(x**2 + 1, x, domain='ZZ'), Poly(x**2 - 1, x, domain='ZZ'), Poly(-2, x, domain='ZZ')] t subresultants(RwRR9RR RER\(RxRyRzR{R|R}R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR s c C s|j|\}}}}t|jdrc|rQ|j|d|\}}qr|j|}nt|d|r||ddtt||fS||ddS(s Computes the resultant of ``f`` and ``g`` via PRS. If includePRS=True, it includes the subresultant PRS in the result. Because the PRS is used to calculate the resultant, this is more efficient than calling :func:`subresultants` separately. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**2 + 1, x) >>> f.resultant(Poly(x**2 - 1, x)) 4 >>> f.resultant(Poly(x**2 - 1, x), includePRS=True) (4, [Poly(x**2 + 1, x, domain='ZZ'), Poly(x**2 - 1, x, domain='ZZ'), Poly(-2, x, domain='ZZ')]) t resultantt includePRSRi(RwRR9RR RER\( RxRyRRzR{R|R}RR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR s%cC sFt|jdr$|jj}nt|d|j|ddS(s Computes the discriminant of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 2*x + 3, x).discriminant() -8 t discriminantRi(RR9RR R{(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR scC sddlm}|||S(sCompute the *dispersion set* of two polynomials. For two polynomials `f(x)` and `g(x)` with `\deg f > 0` and `\deg g > 0` the dispersion set `\operatorname{J}(f, g)` is defined as: .. math:: \operatorname{J}(f, g) & := \{a \in \mathbb{N}_0 | \gcd(f(x), g(x+a)) \neq 1\} \\ & = \{a \in \mathbb{N}_0 | \deg \gcd(f(x), g(x+a)) \geq 1\} For a single polynomial one defines `\operatorname{J}(f) := \operatorname{J}(f, f)`. Examples ======== >>> from sympy import poly >>> from sympy.polys.dispersion import dispersion, dispersionset >>> from sympy.abc import x Dispersion set and dispersion of a simple polynomial: >>> fp = poly((x - 3)*(x + 3), x) >>> sorted(dispersionset(fp)) [0, 6] >>> dispersion(fp) 6 Note that the definition of the dispersion is not symmetric: >>> fp = poly(x**4 - 3*x**2 + 1, x) >>> gp = fp.shift(-3) >>> sorted(dispersionset(fp, gp)) [2, 3, 4] >>> dispersion(fp, gp) 4 >>> sorted(dispersionset(gp, fp)) [] >>> dispersion(gp, fp) -oo Computing the dispersion also works over field extensions: >>> from sympy import sqrt >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ') >>> sorted(dispersionset(fp, gp)) [2] >>> sorted(dispersionset(gp, fp)) [1, 4] We can even perform the computations for polynomials having symbolic coefficients: >>> from sympy.abc import a >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x) >>> sorted(dispersionset(fp)) [0, 1] See Also ======== dispersion References ========== 1. [ManWright94]_ 2. [Koepf98]_ 3. [Abramov71]_ 4. [Man93]_ i(t dispersionset(tsympy.polys.dispersionR(RxRyR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR2 sHcC sddlm}|||S(sCompute the *dispersion* of polynomials. For two polynomials `f(x)` and `g(x)` with `\deg f > 0` and `\deg g > 0` the dispersion `\operatorname{dis}(f, g)` is defined as: .. math:: \operatorname{dis}(f, g) & := \max\{ J(f,g) \cup \{0\} \} \\ & = \max\{ \{a \in \mathbb{N} | \gcd(f(x), g(x+a)) \neq 1\} \cup \{0\} \} and for a single polynomial `\operatorname{dis}(f) := \operatorname{dis}(f, f)`. Examples ======== >>> from sympy import poly >>> from sympy.polys.dispersion import dispersion, dispersionset >>> from sympy.abc import x Dispersion set and dispersion of a simple polynomial: >>> fp = poly((x - 3)*(x + 3), x) >>> sorted(dispersionset(fp)) [0, 6] >>> dispersion(fp) 6 Note that the definition of the dispersion is not symmetric: >>> fp = poly(x**4 - 3*x**2 + 1, x) >>> gp = fp.shift(-3) >>> sorted(dispersionset(fp, gp)) [2, 3, 4] >>> dispersion(fp, gp) 4 >>> sorted(dispersionset(gp, fp)) [] >>> dispersion(gp, fp) -oo Computing the dispersion also works over field extensions: >>> from sympy import sqrt >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ') >>> sorted(dispersionset(fp, gp)) [2] >>> sorted(dispersionset(gp, fp)) [1, 4] We can even perform the computations for polynomials having symbolic coefficients: >>> from sympy.abc import a >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x) >>> sorted(dispersionset(fp)) [0, 1] See Also ======== dispersionset References ========== 1. [ManWright94]_ 2. [Koepf98]_ 3. [Abramov71]_ 4. [Man93]_ i(t dispersion(RR(RxRyR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR} sHc C sv|j|\}}}}t|jdrH|j|\}}}nt|d||||||fS(s# Returns the GCD of ``f`` and ``g`` and their cofactors. Returns polynomials ``(h, cff, cfg)`` such that ``h = gcd(f, g)``, and ``cff = quo(f, h)`` and ``cfg = quo(g, h)`` are, so called, cofactors of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).cofactors(Poly(x**2 - 3*x + 2, x)) (Poly(x - 1, x, domain='ZZ'), Poly(x + 1, x, domain='ZZ'), Poly(x - 2, x, domain='ZZ')) t cofactors(RwRR9RR ( RxRyRzR{R|R}Rtcfftcfg((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR s cC sX|j|\}}}}t|jdr?|j|}nt|d||S(s  Returns the polynomial GCD of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).gcd(Poly(x**2 - 3*x + 2, x)) Poly(x - 1, x, domain='ZZ') tgcd(RwRR9R!R (RxRyRzR{R|R}R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR! s cC sX|j|\}}}}t|jdr?|j|}nt|d||S(s Returns polynomial LCM of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).lcm(Poly(x**2 - 3*x + 2, x)) Poly(x**3 - 2*x**2 - x + 2, x, domain='ZZ') tlcm(RwRR9R"R (RxRyRzR{R|R}R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR" s cC sX|jjj|}t|jdr<|jj|}nt|d|j|S(s Reduce ``f`` modulo a constant ``p``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**3 + 3*x**2 + 5*x + 7, x).trunc(3) Poly(-x**3 - x + 1, x, domain='ZZ') ttrunc(R9RnRXRR#R R{(RxtpR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR# s cC sj|}|r*|jjjr*|j}nt|jdrN|jj}nt|d|j|S(sz Divides all coefficients by ``LC(f)``. Examples ======== >>> from sympy import Poly, ZZ >>> from sympy.abc import x >>> Poly(3*x**2 + 6*x + 9, x, domain=ZZ).monic() Poly(x**2 + 2*x + 3, x, domain='QQ') >>> Poly(3*x**2 + 4*x + 2, x, domain=ZZ).monic() Poly(x**2 + 4/3*x + 2/3, x, domain='QQ') tmonic(R9RnRRdRR%R R{(ReRRxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR%* scC sFt|jdr$|jj}nt|d|jjj|S(s Returns the GCD of polynomial coefficients. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(6*x**2 + 8*x + 12, x).content() 2 tcontent(RR9R&R RnR(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR&G scC s[t|jdr*|jj\}}nt|d|jjj||j|fS(s Returns the content and a primitive form of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**2 + 8*x + 12, x).primitive() (2, Poly(x**2 + 4*x + 6, x, domain='ZZ')) t primitive(RR9R'R RnRR{(RxtcontR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR'\ scC sX|j|\}}}}t|jdr?|j|}nt|d||S(s Computes the functional composition of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + x, x).compose(Poly(x - 1, x)) Poly(x**2 - x, x, domain='ZZ') tcompose(RwRR9R)R (RxRyRzR{R|R}R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR)q s cC sIt|jdr$|jj}nt|dtt|j|S(s= Computes a functional decomposition of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**4 + 2*x**3 - x - 1, x, domain='ZZ').decompose() [Poly(x**2 - x - 1, x, domain='ZZ'), Poly(x**2 + x, x, domain='ZZ')] t decompose(RR9R*R RER\R{(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR* scC sCt|jdr'|jj|}nt|d|j|S(s Efficiently compute Taylor shift ``f(x + a)``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 2*x + 1, x).shift(2) Poly(x**2 + 2*x + 1, x, domain='ZZ') tshift(RR9R+R R{(RxRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR+ scC s|j|\}}|j|\}}|j|\}}t|jdro|jj|j|j}nt|d|j|S(s3 Efficiently evaluate the functional transformation ``q**n * f(p/q)``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 2*x + 1, x).transform(Poly(x + 1, x), Poly(x - 1, x)) Poly(4, x, domain='ZZ') t transform(R~RR9R,R R{(RxR$RtPRR|R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR, scC ss|}|r*|jjjr*|j}nt|jdrN|jj}nt|dtt|j |S(s Computes the Sturm sequence of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 - 2*x**2 + x - 3, x).sturm() [Poly(x**3 - 2*x**2 + x - 3, x, domain='QQ'), Poly(3*x**2 - 4*x + 1, x, domain='QQ'), Poly(2/9*x + 25/9, x, domain='QQ'), Poly(-2079/4, x, domain='QQ')] tsturm( R9RnRRdRR.R RER\R{(ReRRxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR. scC s_t|jdr$|jj}nt|dg|D]!\}}|j||f^q:S(sI Computes greatest factorial factorization of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**5 + 2*x**4 - x**3 - 2*x**2 >>> Poly(f).gff_list() [(Poly(x, x, domain='ZZ'), 1), (Poly(x + 2, x, domain='ZZ'), 4)] tgff_list(RR9R/R R{(RxRRyR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR/ scC s@t|jdr$|jj}nt|d|j|S(s Computes the product, ``Norm(f)``, of the conjugates of a polynomial ``f`` defined over a number field ``K``. Examples ======== >>> from sympy import Poly, sqrt >>> from sympy.abc import x >>> a, b = sqrt(2), sqrt(3) A polynomial over a quadratic extension. Two conjugates x - a and x + a. >>> f = Poly(x - a, x, extension=a) >>> f.norm() Poly(x**2 - 2, x, domain='QQ') A polynomial over a quartic extension. Four conjugates x - a, x - a, x + a and x + a. >>> f = Poly(x - a, x, extension=(a, b)) >>> f.norm() Poly(x**4 - 4*x**2 + 4, x, domain='QQ') tnorm(RR9R0R R{(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR0 scC s[t|jdr-|jj\}}}nt|d||j||j|fS(sf Computes square-free norm of ``f``. Returns ``s``, ``f``, ``r``, such that ``g(x) = f(x-sa)`` and ``r(x) = Norm(g(x))`` is a square-free polynomial over ``K``, where ``a`` is the algebraic extension of the ground domain. Examples ======== >>> from sympy import Poly, sqrt >>> from sympy.abc import x >>> s, f, r = Poly(x**2 + 1, x, extension=[sqrt(3)]).sqf_norm() >>> s 1 >>> f Poly(x**2 - 2*sqrt(3)*x + 4, x, domain='QQ') >>> r Poly(x**4 - 4*x**2 + 16, x, domain='QQ') tsqf_norm(RR9R1R R{(RxRRyR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR1# scC s@t|jdr$|jj}nt|d|j|S(s Computes square-free part of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 - 3*x - 2, x).sqf_part() Poly(x**2 - x - 2, x, domain='ZZ') tsqf_part(RR9R2R R{(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR2B scC s}t|jdr-|jj|\}}nt|d|jjj|g|D]!\}}|j||f^qUfS(s  Returns a list of square-free factors of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = 2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16 >>> Poly(f).sqf_list() (2, [(Poly(x + 1, x, domain='ZZ'), 2), (Poly(x + 2, x, domain='ZZ'), 3)]) >>> Poly(f).sqf_list(all=True) (2, [(Poly(1, x, domain='ZZ'), 1), (Poly(x + 1, x, domain='ZZ'), 2), (Poly(x + 2, x, domain='ZZ'), 3)]) tsqf_list(RR9R3R RnRR{(RxtallR[tfactorsRyR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR3W scC sbt|jdr'|jj|}nt|dg|D]!\}}|j||f^q=S(s Returns a list of square-free factors of ``f``. Examples ======== >>> from sympy import Poly, expand >>> from sympy.abc import x >>> f = expand(2*(x + 1)**3*x**4) >>> f 2*x**7 + 6*x**6 + 6*x**5 + 2*x**4 >>> Poly(f).sqf_list_include() [(Poly(2, x, domain='ZZ'), 1), (Poly(x + 1, x, domain='ZZ'), 3), (Poly(x, x, domain='ZZ'), 4)] >>> Poly(f).sqf_list_include(all=True) [(Poly(2, x, domain='ZZ'), 1), (Poly(1, x, domain='ZZ'), 2), (Poly(x + 1, x, domain='ZZ'), 3), (Poly(x, x, domain='ZZ'), 4)] tsqf_list_include(RR9R6R R{(RxR4R5RyR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR6t scC st|jdrUy|jj\}}Wqdtk rQtj|dfgfSXnt|d|jjj|g|D]!\}}|j ||f^q}fS(s~ Returns a list of irreducible factors of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = 2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y >>> Poly(f).factor_list() (2, [(Poly(x + y, x, y, domain='ZZ'), 1), (Poly(x**2 + 1, x, y, domain='ZZ'), 2)]) t factor_listi( RR9R7R!RRR RnRR{(RxR[R5RyR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR7 s cC st|jdrFy|jj}WqUtk rB|dfgSXnt|dg|D]!\}}|j||f^q\S(s Returns a list of irreducible factors of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = 2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y >>> Poly(f).factor_list_include() [(Poly(2*x + 2*y, x, y, domain='ZZ'), 1), (Poly(x**2 + 1, x, y, domain='ZZ'), 2)] tfactor_list_includei(RR9R8R!R R{(RxR5RyR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR8 s c C s|dk r9tj|}|dkr9tdq9n|dk rWtj|}n|dk rutj|}nt|jdr|jjd|d|d|d|d|d |}nt|d|r1d }|stt ||Sd } |\} } tt || tt | | fSd }|sStt ||Sd } |\} } tt || tt | | fSdS(s Compute isolating intervals for roots of ``f``. For real roots the Vincent-Akritas-Strzebonski (VAS) continued fractions method is used. References ========== .. [#] Alkiviadis G. Akritas and Adam W. Strzebonski: A Comparative Study of Two Real Root Isolation Methods . Nonlinear Analysis: Modelling and Control, Vol. 10, No. 4, 297-304, 2005. .. [#] Alkiviadis G. Akritas, Adam W. Strzebonski and Panagiotis S. Vigklas: Improving the Performance of the Continued Fractions Method Using new Bounds of Positive Roots. Nonlinear Analysis: Modelling and Control, Vol. 13, No. 3, 265-279, 2008. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 3, x).intervals() [((-2, -1), 1), ((1, 2), 1)] >>> Poly(x**2 - 3, x).intervals(eps=1e-2) [((-26/15, -19/11), 1), ((19/11, 26/15), 1)] is!'eps' must be a positive rationalt intervalsR4tepstinftsuptfasttsqfcS s(|\}}tj|tj|fS(N(RR(tintervalRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt_real s cS sV|\\}}\}}tj|ttj|tj|ttj|fS(N(RRR(t rectangletutvRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt_complex scS s4|\\}}}tj|tj|f|fS(N(RR(R?RRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR@ scS sb|\\\}}\}}}tj|ttj|tj|ttj|f|fS(N(RRR(RARBRCRRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRD sN( RVRRXRRR9R9R RER\( RxR4R:R;R<R=R>RR@RDt real_partt complex_part((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR9 s2     *   (   c C s|r|j rtdntj|tj|}}|d k rwtj|}|dkrwtdqwn|d k rt|}n|d krd}nt|jdr|jj ||d|d|d|\}}nt |dtj |tj |fS( s Refine an isolating interval of a root to the given precision. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 3, x).refine_root(1, 2, eps=1e-2) (19/11, 26/15) s&only square-free polynomials supportedis!'eps' must be a positive rationalit refine_rootR:tstepsR=N( tis_sqfR%RRXRVRRRR9RGR R( RxRRR:RHR=t check_sqfRtT((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRG s     0cC stt}}|dk rt|}|tjkr=d}q|j\}}|sgtj|}qtt tj||ft }}n|dk rt|}|tj krd}q|j\}}|stj|}qtt tj||ft }}n|r_|r_t |j drM|j jd|d|}qt|dn|r|dk r|tjf}n|r|dk r|tjf}nt |j dr|j jd|d|}nt|dt|S(s< Return the number of roots of ``f`` in ``[inf, sup]`` interval. Examples ======== >>> from sympy import Poly, I >>> from sympy.abc import x >>> Poly(x**4 - 4, x).count_roots(-3, 3) 2 >>> Poly(x**4 - 4, x).count_roots(0, 1 + 3*I) 1 tcount_real_rootsR;R<tcount_complex_rootsN(RcRVRRtNegativeInfinityt as_real_imagRRXRER\RtInfinityRR9RLR RtRMR(RxR;R<tinf_realtsup_realtretimtcount((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt count_roots< s:    (   ( cC stjjj||d|S(s  Get an indexed root of a polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(2*x**3 - 7*x**2 + 4*x + 4) >>> f.root(0) -1/2 >>> f.root(1) 2 >>> f.root(2) 2 >>> f.root(3) Traceback (most recent call last): ... IndexError: root index out of [-3, 2] range, got 3 >>> Poly(x**5 + x + 1).root(0) CRootOf(x**3 - x**2 + 1, 0) tradicals(tsympytpolyst rootoftoolstrootof(RxRRW((s4lib/python2.7/site-packages/sympy/polys/polytools.pytroot{ scC s<tjjjj|d|}|r(|St|dtSdS(sL Return a list of real roots with multiplicities. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**3 - 7*x**2 + 4*x + 4).real_roots() [-1/2, 2, 2] >>> Poly(x**3 + x + 1).real_roots() [CRootOf(x**3 + x + 1, 0)] RWtmultipleN(RXRYRZtCRootOft real_rootsR3R(RxR]RWtreals((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR_ scC s<tjjjj|d|}|r(|St|dtSdS(s Return a list of real and complex roots with multiplicities. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**3 - 7*x**2 + 4*x + 4).all_roots() [-1/2, 2, 2] >>> Poly(x**3 + x + 1).all_roots() [CRootOf(x**3 + x + 1, 0), CRootOf(x**3 + x + 1, 1), CRootOf(x**3 + x + 1, 2)] RWR]N(RXRYRZR^t all_rootsR3R(RxR]RWtroots((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRa sii2c  s2ddlm|jr,td|n|jdkrBgS|jjtkr|g|jD]}t |^qa}n|jjt krg|jD]}|j ^q}ddl m }||}g|jD]}t ||^q}ng|jD]}|jd|j^q}y&g|D]}tj|^q3}Wn'tk rxtd|jjnXtjj} |tj_zy_tj|d|d |d td |jd } tttt| d fd} Wn'tk rtd||fnXWd| tj_X| S(s Compute numerical approximations of roots of ``f``. Parameters ========== n ... the number of digits to calculate maxsteps ... the maximum number of iterations to do If the accuracy `n` cannot be reached in `maxsteps`, it will raise an exception. You need to rerun with higher maxsteps. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 3).nroots(n=15) [-1.73205080756888, 1.73205080756888] >>> Poly(x**2 - 3).nroots(n=30) [-1.73205080756887729352744634151, 1.73205080756887729352744634151] i(tsigns#can't compute numerical roots of %si(tilcmRs!Numerical domain expected, got %stmaxstepstcleanupterrort extrapreci tkeyc s4|jrdnd|jt|j|jfS(Nii(timagtrealR(R(Rc(s4lib/python2.7/site-packages/sympy/polys/polytools.pytts7convergence to root failed; try n < %s or maxsteps > %sN(t$sympy.functions.elementary.complexesRctis_multivariateR&RR9RnRRRRRtsympy.core.numbersRdtevalfROtmpmathtmpcRR!tmptdpst polyrootsRRER\RtsortedR7( RxRReRfR[RqtdenomsRdtfacRuRb((Rcs4lib/python2.7/site-packages/sympy/polys/polytools.pytnroots sD (" ,.&    %  cC st|jrtd|ni}xK|jdD]9\}}|jr3|j\}}||| |>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**6 - 4*x**4 + 4*x**3 - x**2).ground_roots() {0: 2, 1: 2} s can't compute ground roots of %si(RoR&R7t is_linearR(RxRbtfactorRRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt ground_rootss  cC s|jrtdnt|}|jrH|dkrHt|}ntd||j}td}|j|j j |||||}|j ||S(sf Construct a polynomial with n-th powers of roots of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**4 - x**2 + 1) >>> f.nth_power_roots_poly(2) Poly(x**4 - 2*x**3 + 3*x**2 - 2*x + 1, x, domain='ZZ') >>> f.nth_power_roots_poly(3) Poly(x**4 + 2*x**2 + 1, x, domain='ZZ') >>> f.nth_power_roots_poly(4) Poly(x**4 + 2*x**3 + 3*x**2 + 2*x + 1, x, domain='ZZ') >>> f.nth_power_roots_poly(12) Poly(x**4 - 4*x**3 + 6*x**2 - 4*x + 1, x, domain='ZZ') smust be a univariate polynomialis&'n' must an integer and n >= 1, got %sR( RoR&Rt is_IntegerRRRrR RR]RTR(RxRRRRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pytnth_power_roots_poly-s     )c C s|j|\}}}}t|drB|j|d|}nt|d|s|jro|j}n|\}} } } |j|}|j| } || || || fStt||SdS(s Cancel common factors in a rational function ``f/g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**2 - 2, x).cancel(Poly(x**2 - 2*x + 1, x)) (1, Poly(2*x + 2, x, domain='ZZ'), Poly(x - 1, x, domain='ZZ')) >>> Poly(2*x**2 - 2, x).cancel(Poly(x**2 - 2*x + 1, x), include=True) (Poly(2*x + 2, x, domain='ZZ'), Poly(x - 1, x, domain='ZZ')) tcanceltincludeN( RwRRR RRRRR\( RxRyRRnR{R|R}RtcptcqR$R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRUs cC s |jjS(s Returns ``True`` if ``f`` is a zero polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(0, x).is_zero True >>> Poly(1, x).is_zero False (R9tis_zero(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRzscC s |jjS(s Returns ``True`` if ``f`` is a unit polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(0, x).is_one False >>> Poly(1, x).is_one True (R9tis_one(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC s |jjS(s  Returns ``True`` if ``f`` is a square-free polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 2*x + 1, x).is_sqf False >>> Poly(x**2 - 1, x).is_sqf True (R9RI(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRIscC s |jjS(s  Returns ``True`` if the leading coefficient of ``f`` is one. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 2, x).is_monic True >>> Poly(2*x + 2, x).is_monic False (R9tis_monic(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC s |jjS(s; Returns ``True`` if GCD of the coefficients of ``f`` is one. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**2 + 6*x + 12, x).is_primitive False >>> Poly(x**2 + 3*x + 6, x).is_primitive True (R9t is_primitive(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC s |jjS(sJ Returns ``True`` if ``f`` is an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x, x).is_ground False >>> Poly(2, x).is_ground True >>> Poly(y, x).is_ground True (R9t is_ground(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC s |jjS(s, Returns ``True`` if ``f`` is linear in all its variables. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x + y + 2, x, y).is_linear True >>> Poly(x*y + 2, x, y).is_linear False (R9R{(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR{scC s |jjS(s6 Returns ``True`` if ``f`` is quadratic in all its variables. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x*y + 2, x, y).is_quadratic True >>> Poly(x*y**2 + 2, x, y).is_quadratic False (R9t is_quadratic(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC s |jjS(s% Returns ``True`` if ``f`` is zero or has only one term. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(3*x**2, x).is_monomial True >>> Poly(3*x**2 + 1, x).is_monomial False (R9t is_monomial(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC s |jjS(sZ Returns ``True`` if ``f`` is a homogeneous polynomial. A homogeneous polynomial is a polynomial whose all monomials with non-zero coefficients have the same total degree. If you want not only to check if a polynomial is homogeneous but also compute its homogeneous order, then use :func:`Poly.homogeneous_order`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + x*y, x, y).is_homogeneous True >>> Poly(x**3 + x*y, x, y).is_homogeneous False (R9tis_homogeneous(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR'scC s |jjS(sG Returns ``True`` if ``f`` has no factors over its domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + x + 1, x, modulus=2).is_irreducible True >>> Poly(x**2 + 1, x, modulus=2).is_irreducible False (R9tis_irreducible(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR?scC st|jdkS(s Returns ``True`` if ``f`` is a univariate polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + x + 1, x).is_univariate True >>> Poly(x*y**2 + x*y + 1, x, y).is_univariate False >>> Poly(x*y**2 + x*y + 1, x).is_univariate True >>> Poly(x**2 + x + 1, x, y).is_univariate False i(RNR:(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRRscC st|jdkS(s Returns ``True`` if ``f`` is a multivariate polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + x + 1, x).is_multivariate False >>> Poly(x*y**2 + x*y + 1, x, y).is_multivariate True >>> Poly(x*y**2 + x*y + 1, x).is_multivariate False >>> Poly(x**2 + x + 1, x, y).is_multivariate True i(RNR:(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRoiscC s |jjS(s Returns ``True`` if ``f`` is a cyclotomic polnomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**16 + x**14 - x**10 + x**8 - x**6 + x**2 + 1 >>> Poly(f).is_cyclotomic False >>> g = x**16 + x**14 - x**10 - x**8 - x**6 + x**2 + 1 >>> Poly(g).is_cyclotomic True (R9t is_cyclotomic(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC s |jS(N(R(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__abs__scC s |jS(N(R(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__neg__sRycC sQ|jsDy|j||j}WqDtk r@|j|SXn|j|S(N(RFR]R:R%R`R(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__add__s   cC sQ|jsDy|j||j}WqDtk r@||jSXn|j|S(N(RFR]R:R%R`R(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__radd__s   cC sQ|jsDy|j||j}WqDtk r@|j|SXn|j|S(N(RFR]R:R%R`R(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__sub__s   cC sQ|jsDy|j||j}WqDtk r@||jSXn|j|S(N(RFR]R:R%R`R(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__rsub__s   cC sQ|jsDy|j||j}WqDtk r@|j|SXn|j|S(N(RFR]R:R%R`R(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__mul__s   cC sQ|jsDy|j||j}WqDtk r@||jSXn|j|S(N(RFR]R:R%R`R(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__rmul__s   RcC s4|jr"|dkr"|j|S|j|SdS(Ni(R~RR`(RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__pow__s cC s.|js!|j||j}n|j|S(N(RFR]R:R(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt __divmod__s cC s.|js!|j||j}n|j|S(N(RFR]R:R(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt __rdivmod__s cC s.|js!|j||j}n|j|S(N(RFR]R:R(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__mod__s cC s.|js!|j||j}n|j|S(N(RFR]R:R(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__rmod__s cC s.|js!|j||j}n|j|S(N(RFR]R:R(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt __floordiv__s cC s.|js!|j||j}n|j|S(N(RFR]R:R(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt __rfloordiv__s cC s|j|jS(N(R`(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__div__ scC s|j|jS(N(R`(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__rdiv__stothercC s||}}|js\y%|j||jd|j}Wq\tttfk rXtSXn|j|jkrrtS|jj |jj kry%|jj j |jj |j}Wnt k rtSX|j |}|j |}n|j|jkS(NRU( RFR]R:RsR%R!R"RR9RnR~R#Rb(ReRRxRyRn((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__eq__s   %% cC s ||k S(N((RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__ne__.scC s|j S(N(R(Rx((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt __nonzero__2scC s'|s||kS|jt|SdS(N(t _strict_eqR(RxRytstrict((s4lib/python2.7/site-packages/sympy/polys/polytools.pyteq7s cC s|j|d| S(NR(R(RxRyR((s4lib/python2.7/site-packages/sympy/polys/polytools.pytne=scC s=t||jo<|j|jko<|jj|jdtS(NR(RAR]R:R9RRc(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR@sN(t__name__t __module__t__doc__t __slots__Rctis_commutativeRFt _op_priorityRLt classmethodRPRQRRRSRTRCRDRGRHRfRhtpropertyRjRkRJRrRURtRuRvR~RwRVR{RbRsRRRR<RRaRRRRdRRRRqRiRRRRRRRRRR`RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR[RRRRRRRRRR t_eval_derivativeRRRRRRRRRRRRR!R"R#R%R&R'R)R*R+R,R.R/R0R1R2R3R6R7R8R9RGRVR\R_RaRzR}RRRRRIRRRR{RRRRRRoRRRRtNotImplementedRRRRRRRRRRRRRRRt __truediv__t __rtruediv__RRRt__bool__RRR(((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR88sn+      3      #  $ "            %   %   % *               '   ' % % *     "     % "       ' ' ( &K   !  "  %  K K              #    !  L%? J  ( %           tPurePolycB sYeZdZdZdZedZededZ dZ dZ RS(s)Class for representing pure polynomials. cC s |jfS(s$Allow SymPy to hash Poly instances. (R9(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRfHscC stt|jS(N(RgRRh(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRhLscC s|jS(sR Free symbols of a polynomial. Examples ======== >>> from sympy import PurePoly >>> from sympy.abc import x, y >>> PurePoly(x**2 + 1).free_symbols set() >>> PurePoly(x**2 + y).free_symbols set() >>> PurePoly(x**2 + y, x).free_symbols {y} (Rk(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRjOsRcC s||}}|js\y%|j||jd|j}Wq\tttfk rXtSXnt|jt|jkr~tS|j j |j j kry%|j j j |j j |j}Wnt k rtSX|j |}|j |}n|j |j kS(NRU(RFR]R:RsR%R!R"RRNR9RnR~R#Rb(ReRRxRyRn((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRds   %% cC s+t||jo*|jj|jdtS(NR(RAR]R9RRc(RxRy((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR|sc smt|}|js}y;|jj|j|j|jj|jjj|fSWq}tk rytd||fq}Xnt|j t|j krtd||fnt |jt ot |jt std||fn|j |j }|jjj |jj|}|jj|}|jj|}||dfd}||||fS(Nscan't unify %s with %sc sH|dk r8|| ||d}|s8|j|Snj||S(Ni(RVRRP(R9RnR:R(RI(s4lib/python2.7/site-packages/sympy/polys/polytools.pyR{s  (RRFR9RnR{RR"R#RNR:RARR]R~RXRV(RxRyR:RnR|R}R{((RIs4lib/python2.7/site-packages/sympy/polys/polytools.pyRws"  ; $   ( RRRRfRhRRjRRRRRw(((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRDs   cO stj||}t||S(s+Construct a polynomial from an expression. (R=R>t_poly_from_expr(texprR:RJRK((s4lib/python2.7/site-packages/sympy/polys/polytools.pytpoly_from_exprscC s|t|}}t|ts7t|||ns|jr|jj||}|j|_|j|_|j dkrt |_ n||fS|j r|j }nt ||\}}|jst|||nttt|j\}}|j}|dkr4t|d|\|_}ntt|j|}ttt||}tj||}|j dkrt|_ n||fS(s+Construct a polynomial from an expression. RKN(RRARR(RFR]RGR:RURYRVRctexpandR/RERRWRR\RRBR8RCR(RRKtorigtpolyR9RiRqRU((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs2       $   cO stj||}t||S(s(Construct polynomials from expressions. (R=R>t_parallel_poly_from_expr(texprsR:RJRK((s4lib/python2.7/site-packages/sympy/polys/polytools.pytparallel_poly_from_exprscC sddlm}t|dkr|\}}t|trt|tr|jj||}|jj||}|j|\}}|j|_|j |_ |j dkrt |_ n||g|fSnt |g}}gg}}t}xt|D]{\} } t| } t| trl| jrD|j| qr|j| |jrr| j} qrnt }|j| qW|rt|||t n|rx%|D]} || j|| >> from sympy import degree >>> from sympy.abc import x, y >>> degree(x**2 + y*x + 1, gen=x) 2 >>> degree(x**2 + y*x + 1, gen=y) 1 >>> degree(0, x) -oo See also ======== total_degree degree_list Ris A symbolic generator of interest is required for a multivariate expression like func = %s, e.g. degree(func, gen = %s) instead of degree(func, gen = %s). (RRct is_NumberRFR`RRtZeroRNR:RNRjRR6tnextRRR(RxRrt gen_is_NumR$tisNumRz((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRAs*   +cG spt|}|jr$|j}n|jr6d}n0|jrQ|pK|j}nt||j}t|S(s Return the total_degree of ``f`` in the given variables. Examples ======== >>> from sympy import total_degree, Poly >>> from sympy.abc import x, y, z >>> total_degree(1) 0 >>> total_degree(x + x*y) 2 >>> total_degree(x + x*y, x) 1 If the expression is a Poly and no variables are given then the generators of the Poly will be used: >>> p = Poly(x + x*y, y) >>> total_degree(p) 1 To deal with the underlying expression of the Poly, convert it to an Expr: >>> total_degree(p.as_expr()) 2 This is done automatically if any variables are given: >>> total_degree(p, x) 1 See also ======== degree i(RRFR`RR:R8RR(RxR:R$trv((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR{s(     cO svtj|dgyt|||\}}Wn%tk rV}tdd|nX|j}ttt|S(s Return a list of degrees of ``f`` in all variables. Examples ======== >>> from sympy import degree_list >>> from sympy.abc import x, y >>> degree_list(x**2 + y*x + 1) (2, 1) RYRi( R=t allowed_flagsRR(R)RRR\R(RxR:RJR|RKRtdegrees((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs cO sjtj|dgyt|||\}}Wn%tk rV}tdd|nX|jd|jS(s Return the leading coefficient of ``f``. Examples ======== >>> from sympy import LC >>> from sympy.abc import x, y >>> LC(4*x**2 + 2*x*y**2 + x*y + 3*y) 4 RYRiR;(R=RRR(R)RR;(RxR:RJR|RKR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs cO svtj|dgyt|||\}}Wn%tk rV}tdd|nX|jd|j}|jS(s Return the leading monomial of ``f``. Examples ======== >>> from sympy import LM >>> from sympy.abc import x, y >>> LM(4*x**2 + 2*x*y**2 + x*y + 3*y) x**2 RYRiR;(R=RRR(R)RR;R`(RxR:RJR|RKRRZ((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscO stj|dgyt|||\}}Wn%tk rV}tdd|nX|jd|j\}}||jS(s Return the leading term of ``f``. Examples ======== >>> from sympy import LT >>> from sympy.abc import x, y >>> LT(4*x**2 + 2*x*y**2 + x*y + 3*y) 4*x**2 RYRiR;(R=RRR(R)RR;R`(RxR:RJR|RKRRZR[((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRsc O stj|dgy(t||f||\\}}}Wn%tk rb}tdd|nX|j|\}} |js|j| jfS|| fSdS(s Compute polynomial pseudo-division of ``f`` and ``g``. Examples ======== >>> from sympy import pdiv >>> from sympy.abc import x >>> pdiv(x**2 + 1, 2*x - 4) (2*x + 4, 20) RYRiN(R=RRR(R)RRYR`( RxRyR:RJR|R}RKRRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs( c O stj|dgy(t||f||\\}}}Wn%tk rb}tdd|nX|j|}|js|jS|SdS(s Compute polynomial pseudo-remainder of ``f`` and ``g``. Examples ======== >>> from sympy import prem >>> from sympy.abc import x >>> prem(x**2 + 1, 2*x - 4) 20 RYRiN(R=RRR(R)RRYR`( RxRyR:RJR|R}RKRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR6s(  c O stj|dgy(t||f||\\}}}Wn%tk rb}tdd|nXy|j|}Wn tk rt||nX|js|jS|SdS(s Compute polynomial pseudo-quotient of ``f`` and ``g``. Examples ======== >>> from sympy import pquo >>> from sympy.abc import x >>> pquo(x**2 + 1, 2*x - 4) 2*x + 4 >>> pquo(x**2 - 1, 2*x - 1) 2*x + 1 RYRiN( R=RRR(R)RR'RYR`( RxRyR:RJR|R}RKRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRTs(   c O stj|dgy(t||f||\\}}}Wn%tk rb}tdd|nX|j|}|js|jS|SdS(s_ Compute polynomial exact pseudo-quotient of ``f`` and ``g``. Examples ======== >>> from sympy import pexquo >>> from sympy.abc import x >>> pexquo(x**2 - 1, 2*x - 2) 2*x + 2 >>> pexquo(x**2 + 1, 2*x - 4) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 RYRiN(R=RRR(R)RRYR`( RxRyR:RJR|R}RKRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRws(  c O stj|ddgy(t||f||\\}}}Wn%tk re}tdd|nX|j|d|j\}} |js|j| jfS|| fSdS(s Compute polynomial division of ``f`` and ``g``. Examples ======== >>> from sympy import div, ZZ, QQ >>> from sympy.abc import x >>> div(x**2 + 1, 2*x - 4, domain=ZZ) (0, x**2 + 1) >>> div(x**2 + 1, 2*x - 4, domain=QQ) (x/2 + 1, 5) RRYRiN( R=RRR(R)RRRYR`( RxRyR:RJR|R}RKRRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs( c O stj|ddgy(t||f||\\}}}Wn%tk re}tdd|nX|j|d|j}|js|jS|SdS(s Compute polynomial remainder of ``f`` and ``g``. Examples ======== >>> from sympy import rem, ZZ, QQ >>> from sympy.abc import x >>> rem(x**2 + 1, 2*x - 4, domain=ZZ) x**2 + 1 >>> rem(x**2 + 1, 2*x - 4, domain=QQ) 5 RRYRiN( R=RRR(R)RRRYR`( RxRyR:RJR|R}RKRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs(  c O stj|ddgy(t||f||\\}}}Wn%tk re}tdd|nX|j|d|j}|js|jS|SdS(s Compute polynomial quotient of ``f`` and ``g``. Examples ======== >>> from sympy import quo >>> from sympy.abc import x >>> quo(x**2 + 1, 2*x - 4) x/2 + 1 >>> quo(x**2 - 1, x - 1) x + 1 RRYRiN( R=RRR(R)RRRYR`( RxRyR:RJR|R}RKRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs(  c O stj|ddgy(t||f||\\}}}Wn%tk re}tdd|nX|j|d|j}|js|jS|SdS(sQ Compute polynomial exact quotient of ``f`` and ``g``. Examples ======== >>> from sympy import exquo >>> from sympy.abc import x >>> exquo(x**2 - 1, x - 1) x + 1 >>> exquo(x**2 + 1, 2*x - 4) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 RRYRiN( R=RRR(R)RRRYR`( RxRyR:RJR|R}RKRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs(  c O stj|ddgy(t||f||\\}}}Wntk r}t|j\}\} } y|j| | \} } Wn#tk rtdd|qX|j | |j | fSnX|j|d|j \} } |j s | j | j fS| | fSdS(sT Half extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``. Examples ======== >>> from sympy import half_gcdex >>> from sympy.abc import x >>> half_gcdex(x**4 - 2*x**3 - 6*x**2 + 12*x + 15, x**3 + x**2 - 4*x - 4) (3/5 - x/5, x + 1) RRYRiN( R=RRR(RRRR?R)RRRYR`( RxRyR:RJR|R}RKRRURRRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs(   cO s6tj|ddgy(t||f||\\}}}Wntk r}t|j\}\} } y|j| | \} } } Wn#tk rtdd|qX|j | |j | |j | fSnX|j|d|j \} } } |j s%| j | j | j fS| | | fSdS(sZ Extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``. Examples ======== >>> from sympy import gcdex >>> from sympy.abc import x >>> gcdex(x**4 - 2*x**3 - 6*x**2 + 12*x + 15, x**3 + x**2 - 4*x - 4) (3/5 - x/5, x**2/5 - 6*x/5 + 2, x + 1) RRYRiN( R=RRR(RRRR?R)RRRYR`(RxRyR:RJR|R}RKRRURRRRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRDs( ,! c O stj|ddgy(t||f||\\}}}Wnqtk r}t|j\}\} } y|j|j| | SWqtk rt dd|qXnX|j|d|j } |j s| j S| SdS(s> Invert ``f`` modulo ``g`` when possible. Examples ======== >>> from sympy import invert, S >>> from sympy.core.numbers import mod_inverse >>> from sympy.abc import x >>> invert(x**2 - 1, 2*x - 1) -4/3 >>> invert(x**2 - 1, x - 1) Traceback (most recent call last): ... NotInvertible: zero divisor For more efficient inversion of Rationals, use the ``mod_inverse`` function: >>> mod_inverse(3, 5) 2 >>> (S(2)/5).invert(S(7)/3) 5/2 See Also ======== sympy.core.numbers.mod_inverse RRYRiN( R=RRR(RRRRR?R)RRYR`( RxRyR:RJR|R}RKRRURRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRks (   c O stj|dgy(t||f||\\}}}Wn%tk rb}tdd|nX|j|}|jsg|D]} | j^qS|SdS(s Compute subresultant PRS of ``f`` and ``g``. Examples ======== >>> from sympy import subresultants >>> from sympy.abc import x >>> subresultants(x**2 + 1, x**2 - 1) [x**2 + 1, x**2 - 1, -2] RYRiN(R=RRR(R)RRYR`( RxRyR:RJR|R}RKRRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs( c O s|jdt}tj|dgy(t||f||\\}}}Wn%tk rt}tdd|nX|r|j|d|\} } n|j|} |js|r| j g| D]} | j ^qfS| j S|r| | fS| SdS(s Compute resultant of ``f`` and ``g``. Examples ======== >>> from sympy import resultant >>> from sympy.abc import x >>> resultant(x**2 + 1, x**2 - 1) 4 RRYRiN( tpopRR=RRR(R)RRYR`( RxRyR:RJRR|R}RKRRRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs ( )  cO s~tj|dgyt|||\}}Wn%tk rV}tdd|nX|j}|jsv|jS|SdS(s Compute discriminant of ``f``. Examples ======== >>> from sympy import discriminant >>> from sympy.abc import x >>> discriminant(x**2 + 2*x + 3) -8 RYRiN(R=RRR(R)RRYR`(RxR:RJR|RKRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs   cO s*tj|dgy(t||f||\\}}}Wntk r}t|j\}\} } y|j| | \} } } Wn#tk rtdd|qX|j | |j | |j | fSnX|j|\} } } |j s| j | j | j fS| | | fSdS(s Compute GCD and cofactors of ``f`` and ``g``. Returns polynomials ``(h, cff, cfg)`` such that ``h = gcd(f, g)``, and ``cff = quo(f, h)`` and ``cfg = quo(g, h)`` are, so called, cofactors of ``f`` and ``g``. Examples ======== >>> from sympy import cofactors >>> from sympy.abc import x >>> cofactors(x**2 - 1, x**2 - 3*x + 2) (x - 1, x + 1, x - 2) RYRiN( R=RRR(RRRR?R)RRYR`(RxRyR:RJR|R}RKRRURRRRR ((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs( , c st|}fd}||}|d k r:|Stjdgyt|\}}t|dkrtd|Dr|d}g|d D]}||j^q} td| Drd} x'| D]} t| | j d} qW|| SnWnJt k r_} || j }|d k rD|St dt|| nX|s|j svtjStdd |Sn|d|d}}x*|D]"} |j| }|jrPqqW|j s|jS|Sd S( s Compute GCD of a list of polynomials. Examples ======== >>> from sympy import gcd_list >>> from sympy.abc import x >>> gcd_list([x**3 - 1, x**2 - 1, x**2 - 3*x + 2]) x - 1 c s r rt|\}}|s-|jS|jr|d|d}}x3|D]+}|j||}|j|rRPqRqRW|j|SndS(Nii(RRtRR!RRRV(tseqRUtnumbersRtnumber(RJR:(s4lib/python2.7/site-packages/sympy/polys/polytools.pyttry_non_polynomial_gcd;s  RYics s!|]}|jo|jVqdS(N(t is_algebraict is_irrational(RR((s4lib/python2.7/site-packages/sympy/polys/polytools.pys Ysics s|]}|jVqdS(N(t is_rational(Rtfrc((s4lib/python2.7/site-packages/sympy/polys/polytools.pys \sitgcd_listRKN(RRVR=RRRNR4tratsimpR"tas_numer_denomR(RR)RYRRR8R!RR`(RR:RJRRRYRKRRtlsttlcRRR((RJR:s4lib/python2.7/site-packages/sympy/polys/polytools.pyR*sB   ( '       c O st|dr;|dk r+|f|}nt|||S|dkrVtdntj|dgyt||f||\\}}}tt||f\}}|j r|j r|j r|j r||j } | j r|| j dSnWnqtk rq} t| j\} \}}y| j| j||SWqrtk rmtdd| qrXnX|j|} |js| jS| SdS(s Compute GCD of ``f`` and ``g``. Examples ======== >>> from sympy import gcd >>> from sympy.abc import x >>> gcd(x**2 - 1, x**2 - 3*x + 2) x - 1 t__iter__s2gcd() takes 2 arguments or a sequence of argumentsRYiR!iN(RRVRRR=RRR\RRRRRRR(RRRR!R?R)RYR`( RxRyR:RJR|R}RKRRRRRUR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR!~s0  $$    c st|}fd}||}|d k r:|Stjdgyt|\}}t|dkrtd|Dr|d}g|d D]}||j^q} td| Drd} x'| D]} t| | j d} qW|| SnWnJt k r_} || j }|d k rD|St dt|| nX|s|j svtjStdd|Sn|d |d}}x|D]} |j| }qW|j s|jS|Sd S( s Compute LCM of a list of polynomials. Examples ======== >>> from sympy import lcm_list >>> from sympy.abc import x >>> lcm_list([x**3 - 1, x**2 - 1, x**2 - 3*x + 2]) x**5 - x**4 - 2*x**3 - x**2 + x + 2 c s r~ r~t|\}}|s-|jS|jr~|d|d}}x |D]}|j||}qRW|j|SndS(Nii(RRuRR"RRV(RRURRR(RJR:(s4lib/python2.7/site-packages/sympy/polys/polytools.pyttry_non_polynomial_lcms  RYics s!|]}|jo|jVqdS(N(RR(RR((s4lib/python2.7/site-packages/sympy/polys/polytools.pys sics s|]}|jVqdS(N(R(RR((s4lib/python2.7/site-packages/sympy/polys/polytools.pys stlcm_listRKiN(RRVR=RRRNR4RR"RR(RR)RYRRR8R`(RR:RJRRRYRKRRRRRRR((RJR:s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs>   ( '      c O st|dr;|dk r+|f|}nt|||S|dkrVtdntj|dgyt||f||\\}}}tt||f\}}|j r|j r|j r|j r||j } | j r|| j dSnWnqtk rq} t| j\} \}}y| j| j||SWqrtk rmtdd| qrXnX|j|} |js| jS| SdS(s Compute LCM of ``f`` and ``g``. Examples ======== >>> from sympy import lcm >>> from sympy.abc import x >>> lcm(x**2 - 1, x**2 - 3*x + 2) x**3 - 2*x**2 - x + 2 Rs2lcm() takes 2 arguments or a sequence of argumentsRYiR"iN(RRVRRR=RRR\RRRRRRR(RRRR"R?R)RYR`( RxRyR:RJR|R}RKRRRRRUR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR"s0  $$    cO sEddlm}t|}t|t s5|jr9|S|jdtr|jg|j D]}t |||^q[}|j dt|d>> from sympy import terms_gcd, cos >>> from sympy.abc import x, y >>> terms_gcd(x**6*y**2 + x**3*y, x, y) x**3*y*(x**3*y + 1) The default action of polys routines is to expand the expression given to them. terms_gcd follows this behavior: >>> terms_gcd((3+3*x)*(x+x*y)) 3*x*(x*y + x + y + 1) If this is not desired then the hint ``expand`` can be set to False. In this case the expression will be treated as though it were comprised of one or more terms: >>> terms_gcd((3+3*x)*(x+x*y), expand=False) (3*x + 3)*(x*y + x) In order to traverse factors of a Mul or the arguments of other functions, the ``deep`` hint can be used: >>> terms_gcd((3 + 3*x)*(x + x*y), expand=False, deep=True) 3*x*(x + 1)*(y + 1) >>> terms_gcd(cos(x + x*y), deep=True) cos(x*(y + 1)) Rationals are factored out by default: >>> terms_gcd(x + y/2) (2*x + y)/2 Only the y-term had a coefficient that was a fraction; if one does not want to factor out the 1/2 in cases like this, the flag ``clear`` can be set to False: >>> terms_gcd(x + y/2, clear=False) x + y/2 >>> terms_gcd(x*y/2 + y**2, clear=False) y*(x/2 + y) The ``clear`` flag is ignored if all coefficients are fractions: >>> terms_gcd(x/3 + y/2, clear=False) (2*x + 3*y)/6 See Also ======== sympy.core.exprtools.gcd_terms, sympy.core.exprtools.factor_terms i(tEqualitytdeepRtclearRYRXi(tsympy.core.relationalRRRARtis_AtomRRRRJRRRcR=RRR(RRURRRR'RRRRR:RR`t as_coeff_Mul(RxR:RJRRRRPRR|RKRRtdenomR[RRtterm((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR2sDB 1      5   'cO stj|ddgyt|||\}}Wn%tk rY}tdd|nX|jt|}|js|jS|SdS(s Reduce ``f`` modulo a constant ``p``. Examples ======== >>> from sympy import trunc >>> from sympy.abc import x >>> trunc(2*x**3 + 3*x**2 + 5*x + 7, 3) -x**3 - x + 1 RRYR#iN( R=RRR(R)R#RRYR`(RxR$R:RJR|RKRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR#s  cO stj|ddgyt|||\}}Wn%tk rY}tdd|nX|jd|j}|js|jS|SdS(s Divide all coefficients of ``f`` by ``LC(f)``. Examples ======== >>> from sympy import monic >>> from sympy.abc import x >>> monic(3*x**2 + 4*x + 2) x**2 + 4*x/3 + 2/3 RRYR%iN( R=RRR(R)R%RRYR`(RxR:RJR|RKRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR%s  cO satj|dgyt|||\}}Wn%tk rV}tdd|nX|jS(s Compute GCD of coefficients of ``f``. Examples ======== >>> from sympy import content >>> from sympy.abc import x >>> content(6*x**2 + 8*x + 12) 2 RYR&i(R=RRR(R)R&(RxR:RJR|RKR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR&s cO stj|dgyt|||\}}Wn%tk rV}tdd|nX|j\}}|js||jfS||fSdS(s Compute content and the primitive form of ``f``. Examples ======== >>> from sympy.polys.polytools import primitive >>> from sympy.abc import x >>> primitive(6*x**2 + 8*x + 12) (2, 3*x**2 + 4*x + 6) >>> eq = (2 + 2*x)*x + 2 Expansion is performed by default: >>> primitive(eq) (2, x**2 + x + 1) Set ``expand`` to False to shut this off. Note that the extraction will not be recursive; use the as_content_primitive method for recursive, non-destructive Rational extraction. >>> primitive(eq, expand=False) (1, x*(2*x + 2) + 2) >>> eq.as_content_primitive() (2, x*(x + 1) + 1) RYR'iN(R=RRR(R)R'RYR`(RxR:RJR|RKRR(R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR's  c O stj|dgy(t||f||\\}}}Wn%tk rb}tdd|nX|j|}|js|jS|SdS(s Compute functional composition ``f(g)``. Examples ======== >>> from sympy import compose >>> from sympy.abc import x >>> compose(x**2 + x, x - 1) x**2 - x RYR)iN(R=RRR(R)R)RYR`( RxRyR:RJR|R}RKRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR))s(  cO stj|dgyt|||\}}Wn%tk rV}tdd|nX|j}|jsg|D]}|j^qsS|SdS(s Compute functional decomposition of ``f``. Examples ======== >>> from sympy import decompose >>> from sympy.abc import x >>> decompose(x**4 + 2*x**3 - x - 1) [x**2 - x - 1, x**2 + x] RYR*iN(R=RRR(R)R*RYR`(RxR:RJR|RKRRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR*Gs  cO stj|ddgyt|||\}}Wn%tk rY}tdd|nX|jd|j}|jsg|D]}|j^qS|SdS(s Compute Sturm sequence of ``f``. Examples ======== >>> from sympy import sturm >>> from sympy.abc import x >>> sturm(x**3 - 2*x**2 + x - 3) [x**3 - 2*x**2 + x - 3, 3*x**2 - 4*x + 1, 2*x/9 + 25/9, -2079/4] RRYR.iN( R=RRR(R)R.RRYR`(RxR:RJR|RKRRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR.es c O stj|dgyt|||\}}Wn%tk rV}tdd|nX|j}|jsg|D]\}}|j|f^qsS|SdS(s/ Compute a list of greatest factorial factors of ``f``. Note that the input to ff() and rf() should be Poly instances to use the definitions here. Examples ======== >>> from sympy import gff_list, ff, Poly >>> from sympy.abc import x >>> f = Poly(x**5 + 2*x**4 - x**3 - 2*x**2, x) >>> gff_list(f) [(Poly(x, x, domain='ZZ'), 1), (Poly(x + 2, x, domain='ZZ'), 4)] >>> (ff(Poly(x), 1)*ff(Poly(x + 2), 4)).expand() == f True >>> f = Poly(x**12 + 6*x**11 - 11*x**10 - 56*x**9 + 220*x**8 + 208*x**7 - 1401*x**6 + 1090*x**5 + 2715*x**4 - 6720*x**3 - 1092*x**2 + 5040*x, x) >>> gff_list(f) [(Poly(x**3 + 7, x, domain='ZZ'), 2), (Poly(x**2 + 5*x, x, domain='ZZ'), 3)] >>> ff(Poly(x**3 + 7, x), 2)*ff(Poly(x**2 + 5*x, x), 3) == f True RYR/iN(R=RRR(R)R/RYR`( RxR:RJR|RKRR5RyR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR/s   )cO stddS(s3Compute greatest factorial factorization of ``f``. ssymbolic falling factorialN(R?(RxR:RJ((s4lib/python2.7/site-packages/sympy/polys/polytools.pytgffsc O stj|dgyt|||\}}Wn%tk rV}tdd|nX|j\}}}|jst||j|jfSt|||fSdS(s Compute square-free norm of ``f``. Returns ``s``, ``f``, ``r``, such that ``g(x) = f(x-sa)`` and ``r(x) = Norm(g(x))`` is a square-free polynomial over ``K``, where ``a`` is the algebraic extension of the ground domain. Examples ======== >>> from sympy import sqf_norm, sqrt >>> from sympy.abc import x >>> sqf_norm(x**2 + 1, extension=[sqrt(3)]) (1, x**2 - 2*sqrt(3)*x + 4, x**4 - 4*x**2 + 16) RYR1iN( R=RRR(R)R1RYRR`( RxR:RJR|RKRRRyR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR1s cO s~tj|dgyt|||\}}Wn%tk rV}tdd|nX|j}|jsv|jS|SdS(s Compute square-free part of ``f``. Examples ======== >>> from sympy import sqf_part >>> from sympy.abc import x >>> sqf_part(x**3 - 3*x - 2) x**2 - x - 2 RYR2iN(R=RRR(R)R2RYR`(RxR:RJR|RKRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR2s   cC s1|dkrd}n d}t|d|S(s&Sort a list of ``(expr, exp)`` pairs. R>cS s7|\}}|jj}|t|t|j|fS(N(R9RNR:(RORtexpR9((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRis  cS s7|\}}|jj}t|t|j||fS(N(R9RNR:(RORRR9((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRis  Ri(Rw(R5tmethodRi((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt_sorted_factorss   cC s-tg|D]\}}|j|^q S(s*Multiply a list of ``(expr, exp)`` pairs. (RR`(R5RxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt_factors_productscC stjg}}gtj|D]'}t|drA|jn|^q }xJ|D]B}|jrs||9}qTn|jr|j|j qTn|j r|j \}} |jr| jr||9}qTn|jr|j || fqTqn|tj}} yt ||\} } Wn)t k rE} |j | j| fqTXt| |d} | \}}|tjk r| jr||| 9}q|jr|j || fq|j |tjfn| tjkr|j|qT| jr$|jg|D]\}}||| f^qqTg}xP|D]H\}}|jjrf|j ||| fq1|j ||fq1W|j t|| fqTW||fS(s.Helper function for :func:`_symbolic_factor`. t _eval_factort_list(RRRt make_argsRRRtis_MulRRJtis_PowRRR(RtgetattrR~t is_positivet is_integerR`R(RRKRR[R5RmRJtargtbaseRRRzRRt_coefft_factorsRxRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt_symbolic_factor_list sT:           3cC st|trm|j rmt|dr2|jStt|d|d||\}}t|t|St|dr|j g|j D]}t |||^qSt|dr|j g|D]}t |||^qS|SdS(s%Helper function for :func:`_factor`. RtfractionRJRN( RARt is_RelationalRRRR1RRRRJt_symbolic_factorR](RRKRR[R5R((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRGs (/,cC stj|ddgtj||}t|}t|tr|j rt|j\}}t |||\}}t |||\} } | r|j rt d|n|j t dt} xh|| fD]Z} xQt| D]C\} \}}|jst|| \}}||f| | Helper function for :func:`sqf_list` and :func:`factor_list`. tfracRYsa polynomial expected, got %sRN(R=RR>RRARRR1RRRR%tcloneRBRcRRFRRRYR`(RR:RJRRKtnumerRRtfpRtfqt_optR5RmRxRRzR[((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt_generic_factor_listVs2   +.   cC sT|jdt}tj|gtj||}||dRR(RR:RJRRRK((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt_generic_factors  c sddlmd fd}d fd}d}|jjr||r|j}|||}|r|d|dd |dfS|||}|rd d |d|dfSnd S( s! try to transform a polynomial to have rational coefficients try to find a transformation ``x = alpha*y`` ``f(x) = lc*alpha**n * g(y)`` where ``g`` is a polynomial with rational coefficients, ``lc`` the leading coefficient. If this fails, try ``x = y + beta`` ``f(x) = g(y)`` Returns ``None`` if ``g`` not found; ``(lc, alpha, None, g)`` in case of rescaling ``(None, None, beta, g)`` in case of translation Notes ===== Currently it transforms only polynomials without roots larger than 2. Examples ======== >>> from sympy import sqrt, Poly, simplify >>> from sympy.polys.polytools import to_rational_coeffs >>> from sympy.abc import x >>> p = Poly(((x**2-1)*(x-2)).subs({x:x*(1 + sqrt(2))}), x, domain='EX') >>> lc, r, _, g = to_rational_coeffs(p) >>> lc, r (7 + 5*sqrt(2), 2 - 2*sqrt(2)) >>> g Poly(x**3 + x**2 - 1/4*x - 1/4, x, domain='QQ') >>> r1 = simplify(1/r) >>> Poly(lc*r**3*(g.as_expr()).subs({x:x*r1}), x, domain='EX') == p True i(tsimplifyc  sddlm}t|jdk s7|jdj rAd|fS|j}|j}|ph|j}|j d}g|D]}|^q}|dr|d|d}g}xt t|D]<} || || d}|j sPn|j |qWd|} |jd} | |g} x<t d|dD]'} | j || d| || qSW|| }t |}|| |fSndS(s$ try rescaling ``x -> alpha*x`` to convert f to a polynomial with rational coefficients. Returns ``alpha, f``; if the rescaling is successful, ``alpha`` is the rescaling factor, and ``f`` is the rescaled polynomial; else ``alpha`` is ``None``. i(RiiiN(tsympy.core.addRRNR:RRVRRR%RR RRR8( Rxtf1RRRRqtcoeffxt rescale1_xtcoeffs1Rmt rescale_xRRC(R(s4lib/python2.7/site-packages/sympy/polys/polytools.pyt _try_rescales2'       %  c  sddlm}t|jdk s7|jdj rAd|fS|j}|p\|j}|jd}|d}|r|j r|}|j r|j }|j }n |g}t |ddt\}} || |} |j| } | | fSdS(s+ try translating ``x -> x + alpha`` to convert f to a polynomial with rational coefficients. Returns ``alpha, f``; if the translating is successful, ``alpha`` is the translating factor, and ``f`` is the shifted polynomial; else ``alpha`` is ``None``. i(RiicS s|jS(N(R(tz((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRlRmtbinaryN(R RRNR:RRVRR%RRtis_AddRJRR4RcR+( RxR RRRqRRRJtc1tc2talphatf2(R(s4lib/python2.7/site-packages/sympy/polys/polytools.pyt_try_translates$'       c S sddlm}|j}t}x|D]}xtj|D]}||j}g|jD]6\}}|jra|j ra|j dkra|j ^qa} | sq?nt | dkrt }nt | dkr?tSq?Wq)W|S(sS Return True if ``f`` is a sum with square roots but no other root i(tFactorsi(tsympy.core.exprtoolsRRqRRRR5RWRt is_RationalRtminRctmax( R$RRqthas_sqRRRxRtwxR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt_has_square_rootss  0  iiiN(tsympy.simplify.simplifyRRVRsRpR%(RxRRRR R((Rs4lib/python2.7/site-packages/sympy/polys/polytools.pytto_rational_coeffss&#  cC sVddlm}t||dd}|j}t|}|sGdS|\}}}} t| j} |r|| d|||} |d|} g} x| ddD];}| j||dj i|| |6|dfqWnX| d} g} xE| ddD]5}| j|dj i|||6|dfqW| | fS(s helper function to factor polynomial using to_rational_coeffs Examples ======== >>> from sympy.polys.polytools import _torational_factor_list >>> from sympy.abc import x >>> from sympy import sqrt, expand, Mul >>> p = expand(((x**2-1)*(x-2)).subs({x:x*(1 + sqrt(2))})) >>> factors = _torational_factor_list(p, x); factors (-2, [(-x*(1 + sqrt(2))/2 + 1, 1), (-x*(1 + sqrt(2)) - 1, 1), (-x*(1 + sqrt(2)) + 1, 1)]) >>> expand(factors[0]*Mul(*[z[0] for z in factors[1]])) == p True >>> p = expand(((x**2-1)*(x-2)).subs({x:x + sqrt(2)})) >>> factors = _torational_factor_list(p, x); factors (1, [(x - 2 + sqrt(2), 1), (x - 1 + sqrt(2), 1), (x + 1 + sqrt(2), 1)]) >>> expand(factors[0]*Mul(*[z[0] for z in factors[1]])) == p True i(RRUtEXiiN( R RR8RR!RVR7R`RR(R$RRtp1RtresRRRRyR5Rtr1RR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt_torational_factor_lists&  < 3cO st|||ddS(s Compute a list of square-free factors of ``f``. Examples ======== >>> from sympy import sqf_list >>> from sympy.abc import x >>> sqf_list(2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16) (2, [(x + 1, 2), (x + 2, 3)]) RR>(R(RxR:RJ((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR3;scO st|||ddS(s Compute square-free factorization of ``f``. Examples ======== >>> from sympy import sqf >>> from sympy.abc import x >>> sqf(2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16) 2*(x + 1)**2*(x + 2)**3 RR>(R(RxR:RJ((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR>MscO st|||ddS(s  Compute a list of irreducible factors of ``f``. Examples ======== >>> from sympy import factor_list >>> from sympy.abc import x, y >>> factor_list(2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y) (2, [(x + y, 1), (x**2 + 1, 2)]) RR|(R(RxR:RJ((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR7_sc  s%t|}jdtrddlm}fd}|||}i}|jtt}xK|D]C}t|}|j s|j rn||krn|||>> from sympy import factor, sqrt, exp >>> from sympy.abc import x, y >>> factor(2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y) 2*(x + y)*(x**2 + 1)**2 >>> factor(x**2 + 1) x**2 + 1 >>> factor(x**2 + 1, modulus=2) (x + 1)**2 >>> factor(x**2 + 1, gaussian=True) (x - I)*(x + I) >>> factor(x**2 - 2, extension=sqrt(2)) (x - sqrt(2))*(x + sqrt(2)) >>> factor((x**2 - 1)/(x**2 + 4*x + 4)) (x - 1)*(x + 1)/(x + 2)**2 >>> factor((x**2 + 4*x + 4)**10000000*(x**2 + 1)) (x + 2)**20000000*(x**2 + 1) By default, factor deals with an expression as a whole: >>> eq = 2**(x**2 + 2*x + 1) >>> factor(eq) 2**(x**2 + 2*x + 1) If the ``deep`` flag is True then subexpressions will be factored: >>> factor(eq, deep=True) 2**((x + 1)**2) If the ``fraction`` flag is False then rational expressions won't be combined. By default it is True. >>> factor(5*x + 3*exp(2 - 7*x), deep=True) (5*x*exp(7*x) + 3*exp(2))*exp(-7*x) >>> factor(5*x + 3*exp(2 - 7*x), deep=True, fraction=False) 5*x + 3*exp(2)*exp(-7*x) See Also ======== sympy.ntheory.factor_.factorint Ri(t bottom_upc s,t|}|js$|jr(|S|S(sS Factor, but avoid changing the expression when unable to. (R|RR(RRy(RJR:(s4lib/python2.7/site-packages/sympy/polys/polytools.pyt _try_factorsRR|(t factor_ncN(RRRR R'tatomsRRR|RRtxreplaceRR%RRR)( RxR:RJR'R(tpartialstmuladdR$RytmsgR)((RJR:s4lib/python2.7/site-packages/sympy/polys/polytools.pyR|qs&D      c C st|dsbyt|}Wntk r3gSX|jd|d|d|d|d|d|St|dd \}} t| jd krtnx*t|D]\} } | j j || >> from sympy import intervals >>> from sympy.abc import x >>> intervals(x**2 - 3) [((-2, -1), 1), ((1, 2), 1)] >>> intervals(x**2 - 3, eps=1e-2) [((-26/15, -19/11), 1), ((19/11, 26/15), 1)] RR4R:R;R<R=R>RURiis!'eps' must be a positive rationalRN(RR8R$R9RRNR:R&RR9RVRURXRR2RR(R|R4R:R;R<RR=R>RYRKRmRR9RRRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR9s4 .     !%c C s\yt|}Wn!tk r3td|nX|j||d|d|d|d|S(s Refine an isolating interval of a root to the given precision. Examples ======== >>> from sympy import refine_root >>> from sympy.abc import x >>> refine_root(x**2 - 3, 1, 2, eps=1e-2) (19/11, 26/15) s+can't refine a root of %s, not a polynomialR:RHR=RJ(R8R$R%RG(RxRRR:RHR=RJR|((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRGs  cC sPyt|dt}Wn!tk r9td|nX|jd|d|S(s Return the number of roots of ``f`` in ``[inf, sup]`` interval. If one of ``inf`` or ``sup`` is complex, it will return the number of roots in the complex rectangle with corners at ``inf`` and ``sup``. Examples ======== >>> from sympy import count_roots, I >>> from sympy.abc import x >>> count_roots(x**4 - 4, -3, 3) 2 >>> count_roots(x**4 - 4, 0, 1 + 3*I) 1 tgreedys)can't count roots of %s, not a polynomialR;R<(R8RR$R%RV(RxR;R<R|((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRV&s  cC sJyt|dt}Wn!tk r9td|nX|jd|S(s Return a list of real roots with multiplicities of ``f``. Examples ======== >>> from sympy import real_roots >>> from sympy.abc import x >>> real_roots(2*x**3 - 7*x**2 + 4*x + 4) [-1/2, 2, 2] R/s0can't compute real roots of %s, not a polynomialR](R8RR$R%R_(RxR]R|((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR_Bs  ii2cC sVyt|dt}Wn!tk r9td|nX|jd|d|d|S(sL Compute numerical approximations of roots of ``f``. Examples ======== >>> from sympy import nroots >>> from sympy.abc import x >>> nroots(x**2 - 3, n=15) [-1.73205080756888, 1.73205080756888] >>> nroots(x**2 - 3, n=30) [-1.73205080756887729352744634151, 1.73205080756887729352744634151] R/s5can't compute numerical roots of %s, not a polynomialRReRf(R8RR$R%Rz(RxRReRfR|((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRzZs  cO s^tj|gyt|||\}}Wn%tk rS}tdd|nX|jS(s Compute roots of ``f`` by factorization in the ground domain. Examples ======== >>> from sympy import ground_roots >>> from sympy.abc import x >>> ground_roots(x**6 - 4*x**4 + 4*x**3 - x**2) {0: 2, 1: 2} R}i(R=RRR(R)R}(RxR:RJR|RKR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR}ts cO s~tj|gyt|||\}}Wn%tk rS}tdd|nX|j|}|jsv|jS|SdS(s Construct a polynomial with n-th powers of roots of ``f``. Examples ======== >>> from sympy import nth_power_roots_poly, factor, roots >>> from sympy.abc import x >>> f = x**4 - x**2 + 1 >>> g = factor(nth_power_roots_poly(f, 2)) >>> g (x**2 - x + 1)**2 >>> R_f = [ (r**2).expand() for r in roots(f) ] >>> R_g = roots(g).keys() >>> set(R_f) == set(R_g) True RiN(R=RRR(R)RRYR`(RxRR:RJR|RKRR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs  c sddlm}ddlmtj|dgt|}t|tt fs|j s|t|t s|t|t  r|S||dt }|j\}}nJt|dkr|\}}n)t|t r||Std|y(t||f||\\}}}Wntk rUt|tt fsB|Stj||fSnKtk r} |jr|j rt| n|js|jrt|jfdd t \} } g| D]} t| ^q} |jt|j| | Sg} t|}t|xg|D]_}t|tt t frJq&ny'| j!|t|f|j"Wq&t#k rq&Xq&W|j$t%| SnX|j|\} }}t|tt fs| |j&|j&S|j's| |j&|j&fS| ||fSd S( sd Cancel common factors in a rational function ``f``. Examples ======== >>> from sympy import cancel, sqrt, Symbol >>> from sympy.abc import x >>> A = Symbol('A', commutative=False) >>> cancel((2*x**2 - 2)/(x**2 - 2*x + 1)) (2*x + 2)/(x - 1) >>> cancel((sqrt(3) + sqrt(15)*A)/(sqrt(2) + sqrt(10)*A)) sqrt(6)/2 i(t factor_terms(RRYtradicalisunexpected argument: %sc s|jtko|j S(N(RRcthas(R(R(s4lib/python2.7/site-packages/sympy/polys/polytools.pyRlsRN((RR0RRR=RRRARR RRRRcRRNRRR(RRR%RR2RRR4RJRRR RRRtskipR?R+RBR`RY(RxR:RJR0R$RR|R}RKR.RtncRmRtpotteR-R((Rs4lib/python2.7/site-packages/sympy/polys/polytools.pyRs\ ( (      cO s/tj|ddgy)t|gt|||\}}Wn%tk rf}tdd|nX|j}t}|jr|j r|j r|j t d|j }t}nddlm} | |j|j|j\} } xHt|D]:\} } | j|jjj} | j| || >> from sympy import reduced >>> from sympy.abc import x, y >>> reduced(2*x**4 + y**2 - x**2 + y**3, [x**3 - x, y**3 - y]) ([2*x, 1], x**2 + y**2 + y) RYRtreducediRUi(txringiN(R=RRRER(R)RURRRRRRBt get_fieldRctsympy.polys.ringsR8R:R;RRbR9RRQRR8RCRR"RYR`(RxR}R:RJRYRKRRURR8t_ringRzRmRRRRt_Qt_r((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR7s6)  !+0  )cO st|||S(s Computes the reduced Groebner basis for a set of polynomials. Use the ``order`` argument to set the monomial ordering that will be used to compute the basis. Allowed orders are ``lex``, ``grlex`` and ``grevlex``. If no order is specified, it defaults to ``lex``. For more information on Groebner bases, see the references and the docstring of `solve_poly_system()`. Examples ======== Example taken from [1]. >>> from sympy import groebner >>> from sympy.abc import x, y >>> F = [x*y - 2*y, 2*y**2 - x**2] >>> groebner(F, x, y, order='lex') GroebnerBasis([x**2 - 2*y**2, x*y - 2*y, y**3 - 2*y], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, order='grlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grlex') >>> groebner(F, x, y, order='grevlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grevlex') By default, an improved implementation of the Buchberger algorithm is used. Optionally, an implementation of the F5B algorithm can be used. The algorithm can be set using ``method`` flag or with the :func:`setup` function from :mod:`sympy.polys.polyconfig`: >>> F = [x**2 - x - 1, (2*x - 1) * y - (x**10 - (1 - x)**10)] >>> groebner(F, x, y, method='buchberger') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, method='f5b') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex') References ========== 1. [Buchberger01]_ 2. [Cox97]_ (t GroebnerBasis(R|R:RJ((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR?s3cO st|||jS(s[ Checks if the ideal generated by a Groebner basis is zero-dimensional. The algorithm checks if the set of monomials not divisible by the leading monomial of any element of ``F`` is bounded. References ========== David A. Cox, John B. Little, Donal O'Shea. Ideals, Varieties and Algorithms, 3rd edition, p. 230 (R>tis_zero_dimensional(R|R:RJ((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR?usR>cB seZdZdZedZedZedZedZ edZ edZ edZ d Z d Zd Zd Zd ZdZedZdZedZdZRS(s%Represents a reduced Groebner basis. c O s tj|ddgyt|||\}}Wn+tk r_}tdt||nXddlm}||j|j |j }g|D]$} | r|j | j j ^q}t||d|j} g| D]} tj| |^q} |j| |S(s>Compute a reduced Groebner basis for a system of polynomials. RYRRi(tPolyRing(R=RRR(R)RNR:R@R:RUR;RQR9Rt _groebnerRR8RCt_new( RIR|R:RJRYRKRR@tringRR}Ry((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRLs1%cC s+tj|}t||_||_|S(N(RRLRt_basist_options(RItbasisR=RO((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRBs cC st|jt|jjfS(N(R RDRER:(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRJscC s g|jD]}|j^q S(N(RDR`(ReR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC s t|jS(N(RERD(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRYscC s |jjS(N(RER:(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR:scC s |jjS(N(RERU(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRUscC s |jjS(N(RER;(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR;scC s t|jS(N(RNRD(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt__len__scC s*|jjrt|jSt|jSdS(N(RERYtiterR(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs  cC s)|jjr|j}n |j}||S(N(RERYR(RetitemRF((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt __getitem__s   cC s"t|jt|jjfS(N(thashRDRRERW(Re((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRhscC spt||jr4|j|jko3|j|jkSt|rh|jt|kpg|jt|kStSdS(N( RAR]RDRER RYRERR(ReR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRs " (cC s ||k S(N((ReR((s4lib/python2.7/site-packages/sympy/polys/polytools.pyRscC szd}tdgt|j}|jj}x<|jD]1}|jd|}||r;||9}q;q;Wt|S(s{ Checks if the ideal generated by a Groebner basis is zero-dimensional. The algorithm checks if the set of monomials not divisible by the leading monomial of any element of ``F`` is bounded. References ========== David A. Cox, John B. Little, Donal O'Shea. Ideals, Varieties and Algorithms, 3rd edition, p. 230 cS sttt|dkS(Ni(tsumR\R(tmonomial((s4lib/python2.7/site-packages/sympy/polys/polytools.pyt single_varsiR;(RRNR:RER;RYRR4(ReRNRR;RRM((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR?s   cC s|j}|j}t|}||kr.|S|jsFtdnt|j}|j}|jt d|j d|}ddl m }||j |j|\}} xHt|D]:\} } | j|jjj} |j| || >> from sympy.abc import x, y >>> from sympy import groebner >>> F = [x**2 - 3*y - x + 1, y**2 - 2*x + y - 1] >>> G = groebner(F, x, y, order='grlex') >>> list(G.fglm('lex')) [2*x - y**2 - y + 1, y**4 + 2*y**3 - 3*y**2 - 16*y + 7] >>> list(groebner(F, x, y, order='lex')) [2*x - y**2 - y + 1, y**4 + 2*y**3 - 3*y**2 - 16*y + 7] References ========== .. [1] J.C. Faugere, P. Gianni, D. Lazard, T. Mora (1994). Efficient Computation of Zero-dimensional Groebner Bases by Change of Ordering s>can't convert Groebner bases of ideals with positive dimensionRUR;i(R8RXi(RER;RR?R?RERDRURRBR9R:R8R:RRbR9RRQRR8RCRRRcRB(ReR;RKt src_ordert dst_orderRYRUR8R;RzRmRR}Ry((s4lib/python2.7/site-packages/sympy/polys/polytools.pytfglms.         + ) cC stj||j}|gt|j}|j}|j}t}|r|jr|j r|j t d|j }t }nddl m}||j|j|j\} } xHt|D]:\} }|j|jjj}| j||| >> from sympy import groebner, expand >>> from sympy.abc import x, y >>> f = 2*x**4 - x**2 + y**3 + y**2 >>> G = groebner([x**3 - x, y**3 - y]) >>> G.reduce(f) ([2*x, 1], x**2 + y**2 + y) >>> Q, r = _ >>> expand(sum(q*g for q, g in zip(Q, G)) + r) 2*x**4 - x**2 + y**3 + y**2 >>> _ == f True RUi(R8iiN(R8RHRERERDRURRRRRBR9RcR:R8R:R;RRbR9RRQRRCRR"RYR`(ReRRRRYRKRURR8R;RzRmRRRR<R=((s4lib/python2.7/site-packages/sympy/polys/polytools.pytreduce@s2   !+0  )cC s|j|ddkS(sm Check if ``poly`` belongs the ideal generated by ``self``. Examples ======== >>> from sympy import groebner >>> from sympy.abc import x, y >>> f = 2*x**3 + y**3 + 3*y >>> G = groebner([x**2 + y**2 - 1, x*y - 2]) >>> G.contains(f) True >>> G.contains(f + 1) False ii(RR(ReR((s4lib/python2.7/site-packages/sympy/polys/polytools.pytcontainss(RRRRLRRBRRJRRYR:RUR;RGRRJRhRRR?RQRcRRRS(((s4lib/python2.7/site-packages/sympy/polys/polytools.pyR>s&         B Ac stjgfdt|}|jrGt||Sdkr`td>> from sympy import poly >>> from sympy.abc import x >>> poly(x*(x**2 + x - 1)**2) Poly(x**5 + 2*x**4 - x**3 - 2*x**2 + x, x, domain='ZZ') c  s!gg}}xatj|D]P}gg}}xtj|D]}|jrh|j||q@|jr|jjr|jjr|jdkr|j|j|j |jq@|j|q@W|s|j|q|d}x!|dD]}|j |}qW|r`t|}|j rB|j |}q`|j t j ||}n|j|qW|st j ||} ny|d} x!|dD]}| j|} qW|rt|}|j r| j|} q| jt j ||} n| j|jddS(NiiR:((RRRRRRRRR~RRRR8RHRRaR( RRKRt poly_termsRR5t poly_factorsR|tproductR(t_polyRJ(s4lib/python2.7/site-packages/sympy/polys/polytools.pyRWsB   "      R(R=RRRFR8RR>(RR:RJRK((RWRJs4lib/python2.7/site-packages/sympy/polys/polytools.pyRs4    (Rt __future__RRt sympy.coreRRRRRRRR R tsympy.core.basicR tsympy.core.compatibilityR R Rtsympy.core.decoratorsRtsympy.core.functionRtsympy.core.mulRRRtsympy.core.symbolRtsympy.core.sympifyRtsympy.logic.boolalgRt sympy.polysRR=tsympy.polys.constructorRtsympy.polys.domainsRRRtsympy.polys.fglmtoolsRtsympy.polys.groebnertoolsRRAtsympy.polys.monomialsRtsympy.polys.orderingsRtsympy.polys.polyclassesRtsympy.polys.polyerrorsR R!R"R#R$R%R&R'R(R)R*tsympy.polys.polyutilsR+R,R-R.R/R0tsympy.polys.rationaltoolsR1tsympy.polys.rootisolationR2tsympy.utilitiesR3R4R5R6RXRrtmpmath.libmp.libhyperR7R8RRRRRRRRRRRRRRRRRRRRRRRRRRRRRVR!RR"RR#R%R&R'R)R*R.R/RR1R2RRRRRRR!R&R3R>R7R|RR9RGRVRcR_RzR}RRR7R?R>R(((s4lib/python2.7/site-packages/sympy/polys/polytools.pyts@L ."  ] ( _ 95##   #''4&)T2N2t./"   :  ) ,e!7'O<6