B dd@sdZddlmZmZddlmZddlmZmZm Z m Z ddl m Z ddl mZddlmZmZmZddlmZmZmZmZmZdd lmZdd lmZmZdd lmZm Z m!Z!dd l"m#Z#m$Z$dd l%m&Z&ddl'm(Z(m)Z)ddl*m+Z+m,Z,ddl-m.Z.m/Z/ddl0m1Z1ddl2m3Z4ddl5m6Z6ddl7m8Z8m9Z9m:Z:ddl;mZ>ddl?m@ZAddlBmCZCddlDmEZEddlFmGZGmHZHmIZIddlJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUddlVmWZWmXZXmYZYmZZZm[Z[m\Z\ddl]m^Z^ddl_m`Z`ddlambZbmcZcmdZddd lemfZfdd!lgmhZhmiZidd"l2Zjdd"lkZkdd#llmmZmd$d%ZnecGd&d'd'e ZoecGd(d)d)eoZpecd*d+Zqd,d-Zrecd.d/Zsd0d1Ztd2d3Zuecdd4d5Zvecd6d7Zwecd8d9Zxecd:d;Zyecdd?Z{ecd@dAZ|ecdBdCZ}ecdDdEZ~ecdFdGZecdHdIZecdJdKZecdLdMZecdNdOZecdPdQZecdRdSZecdTdUZecdVdWZecdXdYdZd[Zecd\d]Zecd^d_Zecd`daZecddbdcZecdddeZecddfdgZecdhdiZecdjdkZecdldmZecdndoZecdpdqZecdrdsZecdtduZecdvdwZecdxdyZecdzd{Zecd|d}Zecd~dZddZddZddZddZddZddZddZddZecddZecddZecddZecdXdddZecdddZecdddZecdddZecdddZecdddZecddZecddZecddddZecddZecddZ@ecddZecGddde ZecddZd"S)z8User-friendly public interface to polynomial functions. )wrapsreduce)mul)SExprAddTuple)Basic) _sympifyit)Factors factor_nc factor_terms) pure_complexevalffastlog_evalf_with_bounded_errorquad_to_mpmath) Derivative)Mul _keep_coeff)ilcmIInteger) RelationalEquality)ordered)DummySymbol)sympify_sympify)preorder_traversal bottom_up) BooleanAtom) polyoptions)construct_domain)FFQQZZ) DomainElement) matrix_fglm)groebner)Monomial) monomial_key)DMPDMFANP) OperationNotSupported DomainErrorCoercionFailedUnificationFailedGeneratorsNeededPolynomialErrorMultivariatePolynomialErrorExactQuotientFailedPolificationFailedComputationFailedGeneratorsError)basic_from_dict _sort_gens _unify_gens _dict_reorder_dict_from_expr_parallel_dict_from_expr)together)dup_isolate_real_roots_list)grouppublic filldedent)sympy_deprecation_warning)iterablesiftN) NoConvergencecstfdd}|S)Ncst|}t|tr||St|try|j|f|j}WnLtk r|jrVtSt | j }||}|tk rt dddd|SX||SntSdS)Na@ Mixing Poly with non-polynomial expressions in binary operations is deprecated. Either explicitly convert the non-Poly operand to a Poly with as_poly() or convert the Poly to an Expr with as_expr(). z1.6z)deprecated-poly-nonpoly-binary-operations)Zdeprecated_since_versionZactive_deprecations_target) r isinstancePolyr from_exprgensr5Z is_MatrixNotImplementedgetattras_expr__name__rF)fgZ expr_methodresult)funcb/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/sympy/polys/polytools.pywrapperCs&    z_polifyit..wrapper)r)rUrXrV)rUrW _polifyitBsrYcsBeZdZdZdZdZdZdZddZe ddZ e d d Z e d d Z d dZe ddZe ddZe ddZe ddZe ddZe ddZe ddZe ddZe dd Zfd!d"Ze d#d$Ze d%d&Ze d'd(Ze d)d*Ze d+d,Ze d-d.Ze d/d0Zd1d2Z d3d4Z!dtd6d7Z"d8d9Z#d:d;Z$dd?Z&d@dAZ'dBdCZ(dudDdEZ)dFdGZ*dHdIZ+dJdKZ,dLdMZ-dNdOZ.dPdQZ/dRdSZ0dvdTdUZ1dwdVdWZ2dxdXdYZ3dydZd[Z4dzd\d]Z5d^d_Z6d`daZ7dbdcZ8dddeZ9dfdgZ:d{didjZ;d|dkdlZdqdrZ?dsdtZ@d}dudvZAdwdxZBdydzZCd{d|ZDd}d~ZEddZFddZGddZHddZIddZJddZKddZLddZMddZNddZOddZPddZQddZRddZSd~ddZTdddZUdddZVdddZWddZXdddZYddZZddZ[ddZ\ddZ]dddZ^ddZ_dddZ`ddZaddZbdddZcdddZddddZeddd„ZfdddĄZgddƄZhddȄZidddʄZjdd̄Zkdd΄ZlddЄZmemZnddd҄ZoddԄZpdddքZqddd؄ZrdddڄZsdd܄ZtddބZudddZvddZwdddZxdddZyddZzddZ{ddZ|ddZ}dddZ~ddZddZddZddZddZddZdddZddZddZddZddZdddZdd d Zd d Zd dZdddZdddZdddZdddZdddZdddZdddZdd Zd!d"Zd#d$Zdd%d&Ze d'd(Ze d)d*Ze d+d,Ze d-d.Ze d/d0Ze d1d2Ze d3d4Ze d5d6Ze d7d8Ze d9d:Ze d;d<Ze d=d>Ze d?d@Ze dAdBZdCdDZdEdFZedGdHZedIdJZedKdLZedMdNZedOdPZedQdRZedSedTdUZedVdWZedXdYZedZd[Zed\d]Zed^d_Zed`daZedbedcddZedbededfZedgedhdiZedbedjdkZdldmZddndoZddpdqZdrdsZZS(rKaP Generic class for representing and operating on polynomial expressions. See :ref:`polys-docs` for general documentation. Poly is a subclass of Basic rather than Expr but instances can be converted to Expr with the :py:meth:`~.Poly.as_expr` method. .. deprecated:: 1.6 Combining Poly with non-Poly objects in binary operations is deprecated. Explicitly convert both objects to either Poly or Expr first. See :ref:`deprecated-poly-nonpoly-binary-operations`. 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 )reprMTgn$@cOst||}d|krtdt|ttttfr:|||St |t drnt|t r\| ||S| t||Sn&t|}|jr|||S|||SdS)z:Create a new polynomial instance out of something useful. orderz&'order' keyword is not implemented yet)excludeN)options build_optionsNotImplementedErrorrJr-r.r/r(_from_domain_elementrGstrdict _from_dict _from_listlistris_Poly _from_poly _from_expr)clsrZrMargsoptrVrVrW__new__s      z Poly.__new__cGsTt|tstd|n"|jt|dkr:td||ft|}||_||_|S)z:Construct :class:`Poly` instance from raw representation. z%invalid polynomial representation: %szinvalid arguments: %s, %s) rJr-r5levlenr rlrZrM)rirZrMobjrVrVrWnews   zPoly.newcCst|jf|jS)N)r;rZ to_sympy_dictrM)selfrVrVrWexprsz Poly.exprcCs|jf|jS)N)rtrM)rsrVrVrWrjsz Poly.argscCs|jf|jS)N)rZrM)rsrVrVrW_hashable_contentszPoly._hashable_contentcOst||}|||S)z(Construct a polynomial from a ``dict``. )r]r^rc)rirZrMrjrkrVrVrW from_dicts zPoly.from_dictcOst||}|||S)z(Construct a polynomial from a ``list``. )r]r^rd)rirZrMrjrkrVrVrW from_lists zPoly.from_listcOst||}|||S)z*Construct a polynomial from a polynomial. )r]r^rg)rirZrMrjrkrVrVrW from_polys zPoly.from_polycOst||}|||S)z+Construct a polynomial from an expression. )r]r^rh)rirZrMrjrkrVrVrWrLs zPoly.from_exprcCs||j}|stdt|d}|j}|dkr>t||d\}}n$x"|D]\}}||||<qHW|jt |||f|S)z(Construct a polynomial from a ``dict``. z0Cannot initialize from 'dict' without generatorsrmN)rk) rMr4rodomainr$itemsconvertrqr-rv)rirZrkrMlevelrymonomcoeffrVrVrWrcs zPoly._from_dictcCs~|j}|stdnt|dkr(tdt|d}|j}|dkrTt||d\}}ntt|j|}|j t |||f|S)z(Construct a polynomial from a ``list``. z0Cannot initialize from 'list' without generatorsrmz#'list' representation not supportedN)rk) rMr4ror6ryr$remapr{rqr-rw)rirZrkrMr|ryrVrVrWrds  zPoly._from_listcCs||jkr|j|jf|j}|j}|j}|j}|rj|j|krjt|jt|kr`|||S|j |}d|kr|r| |}n|dkr| }|S)z*Construct a polynomial from a polynomial. ryT) __class__rqrZrMfieldrysetrhrPreorder set_domainto_field)rirZrkrMrryrVrVrWrgs    zPoly._from_polycCst||\}}|||S)z+Construct a polynomial from an expression. )r?rc)rirZrkrVrVrWrh3szPoly._from_exprcCs>|j}|j}t|d}||g}|jt|||f|S)Nrm)rMryror{rqr-rw)rirZrkrMryr|rVrVrWr`9s   zPoly._from_domain_elementcs tS)N)super__hash__)rs)rrVrWrCsz Poly.__hash__cCsVt}|j}x>tt|D].}x(|D]}||r(|||jO}Pq(WqW||jBS)a Free symbols of a polynomial expression. Examples ======== >>> 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} )rrMrangeromonoms free_symbolsfree_symbols_in_domain)rssymbolsrMir}rVrVrWrFs zPoly.free_symbolscCsX|jjt}}|jr2x<|jD]}||jO}qWn"|jrTx|D]}||jO}qBW|S)aj 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} )rZdomr is_Compositerris_EXcoeffs)rsryrgenr~rVrVrWres zPoly.free_symbols_in_domaincCs |jdS)z Return the principal generator. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).gen x r)rM)rsrVrVrWrszPoly.gencCs|S)aGet the ground domain of a :py:class:`~.Poly` Returns ======= :py:class:`~.Domain`: Ground domain of the :py:class:`~.Poly`. Examples ======== >>> from sympy import Poly, Symbol >>> x = Symbol('x') >>> p = Poly(x**2 + x) >>> p Poly(x**2 + x, x, domain='ZZ') >>> p.domain ZZ ) get_domain)rsrVrVrWrysz Poly.domaincCs$|j|j|jj|jjf|jS)z3Return zero polynomial with ``self``'s properties. )rqrZzerornrrM)rsrVrVrWrsz Poly.zerocCs$|j|j|jj|jjf|jS)z2Return one polynomial with ``self``'s properties. )rqrZonernrrM)rsrVrVrWrszPoly.onecCs$|j|j|jj|jjf|jS)z3Return unit polynomial with ``self``'s properties. )rqrZunitrnrrM)rsrVrVrWrsz Poly.unitcCs"||\}}}}||||fS)a 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') )_unify)rRrS_perFGrVrVrWunifysz Poly.unifyc stjsZy&jjjjjjjfStk rXtdfYnXtjt rtjt rt j j }jj jj|t |d}j |krtjj |\}}jjkrfdd|D}t ttt|||}n j}j |krttjj |\}}jjkrXfdd|D}t ttt|||} n j} ntdfj|dffdd } | || fS)NzCannot unify %s with %srmcsg|]}|jjqSrV)r{rZr).0c)rrRrVrW szPoly._unify..csg|]}|jjqSrV)r{rZr)rr)rrSrVrWrscsB|dk r2|d|||dd}|s2||Sj|f|S)Nrm)to_sympyrq)rZrrMremove)rirVrWrs  zPoly._unify..per)rrfrZrr from_sympyr2r3rJr-r=rMrror>to_dictrbrezipr{r) rRrSrMrnZf_monomsZf_coeffsrZg_monomsZg_coeffsrrrV)rirrRrSrWrs6&"     z Poly._unifyNcCsV|dkr|j}|dk rD|d|||dd}|sD|jj|S|jj|f|S)ab 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') Nrm)rMrZrrrrq)rRrZrMrrVrVrWr szPoly.percCs&t|jd|i}||j|jS)z Set the ground domain of ``f``. ry)r]r^rMrrZr{ry)rRryrkrVrVrWr&szPoly.set_domaincCs|jjS)z Get the ground domain of ``f``. )rZr)rRrVrVrWr+szPoly.get_domaincCstj|}|t|S)z 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]ZModulus preprocessrr%)rRmodulusrVrVrW set_modulus/s zPoly.set_moduluscCs&|}|jrt|StddS)z Get the modulus of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, modulus=2).get_modulus() 2 z$not a polynomial over a Galois fieldN)rZis_FiniteFieldrZcharacteristicr5)rRryrVrVrW get_modulus@s zPoly.get_moduluscCsN||jkr>|jr|||Sy |||Stk r<YnX|||S)z)Internal implementation of :func:`subs`. )rM is_numberevalreplacer5rPsubs)rRoldrqrVrVrW _eval_subsUs   zPoly._eval_subscCsP|j\}}g}x.tt|jD]}||kr"||j|q"W|j||dS)a  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') )rM)rZr\rrorMappendr)rRJrqrMjrVrVrWr\bs z Poly.excludecKs|dkr$|jr|j|}}ntd||ks6||jkr:|S||jkr||jkr|}|jrf||jkrt|j}||||<|j |j |dStd|||fdS)a 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') Nz(syntax supported only in univariate case)rMzCannot replace %s with %s in %s) is_univariaterr5rMrrrreindexrrZ)rRxy_ignorerrMrVrVrWrys z Poly.replacecOs|j||S)z-Match expression from Poly. See Basic.match())rPmatch)rRrjkwargsrVrVrWrsz Poly.matchcOs|td|}|s t|j|d}nt|jt|kr:tdtttt |j |j|}|j t ||j jt|d|dS)a 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') rV)rkz7generators list can differ only up to order of elementsrm)rM)r]Optionsr<rMrr5rbrerr>rZrrr-rro)rRrMrjrkrZrVrVrWrs  z Poly.reordercCs|jdd}||}i}x@|D]4\}}t|d|rHtd|||||d<q$W|j|d}|jt|t |d|j j f|S)a( Remove dummy generators from ``f`` that are to the left of specified ``gen`` in the generators as ordered. When ``gen`` is an integer, it refers to the generator located at that position within the tuple of generators of ``f``. Examples ======== >>> 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') T)nativeNzCannot left trim %srm) as_dict _gen_to_levelrzanyr5rMrqr-rvrorZr)rRrrZrtermsr}r~rMrVrVrWltrims   z Poly.ltrimc Gst}xL|D]D}y|j|}Wn$tk rDtd||fYq X||q Wx6|D]*}x$t|D]\}}||krl|rldSqlWq^WdS)aJ 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 z%s doesn't have %s as generatorFT)rrMr ValueErrorr:addr enumerate)rRrMindicesrrr}reltrVrVrW has_only_genss   zPoly.has_only_genscCs,t|jdr|j}n t|d||S)z 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') to_ring)hasattrrZrr0r)rRrTrVrVrWrs   z Poly.to_ringcCs,t|jdr|j}n t|d||S)z 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') r)rrZrr0r)rRrTrVrVrWrs   z Poly.to_fieldcCs,t|jdr|j}n t|d||S)z 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') to_exact)rrZrr0r)rRrTrVrVrWr*s   z Poly.to_exactcCs4t|jdd||jjpdd\}}|j||j|dS)a 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') T)rN)rZ composite)ry)r$rryrrvrM)rRrrrZrVrVrWretract?s z Poly.retractcCsh|dkrd||}}}n ||}t|t|}}t|jdrT|j|||}n t|d||S)z1Take a continuous subsequence of terms of ``f``. Nrslice)rintrrZrr0r)rRrmnrrTrVrVrWrWs   z Poly.slicecsfddjj|dDS)aQ 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 csg|]}jj|qSrV)rZrr)rr)rRrVrWr{szPoly.coeffs..)r[)rZr)rRr[rV)rRrWrgsz Poly.coeffscCs|jj|dS)aU 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[)rZr)rRr[rVrVrWr}sz Poly.monomscsfddjj|dDS)ac 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 cs"g|]\}}|jj|fqSrV)rZrr)rrr)rRrVrWrszPoly.terms..)r[)rZr)rRr[rV)rRrWrsz Poly.termscsfddjDS)a 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] csg|]}jj|qSrV)rZrr)rr)rRrVrWrsz#Poly.all_coeffs..)rZ all_coeffs)rRrV)rRrWrszPoly.all_coeffscCs |jS)a? 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 )rZ all_monoms)rRrVrVrWrszPoly.all_monomscsfddjDS)a 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)] cs"g|]\}}|jj|fqSrV)rZrr)rrr)rRrVrWrsz"Poly.all_terms..)rZ all_terms)rRrV)rRrWrszPoly.all_termscOsvi}xX|D]L\}}|||}t|tr4|\}}n|}|r||krN|||<qtd|qW|j|f|pn|j|S)ah Apply a function to all terms of ``f``. Examples ======== >>> 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') z%s monomial was generated twice)rrJtupler5rvrM)rRrUrMrjrr}r~rTrVrVrWtermwises    z Poly.termwisecCs t|S)z 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 )ror)rRrVrVrWlengthsz Poly.lengthFcCs$|r|jj|dS|jj|dSdS)a 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} )rN)rZrrr)rRrrrVrVrWrsz Poly.as_dictcCs|r|jS|jSdS)z%Switch to a ``list`` representation. N)rZZto_listZ to_sympy_list)rRrrVrVrWas_list!s z Poly.as_listc Gs|s |jSt|dkrt|dtr|d}t|j}xP|D]D\}}y||}Wn$tk rzt d||fYq@X|||<q@Wt |j f|S)ar Convert a Poly instance to an Expr instance. Examples ======== >>> 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 rmrz%s doesn't have %s as generator) rtrorJrbrerMrzrrr:r;rZrr)rRrMmappingrvaluerrVrVrWrP(s  z Poly.as_exprcOs<y"t|f||}|jsdS|SWntk r6dSXdS)a{Converts ``self`` to a polynomial or returns ``None``. >>> from sympy import sin >>> from sympy.abc import x, y >>> print((x**2 + x*y).as_poly()) Poly(x**2 + x*y, x, y, domain='ZZ') >>> print((x**2 + x*y).as_poly(x, y)) Poly(x**2 + x*y, x, y, domain='ZZ') >>> print((x**2 + sin(y)).as_poly(x, y)) None N)rKrfr5)rsrMrjpolyrVrVrWas_polyNsz Poly.as_polycCs,t|jdr|j}n t|d||S)a 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') lift)rrZrr0r)rRrTrVrVrWrhs   z Poly.liftcCs4t|jdr|j\}}n t|d|||fS)a+ 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')) deflate)rrZrr0r)rRrrTrVrVrWr}s  z Poly.deflatecCsx|jj}|jr|S|js$td|t|jdr@|jj|d}n t|d|r\|j|j }n |j |j}|j |f|S)a 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') z Cannot inject generators over %sinject)front) rZr is_Numericalrfr1rrr0rrMrq)rRrrrTrMrVrVrWrs    z Poly.injectcGs|jj}|jstd|t|}|jd||krJ|j|dd}}n4|j| d|krv|jd| d}}ntd|j|}t|jdr|jj ||d}n t |d|j |f|S)a 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]') zCannot eject generators over %sNTFz'can only eject front or back generatorseject)r) rZrrr1rorMr_rrrr0rq)rRrMrkZ_gensrrTrVrVrWrs    z Poly.ejectcCs4t|jdr|j\}}n t|d|||fS)a 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')) terms_gcd)rrZrr0r)rRrrTrVrVrWrs  zPoly.terms_gcdcCs.t|jdr|j|}n t|d||S)z 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') add_ground)rrZrr0r)rRr~rTrVrVrWrs  zPoly.add_groundcCs.t|jdr|j|}n t|d||S)z 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') sub_ground)rrZrr0r)rRr~rTrVrVrWr s  zPoly.sub_groundcCs.t|jdr|j|}n t|d||S)z 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') mul_ground)rrZrr0r)rRr~rTrVrVrWr s  zPoly.mul_groundcCs.t|jdr|j|}n t|d||S)aO 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') quo_ground)rrZrr0r)rRr~rTrVrVrWr5s  zPoly.quo_groundcCs.t|jdr|j|}n t|d||S)a 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 exquo_ground)rrZrr0r)rRr~rTrVrVrWrMs  zPoly.exquo_groundcCs,t|jdr|j}n t|d||S)z 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') abs)rrZrr0r)rRrTrVrVrWrgs   zPoly.abscCs,t|jdr|j}n t|d||S)a4 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') neg)rrZrr0r)rRrTrVrVrWr|s   zPoly.negcCsTt|}|js||S||\}}}}t|jdrB||}n t|d||S)a[ 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)rrfrrrrZrr0)rRrSrrrrrTrVrVrWrs    zPoly.addcCsTt|}|js||S||\}}}}t|jdrB||}n t|d||S)a` 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') sub)rrfrrrrZrr0)rRrSrrrrrTrVrVrWrs    zPoly.subcCsTt|}|js||S||\}}}}t|jdrB||}n t|d||S)ap 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') r)rrfrrrrZrr0)rRrSrrrrrTrVrVrWrs    zPoly.mulcCs,t|jdr|j}n t|d||S)a3 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') sqr)rrZrr0r)rRrTrVrVrWrs   zPoly.sqrcCs6t|}t|jdr"|j|}n t|d||S)aX 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') pow)rrrZrr0r)rRrrTrVrVrWr s   zPoly.powcCsH||\}}}}t|jdr.||\}}n t|d||||fS)a# 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')) pdiv)rrrZrr0)rRrSrrrrqrrVrVrWr#s   z Poly.pdivcCs<||\}}}}t|jdr*||}n t|d||S)aN 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') prem)rrrZrr0)rRrSrrrrrTrVrVrWr:s    z Poly.premcCs<||\}}}}t|jdr*||}n t|d||S)a 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') pquo)rrrZrr0)rRrSrrrrrTrVrVrWras    z Poly.pquoc Csx||\}}}}t|jdrfy||}Wqptk rb}z|||Wdd}~XYqpXn t|d||S)a 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 pexquoN)rrrZrr7rqrPr0)rRrSrrrrrTexcrVrVrWr}s ( z Poly.pexquoc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdrX||\}} n t|d|ry|| } } Wnt k rYn X| | }} |||| fS)a 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')) FTdiv) ris_Ringis_FieldrrrZrr0rr2) rRrSautorrrrrrrQRrVrVrWrs   zPoly.divc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdrT||}n t|d|ry |}Wnt k rYnX||S)ao 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') FTrem) rrrrrrZrr0rr2) rRrSrrrrrrrrVrVrWrs    zPoly.remc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdrT||}n t|d|ry |}Wnt k rYnX||S)aa 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') FTquo) rrrrrrZrr0rr2) rRrSrrrrrrrrVrVrWrs    zPoly.quoc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdry||}Wqtk r} z| | | Wdd} ~ XYqXn t |d|ry | }Wnt k rYnX||S)a 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 FTexquoN) rrrrrrZrr7rqrPr0rr2) rRrSrrrrrrrrrVrVrWr s" (  z Poly.exquocCst|trXt|j}| |kr*|krDnn|dkr>||S|Sqtd|||fn2y|jt|Stk rtd|YnXdS)z3Returns level associated with the given generator. rz -%s <= gen < %s expected, got %sz"a valid generator expected, got %sN)rJrrorMr5rrr)rRrrrVrVrWr7s  zPoly._gen_to_levelrcCs0||}t|jdr"|j|St|ddS)au 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 degreeN)rrrZrr0)rRrrrVrVrWrKs   z Poly.degreecCs$t|jdr|jSt|ddS)z 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) degree_listN)rrZrr0)rRrVrVrWrfs  zPoly.degree_listcCs$t|jdr|jSt|ddS)a 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 total_degreeN)rrZrr0)rRrVrVrWrys  zPoly.total_degreecCs~t|tstdt|||jkr8|j|}|j}nt|j}|j|f}t|jdrp|j |j ||dSt |ddS)a 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') z``Symbol`` expected, got %s homogenize)rMhomogeneous_orderN) rJr TypeErrortyperMrrorrZrrr0)rRsrrMrVrVrWrs      zPoly.homogenizecCs$t|jdr|jSt|ddS)a- 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)rrZrr0)rRrVrVrWrs  zPoly.homogeneous_ordercCsF|dk r||dSt|jdr.|j}n t|d|jj|S)z 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 NrLC)rrrZrr0rr)rRr[rTrVrVrWrs    zPoly.LCcCs0t|jdr|j}n t|d|jj|S)z 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 TC)rrZrr0rr)rRrTrVrVrWrs   zPoly.TCcCs(t|jdr||dSt|ddS)z 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 rECN)rrZrr0)rRr[rVrVrWrs zPoly.ECcCs|jt||jjS)aE 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 )nthr+rM exponents)rRr}rVrVrWcoeff_monomial s#zPoly.coeff_monomialcGsVt|jdr>t|t|jkr&td|jjttt|}n t |d|jj |S)a. 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 rz,exponent of each generator must be specified) rrZrorMrrrerrr0rr)rRNrTrVrVrWr.s   zPoly.nthrmcCs tddS)NzyEither convert to Expr with `as_expr` method to use Expr's coeff method or else use the `coeff_monomial` method of Polys.)r_)rRrrrightrVrVrWr~Psz Poly.coeffcCst||d|jS)a 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 r)r+rrM)rRr[rVrVrWLM\szPoly.LMcCst||d|jS)z 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 r)r+rrM)rRr[rVrVrWEMpszPoly.EMcCs"||d\}}t||j|fS)a 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) r)rr+rM)rRr[r}r~rVrVrWLTszPoly.LTcCs"||d\}}t||j|fS)z 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) r)rr+rM)rRr[r}r~rVrVrWETszPoly.ETcCs0t|jdr|j}n t|d|jj|S)z 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 max_norm)rrZrr0rr)rRrTrVrVrWrs   z Poly.max_normcCs0t|jdr|j}n t|d|jj|S)z 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 l1_norm)rrZrr0rr)rRrTrVrVrWrs   z Poly.l1_normcCs|}|jjjstj|fS|}|jr2|jj}t|jdrN|j \}}n t |d| || |}}|rx|js||fS|| fSdS)a 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')) clear_denomsN)rZrrrOnerhas_assoc_Ringget_ringrrr0rrr)rsr{rRrr~rTrVrVrWrs      zPoly.clear_denomscCsv|}||\}}}}||}||}|jr2|js:||fS|jdd\}}|jdd\}}||}||}||fS)a 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]') T)r{)rrrrr)rsrSrRrrabrVrVrWrat_clear_denomss   zPoly.rat_clear_denomscOs|}|ddr"|jjjr"|}t|jdr|sF||jjddS|j}x@|D]8}t|t rj|\}}n |d}}|t || |}qRW||St |ddS)a 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 integraterm)rN) getrZrrrrrrrJrrrr0)rsspecsrjrRrZspecrrrVrVrWr s      zPoly.integratecOs|ddst|f||St|jdr|s@||jjddS|j}x@|D]8}t|trd|\}}n |d}}|t|| |}qLW||St |ddS)aX 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') evaluateTdiffrm)rN) rrrrZrrrJrrrr0)rRrrrZrrrrVrVrWrF s       z Poly.diffc Cs\|}|dkrt|tr@|}x |D]\}}|||}q$W|St|ttfr|}t|t|jkrltdx$t |j|D]\}}|||}qzW|Sd|} }n | |} t |j dst |dy|j || } Wnxtk rL|std||j jfnFt|g\} \}|| |j} || }| || }|j || } YnX|j| | dS)a 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') Nztoo many values providedrrzCannot evaluate at %s in %s)r)rJrbrzrrrerorMrrrrrZr0r2r1rr$rZunify_with_symbolsrr{r) rsrrrrRrrrvaluesrrTZa_domainZ new_domainrVrVrWrn s:       z Poly.evalcGs ||S)az 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)rRrrVrVrW__call__ sz Poly.__call__c Csd||\}}}}|r.|jr.||}}t|jdrJ||\}}n t|d||||fS)a 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')) half_gcdex)rrrrrZr!r0) rRrSrrrrrrhrVrVrWr! s   zPoly.half_gcdexc Csl||\}}}}|r.|jr.||}}t|jdrL||\}}} n t|d|||||| fS)a 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')) gcdex)rrrrrZr#r0) rRrSrrrrrrtr"rVrVrWr# s   z Poly.gcdexcCsX||\}}}}|r.|jr.||}}t|jdrF||}n t|d||S)a 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 invert)rrrrrZr%r0)rRrSrrrrrrTrVrVrWr% s    z Poly.invertcCs2t|jdr|jt|}n t|d||S)ad 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 - 2, x).revert(2) Traceback (most recent call last): ... NotReversible: only units are 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 revert)rrZr&rr0r)rRrrTrVrVrWr&. s  z Poly.revertcCsB||\}}}}t|jdr*||}n t|dtt||S)ad 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')] subresultants)rrrZr'r0rer)rRrSrrrrrTrVrVrWr'P s    zPoly.subresultantsc Csv||\}}}}t|jdrB|r6|j||d\}}qL||}n t|d|rj||ddtt||fS||ddS)a 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')]) resultant) includePRSr)r)rrrZr(r0rer) rRrSr)rrrrrTrrVrVrWr(i s   zPoly.resultantcCs0t|jdr|j}n t|d|j|ddS)z Computes the discriminant of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 2*x + 3, x).discriminant() -8 discriminantr)r)rrZr*r0r)rRrTrVrVrWr* s   zPoly.discriminantcCsddlm}|||S)aCompute 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]_ r) dispersionset)sympy.polys.dispersionr+)rRrSr+rVrVrWr+ sH zPoly.dispersionsetcCsddlm}|||S)aCompute 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]_ r) dispersion)r,r-)rRrSr-rVrVrWr- sH zPoly.dispersionc CsP||\}}}}t|jdr0||\}}}n t|d||||||fS)a# 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')) cofactors)rrrZr.r0) rRrSrrrrr"cffcfgrVrVrWr.9 s   zPoly.cofactorscCs<||\}}}}t|jdr*||}n t|d||S)a  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') gcd)rrrZr1r0)rRrSrrrrrTrVrVrWr1V s    zPoly.gcdcCs<||\}}}}t|jdr*||}n t|d||S)a 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') lcm)rrrZr2r0)rRrSrrrrrTrVrVrWr2m s    zPoly.lcmcCs<|jj|}t|jdr(|j|}n t|d||S)a 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') trunc)rZrr{rr3r0r)rRprTrVrVrWr3 s   z Poly.trunccCsF|}|r|jjjr|}t|jdr2|j}n t|d||S)az 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') monic)rZrrrrr5r0r)rsrrRrTrVrVrWr5 s   z Poly.moniccCs0t|jdr|j}n t|d|jj|S)z 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 content)rrZr6r0rr)rRrTrVrVrWr6 s   z Poly.contentcCs>t|jdr|j\}}n t|d|jj|||fS)a 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')) primitive)rrZr7r0rrr)rRcontrTrVrVrWr7 s  zPoly.primitivecCs<||\}}}}t|jdr*||}n t|d||S)a 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') compose)rrrZr9r0)rRrSrrrrrTrVrVrWr9 s    z Poly.composecCs2t|jdr|j}n t|dtt|j|S)a= 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')] decompose)rrZr:r0rerr)rRrTrVrVrWr: s   zPoly.decomposecCs.t|jdr|j|}n t|d||S)a 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') shift)rrZr;r0r)rRrrTrVrVrWr; s  z Poly.shiftcCs^||\}}||\}}||\}}t|jdrJ|j|j|j}n t|d||S)a3 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') transform)rrrZr<r0r)rRr4rPrrrTrVrVrWr<# s  zPoly.transformcCsL|}|r|jjjr|}t|jdr2|j}n t|dtt|j |S)a 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')] sturm) rZrrrrr>r0rerr)rsrrRrTrVrVrWr>= s   z Poly.sturmcs4tjdrj}n tdfdd|DS)aI 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)] gff_listcsg|]\}}||fqSrV)r)rrSr)rRrVrWro sz!Poly.gff_list..)rrZr?r0)rRrTrV)rRrWr?Z s   z Poly.gff_listcCs,t|jdr|j}n t|d||S)a 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') norm)rrZr@r0r)rRrrVrVrWr@q s   z Poly.normcCs>t|jdr|j\}}}n t|d|||||fS)af 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') sqf_norm)rrZrAr0r)rRrrSrrVrVrWrA s  z Poly.sqf_normcCs,t|jdr|j}n t|d||S)z 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') sqf_part)rrZrBr0r)rRrTrVrVrWrB s   z Poly.sqf_partcsHtjdrj|\}}n tdjj|fdd|DfS)a  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)]) sqf_listcsg|]\}}||fqSrV)r)rrSr)rRrVrWr sz!Poly.sqf_list..)rrZrCr0rr)rRallr~factorsrV)rRrWrC s  z Poly.sqf_listcs6tjdrj|}n tdfdd|DS)a 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)] sqf_list_includecsg|]\}}||fqSrV)r)rrSr)rRrVrWr sz)Poly.sqf_list_include..)rrZrFr0)rRrDrErV)rRrWrF s  zPoly.sqf_list_includecsltjdrByj\}}WqLtk r>tjdfgfSXn tdjj|fdd|DfS)a~ 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)]) factor_listrmcsg|]\}}||fqSrV)r)rrSr)rRrVrWr sz$Poly.factor_list..) rrZrGr1rrr0rr)rRr~rErV)rRrWrG s  zPoly.factor_listcsTtjdr8yj}WqBtk r4dfgSXn tdfdd|DS)a 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)] factor_list_includermcsg|]\}}||fqSrV)r)rrSr)rRrVrWr: sz,Poly.factor_list_include..)rrZrHr1r0)rRrErV)rRrWrH! s  zPoly.factor_list_includec Cs |dk r"t|}|dkr"td|dk r4t|}|dk rFt|}t|jdrl|jj||||||d}n t|d|rdd}|stt||Sdd } |\} } tt|| tt| | fSd d}|stt||Sd d } |\} } tt|| tt| | fSdS) a 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)] Nrz!'eps' must be a positive rational intervals)rDepsinfsupfastsqfcSs|\}}t|t|fS)N)r&r)intervalrr$rVrVrW_realh szPoly.intervals.._realcSs@|\\}}\}}t|tt|t|tt|fS)N)r&rr) rectangleuvrr$rVrVrW_complexo sz Poly.intervals.._complexcSs$|\\}}}t|t|f|fS)N)r&r)rOrr$rrVrVrWrPx s cSsH|\\\}}\}}}t|tt|t|tt|f|fS)N)r&rr)rQrRrSrr$rrVrVrWrT s) r&r{rrrZrIr0rer) rRrDrJrKrLrMrNrTrPrTZ real_partZ complex_partrVrVrWrI< s2     zPoly.intervalsc Cs|r|jstdt|t|}}|dk rJt|}|dkrJtd|dk r\t|}n |dkrhd}t|jdr|jj|||||d\}}n t |dt |t |fS)a 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) z&only square-free polynomials supportedNrz!'eps' must be a positive rationalrm refine_root)rJstepsrM) is_sqfr5r&r{rrrrZrUr0r) rRrr$rJrVrM check_sqfrTrVrVrWrU s     zPoly.refine_rootcCsLd\}}|dk r^t|}|tjkr(d}n6|\}}|sDt|}ntttj||fd}}|dk rt|}|tjkr~d}n6|\}}|st|}ntttj||fd}}|r|rt |j dr|j j ||d}n t |dn^|r|dk r|tj f}|r|dk r|tj f}t |j dr:|j j||d}n t |dt|S)a< 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 )TTNFcount_real_roots)rKrLcount_complex_roots)rrNegativeInfinity as_real_imagr&r{rerInfinityrrZrZr0rr[r)rRrKrLZinf_realZsup_realreZimcountrVrVrW count_roots s:           zPoly.count_rootscCstjjj|||dS)a  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) )radicals)sympypolys rootoftoolsZrootof)rRrrbrVrVrWroot sz Poly.rootcCs,tjjjj||d}|r|St|ddSdS)aL 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)] )rbF)multipleN)rcrdreCRootOf real_rootsrC)rRrgrbZrealsrVrVrWri szPoly.real_rootscCs,tjjjj||d}|r|St|ddSdS)a 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)] )rbF)rgN)rcrdrerh all_rootsrC)rRrgrbrootsrVrVrWrj szPoly.all_roots2c sddlm|jrtd||dkr.gS|jjtkrNdd|D}n|jjt krdd|D}t |fdd|D}nNfdd|D}yd d|D}Wn$t k rt d |jjYnXt jj}t j_zy>t j|||d |d d }tttt|fddd}Wn|tk ry>t j|||d |dd }tttt|fddd}Wn&tk rtd|fYnXYnXWd|t j_X|S)a 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] r)signz$Cannot compute numerical roots of %scSsg|] }t|qSrV)r)rr~rVrVrWr^szPoly.nroots..cSsg|] }|jqSrV)r)rr~rVrVrWr`scsg|]}t|qSrV)r)rr~)facrVrWrbscsg|]}|jdqS))r)rr])rr~)rrVrWrdscSsg|]}tj|qSrV)mpmathZmpc)rr~rVrVrWrgsz!Numerical domain expected, got %sF )maxstepscleanuperrorZ extrapreccs$|jr dnd|jt|j|jfS)Nrmr)imagrealr)r)rnrVrWxzPoly.nroots..)keyrlcs$|jr dnd|jt|j|jfS)Nrmr)rurvr)r)rnrVrWrwrxz7convergence to root failed; try n < %s or maxsteps > %sN)Z$sympy.functions.elementary.complexesrnis_multivariater6rrZrr'rr&rrr1rpmpdpsZ polyrootsrerrsortedrI)rRrrrrsrZdenomsr|rkrV)rorrnrWnroots9sL        z Poly.nrootscCsT|jrtd|i}x8|dD](\}}|jr$|\}}||| |<q$W|S)a Compute roots of ``f`` by factorization in the ground domain. Examples ======== >>> 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} z!Cannot compute ground roots of %srm)rzr6rG is_linearr)rRrkfactorrrrrVrVrW ground_rootss  zPoly.ground_rootscCsr|jrtdt|}|jr.|dkr.t|}n td||j}td}||j |||||}| ||S)af 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') zmust be a univariate polynomialrmz&'n' must an integer and n >= 1, got %sr$) rzr6r is_Integerrrrrr(rrLr)rRrr rr$rrVrVrWnth_power_roots_polys  zPoly.nth_power_roots_polyc s|jrtd|j}|j|}|d}td|di\}}}}t|}|d|dfdd} | || |} } | j | j d| j | j d|kS)a Decide whether two roots of this polynomial are equal. Examples ======== >>> from sympy import Poly, cyclotomic_poly, exp, I, pi >>> f = Poly(cyclotomic_poly(5)) >>> r0 = exp(2*I*pi/5) >>> indices = [i for i, r in enumerate(f.all_roots()) if f.same_root(r, r0)] >>> print(indices) [3] Raises ====== DomainError If the domain of the polynomial is not :ref:`ZZ`, :ref:`QQ`, :ref:`RR`, or :ref:`CC`. MultivariatePolynomialError If the polynomial is not univariate. PolynomialError If the polynomial is of degree < 2. zMust be a univariate polynomial rmcstt|dS)N)r)rr)r)rrVrWrwrxz Poly.same_root..) rzr6rZZmignotte_sep_bound_squaredry get_fieldrrrrvru) rRrrZ dom_delta_sqZdelta_sqZeps_sqrrrZevABrV)rrW same_roots  zPoly.same_rootc Cs||\}}}}t|dr,|j||d}n t|d|s~|jrH|}|\}} } } ||}|| } || || || fStt||SdS)a 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')) cancel)includeN) rrrr0rrrrr) rRrSrrrrrrTcpcqr4rrVrVrWrs     z Poly.cancelcCs|jjS)a 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 )rZis_zero)rRrVrVrWr$sz Poly.is_zerocCs|jjS)a 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 )rZis_one)rRrVrVrWr7sz Poly.is_onecCs|jjS)a  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 )rZrW)rRrVrVrWrWJsz Poly.is_sqfcCs|jjS)a  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 )rZis_monic)rRrVrVrWr]sz Poly.is_moniccCs|jjS)a; 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 )rZ is_primitive)rRrVrVrWrpszPoly.is_primitivecCs|jjS)aJ 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 )rZ is_ground)rRrVrVrWrszPoly.is_groundcCs|jjS)a, 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 )rZr)rRrVrVrWrszPoly.is_linearcCs|jjS)a6 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 )rZ is_quadratic)rRrVrVrWrszPoly.is_quadraticcCs|jjS)a% 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 )rZ is_monomial)rRrVrVrWrszPoly.is_monomialcCs|jjS)aZ 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 )rZis_homogeneous)rRrVrVrWrszPoly.is_homogeneouscCs|jjS)aG 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 )rZis_irreducible)rRrVrVrWrszPoly.is_irreduciblecCst|jdkS)a 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 rm)rorM)rRrVrVrWrszPoly.is_univariatecCst|jdkS)a 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 rm)rorM)rRrVrVrWrzszPoly.is_multivariatecCs|jjS)a 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 )rZ is_cyclotomic)rRrVrVrWr*szPoly.is_cyclotomiccCs|S)N)r)rRrVrVrW__abs__Bsz Poly.__abs__cCs|S)N)r)rRrVrVrW__neg__Esz Poly.__neg__cCs ||S)N)r)rRrSrVrVrW__add__Hsz Poly.__add__cCs ||S)N)r)rRrSrVrVrW__radd__Lsz Poly.__radd__cCs ||S)N)r)rRrSrVrVrW__sub__Psz Poly.__sub__cCs ||S)N)r)rRrSrVrVrW__rsub__Tsz Poly.__rsub__cCs ||S)N)r)rRrSrVrVrW__mul__Xsz Poly.__mul__cCs ||S)N)r)rRrSrVrVrW__rmul__\sz Poly.__rmul__rcCs |jr|dkr||StSdS)Nr)rrrN)rRrrVrVrW__pow__`s z Poly.__pow__cCs ||S)N)r)rRrSrVrVrW __divmod__gszPoly.__divmod__cCs ||S)N)r)rRrSrVrVrW __rdivmod__kszPoly.__rdivmod__cCs ||S)N)r)rRrSrVrVrW__mod__osz Poly.__mod__cCs ||S)N)r)rRrSrVrVrW__rmod__ssz Poly.__rmod__cCs ||S)N)r)rRrSrVrVrW __floordiv__wszPoly.__floordiv__cCs ||S)N)r)rRrSrVrVrW __rfloordiv__{szPoly.__rfloordiv__rScCs||S)N)rP)rRrSrVrVrW __truediv__szPoly.__truediv__cCs||S)N)rP)rRrSrVrVrW __rtruediv__szPoly.__rtruediv__otherc Csv||}}|jsFy|j||j|d}Wntttfk rDdSX|j|jkrVdS|jj|jjkrjdS|j|jkS)N)ryF) rfrrMrr5r1r2rZr)rsrrRrSrVrVrW__eq__s  z Poly.__eq__cCs ||k S)NrV)rRrSrVrVrW__ne__sz Poly.__ne__cCs|j S)N)r)rRrVrVrW__bool__sz Poly.__bool__cCs|s ||kS|t|SdS)N) _strict_eqr)rRrSstrictrVrVrWeqszPoly.eqcCs|j||d S)N)r)r)rRrSrrVrVrWneszPoly.necCs*t||jo(|j|jko(|jj|jddS)NT)r)rJrrMrZr)rRrSrVrVrWrszPoly._strict_eq)NN)N)N)N)N)N)N)FF)F)F)T)T)T)T)r)N)N)rmF)N)N)N)N)F)NT)T)T)T)F)N)N)T)T)F)F)FNNNFF)NNFF)NN)T)TT)TT)rlrmT)F)F)F)rQ __module__ __qualname____doc__ __slots__is_commutativerfZ _op_priorityrl classmethodrqpropertyrtrjrurvrwrxrLrcrdrgrhr`rrrrryrrrrrrrrrrrr\rrrrrrrrrrrrrrrrrrrrrPrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rr~r r rrrrrrrrZ_eval_derivativerr r!r#r%r&r'r(r*r+r-r.r1r2r3r5r6r7r9r:r;r<r>r?r@rArBrCrFrGrHrIrUrarfrirjr~rrrrrrrWrrrrrrrrrrzrrrrYrrrrrrr rNrrrrrrrrrrrrrrr __classcell__rVrV)rrWrKdsr5                   3   #$"     %  & %*' ' % % * "  %"     ''(& K  ! " % K K    #  !  L%?P  ( 3%   rKcsVeZdZdZddZfddZeddZede d d Z d d Z d dZ Z S)PurePolyz)Class for representing pure polynomials. cCs|jfS)z$Allow SymPy to hash Poly instances. )rZ)rsrVrVrWruszPurePoly._hashable_contentcs tS)N)rr)rs)rrVrWrszPurePoly.__hash__cCs|jS)aR 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} )r)rsrVrVrWrszPurePoly.free_symbolsrc Cs||}}|jsFy|j||j|d}Wntttfk rDdSXt|jt|jkr^dS|jj |jj kry|jj |jj |j}Wnt k rdSX| |}| |}|j|jkS)N)ryF) rfrrMrr5r1r2rorZrrr3r)rsrrRrSrrVrVrWrs    zPurePoly.__eq__cCst||jo|jj|jddS)NT)r)rJrrZr)rRrSrVrVrWrszPurePoly._strict_eqcst|}|jsZy&|jj|j|j|j|jj|fStk rXtd||fYnXt|j t|j kr~td||ft |jt rt |jt std||f|j |j }|jj |jj|}|j|}|j|}||dffdd }||||fS)NzCannot unify %s with %scsB|dk r2|d|||dd}|s2||Sj|f|S)Nrm)rrq)rZrrMr)rirVrWrs  zPurePoly._unify..per)rrfrZrrrr2r3rorMrJr-rrr{)rRrSrMrrrrrV)rirWrs"&   zPurePoly._unify)rQrrrrurrrr rNrrrrrVrV)rrWrs  rcOst||}t||S)z+Construct a polynomial from an expression. )r]r^_poly_from_expr)rtrMrjrkrVrVrWpoly_from_expr s rcCs|t|}}t|ts&t|||nJ|jrb|j||}|j|_|j|_|j dkrZd|_ ||fS|j rp| }t ||\}}|jst|||t t t |\}}|j}|dkrt||d\|_}nt t|j|}tt t ||}t||}|j dkr d|_ ||fS)z+Construct a polynomial from an expression. NT)rkF)rrJr r8rfrrgrMryrdexpandr?rerrzr$rrrbrKrc)rtrkorigrrZrrryrVrVrWrs2     rcOst||}t||S)z(Construct polynomials from expressions. )r]r^_parallel_poly_from_expr)exprsrMrjrkrVrVrWparallel_poly_from_expr:s rcCsddlm}t|dkr|\}}t|trt|tr|j||}|j||}||\}}|j|_|j |_ |j dkr~d|_ ||g|fSt |g}}gg}}d}x`t |D]T\} } t | } t| tr| jr|| q|| |jr| } nd}|| qW|rt|||d|rBx|D]} || || <q(Wt||\} }|jsft|||dx$|jD]} t| |rntdqnWgg} }g}g}xH| D]@}t tt |\}}| ||||t|qW|j }|dkr t| |d\|_ } nt t|j| } x,|D]$} || d| | | d} q"Wg}x@t||D]2\}}tt t||}t||}||qZW|j dkrt||_ ||fS) z(Construct polynomials from expressions. r) PiecewiserNTFz&Piecewise generators do not make sense)rk)$sympy.functions.elementary.piecewiserrorJrKrrgrrMryrdrerrr rfrrr8rPr@r5rrzextendr$rrrbrcbool)rrkrrRrSZorigsZ_exprsZ_polysfailedrrtrepsrZ coeffs_listlengthsrrrZrrryrdrrVrVrWrAsv                     rcCst|}||kr|||<|S)z7Add a new ``(key, value)`` pair to arguments ``dict``. )rb)rjryrrVrVrW _update_argssrcCst|dd}t|ddj}|jr0|}|j}n*|j}|sZ|rLt|\}}nt||\}}|rn|rhtjStjS|s|jr||jkrt|\}}||jkrtjSn4|jst |j dkrt t d|t t|j |f||}t|trt|StjS)a Return the degree of ``f`` in the given variable. The degree of 0 is negative infinity. Examples ======== >>> 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 ======== sympy.polys.polytools.Poly.total_degree degree_list T)rrmz 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). )r is_NumberrfrPrrZeror\rMrorrrEnextrrrJrr)rRrZ gen_is_Numr4ZisNumrrTrVrVrWrs,    rcGsHt|}|jr|}|jr"d}n|jr2|p0|j}t||}t|S)a Return the total_degree of ``f`` in the given variables. Examples ======== >>> from sympy import total_degree, Poly >>> from sympy.abc import x, y >>> 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 r)rrfrPrrMrKrr)rRrMr4rvrVrVrWrs( rc Oslt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|}ttt|S)z 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) rdrrmN) r] allowed_flagsrr8r9rrrr)rRrMrjrrkrdegreesrVrVrWrsrc Osdt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|j|jdS)z 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 rdrrmN)r[)r]rrr8r9rr[)rRrMrjrrkrrVrVrWr5s rc Oslt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|j|jd}|S)z 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 rdr rmN)r[)r]rrr8r9r r[rP)rRrMrjrrkrr}rVrVrWr Nsr c Ostt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|j|jd\}}||S)z 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 rdrrmN)r[)r]rrr8r9rr[rP)rRrMrjrrkrr}r~rVrVrWrhsrc Ost|dgy t||ff||\\}}}Wn.tk r\}ztdd|Wdd}~XYnX||\}} |js|| fS|| fSdS)z 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) rdrrN)r]rrr8r9rrdrP) rRrSrMrjrrrkrrrrVrVrWrs rc Os~t|dgy t||ff||\\}}}Wn.tk r\}ztdd|Wdd}~XYnX||}|jsv|S|SdS)z 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 rdrrN)r]rrr8r9rrdrP) rRrSrMrjrrrkrrrVrVrWrs  rc Ost|dgy t||ff||\\}}}Wn.tk r\}ztdd|Wdd}~XYnXy||}Wntk rt||YnX|js|S|SdS)z 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 rdrrN) r]rrr8r9rr7rdrP) rRrSrMrjrrrkrrrVrVrWrs rc Os~t|dgy t||ff||\\}}}Wn.tk r\}ztdd|Wdd}~XYnX||}|jsv|S|SdS)a_ 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 rdrrN)r]rrr8r9rrdrP) rRrSrMrjrrrkrrrVrVrWrs  rc Ost|ddgy t||ff||\\}}}Wn.tk r^}ztdd|Wdd}~XYnX|j||jd\}} |js|| fS|| fSdS)a 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) rrdrrN)r) r]rrr8r9rrrdrP) rRrSrMrjrrrkrrrrVrVrWrs rc Ost|ddgy t||ff||\\}}}Wn.tk r^}ztdd|Wdd}~XYnX|j||jd}|js~|S|SdS)a 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 rrdrrN)r) r]rrr8r9rrrdrP) rRrSrMrjrrrkrrrVrVrWr$s rc Ost|ddgy t||ff||\\}}}Wn.tk r^}ztdd|Wdd}~XYnX|j||jd}|js~|S|SdS)z 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 rrdrrN)r) r]rrr8r9rrrdrP) rRrSrMrjrrrkrrrVrVrWrDs rc Ost|ddgy t||ff||\\}}}Wn.tk r^}ztdd|Wdd}~XYnX|j||jd}|js~|S|SdS)aQ 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 rrdrrN)r) r]rrr8r9rrrdrP) rRrSrMrjrrrkrrrVrVrWrds rc Ost|ddgy t||ff||\\}}}Wn~tk r}z`t|j\}\} } y|| | \} } Wn tk rtdd|YnX| | | | fSWdd}~XYnX|j||j d\} } |j s| | fS| | fSdS)aT 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) rrdr!rN)r) r]rrr8r$rr!r_r9rrrdrP) rRrSrMrjrrrkrryrrrr"rVrVrWr!s &r!c Ost|ddgy t||ff||\\}}}Wntk r}zjt|j\}\} } y|| | \} } } Wn tk rtdd|YnX| | | | | | fSWdd}~XYnX|j||j d\} } } |j s| | | fS| | | fSdS)aZ 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) rrdr#rN)r) r]rrr8r$rr#r_r9rrrdrP)rRrSrMrjrrrkrryrrrr$r"rVrVrWr#s .r#c Ost|ddgy t||ff||\\}}}Wnhtk r}zJt|j\}\} } y||| | Stk rt dd|YnXWdd}~XYnX|j||j d} |j s| S| SdS)a Invert ``f`` modulo ``g`` when possible. Examples ======== >>> from sympy import invert, S, 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 :obj:`~.mod_inverse` function: >>> mod_inverse(3, 5) 2 >>> (S(2)/5).invert(S(7)/3) 5/2 See Also ======== sympy.core.numbers.mod_inverse rrdr%rN)r) r]rrr8r$rrr%r_r9rrdrP) rRrSrMrjrrrkrryrrr"rVrVrWr%s! $r%c Ost|dgy t||ff||\\}}}Wn.tk r\}ztdd|Wdd}~XYnX||}|js|dd|DS|SdS)z 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] rdr'rNcSsg|] }|qSrV)rP)rrrVrVrWr#sz!subresultants..)r]rrr8r9r'rd) rRrSrMrjrrrkrrTrVrVrWr' s  r'F)r)c Ost|dgy t||ff||\\}}}Wn.tk r\}ztdd|Wdd}~XYnX|rv|j||d\} } n ||} |js|r| dd| DfS| S|r| | fS| SdS)z Compute resultant of ``f`` and ``g``. Examples ======== >>> from sympy import resultant >>> from sympy.abc import x >>> resultant(x**2 + 1, x**2 - 1) 4 rdr(rN)r)cSsg|] }|qSrV)rP)rrrVrVrWrEszresultant..)r]rrr8r9r(rdrP) rRrSr)rMrjrrrkrrTrrVrVrWr((s  r(c Ostt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|}|jsl|S|SdS)z Compute discriminant of ``f``. Examples ======== >>> from sympy import discriminant >>> from sympy.abc import x >>> discriminant(x**2 + 2*x + 3) -8 rdr*rmN)r]rrr8r9r*rdrP)rRrMrjrrkrrTrVrVrWr*Msr*c Ost|dgy t||ff||\\}}}Wntk r}zjt|j\}\} } y|| | \} } } Wn tk rtdd|YnX| | | | | | fSWdd}~XYnX||\} } } |j s| | | fS| | | fSdS)a 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) rdr.rN) r]rrr8r$rr.r_r9rrdrP)rRrSrMrjrrrkrryrrr"r/r0rVrVrWr.ks .r.c st|}fdd}||}|dk r*|Stdgyt|f\}}t|dkrtdd|Dr|dfd d |ddD}td d|Drd}x|D]} t|| d }qWt|SWnJt k r} z*|| j }|dk r|St d t|| Wdd} ~ XYnX|s>|j s2t jStd |dS|d |dd}}x"|D]} || }|jrZPqZW|j s|S|SdS)z 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 csnsjsjt|\}}|s|jS|jrj|d|dd}}x$|D]}|||}||r@Pq@W||SdS)Nrrm)r$rrr1rr)seqrynumbersrTnumber)rjrMrVrWtry_non_polynomial_gcds     z(gcd_list..try_non_polynomial_gcdNrdrmcss|]}|jo|jVqdS)N) is_algebraic is_irrational)rrrVrVrW szgcd_list..rcsg|]}|qSrV)ratsimp)rr)rrVrWrszgcd_list..css|] }|jVqdS)N) is_rational)rfrcrVrVrWrsrgcd_list)rk)rr]rrrorDr2as_numer_denomrr8rr9rdrrrKr1rrP) rrMrjrrTrdrklstlcrrrrV)rrjrMrWrsB  "   rc OsJt|dr,|dk r|f|}t|f||S|dkr>> from sympy import gcd >>> from sympy.abc import x >>> gcd(x**2 - 1, x**2 - 3*x + 2) x - 1 __iter__Nz2gcd() takes 2 arguments or a sequence of argumentsrdrr1r)rrrr]rrrrrrrrrrr8r$rrr1r_r9rdrP) rRrSrMrjrrrkrrrrryrTrVrVrWr1s0   $ r1c st|}fdd}||}|dk r*|Stdgyt|f\}}t|dkrtdd|Dr|dfd d |ddD}td d|Drd}x|D]} t|| d}qW|SWnJtk r} z*|| j }|dk r|St d t|| Wdd} ~ XYnX|s:|j s.t j Std|d S|d|dd}}x|D]} || }qVW|j sz|S|SdS)z 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 csbs^s^t|\}}|s|jS|jr^|d|dd}}x|D]}|||}q@W||SdS)Nrrm)r$rrr2r)rryrrTr)rjrMrVrWtry_non_polynomial_lcm.s   z(lcm_list..try_non_polynomial_lcmNrdrmcss|]}|jo|jVqdS)N)rr)rrrVrVrWrIszlcm_list..rcsg|]}|qSrV)r)rr)rrVrWrKszlcm_list..css|] }|jVqdS)N)r)rrrVrVrWrLslcm_list)rkr)rr]rrrorDr2rr8rr9rdrrrKrP) rrMrjrrTrdrkrrrrrrV)rrjrMrWrs>   "  rc OsFt|dr,|dk r|f|}t|f||S|dkr| S| SdS)z 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 rNz2lcm() takes 2 arguments or a sequence of argumentsrdrmr2r)rrrr]rrrrrrrrrr8r$rrr2r_r9rdrP) rRrSrMrjrrrkrrrrryrTrVrVrWr2ks0   $ r2c st|}t|tr2tfdd|j|jgDSt|trJtd|ft|trZ|jr^|S ddr|j fdd|j D} ddd<t |fS d d }td gyt|f\}}Wn&tk r}z|jSd }~XYnX| \} }|jjrR|jjr2|jd d \} }|\} }|jjrX| | } ntj} tddt|j| D} | dkrtj} | dkr|S|rt| | |St| |dd\} }t| | |ddS)az Remove GCD of terms from ``f``. If the ``deep`` flag is True, then the arguments of ``f`` will have terms_gcd applied to them. If a fraction is factored out of ``f`` and ``f`` is an Add, then an unevaluated Mul will be returned so that automatic simplification does not redistribute it. The hint ``clear``, when set to False, can be used to prevent such factoring when all coefficients are not fractions. Examples ======== >>> 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 c3s|]}t|fVqdS)N)r)rr)rjrMrVrWrszterms_gcd..z5Inequalities cannot be used with terms_gcd. Found: %sdeepFcsg|]}t|fqSrV)r)rr)rjrMrVrWrszterms_gcd..rclearTrdN)r{cSsg|]\}}||qSrVrV)rrrrVrVrWrsrm)r) rrJrlhsrhsrrris_AtomrrUrjpoprr]rrr8rtryrrrr7rrrrrMrrPZ as_coeff_Mul) rRrMrjrrqrrrkrrdenomr~termrV)rjrMrWrsFC              rc Os|t|ddgyt|f||\}}Wn.tk rV}ztdd|Wdd}~XYnX|t|}|jst|S|SdS)z 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 rrdr3rmN) r]rrr8r9r3rrdrP)rRr4rMrjrrkrrTrVrVrWr3sr3c Os|t|ddgyt|f||\}}Wn.tk rV}ztdd|Wdd}~XYnX|j|jd}|jst|S|SdS)z 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 rrdr5rmN)r) r]rrr8r9r5rrdrP)rRrMrjrrkrrTrVrVrWr52sr5c Os^t|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|S)z Compute GCD of coefficients of ``f``. Examples ======== >>> from sympy import content >>> from sympy.abc import x >>> content(6*x**2 + 8*x + 12) 2 rdr6rmN)r]rrr8r9r6)rRrMrjrrkrrVrVrWr6Ps r6c Ost|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|\}}|jst||fS||fSdS)a 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) rdr7rmN)r]rrr8r9r7rdrP)rRrMrjrrkrr8rTrVrVrWr7is   r7c Os~t|dgy t||ff||\\}}}Wn.tk r\}ztdd|Wdd}~XYnX||}|jsv|S|SdS)z Compute functional composition ``f(g)``. Examples ======== >>> from sympy import compose >>> from sympy.abc import x >>> compose(x**2 + x, x - 1) x**2 - x rdr9rN)r]rrr8r9r9rdrP) rRrSrMrjrrrkrrTrVrVrWr9s  r9c Oszt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|}|jsrdd|DS|SdS)z 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] rdr:rmNcSsg|] }|qSrV)rP)rrrVrVrWrszdecompose..)r]rrr8r9r:rd)rRrMrjrrkrrTrVrVrWr:sr:c Ost|ddgyt|f||\}}Wn.tk rV}ztdd|Wdd}~XYnX|j|jd}|jszdd|DS|SdS) z 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] rrdr>rmN)rcSsg|] }|qSrV)rP)rrrVrVrWrszsturm..)r]rrr8r9r>rrd)rRrMrjrrkrrTrVrVrWr>sr>c Oszt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|}|jsrdd|DS|SdS)a& 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)) == 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 rdr?rmNcSsg|]\}}||fqSrV)rP)rrSrrVrVrWrszgff_list..)r]rrr8r9r?rd)rRrMrjrrkrrErVrVrWr?s r?cOs tddS)z3Compute greatest factorial factorization of ``f``. zsymbolic falling factorialN)r_)rRrMrjrVrVrWgff src Ost|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|\}}}|jst|||fSt|||fSdS)a 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) rdrArmN) r]rrr8r9rArdrrP) rRrMrjrrkrrrSrrVrVrWrA&srAc Ostt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|}|jsl|S|SdS)z 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 rdrBrmN)r]rrr8r9rBrdrP)rRrMrjrrkrrTrVrVrWrBHsrBcCs&|dkrdd}ndd}t||dS)z&Sort a list of ``(expr, exp)`` pairs. rNcSs.|\}}|jj}|t|t|jt|j|fS)N)rZrorMrary)rprexprZrVrVrWryisz_sorted_factors..keycSs.|\}}|jj}t|t|j|t|j|fS)N)rZrorMrary)rprrrZrVrVrWryns)ry)r})rEmethodryrVrVrW_sorted_factorsfs rcCstdd|DS)z*Multiply a list of ``(expr, exp)`` pairs. cSsg|]\}}||qSrV)rP)rrRrrVrVrWrxsz$_factors_product..)r)rErVrVrW_factors_productvsrc stjg}ddt|D}x|D]}|jsFt|trRt|rR||9}q(nV|jr|j tj kr|j \}|jrjr||9}q(|jr |fq(n |tj}yt ||\}}Wn2tk r} z | jfWdd} ~ XYq(Xt||d} | \} } | tjk rPjr(|| 9}n(| jr@ | fn| | tjftjkrh| q(jrfdd| Dq(g} x@| D]8\}}|jr ||fn| ||fqW t| fq(W|dkr fdddd DD|fS) z.Helper function for :func:`_symbolic_factor`. cSs"g|]}t|dr|n|qS) _eval_factor)rr)rrrVrVrWrsz)_symbolic_factor_list..NZ_listcsg|]\}}||fqSrVrV)rrRr)rrVrWrsrNcs(g|] ttfddDfqS)c3s|]\}}|kr|VqdS)NrV)rrRr)rrVrWrsz3_symbolic_factor_list...)rr)r)rE)rrWrscSsh|] \}}|qSrVrV)rrrrVrVrW sz(_symbolic_factor_list..)rrr make_argsrrJrris_PowbaseZExp1rjrrr8rtrOrZ is_positiver is_integerrPr)rtrkrr~rjargrrrrrUZ_coeffZ_factorsrrRrrV)rrErW_symbolic_factor_list{sT    "       rcst|trFt|dr|Stt|dd\}}t|t|St|drl|jfdd|j DSt|dr| fdd|DS|Sd S) z%Helper function for :func:`_factor`. rfraction)rrjcsg|]}t|qSrV)_symbolic_factor)rr)rrkrVrWrsz$_symbolic_factor..rcsg|]}t|qSrV)r)rr)rrkrVrWrsN) rJrrrrrArrrUrjr)rtrkrr~rErV)rrkrWrs    rcCsXt|ddgt||}t|}t|ttfrHt|trJ|d}}nt|\}}t |||\}}t |||\} } | r|j st d|| t dd} xJ|| fD]>} x8t| D],\} \}}|jst|| \}}||f| | <qWqWt||}t| |} |js$dd|D}d d| D} || }|j s<||fS||| fSn t d|d S) z>Helper function for :func:`sqf_list` and :func:`factor_list`. fracrdrmza polynomial expected, got %sT)rcSsg|]\}}||fqSrV)rP)rrRrrVrVrWrsz(_generic_factor_list..cSsg|]\}}||fqSrV)rP)rrRrrVrVrWrsN)r]rr^rrJrrKrArrrr5clonerbrrfrrrd)rtrMrjrrkZnumerrrfprZfqZ_optrErrRrrr~rVrVrW_generic_factor_lists6        rcCs<|dd}t|gt||}||d<tt|||S)z4Helper function for :func:`sqf` and :func:`factor`. rT)rr]rr^rr)rtrMrjrrrkrVrVrW_generic_factors    rcsddlmd fdd }d fdd }dd }|jr||r|}|||}|rp|d|d d|d fS|||}|rdd|d|d fSdS)a! 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 r)simplifyNc sFt|jdkr|jdjs"d|fS|}|}|p<|}|dd}fdd|D}t|dkrB|drB|d|d}g}xtt|D].}||||d}|jsP| |qWd|} |jd} | |g} x6td|dD]$}| ||d| ||qWt | }t |}|| |fSdS)a$ 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``. rmrNcsg|] }|qSrVrV)rcoeffx)rrVrWr/sz._try_rescale..r) rorMrrrr5rrrrrrK) rRf1rrrZ rescale1_xZcoeffs1rrZ rescale_xrrS)rrVrW _try_rescale!s0    $ z(to_rational_coeffs.._try_rescalec st|jdkr|jdjs"d|fS|}|p4|}|dd}|d}|jr|jst|j dddd\}}|j | |}| |}||fSdS)a+ 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``. rmrNcSs |jdkS)NT)r)zrVrVrWrwSrxz._try_translate..T)binary) rorMrrr5ris_AddrrHrjrUr;) rRrrrrratZnonratalphaf2)rrVrW_try_translateCs    z*to_rational_coeffs.._try_translatecSst|}d}xb|D]Z}xTt|D]F}t|j}dd|D}|sHq"t|dkrXd}t|dkr"dSq"WqW|S)zS Return True if ``f`` is a sum with square roots but no other root FcSs,g|]$\}}|jr|jr|jdkr|jqS)r)rZ is_Rationalr)rrZwxrVrVrWrbszAto_rational_coeffs.._has_square_roots..rT)rrrr rErzminmax)r4rZhas_sqrrrRrrVrVrW_has_square_rootsYs     z-to_rational_coeffs.._has_square_rootsrmr)N)N)sympy.simplify.simplifyrrrr5)rRrrr rrrV)rrWto_rational_coeffss& "  r c Cs ddlm}t||dd}|}t|}|s2dS|\}}}} t| } |r|| d|||} |d|} g} x| dddD],}| ||d||| i|dfqWnJ| d} g} x<| dddD](}| |d|||i|dfqW| | fS)a 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 r)rZEX)ryNrm) r rrKrr rGrPrr)r4rrp1rresrrr$rSrErr1rrrVrVrW_torational_factor_listxs&    .(rcOst|||ddS)z 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)]) rN)r)r)rRrMrjrVrVrWrCsrCcOst|||ddS)z 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 rN)r)r)rRrMrjrVrVrWrNsrNcOst|||ddS)a  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)]) r)r)r)rRrMrjrVrVrWrGsrG)rc st|}|rxfdd}t||}i}|tt}x8|D]0}t|f}|jsZ|jr:||kr:|||<q:W||Syt |ddSt k r} z|j st |St | Wdd} ~ XYnXdS)a Compute the factorization of expression, ``f``, into irreducibles. (To factor an integer into primes, use ``factorint``.) There two modes implemented: symbolic and formal. If ``f`` is not an instance of :class:`Poly` and generators are not specified, then the former mode is used. Otherwise, the formal mode is used. In symbolic mode, :func:`factor` will traverse the expression tree and factor its components without any prior expansion, unless an instance of :class:`~.Add` is encountered (in this case formal factorization is used). This way :func:`factor` can handle large or symbolic exponents. By default, the factorization is computed over the rationals. To factor over other domain, e.g. an algebraic or finite field, use appropriate options: ``extension``, ``modulus`` or ``domain``. Examples ======== >>> 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 will not 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 cs$t|f}|js|jr |S|S)zS Factor, but avoid changing the expression when unable to. )ris_Mulr)rtro)rjrMrVrW _try_factor s zfactor.._try_factorr)rN) rr!Zatomsrrrrrxreplacerr5rr ) rRrrMrjrZpartialsZmuladdr4romsgrV)rjrMrWrs"D     rc Cs8t|dsBy t|}Wntk r*gSX|j||||||dSt|dd\}} t| jdkrdtx t|D]\} } | j j || <qnW|dk r| j |}|dkrt d|dk r| j |}|dk r| j |}t || j |||||d } g} x@| D]8\\}}}| j || j |}}| ||f|fqW| SdS) a/ Compute isolating intervals for roots of ``f``. Examples ======== >>> 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)] r)rDrJrKrLrMrNr&)ryrmNrz!'eps' must be a positive rational)rJrKrLrrM)rrKr4rIrrorMr6rrZryr{rrBrr)rrDrJrKrLrrMrNrdrkrrrIrTrr$rrVrVrWrI=s4     rIcCs^y&t|}t|ts$|jjs$tdWn tk rFtd|YnX|j||||||dS)z 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) zgenerator must be a Symbolz,Cannot refine a root of %s, not a polynomial)rJrVrMrX)rKrJr is_Symbolr5r4rU)rRrr$rJrVrMrXrrVrVrWrUus rUcCsZy*t|dd}t|ts(|jjs(tdWn tk rJtd|YnX|j||dS)a 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 F)greedyzgenerator must be a Symbolz*Cannot count roots of %s, not a polynomial)rKrL)rKrJrrr5r4ra)rRrKrLrrVrVrWras  raTcCsXy*t|dd}t|ts(|jjs(tdWn tk rJtd|YnX|j|dS)z 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] F)rzgenerator must be a Symbolz1Cannot compute real roots of %s, not a polynomial)rg)rKrJrrr5r4ri)rRrgrrVrVrWris  rirlrmcCs\y*t|dd}t|ts(|jjs(tdWn tk rJtd|YnX|j|||dS)aL 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] F)rzgenerator must be a Symbolz6Cannot compute numerical roots of %s, not a polynomial)rrrrs)rKrJrrr5r4r~)rRrrrrsrrVrVrWr~s  r~c Osvt|gy2t|f||\}}t|ts<|jjs>> 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} zgenerator must be a SymbolrrmN) r]rrrJrKrrr5r8r9r)rRrMrjrrkrrVrVrWrs  rc Ost|gy2t|f||\}}t|ts<|jjs>> 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 zgenerator must be a SymbolrrmN) r]rrrJrKrrr5r8r9rrdrP)rRrrMrjrrkrrTrVrVrWr s   r) _signsimpc sDddlm}ddlmddlm}t|dgt|}|rF||}i}d|kr^|d|d<t |t t fs|j st |t st |ts|St|dd}|\}}nt|dkr|\}}t |trt |tr|j|d <|j|d <|dd|d<||}}n t |t rt|Std |y`|r:t|||ff||\} \} } | jst |t t fsv|Stj||fSWntk r} z|jr|st| |js|j r t!|j"fd d dd\} }dd|D}|j#t$|j#| f|Sg}t%|}t&|xZ|D]R}t |t t t'fr>q$y|(|t$|f|)Wnt*k rrYnXq$W|+t,|SWdd} ~ XYnXd| $| } \}}|ddrd |kr| j-|d <t |t t fs| ||S||}}|dds| ||fS| t|f||t|f||fSdS)a[ Cancel common factors in a rational function ``f``. Examples ======== >>> from sympy import cancel, sqrt, Symbol, together >>> 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 Note: due to automatic distribution of Rationals, a sum divided by an integer will appear as a sum. To recover a rational form use `together` on the result: >>> cancel(x/2 + 1) x/2 + 1 >>> together(_) (x + 2)/2 r)signsimp)r)sringrdT)radicalrrMryzunexpected argument: %scs|jdko| S)NT)rhas)r)rrVrWrw}szcancel..)rcSsg|] }t|qSrV)r)rrrVrVrWrszcancel..NrmF).r rrrsympy.polys.ringsrr]rrrJrrrrrr rrorKrMryrrPrrr5ZngensrrrrrrrHrjrUrr rr"rskipr_rrbr)rRrrMrjrrrkr4rrrrrrncrpoter=rrV)rrWr8s|                 rc st|ddgy"t|gt|f||\}Wn.tk r`}ztdd|Wdd}~XYnXj}d}jr|jr|j s t | dd}dd l m}|jjj\} } x4t|D](\} } | jj} | | || <qW|d|d d\} }fd d | D} tt |}|rnyd d | D|}}Wntk rbYn X||} }jsdd | D|fS| |fSdS)a< Reduces a polynomial ``f`` modulo a set of polynomials ``G``. Given a polynomial ``f`` and a set of polynomials ``G = (g_1, ..., g_n)``, computes a set of quotients ``q = (q_1, ..., q_n)`` and the remainder ``r`` such that ``f = q_1*g_1 + ... + q_n*g_n + r``, where ``r`` vanishes or ``r`` is a completely reduced polynomial with respect to ``G``. Examples ======== >>> 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) rdrreducedrNF)ryT)xringrmcsg|]}tt|qSrV)rKrcrb)rr)rkrVrWrszreduced..cSsg|] }|qSrV)r)rrrVrVrWrscSsg|] }|qSrV)rP)rrrVrVrWrs)r]rrrer8r9ryrrrrrbrrr"rMr[rrrZrrvrrKrcrr2rdrP)rRrrMrjrdrryrr"_ringrrrrr_Q_rrV)rkrWr!s6"  r!cOst|f||S)a 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 :func:`~.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 the ``method`` flag or with the :func:`sympy.polys.polyconfig.setup` function. >>> 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]_ ) GroebnerBasis)rrMrjrVrVrWr*s3r*cOst|f||jS)a[ 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&is_zero_dimensional)rrMrjrVrVrWr'sr'c@seZdZdZddZeddZeddZedd Z ed d Z ed d Z eddZ eddZ ddZddZddZddZddZddZeddZd d!Zd(d#d$Zd%d&Zd'S))r&z%Represents a reduced Groebner basis. c st|ddgyt|f||\}Wn2tk rZ}ztdt||Wdd}~XYnXddlm}|jj j fdd|D}t |j d }fd d|D}| |S) z>Compute a reduced Groebner basis for a system of polynomials. rdrr*Nr)PolyRingcs g|]}|r|jqSrV)rvrZr)rr)ringrVrWr3sz)GroebnerBasis.__new__..)rcsg|]}t|qSrV)rKrc)rrS)rkrVrWr6s)r]rrr8r9rorr(rMryr[ _groebnerr_new)rirrMrjrdrr(rrV)rkr)rWrl's" zGroebnerBasis.__new__cCst|}t||_||_|S)N)r rlr_basis_options)ribasisr]rprVrVrWr+:s  zGroebnerBasis._newcCs$dd|jD}t|t|jjfS)Ncss|]}|VqdS)N)rP)rr4rVrVrWrEsz%GroebnerBasis.args..)r,rr-rM)rsr.rVrVrWrjCszGroebnerBasis.argscCsdd|jDS)NcSsg|] }|qSrV)rP)rrrVrVrWrJsz'GroebnerBasis.exprs..)r,)rsrVrVrWrHszGroebnerBasis.exprscCs t|jS)N)rer,)rsrVrVrWrdLszGroebnerBasis.polyscCs|jjS)N)r-rM)rsrVrVrWrMPszGroebnerBasis.genscCs|jjS)N)r-ry)rsrVrVrWryTszGroebnerBasis.domaincCs|jjS)N)r-r[)rsrVrVrWr[XszGroebnerBasis.ordercCs t|jS)N)ror,)rsrVrVrW__len__\szGroebnerBasis.__len__cCs |jjrt|jSt|jSdS)N)r-rditerr)rsrVrVrWr_s zGroebnerBasis.__iter__cCs|jjr|j}n|j}||S)N)r-rdr)rsitemr.rVrVrW __getitem__eszGroebnerBasis.__getitem__cCst|jt|jfS)N)hashr,rr-rz)rsrVrVrWrmszGroebnerBasis.__hash__cCsPt||jr$|j|jko"|j|jkSt|rH|jt|kpF|jt|kSdSdS)NF)rJrr,r-rGrdrer)rsrrVrVrWrps  zGroebnerBasis.__eq__cCs ||k S)NrV)rsrrVrVrWrxszGroebnerBasis.__ne__cCsXdd}tdgt|j}|jj}x*|jD] }|j|d}||r,||9}q,Wt|S)a{ 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 cSsttt|dkS)Nrm)sumrr)monomialrVrVrW single_varsz5GroebnerBasis.is_zero_dimensional..single_varr)r[)r+rorMr-r[rdr rD)rsr6rr[rr5rVrVrWr'{s   z!GroebnerBasis.is_zero_dimensionalc s|jj}t|}||kr |S|js.tdt|j}j}t | |dddl m }|j j|\}}x4t|D](\} } | jj} || || <q~Wt|||} fdd| D} |jsdd| D} |_|| S)a Convert a Groebner basis from one ordering to another. The FGLM algorithm converts reduced Groebner bases of zero-dimensional ideals from one ordering to another. This method is often used when it is infeasible to compute a Groebner basis with respect to a particular ordering directly. Examples ======== >>> 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 z?Cannot convert Groebner bases of ideals with positive dimension)ryr[r)r"csg|]}tt|qSrV)rKrcrb)rrS)rkrVrWrsz&GroebnerBasis.fglm..cSsg|]}|jdddqS)T)r{rm)r)rrSrVrVrWrs)r-r[r,r'r_rer,ryrrbrrr"rMrrrZrrvr)rr+) rsr[Z src_orderZ dst_orderrdryr"r#rrrrrV)rkrWfglms.    zGroebnerBasis.fglmTcsXt||j}|gt|j}|jj}d}|rV|jrV|jsVt | dd}ddl m }|j jj\}} x4t|D](\} }|jj}|||| <qW|d|dd\} } fdd | D} tt | } |r.yd d | D| } }Wntk r"Yn X| |} } jsLd d | D| fS| | fSdS) a# Reduces a polynomial modulo a Groebner basis. Given a polynomial ``f`` and a set of polynomials ``G = (g_1, ..., g_n)``, computes a set of quotients ``q = (q_1, ..., q_n)`` and the remainder ``r`` such that ``f = q_1*f_1 + ... + q_n*f_n + r``, where ``r`` vanishes or ``r`` is a completely reduced polynomial with respect to ``G``. Examples ======== >>> 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 F)ryTr)r"rmNcsg|]}tt|qSrV)rKrcrb)rr)rkrVrWrsz(GroebnerBasis.reduce..cSsg|] }|qSrV)r)rrrVrVrWrscSsg|] }|qSrV)rP)rrrVrVrWrs)rKrhr-rer,ryrrrrbrrr"rMr[rrrZrrvrrcrr2rdrP)rsrtrrrdryrr"r#rrrrr$r%rV)rkrWrs2  zGroebnerBasis.reducecCs||ddkS)am 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 rmr)r)rsrrVrVrWcontainsszGroebnerBasis.containsN)T)rQrrrrlrr+rrjrrdrMryr[r/rr2rrrr'r7rr8rVrVrVrWr&#s&       B Ar&cs^tgfddt|}|jr8t|f|SdkrHdd<t|}||S)z Efficiently transform an expression into a polynomial. Examples ======== >>> 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 sgg}}xt|D]}gg}}xpt|D]b}|jrN|||q2|jr|jjr|jjr|jdkr||j| |jq2||q2W|s||q|d}x|ddD]}| |}qW|rt|}|j r| |}n| t ||}||qW|s$t ||} n^|d} x |ddD]}| |} q:W|rt|}|j rp| |} n| t ||} | j|ddS)NrrmrMrV)rrrrrrrrrrrrrKrhrrr) rtrkrZ poly_termsrrEZ poly_factorsrproductrT)_polyrjrVrWr:EsB     zpoly.._polyrF)r]rrrfrKr^)rtrMrjrkrV)r:rjrWr4s 4 r)r)N)N)FNNNFFF)NNFF)NN)T)rlrmT)r functoolsrroperatorrZ sympy.corerrrrZsympy.core.basicr Zsympy.core.decoratorsr Zsympy.core.exprtoolsr r r Zsympy.core.evalfrrrrrZsympy.core.functionrZsympy.core.mulrrZsympy.core.numbersrrrZsympy.core.relationalrrZsympy.core.sortingrZsympy.core.symbolrrZsympy.core.sympifyrrZsympy.core.traversalr r!Zsympy.logic.boolalgr"Z sympy.polysr#r]Zsympy.polys.constructorr$Zsympy.polys.domainsr%r&r'Z!sympy.polys.domains.domainelementr(Zsympy.polys.fglmtoolsr)Zsympy.polys.groebnertoolsr*r*Zsympy.polys.monomialsr+Zsympy.polys.orderingsr,Zsympy.polys.polyclassesr-r.r/Zsympy.polys.polyerrorsr0r1r2r3r4r5r6r7r8r9r:Zsympy.polys.polyutilsr;r<r=r>r?r@Zsympy.polys.rationaltoolsrAZsympy.polys.rootisolationrBZsympy.utilitiesrCrDrEZsympy.utilities.exceptionsrFZsympy.utilities.iterablesrGrHrcrpZmpmath.libmp.libhyperrIrYrKrrrrrrrrrrr rrrrrrrrrr!r#r%r'r(r*r.rr1rr2rr3r5r6r7r9r:r>r?rrArBrrrrrrr rrCrNrGrrIrUrarir~rrrr!r'r&rrVrVrVrWs2             4     " h ] ( _  : 5       # # # ' ' 5 $  ) U 3 N 2 v    .    /  " :, ,   b 7      ,f < 6