a RG5d@sdZddlmZmZddlmZddlmZddlm Z m Z m Z m Z ddl mZddlmZddlmZmZmZdd lmZmZmZmZmZdd lmZdd lmZmZdd l m!Z!m"Z"m#Z#dd l$m%Z%m&Z&ddl'm(Z(ddl)m*Z*m+Z+ddl,m-Z-m.Z.ddl/m0Z0m1Z1ddl2m3Z3ddl4m5Z6ddl7m8Z8ddl9m:Z:m;Z;mZ>ddl?m@Z@ddlAmBZCddlDmEZEddlFmGZGddlHmIZImJZJmKZKddlLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWddlXmYZYmZZZm[Z[m\Z\m]Z]m^Z^ddl_m`Z`ddlambZbdd lcmdZdmeZemfZfdd!lgmhZhdd"limjZjmkZkdd#l4Zldd#lmZmdd$lnmoZod%d&ZpeeGd'd(d(eZqeeGd)d*d*eqZreed+d,Zsd-d.Zteed/d0Zud1d2Zvd3d4Zweedd5d6Zxeed7d8Zyeed9d:Zzeed;d<Z{eed=d>Z|eed?d@Z}eedAdBZ~eedCdDZeedEdFZeedGdHZeedIdJZeedKdLZeedMdNZeedOdPZeedQdRZeedSdTZeedUdVZeedWdXZeedYdZd[d\Zeed]d^Zeed_d`ZeedadbZeeddcddZeededfZeeddgdhZeedidjZeedkdlZeedmdnZeedodpZeedqdrZeedsdtZeedudvZeedwdxZeedydzZeed{d|Zeed}d~ZeeddZddZddZddZddZddZddZddZddZeeddZeeddZeeddZeedYdddZeedddZeedddZeedddZeedddZeedddZeeddZeeddZeeddddZeeddZeeddZBeeddZeeGdddeZeeddZd#S)z8User-friendly public interface to polynomial functions. )wrapsreducemul)Optional)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|trz|j|g|jR}WnRty|jrZtYSt | j }||}|turt dddd|YS0||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)deprecated_since_versionactive_deprecations_target) r! isinstancePolyr from_exprgensr7 is_MatrixNotImplementedgetattras_expr__name__rH)fgZ expr_methodresultfuncQ/var/www/html/django/DPS/env/lib/python3.9/site-packages/sympy/polys/polytools.pywrapperDs(      z_polifyit..wrapper)r)r[r^r\rZr] _polifyitCsr_csBeZdZdZdZdZdZdZddZe 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(rOaP 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 reprQTgn$@cOst||}d|vrtdt|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_optionsNotImplementedErrorrNr/r0r1r*_from_domain_elementrIstrdict _from_dict _from_listlistr is_Poly _from_poly _from_exprclsrarQargsoptr\r\r]__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) rNr/r7levlenr rtrarQ)rqrarQobjr\r\r]news  zPoly.newcCst|jg|jRSN)r=ra to_sympy_dictrQselfr\r\r]exprsz Poly.exprcCs|jf|jSrz)r~rQr|r\r\r]rrsz Poly.argscCs|jf|jSrzr`r|r\r\r]_hashable_contentszPoly._hashable_contentcOst||}|||S)(Construct a polynomial from a ``dict``. )rdrerjrpr\r\r] from_dicts zPoly.from_dictcOst||}|||S)(Construct a polynomial from a ``list``. )rdrerkrpr\r\r] from_lists zPoly.from_listcOst||}|||S)*Construct a polynomial from a polynomial. )rdrernrpr\r\r] from_polys zPoly.from_polycOst||}|||S+Construct a polynomial from an expression. )rdrerorpr\r\r]rPs zPoly.from_exprcCsz|j}|stdt|d}|j}|dur>t||d\}}n |D]\}}||||<qF|jt |||g|RS)rz0Cannot initialize from 'dict' without generatorsruNrs) rQr6rwdomainr&itemsconvertryr/r)rqrarsrQlevelrmonomcoeffr\r\r]rjs zPoly._from_dictcCs|j}|stdnt|dkr(tdt|d}|j}|durTt||d\}}ntt|j|}|j t |||g|RS)rz0Cannot initialize from 'list' without generatorsruz#'list' representation not supportedNr) rQr6rwr8rr&rlmaprryr/r)rqrarsrQrrr\r\r]rks  zPoly._from_listcCs||jkr |j|jg|jR}|j}|j}|j}|rl|j|krlt|jt|krb|||S|j |}d|vr|r| |}n|dur| }|S)rrT) __class__ryrarQfieldrsetrorUreorder set_domainto_field)rqrarsrQrrr\r\r]rns    zPoly._from_polycCst||\}}|||Sr)rArj)rqrarsr\r\r]ro4szPoly._from_exprcCs@|j}|j}t|d}||g}|jt|||g|RSNru)rQrrwrryr/r)rqrarsrQrrr\r\r]rg:s   zPoly._from_domain_elementcs tSrzsuper__hash__r|rr\r]rDsz Poly.__hash__cCsPt}|j}tt|D],}|D]}||r$|||jO}qq$q||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} )rrQrangerwmonoms free_symbolsfree_symbols_in_domain)r}symbolsrQirr\r\r]rGs zPoly.free_symbolscCsP|jjt}}|jr.|jD]}||jO}qn|jrL|D]}||jO}q<|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} )radomr is_Compositerris_EXcoeffs)r}rrgenrr\r\r]rfs   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 rrQr|r\r\r]rszPoly.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_domainr|r\r\r]rsz Poly.domaincCs&|j|j|jj|jjg|jRS)z3Return zero polynomial with ``self``'s properties. )ryrazerorvrrQr|r\r\r]rsz Poly.zerocCs&|j|j|jj|jjg|jRS)z2Return one polynomial with ``self``'s properties. )ryraonervrrQr|r\r\r]rszPoly.onecCs&|j|j|jj|jjg|jRS)z3Return unit polynomial with ``self``'s properties. )ryraunitrvrrQr|r\r\r]rsz 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)rWrX_perFGr\r\r]unifysz Poly.unifyc stjsZz(jjjjjjjfWStyXtdfYn0tjt 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)NCannot unify %s with %srucsg|]}|jjqSr\rrar.0c)rrWr\r] zPoly._unify..csg|]}|jjqSr\rr)rrXr\r]rrcsD|dur2|d|||dd}|s2||Sj|g|RSrto_sympyryrarrQremoverqr\r]rs  zPoly._unify..per)r rmrarr from_sympyr4r5rNr/r?rQrrwr@to_dictrirlziprr) rWrXrQrvZf_monomsZf_coeffsrZg_monomsZg_coeffsrrr\)rqrrWrXr]rs:( "     z Poly._unifyNcCsX|dur|j}|durD|d|||dd}|sD|jj|S|jj|g|RS)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') Nru)rQrarrrry)rWrarQrr\r\r]r szPoly.percCs&t|jd|i}||j|jS)z Set the ground domain of ``f``. r)rdrerQrrarr)rWrrsr\r\r]r'szPoly.set_domaincCs|jjS)z Get the ground domain of ``f``. )rarrWr\r\r]r,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) )rdZModulus preprocessrr')rWmodulusr\r\r] set_modulus0s 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_FiniteFieldrZcharacteristicr7)rWrr\r\r] get_modulusAs zPoly.get_moduluscCsN||jvr>|jr|||Sz|||WSty<Yn0|||S)z)Internal implementation of :func:`subs`. )rQ is_numberevalreplacer7rUsubs)rWoldryr\r\r] _eval_subsVs   zPoly._eval_subscs4|j\}fddt|jD}|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') csg|]\}}|vr|qSr\r\)rjrJr\r]rrrz Poly.exclude..r)rarc enumeraterQr)rWryrQr\rr]rccsz Poly.excludecKs|dur$|jr|j|}}ntd||ks6||jvr:|S||jvr||jvr|}|jrf||jvrt|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 caserzCannot replace %s with %s in %s) is_univariaterr7rQrrrrlindexrra)rWxy_ignorerrQr\r\r]rvs z Poly.replacecOs|j|i|S)z-Match expression from Poly. See Basic.match())rUmatch)rWrrkwargsr\r\r]rsz 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') r\rz7generators list can differ only up to order of elementsrur)rdOptionsr>rQrr7rirlrr@rarrr/rrw)rWrQrrrsrar\r\r]rs  z Poly.reordercCs|jdd}||}i}|D]4\}}t|d|rFtd|||||d<q"|j|d}|jt|t |d|j j g|RS)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 %sru) as_dict _gen_to_levelranyr7rQryr/rrwrar)rWrrartermsrrrQr\r\r]ltrims   z Poly.ltrimc Gst}|D]B}z|j|}Wn"ty@td||fYq 0||q |D]*}t|D]\}}||vrb|rbdSqbqVdS)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 %s doesn't have %s as generatorFT)rrQr ValueErrorr<addrr)rWrQindicesrrrreltr\r\r] 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)hasattrrarr2rrWrYr\r\r]rs   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)rrarr2rrr\r\r]rs   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)rrarr2rrr\r\r]r'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') TrN)r compositer)r&rrrrrQ)rWrrrar\r\r]retract<s  z Poly.retractcCsh|durd||}}}n ||}t|t|}}t|jdrT|j|||}n t|d||S)z1Take a continuous subsequence of terms of ``f``. Nrslice)rintrrarr2r)rWrmnrrYr\r\r]rTs   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|qSr\rarrrrr\r]rxrzPoly.coeffs..rb)rarrWrbr\rr]rdsz 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)rarrr\r\r]rzsz 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|fqSr\rrrrrr\r]rrzPoly.terms..r)rarrr\rr]rsz 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|qSr\rrrr\r]rrz#Poly.all_coeffs..)ra all_coeffsrr\rr]rszPoly.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 )ra all_monomsrr\r\r]rszPoly.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|fqSr\rrrr\r]rrz"Poly.all_terms..)ra all_termsrr\rr]rszPoly.all_termscOsxi}|D]L\}}|||}t|tr2|\}}n|}|r ||vrL|||<q td|q |j|g|pj|jRi|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)rrNtupler7rrQ)rWr[rQrrrrrrYr\r\r]termwises    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 )rwrrr\r\r]lengthsz 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)rarr{)rWrrr\r\r]r sz Poly.as_dictcCs|r|jS|jSdS)z%Switch to a ``list`` representation. N)rato_listZ to_sympy_list)rWrr\r\r]as_lists z Poly.as_listc Gs|s |jSt|dkrt|dtr|d}t|j}|D]B\}}z||}Wn"tyvt d||fYq>0|||<q>t |j g|RS)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 rurr) r~rwrNrirlrQrrrr<r=rar{)rWrQmappingrvaluerr\r\r]rU%s    z Poly.as_exprcOsFz,t|g|Ri|}|js$WdS|WSWnty@YdS0dS)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)rOrmr7)r}rQrrpolyr\r\r]as_polyKs  z 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)rrarr2rrr\r\r]res   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)rrarr2rrWrrYr\r\r]rzs  z Poly.deflatecCsz|jj}|jr|S|js$td|t|jdr@|jj|d}n t|d|r\|j|j }n |j |j}|j |g|RS)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 %sinjectfront) rar is_Numericalrmr3rrr2rrQry)rWrrrYrQr\r\r]rs    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 |g|RS)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 generatorsejectr) rarrr3rwrQrfrrrr2ry)rWrQrkZ_gensrrYr\r\r]rs     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)rrarr2rrr\r\r]rs  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)rrar r2rrWrrYr\r\r]r s  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)rrar r2rr r\r\r]r 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)rrar r2rr r\r\r]r 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)rrar r2rr r\r\r]r 2s  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)rrarr2rr r\r\r]rJs  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)rrarr2rrr\r\r]rds   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)rrarr2rrr\r\r]rys   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)r rmr rrrarr2rWrXrrrrrYr\r\r]rs    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)r rmr rrrarr2rr\r\r]rs    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)r rmr rrrarr2rr\r\r]rs    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)rrarr2rrr\r\r]rs   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)rrrarr2rrWrrYr\r\r]rs   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)rrrarr2)rWrXrrrrqrr\r\r]r 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)rrrarr2rr\r\r]r7s    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)rrrarr2rr\r\r]r^s    z Poly.pquoc Csz||\}}}}t|jdrhz||}Wqrtyd}z |||WYd}~qrd}~00n 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)rrrarr9ryrUr2)rWrXrrrrrYexcr\r\r]rzs , z Poly.pexquoc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdrX||\}} n t|d|rz|| } } Wnt yYn 0| | }} |||| 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_Fieldrrrarr2rr4) rWrXautorrrrrrrQRr\r\r]rs    zPoly.divc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdrT||}n t|d|rz |}Wnt yYn0||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) rrrrrrar#r2rr4) rWrXr rrrrrrr\r\r]r#s     zPoly.remc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdrT||}n t|d|rz |}Wnt yYn0||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) rrrrrrar$r2rr4) rWrXr rrrrrrr\r\r]r$s     zPoly.quoc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdrz||}Wqty} z | | | WYd} ~ qd} ~ 00n t |d|rz | }Wnt yYn0||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) rrrrrrar%r9ryrUr2rr4) rWrXr rrrrrrrr\r\r]r% s" ,   z Poly.exquocCst|trXt|j}| |kr*|krDnn|dkr>||S|Sqtd|||fn2z|jt|WStytd|Yn0dS)z3Returns level associated with the given generator. rz -%s <= gen < %s expected, got %sz"a valid generator expected, got %sN)rNrrwrQr7rr r)rWrrr\r\r]r4s   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)rrrar&r2)rWrrr\r\r]r&Hs   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)rrar'r2rr\r\r]r'cs  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)rrar(r2rr\r\r]r(vs  zPoly.total_degreecCs~t|tstdt|||jvr8|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 homogenizerhomogeneous_orderN) rNr TypeErrortyperQrrwrrarr)r2)rWsrrQr\r\r]r)s      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 r*N)rrar*r2rr\r\r]r*s  zPoly.homogeneous_ordercCsF|dur||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)rrrar.r2rr)rWrbrYr\r\r]r.s    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)rrar/r2rrrr\r\r]r/s   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)rrarr2rr\r\r]r1s 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-rQ exponents)rWrr\r\r]coeff_monomials#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 r2z,exponent of each generator must be specified) rrarwrQrr2rlrrr2rr)rWNrYr\r\r]r2+s   zPoly.nthrucCs tddS)NzyEither convert to Expr with `as_expr` method to use Expr's coeff method or else use the `coeff_monomial` method of Polys.rf)rWrrrightr\r\r]rMsz 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 rr-rrQrr\r\r]LMYszPoly.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 r0r8rr\r\r]EMmszPoly.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) rrr-rQrWrbrrr\r\r]LT}szPoly.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) r0r;r<r\r\r]ETszPoly.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)rrar?r2rrrr\r\r]r?s   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)rrar@r2rrrr\r\r]r@s   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)rarrrOnerhas_assoc_Ringget_ringrrAr2rrr)r}rrWrrrYr\r\r]rAs      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]') Tr)rrrCrAr )r}rXrWrrabr\r\r]rat_clear_denomss   zPoly.rat_clear_denomscOs|}|ddr"|jjjr"|}t|jdr|sF||jjddS|j}|D]8}t|t rh|\}}n |d}}|t || |}qP||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') r T integraterurN) getrarrrrrrIrNrrrr2)r}specsrrrWraspecrrr\r\r]rI s     zPoly.integratecOs|dds"t|g|Ri|St|jdr|sF||jjddS|j}|D]8}t|trh|\}}n |d}}|t|| |}qP||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') evaluateTdiffrurJN) rKrrrarrOrNrrrr2)rWrLrrarMrrr\r\r]rOC s      z Poly.diffc CsP|}|durt|tr<|}|D]\}}|||}q"|St|ttfr|}t|t|jkrhtdt |j|D]\}}|||}qt|Sd|} }n | |} t |j dst |dz|j || } Wntty@|std||j jfnFt|g\} \}|| |j} || }| || }|j || } Yn0|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 %sr)rNrirrrrlrwrQrrrrrar2r4r3rr&rZunify_with_symbolsrrr) r}rrFr rWrrrvaluesrrYZa_domainZ new_domainr\r\r]rk 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)rWrQr\r\r]__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)rrrrrarSr2) rWrXr rrrrr-hr\r\r]rS 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)rrrrrarUr2) rWrXr rrrrr-trTr\r\r]rU 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)rrrrrarWr2)rWrXr rrrrrYr\r\r]rW 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)rrarXrr2rrr\r\r]rX+ 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)rrrarYr2rlrrr\r\r]rYM 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 includePRSrrP)rrrarZr2rlr) rWrXr\rrrrrYr"r\r\r]rZf 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 discriminantrrP)rrar]r2rrr\r\r]r] 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^)rWrXr^r\r\r]r^ 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`)rWrXr`r\r\r]r` 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)rrrarar2) rWrXrrrrrTcffcfgr\r\r]ra6 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)rrrardr2rr\r\r]rdS 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)rrrarer2rr\r\r]rej 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)rarrrrfr2r)rWprYr\r\r]rf 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)rarrrrrhr2rr}r rWrYr\r\r]rh 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)rrarjr2rrrr\r\r]rj 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)rrarkr2rrr)rWcontrYr\r\r]rk 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)rrrarmr2rr\r\r]rm 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)rrarnr2rlrrrr\r\r]rn 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)rraror2r)rWrFrYr\r\r]ro 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)rrrarpr2r)rWrgrPr!rrYr\r\r]rp 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) rarrrrrrr2rlrrrir\r\r]rr: 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|]\}}||fqSr\rrrXrrr\r]rl rz!Poly.gff_list..)rrarsr2rr\rr]rsW 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)rrarvr2r)rWrr\r\r]rvn 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)rrarwr2r)rWr-rXrr\r\r]rw 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)rrarxr2rrr\r\r]rx 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|]\}}||fqSr\rtrurr\r]r rz!Poly.sqf_list..)rraryr2rr)rWallrfactorsr\rr]ry 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|]\}}||fqSr\rtrurr\r]r rz)Poly.sqf_list_include..)rrar|r2)rWrzr{r\rr]r| s  zPoly.sqf_list_includecsntjdrDzj\}}WqNty@tjdfgfYS0n 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_listrucsg|]\}}||fqSr\rtrurr\r]r rz$Poly.factor_list..) rrar}r3rrBr2rr)rWrr{r\rr]r} s   zPoly.factor_listcsVtjdr:zj}WqDty6dfgYS0n 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_includerucsg|]\}}||fqSr\rtrurr\r]r7 rz,Poly.factor_list_include..)rrar~r3r2)rWr{r\rr]r~ s   zPoly.factor_list_includec Cs |dur"t|}|dkr"td|dur4t|}|durFt|}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)] Nr!'eps' must be a positive rational intervalsrzepsinfsupfastsqfcSs|\}}t|t|fSrzr(r)intervalr-rVr\r\r]_reale szPoly.intervals.._realcSs@|\\}}\}}t|tt|t|tt|fSrzr(rr) rectangleuvr-rVr\r\r]_complexl sz Poly.intervals.._complexcSs$|\\}}}t|t|f|fSrzr)rr-rVrr\r\r]ru s cSsH|\\\}}\}}}t|tt|t|tt|f|fSrzr)rrrr-rVrr\r\r]r| s ) r(rrrrarr2rlr) rWrzrrrrrrYrrZ real_partZ complex_partr\r\r]r9 s4      zPoly.intervalsc Cs|r|jstdt|t|}}|durJt|}|dkrJtd|dur\t|}n |durhd}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 supportedNrrru refine_root)rstepsr) is_sqfr7r(rrrrrarr2r) rWr-rVrrr check_sqfrTr\r\r]r s     zPoly.refine_rootcCsLd\}}|dur^t|}|tjur(d}n6|\}}|sDt|}ntttj||fd}}|durt|}|tjur~d}n6|\}}|st|}ntttj||fd}}|r|rt |j dr|j j ||d}n t |dn^|r|dur|tj f}|r|dur|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_rootsrrcount_complex_roots)r rNegativeInfinity as_real_imagr(rrlrInfinityrrarr2rrr)rWrrZinf_realZsup_realreimcountr\r\r] 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 rootoftoolsrootof)rWrrr\r\r]root 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)] rFmultipleN)rrrCRootOf real_rootsrE)rWrrZrealsr\r\r]rszPoly.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)] rFrN)rrrr all_rootsrE)rWrrrootsr\r\r]rszPoly.all_roots2c s|jrtd||dkr"gS|jjturBdd|D}n|jjturdd|D}t|fdd|D}nLfdd|D}zdd|D}Wn"t yt d |jjYn0t j j }t j _ dd lmzz>t j|||d |d d }tttt|fddd}Wnxtyz>t j|||d |dd }tttt|fddd}Wn$tytd|fYn0Yn0W|t j _ n |t j _ 0|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] z$Cannot compute numerical roots of %srcSsg|] }t|qSr\rrrr\r\r]rZrzPoly.nroots..cSsg|] }|jqSr\)rrr\r\r]r\rcsg|]}t|qSr\rr)facr\r]r^rcsg|]}|jdqS)r)rrrrr\r]r`scSsg|]}tj|qSr\)mpmathmpcrr\r\r]rcrz!Numerical domain expected, got %ssignF )maxstepscleanuperror extrapreccs$|jr dnd|jt|j|jfSNrurimagrealrrrr\r]urzPoly.nroots..keyrcs$|jr dnd|jt|j|jfSrrrrr\r]r|rz7convergence to root failed; try n < %s or maxsteps > %s)is_multivariater8r&rarr)rr(rr+r3rmpdps$sympy.functions.elementary.complexesr polyrootsrlrr sortedrK)rWrrrrdenomsrrr\)rrrr]nroots6s^         z Poly.nrootscCsP|jrtd|i}|dD](\}}|jr"|\}}||| |<q"|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 %sru)rr8r} is_linearr)rWrfactorrrFrGr\r\r] 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 polynomialruz&'n' must an integer and n >= 1, got %srV) rr8r is_IntegerrrrrrZrrPr)rWrr5rrVrr\r\r]nth_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 rucstt|dS)NrJ)rrrrJr\r]rrz Poly.same_root..) rr8raZmignotte_sep_bound_squaredr get_fieldrrrrr) rWrFrGZ dom_delta_sqZdelta_sqZeps_sqrrrevABr\rJr] 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) rrrr2rCrDrrr) rWrXrrrrrrYcpcqrgrr\r\r]rs     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 )rais_zerorr\r\r]r!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 )rais_onerr\r\r]r4sz 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 )rarrr\r\r]rGsz 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 )rais_monicrr\r\r]rZsz 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 )ra is_primitiverr\r\r]rmszPoly.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 )ra is_groundrr\r\r]rszPoly.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 )rarrr\r\r]rszPoly.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 )ra is_quadraticrr\r\r]rszPoly.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 )ra is_monomialrr\r\r]rszPoly.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 )rais_homogeneousrr\r\r]rszPoly.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 )rais_irreduciblerr\r\r]rszPoly.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 rurwrQrr\r\r]rszPoly.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 rurrr\r\r]rszPoly.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 )ra is_cyclotomicrr\r\r]r'szPoly.is_cyclotomiccCs|Srz)rrr\r\r]__abs__?sz Poly.__abs__cCs|Srz)rrr\r\r]__neg__Bsz Poly.__neg__cCs ||SrzrrWrXr\r\r]__add__Esz Poly.__add__cCs ||Srzrrr\r\r]__radd__Isz Poly.__radd__cCs ||Srzrrr\r\r]__sub__Msz Poly.__sub__cCs ||Srzrrr\r\r]__rsub__Qsz Poly.__rsub__cCs ||Srzrrr\r\r]__mul__Usz Poly.__mul__cCs ||Srzrrr\r\r]__rmul__Ysz Poly.__rmul__rcCs |jr|dkr||StSdS)Nr)rrrS)rWrr\r\r]__pow__]s z Poly.__pow__cCs ||Srzrrr\r\r] __divmod__dszPoly.__divmod__cCs ||Srzrrr\r\r] __rdivmod__hszPoly.__rdivmod__cCs ||Srzr#rr\r\r]__mod__lsz Poly.__mod__cCs ||Srzrrr\r\r]__rmod__psz Poly.__rmod__cCs ||Srzr$rr\r\r] __floordiv__tszPoly.__floordiv__cCs ||Srzrrr\r\r] __rfloordiv__xszPoly.__rfloordiv__rXcCs||SrzrUrr\r\r] __truediv__|szPoly.__truediv__cCs||Srzrrr\r\r] __rtruediv__szPoly.__rtruediv__otherc Csv||}}|jsFz|j||j|d}WntttfyDYdS0|j|jkrVdS|jj|jjkrjdS|j|jkSNrF) rmrrQrr7r3r4rar)r}rrWrXr\r\r]__eq__s  z Poly.__eq__cCs ||k Srzr\rr\r\r]__ne__sz Poly.__ne__cCs|j Srz)rrr\r\r]__bool__sz Poly.__bool__cCs|s ||kS|t|SdSrz) _strict_eqr rWrXstrictr\r\r]eqszPoly.eqcCs|j||d S)Nr)rrr\r\r]neszPoly.necCs*t||jo(|j|jko(|jj|jddSNTr)rNrrQrarrr\r\r]rszPoly._strict_eq)NN)N)N)N)N)N)N)FF)F)F)T)T)T)T)r)N)N)ruF)N)N)N)N)F)NT)T)T)T)F)N)N)T)T)F)F)FNNNFF)NNFF)NN)T)TT)TT)rrT)F)F)F)rV __module__ __qualname____doc__ __slots__is_commutativerm _op_priorityrt classmethodrypropertyr~rrrrrrrPrjrkrnrorgrrrrrrrrrrrrrrrrrcrrrrrrrrrrrrrrrrrrrrrUrrrrrrr r r r rrrrrrrrrrrrrr#r$r%rr&r'r(r)r*r.r/r1r4r2rr9r:r=r>r?r@rArHrIrO_eval_derivativerrRrSrUrWrXrYrZr]r^r`rardrerfrhrjrkrmrnrorprrrsrvrwrxryr|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrr_rrrrrrr rSrrrrrrrrrrrrrrr __classcell__r\r\rr]rOes5                   3   #$"     %  & %*' ' % % * "  %"     ''(& K  ! " % K K    #  !  L%?P  ( 3%        rOcsVeZdZdZddZfddZeddZede 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. )rar|r\r\r]rszPurePoly._hashable_contentcs tSrzrr|rr\r]rszPurePoly.__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} )rr|r\r\r]rszPurePoly.free_symbolsrc Cs||}}|jsFz|j||j|d}WntttfyDYdS0t|jt|jkr^dS|jj |jj krz|jj |jj |j}Wnt yYdS0| |}| |}|j|jkSr) rmrrQrr7r3r4rwrarrr5r)r}rrWrXrr\r\r]rs     zPurePoly.__eq__cCst||jo|jj|jddSr )rNrrarrr\r\r]rszPurePoly._strict_eqcst|}|jsZz(|jj|j|j|j|jj|fWStyXtd||fYn0t|j t|j kr~td||ft |jt rt |jt std||f|j |j }|jj |jj|}|j|}|j|}||dffdd }||||fS)NrcsD|dur2|d|||dd}|s2||Sj|g|RSrrrrr\r]rs  zPurePoly._unify..per)r rmrarrrr4r5rwrQrNr/rrr)rWrXrQrrrrr\rr]rs"(    zPurePoly._unify)rVr r r rrrrr rSrrrrr\r\rr]rs   rcOst||}t||Sr)rdre_poly_from_exprr~rQrrrsr\r\r]poly_from_exprs rcCs|t|}}t|ts&t|||nJ|jrb|j||}|j|_|j|_|j durZd|_ ||fS|j rp| }t ||\}}|jst|||t t t |\}}|j}|durt||d\|_}nt t|j|}tt t ||}t||}|j dur d|_ ||fS)rNTrF)r rNr r:rmrrnrQrrexpandrArlrrr&rrrirOrj)r~rsorigrrarrrr\r\r]rs2     rcOst||}t||S)(Construct polynomials from expressions. )rdre_parallel_poly_from_expr)exprsrQrrrsr\r\r]parallel_poly_from_expr7s rcCst|dkr~|\}}t|tr~t|tr~|j||}|j||}||\}}|j|_|j|_|jdurrd|_||g|fSt |g}}gg}}d}t |D]T\}} t | } t| t r| j r||q|||jr| } nd}|| q|r t|||d|r.|D]}||||<qt||\} }|jsRt|||dddlm} |jD]} t| | rdtdqdgg} }g}g}| D]@}t tt |\}}| ||||t|q|j}|durt| |d\|_} nt t|j| } |D]$} || d| | | d} qg}t||D]2\}}tt t||}t||}||qD|jdurt||_||fS) rrNTFr Piecewisez&Piecewise generators do not make senser)rwrNrOrrnrrQrrrlrr r rmappendrr:rUrB$sympy.functions.elementary.piecewiserr7rrextendr&rrrirjbool)rrsrWrXZorigsZ_exprsZ_polysfailedrr~repsrrZ coeffs_listlengthsrrrarrrrrr\r\r]r>sv                    rcCst|}||vr|||<|S)z7Add a new ``(key, value)`` pair to arguments ``dict``. )ri)rrrrr\r\r] _update_argssr'cCst|dd}t|ddj}|jr0|}|j}n*|j}|sZ|rLt|\}}nt||\}}|rn|rhtjStjS|s|jr||jvrt|\}}||jvrtjSn4|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 Trruz 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_NumberrmrUrrZerorrQrwrr+rGnextrr&rNrr)rWrZ gen_is_NumrgZisNumrrYr\r\r]r&s.    r&cGsHt|}|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)r rmrUr(rQrOr(r)rWrQrgrvr\r\r]r(s( r(c Ostt|dgzt|g|Ri|\}}Wn0ty\}ztdd|WYd}~n d}~00|}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) rr'ruN) rd allowed_flagsrr:r;r'rrr)rWrQrrrrsrdegreesr\r\r]r's"r'c Oslt|dgzt|g|Ri|\}}Wn0ty\}ztdd|WYd}~n d}~00|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 rr.ruNr)rdr,rr:r;r.rbrWrQrrrrsrr\r\r]r.1s "r.c Ostt|dgzt|g|Ri|\}}Wn0ty\}ztdd|WYd}~n d}~00|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 rr9ruNr)rdr,rr:r;r9rbrU)rWrQrrrrsrrr\r\r]r9Js"r9c Os|t|dgzt|g|Ri|\}}Wn0ty\}ztdd|WYd}~n d}~00|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 rr=ruNr)rdr,rr:r;r=rbrU)rWrQrrrrsrrrr\r\r]r=ds"r=c Ost|dgz&t||fg|Ri|\\}}}Wn0tyd}ztdd|WYd}~n d}~00||\}} |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) rrrN)rdr,rr:r;rrrU rWrXrQrrrrrsrrrr\r\r]r~s&"rc Ost|dgz&t||fg|Ri|\\}}}Wn0tyd}ztdd|WYd}~n d}~00||}|js~|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 rrrN)rdr,rr:r;rrrU rWrXrQrrrrrsrrr\r\r]rs&" rc Ost|dgz&t||fg|Ri|\\}}}Wn0tyd}ztdd|WYd}~n d}~00z||}Wntyt||Yn0|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 rrrN) rdr,rr:r;rr9rrU rWrXrQrrrrrsrrr\r\r]rs&" rc Ost|dgz&t||fg|Ri|\\}}}Wn0tyd}ztdd|WYd}~n d}~00||}|js~|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 rrrN)rdr,rr:r;rrrUr1r\r\r]rs&" rc Ost|ddgz&t||fg|Ri|\\}}}Wn0tyf}ztdd|WYd}~n d}~00|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) r rrrNr ) rdr,rr:r;rr rrUr/r\r\r]rs&"rc Ost|ddgz&t||fg|Ri|\\}}}Wn0tyf}ztdd|WYd}~n d}~00|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 r rr#rNr2) rdr,rr:r;r#r rrUr0r\r\r]r# s&"r#c Ost|ddgz&t||fg|Ri|\\}}}Wn0tyf}ztdd|WYd}~n d}~00|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 r rr$rNr2) rdr,rr:r;r$r rrUr1r\r\r]r$@s&"r$c Ost|ddgz&t||fg|Ri|\\}}}Wn0tyf}ztdd|WYd}~n d}~00|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 r rr%rNr2) rdr,rr:r;r%r rrUr1r\r\r]r%`s&"r%c Ost|ddgz&t||fg|Ri|\\}}}Wnty}zrt|j\}\} } z|| | \} } Wntytdd|Yn"0| | | | fWYd}~SWYd}~n d}~00|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) r rrSrNr2) rdr,rr:r&rrSrfr;rr rrU) rWrXrQrrrrrsrrrFrGr-rTr\r\r]rSs& 6rSc Ost|ddgz&t||fg|Ri|\\}}}Wnty}z|t|j\}\} } z|| | \} } } Wntytdd|Yn*0| | | | | | fWYd}~SWYd}~n d}~00|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) r rrUrNr2) rdr,rr:r&rrUrfr;rr rrU)rWrXrQrrrrrsrrrFrGr-rVrTr\r\r]rUs& >rUc Ost|ddgz&t||fg|Ri|\\}}}Wnvty}z^t|j\}\} } z ||| | WWYd}~Styt dd|Yn0WYd}~n d}~00|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 r rNrWrr2) rdr,rr:r&rrrWrfr;r rrU) rWrXrQrrrrrsrrrFrGrTr\r\r]rWs!&  (rWc Ost|dgz&t||fg|Ri|\\}}}Wn0tyd}ztdd|WYd}~n d}~00||}|jsdd|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] rrYrNcSsg|] }|qSr\rrrr\r\r]rrz!subresultants..)rdr,rr:r;rYr rWrXrQrrrrrsrrYr\r\r]rYs&" rYFr[c Ost|dgz&t||fg|Ri|\\}}}Wn0tyd}ztdd|WYd}~n d}~00|r~|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 rrZrNr[cSsg|] }|qSr\rr3r\r\r]rArzresultant..)rdr,rr:r;rZrrU) rWrXr\rQrrrrrsrrYr"r\r\r]rZ$s&" rZc Os|t|dgzt|g|Ri|\}}Wn0ty\}ztdd|WYd}~n d}~00|}|jst|S|SdS)z Compute discriminant of ``f``. Examples ======== >>> from sympy import discriminant >>> from sympy.abc import x >>> discriminant(x**2 + 2*x + 3) -8 rr]ruN)rdr,rr:r;r]rrUrWrQrrrrsrrYr\r\r]r]Is"r]c Ost|dgz&t||fg|Ri|\\}}}Wnty}z|t|j\}\} } z|| | \} } } Wntytdd|Yn*0| | | | | | fWYd}~SWYd}~n d}~00||\} } } |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) rrarN) rdr,rr:r&rrarfr;rrrU)rWrXrQrrrrrsrrrFrGrTrbrcr\r\r]rags& >rac st|}fdd}||}|dur*|Stdgzt|gRi\}}t|dkrtdd|Dr|dfd d |ddD}td d|Drd}|D]} t|| d }qt|WSWnZt y0} z@|| j }|dur |WYd} ~ St d t|| WYd} ~ n d} ~ 00|sR|j sFt jStd |dS|d |dd}}|D]} || }|jrlqql|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 cslshsht|\}}|s|jS|jrh|d|dd}}|D]}|||}||r>q^q>||SdSNrru)r&rrrdrrseqrnumbersrYnumberrrrQr\r]try_non_polynomial_gcds    z(gcd_list..try_non_polynomial_gcdNrrucss|]}|jo|jVqdSrz is_algebraic is_irrationalrrr\r\r] rzgcd_list..r0csg|]}|qSr\ratsimpr@rFr\r]rrzgcd_list..css|] }|jVqdSrz is_rationalrfrcr\r\r]rArrgcd_listr)r rdr,rrwrzreas_numer_denomrr:rr;rrr)rOrdrrU) r8rQrrr<rYrrslstlcrHrrr\rFrrrQr]rIsB  &   rIc Osft|dr2|dur|f|}t|g|Ri|S|durBtdt|dgzxt||fg|Ri|\\}}}tt||f\}}|jr|j r|jr|j r|| } | j rt || dWSWnztyB} z`t| j\} \}}z | | ||WWYd} ~ Sty,tdd| Yn0WYd} ~ n d} ~ 00||} |js^| S| SdS)z Compute GCD of ``f`` and ``g``. Examples ======== >>> from sympy import gcd >>> from sympy.abc import x >>> gcd(x**2 - 1, x**2 - 3*x + 2) x - 1 __iter__Nz2gcd() takes 2 arguments or a sequence of argumentsrrrdr)rrIr+rdr,rrr r>r?rCrFrrJr:r&rrrdrfr;rrU rWrXrQrrrrrsrFrGrHrrrYr\r\r]rds0  "  ( rdc st|}ttdfdd }||}|dur4|Stdgzt|gRi\}}t|dkrtdd|Dr|d fd d |dd D}td d|Drd}|D]} t|| d}q|WSWnZt y6} z@|| j }|dur|WYd} ~ St d t|| WYd} ~ n d} ~ 00|sX|j sLtjStd|dS|d|dd}}|D]} || }qr|j s|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 )returncsds`s`t|\}}|s$||jS|jr`|d|dd}}|D]}|||}qD||SdSr6)r&rrrrer7r;r\r]try_non_polynomial_lcm*s   z(lcm_list..try_non_polynomial_lcmNrrucss|]}|jo|jVqdSrzr=r@r\r\r]rAErzlcm_list..r0csg|]}|qSr\rBr@rDr\r]rGrzlcm_list..css|] }|jVqdSrzrErGr\r\r]rAHrlcm_listrr)r rrrdr,rrwrzrerJr:rr;rrrBrOrU) r8rQrrrQrYrrsrKrLrHrrr\rMr]rRs>  & rRc Osbt|dr2|dur|f|}t|g|Ri|S|durBtdt|dgztt||fg|Ri|\\}}}tt||f\}}|jr|j r|jr|j r|| } | j r|| dWSWnzt y>} z`t| j\} \}}z | | ||WWYd} ~ Sty(tdd| Yn0WYd} ~ n d} ~ 00||} |jsZ| 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 rNNz2lcm() takes 2 arguments or a sequence of argumentsrrurer)rrRr+rdr,rrr r>r?rCrFrJr:r&rrrerfr;rrUrOr\r\r]regs0  "  ( rec st|}t|tr2tfdd|j|jfDSt|trJtd|ft|trZ|jr^|S ddr|j fdd|j D} ddd<t |gRiS d d }td gzt|gRi\}}Wn,ty}z|jWYd }~Sd }~00| \} }|jjrd|jjrD|jd d \} }|\} }|jjrj| | } 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|gRiVqdSrzr)rr-r;r\r]rArzterms_gcd..z5Inequalities cannot be used with terms_gcd. Found: %sdeepFcs"g|]}t|gRiqSr\rS)rrFr;r\r]rrzterms_gcd..rclearTrNrEcSsg|]\}}||qSr\r\)rrrr\r\r]rrru)rU) r rNrlhsrhsrr+ris_AtomrKr[rrpoprrdr,rr:r~rrrrArkrrBrrrQrrU as_coeff_Mul) rWrQrrrryrUrrsrrdenomrtermr\r;r]rsFC              rc Ost|ddgzt|g|Ri|\}}Wn0ty^}ztdd|WYd}~n d}~00|t|}|js||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 r rrfruN) rdr,rr:r;rfr rrU)rWrgrQrrrrsrrYr\r\r]rfs"rfc Ost|ddgzt|g|Ri|\}}Wn0ty^}ztdd|WYd}~n d}~00|j|jd}|js||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 r rrhruNr2) rdr,rr:r;rhr rrUr5r\r\r]rh.s"rhc Osft|dgzt|g|Ri|\}}Wn0ty\}ztdd|WYd}~n d}~00|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 rrjruN)rdr,rr:r;rjr.r\r\r]rjLs "rjc Ost|dgzt|g|Ri|\}}Wn0ty\}ztdd|WYd}~n d}~00|\}}|js|||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) rrkruN)rdr,rr:r;rkrrU)rWrQrrrrsrrlrYr\r\r]rkes "  rkc Ost|dgz&t||fg|Ri|\\}}}Wn0tyd}ztdd|WYd}~n d}~00||}|js~|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 rrmrN)rdr,rr:r;rmrrUr4r\r\r]rms&" rmc Ost|dgzt|g|Ri|\}}Wn0ty\}ztdd|WYd}~n d}~00|}|jszdd|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] rrnruNcSsg|] }|qSr\rr3r\r\r]rrzdecompose..)rdr,rr:r;rnrr5r\r\r]rns"rnc Ost|ddgzt|g|Ri|\}}Wn0ty^}ztdd|WYd}~n d}~00|j|jd}|jsdd|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] r rrrruNr2cSsg|] }|qSr\rr3r\r\r]rrzsturm..)rdr,rr:r;rrr rr5r\r\r]rrs"rrc Ost|dgzt|g|Ri|\}}Wn0ty\}ztdd|WYd}~n d}~00|}|jszdd|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 rrsruNcSsg|]\}}||fqSr\rrur\r\r]rrzgff_list..)rdr,rr:r;rsr)rWrQrrrrsrr{r\r\r]rss "rscOs tddS)z3Compute greatest factorial factorization of ``f``. zsymbolic falling factorialNr6rWrQrrr\r\r]gffsr^c Ost|dgzt|g|Ri|\}}Wn0ty\}ztdd|WYd}~n d}~00|\}}}|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) rrwruN) rdr,rr:r;rwrrrU) rWrQrrrrsrr-rXrr\r\r]rw"s"rwc Os|t|dgzt|g|Ri|\}}Wn0ty\}ztdd|WYd}~n d}~00|}|jst|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 rrxruN)rdr,rr:r;rxrrUr5r\r\r]rxDs"rxcCs&|dkrdd}ndd}t||dS)z&Sort a list of ``(expr, exp)`` pairs. rcSs.|\}}|jj}|t|t|jt|j|fSrzrarwrQrhrrxrexprar\r\r]resz_sorted_factors..keycSs.|\}}|jj}t|t|j|t|j|fSrzr_r`r\r\r]rjsr)r)r{methodrr\r\r]_sorted_factorsbs rccCstdd|DS)z*Multiply a list of ``(expr, exp)`` pairs. cSsg|]\}}||qSr\rrrWrr\r\r]rtrz$_factors_product..)rr{r\r\r]_factors_productrsrfc s tjg}ddt|D}|D]}|jsBt|trNt|rN||9}q$nV|jr|j tj kr|j \}|jrjr||9}q$|jr |fq$n |tj}zt ||\}}Wn4ty} z | jfWYd} ~ q$d} ~ 00t||d} | \} } | tjurNjr&|| 9}n(| jr> | fn| | tjftjurf| q$jrfdd| Dq$g} | D]8\}}|jr ||fn| ||fq t| fq$|dkrfdddd DD|fS) z.Helper function for :func:`_symbolic_factor`. cSs"g|]}t|dr|n|qS) _eval_factor)rrgrrr\r\r]r{sz)_symbolic_factor_list..N_listcsg|]\}}||fqSr\r\rd)rar\r]rrrcs(g|] ttfddDfqS)c3s|]\}}|kr|VqdSrzr\)rrWrrr\r]rArz3_symbolic_factor_list...)rr)rrerjr]rscSsh|] \}}|qSr\r\)rrrr\r\r] rz(_symbolic_factor_list..)rrBr make_argsr(rNrris_PowbaseExp1rrr rr:r~rTr is_positiver" is_integerrUrf)r~rsrbrrrargrnrrrr[_coeffZ_factorsrrWrr\)rar{r]_symbolic_factor_listwsX     &         rtcst|trFt|dr|Stt|dd\}}t|t|St|drl|jfdd|j DSt|dr| fdd|DS|Sd S) z%Helper function for :func:`_factor`. rgfraction)rurrcsg|]}t|qSr\_symbolic_factorrrrrbrsr\r]rrz$_symbolic_factor..rNcsg|]}t|qSr\rvrxryr\r]rrN) rNrrrgrtrCrrfr[rrr)r~rsrbrr{r\ryr]rws    rwcCsPt|ddgt||}t|}t|ttfr@t|trJ|d}}nt|\}}t |||\}}t |||\} } | r|j st d|| t dd} || fD]:} t| D],\} \}}|jst|| \}}||f| | <qqt||}t| |} |jsdd|D}d d| D} || }|j s4||fS||| fSn t d|d S) z>Helper function for :func:`sqf_list` and :func:`factor_list`. fracrruza polynomial expected, got %sT)rcSsg|]\}}||fqSr\rrdr\r\r]rrz(_generic_factor_list..cSsg|]\}}||fqSr\rrdr\r\r]rrN)rdr,rer rNrrOrCrJrtrzr7clonerirrmrrcr)r~rQrrrbrsnumerr[rfprfqZ_optr{rrWrrrr\r\r]_generic_factor_lists6         rcCs<|dd}t|gt||}||d<tt|||S)z4Helper function for :func:`sqf` and :func:`factor`. ruT)rYrdr,rerwr )r~rQrrrbrursr\r\r]_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 rsimplifyNc s@t|jdkr|jdjs"d|fS|}|}|p<|}|dd}fdd|D}t|dkr<|dr<|d|d}g}tt|D]2}||||d}|jsq<| |qd|} |jd} | |g} td|dD]"}| ||d| ||qt | }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``. rurNcsg|] }|qSr\r\)rcoeffxrr\r]r+rz._try_rescale..r0) rwrQrXr&r.rhrrrFr r rO) rWf1rrLrZ rescale1_xZcoeffs1rrZ rescale_xrrrr\r] _try_rescales0       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``. rurNcSs |jduSNTrE)zr\r\r]rOrz._try_translate..Tbinary) rwrQrXr&rhris_AddrFrJrrr[ro) rWrrrrratZnonratalphaf2rr\r]_try_translate?s     z*to_rational_coeffs.._try_translatecSsp|}d}|D]Z}t|D]J}t|j}dd|D}|sDqt|dkrTd}t|dkrdSqq|S)zS Return True if ``f`` is a sum with square roots but no other root FcSs,g|]$\}}|jr|jr|jdkr|jqS)r)r is_Rationalr)rrGZwxr\r\r]r^s zAto_rational_coeffs.._has_square_roots..rT)rr rlr r{rminmax)rgrZhas_sqrrrWrr\r\r]_has_square_rootsUs    z-to_rational_coeffs.._has_square_rootsrur)N)N)sympy.simplify.simplifyrrrrh)rWrrrrrr\rr]to_rational_coeffss& "  rc Csddlm}t||dd}|}t|}|s2dS|\}}}} t| } |r|| d|||} |d|} g} | dddD],}| ||d||| i|dfqnF| d} g} | dddD](}| |d|||i|dfq| | 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 rrEXrNru) rrrOr&rr}rUr r)rgrrp1rresrLrrVrXr{rr1rFrr\r\r]_torational_factor_listts&    ,&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)]) rrbrr]r\r\r]rysrycOst|||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 rr)rr]r\r\r]rsrcOst|||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)]) rrrr]r\r\r]r}sr})rTc st|}|rzfdd}t||}i}|tt}|D]6}t|gRi}|js^|jr8||kr8|||<q8||Szt |ddWSt y} z.|j st |WYd} ~ St | WYd} ~ n d} ~ 00dS)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|gRi}|js"|jr&|S|S)zS Factor, but avoid changing the expression when unable to. )ris_Mulrm)r~rr;r\r] _try_factors zfactor.._try_factorrrN) r r#atomsrr rrrmxreplacerr7rr) rWrTrQrrrZpartialsZmuladdrgrmsgr\r;r]rs"D    rc Cs2t|dsDz t|}Wnty,gYS0|j||||||dSt|dd\}} t| jdkrftt|D]\} } | j j || <qn|dur| j |}|dkrt d|dur| j |}|dur| j |}t || j |||||d } g} | D]8\\}}}| j || j |}}| ||f|fq| 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)] rNrr(rruNrr)rrrrr)rrOr6rrrwrQr8rrarrrrDrr )rrzrrrrrrrrsrrrrYr-rVrr\r\r]r9s6        rcCs\z&t|}t|ts$|jjs$tdWntyDtd|Yn0|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) generator must be a Symbolz,Cannot refine a root of %s, not a polynomial)rrrr)rOrNr is_Symbolr7r6r)rWr-rVrrrrrr\r\r]rqs   rcCsXz*t|dd}t|ts(|jjs(tdWntyHtd|Yn0|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 Fgreedyrz*Cannot count roots of %s, not a polynomialr)rOrNrrr7r6r)rWrrrr\r\r]rs   rTcCsVz*t|dd}t|ts(|jjs(tdWntyHtd|Yn0|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] Frrz1Cannot compute real roots of %s, not a polynomialr)rOrNrrr7r6r)rWrrr\r\r]rs    rrrcCsZz*t|dd}t|ts(|jjs(tdWntyHtd|Yn0|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] Frrz6Cannot compute numerical roots of %s, not a polynomial)rrr)rOrNrrr7r6r)rWrrrrr\r\r]rs    rc Os~t|gz8t|g|Ri|\}}t|tsB|jjsBtdWn0tyt}zt dd|WYd}~n d}~00| S)z Compute roots of ``f`` by factorization in the ground domain. Examples ======== >>> from sympy import ground_roots >>> from sympy.abc import x >>> ground_roots(x**6 - 4*x**4 + 4*x**3 - x**2) {0: 2, 1: 2} rrruN) rdr,rrNrOrrr7r:r;rr.r\r\r]rs  "rc Ost|gz8t|g|Ri|\}}t|tsB|jjsBtdWn0tyt}zt dd|WYd}~n d}~00| |}|j s| S|SdS)a Construct a polynomial with n-th powers of roots of ``f``. Examples ======== >>> from sympy import nth_power_roots_poly, factor, roots >>> from sympy.abc import x >>> f = x**4 - x**2 + 1 >>> g = factor(nth_power_roots_poly(f, 2)) >>> g (x**2 - x + 1)**2 >>> R_f = [ (r**2).expand() for r in roots(f) ] >>> R_g = roots(g).keys() >>> set(R_f) == set(R_g) True rrruN) rdr,rrNrOrrr7r:r;rrrU)rWrrQrrrrsrrYr\r\r]rs  " r) _signsimpc spddlm}ddlm}t|dgt|}|r:||}i}d|vrR|d|d<t|tt fs|j szt|t szt|t s~|St |dd}|\}}nt|dkr|\}}t|trt|tr|j|d<|j|d <|dd|d<||}}n t|t r t |Std |dd lmzj|r8t|||fg|Ri|\} \} } | jst|tt fs||WStj||fWSWn*ty} z|jr|st| |js|j r t!|j"fd d dd\} }dd|D}|j#t$|j#| g|RWYd} ~ Sg}t%|}t&||D]P}t|tt t'frRq8z|(|t$|f|)Wnt*yYn0q8|+t,|WYd} ~ SWYd} ~ n d} ~ 00d| $| } \}}|ddrd|vr| j-|d<t|tt fs| ||S||}}|dds>| ||fS| t|g|Ri|t|g|Ri|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)sringrT)radicalrrQrzunexpected argument: %srcs|jduo| Sr)rhasrrr\r]ryszcancel..rcSsg|] }t|qSr\)rrhr\r\r]r|rzcancel..NruF).rrsympy.polys.ringsrrdr,r rNrr r(rrrrJrwrOrQrrKrUrr!rrr7ZngensrrrBrrrrJrrr[rr"r*r$r skiprfrrir)rWrrQrrrrrsrgrr"rrrrncr%poterqr!r\rr]r4s~           "  (  0  rc st|ddgz(t|gt|g|Ri|\}Wn0tyh}ztdd|WYd}~n d}~00j}d}jr|jr|j s t | dd}dd l m}|jjj\} } t|D](\} } | jj} | | || <q|d|d d\} }fd d | D} tt |}|rpzd d | D|}}WntydYn 0||} }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) rr reducedrNFrTxringrucsg|]}tt|qSr\rOrjrirrrr\r]rrzreduced..cSsg|] }|qSr\rrr\r\r]rrcSsg|] }|qSr\rrr\r\r]rr)rdr,rrlr:r;rr rrr{rirrrrQrbrrrarrrrOrjrr4rrU)rWrrQrrrrrrr_ringrrrr!r_Q_rr\rr]rs6("  rcOst|g|Ri|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]_ ) GroebnerBasisrrQrrr\r\r]r,s3r,cOst|g|Ri|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 )ris_zero_dimensionalrr\r\r]r src@seZdZdZddZeddZeddZedd Z ed d Z ed d Z eddZ eddZ ddZddZddZddZddZddZeddZd d!Zd(d#d$Zd%d&Zd'S))rz%Represents a reduced Groebner basis. c st|ddgzt|g|Ri|\}Wn4tyb}ztdt||WYd}~n d}~00ddlm}|jj j fdd|D}t |j d }fd d|D}| |S) z>Compute a reduced Groebner basis for a system of polynomials. rrbr,Nr)PolyRingcs g|]}|r|jqSr\)rrarrr)ringr\r]r/rz)GroebnerBasis.__new__..rcsg|]}t|qSr\)rOrjrrXrr\r]r2r)rdr,rr:r;rwrrrQrrb _groebnerrb_new)rqrrQrrrrrrr\)rsrr]rt#s& zGroebnerBasis.__new__cCst|}t||_||_|Srz)r rtr_basis_options)rqbasisrdrxr\r\r]r6s  zGroebnerBasis._newcCs$dd|jD}t|t|jjfS)Ncss|]}|VqdSrzr)rrgr\r\r]rAArz%GroebnerBasis.args..)rr rrQ)r}rr\r\r]rr?szGroebnerBasis.argscCsdd|jDS)NcSsg|] }|qSr\rrr\r\r]rFrz'GroebnerBasis.exprs..)rr|r\r\r]rDszGroebnerBasis.exprscCs t|jSrz)rlrr|r\r\r]rHszGroebnerBasis.polyscCs|jjSrz)rrQr|r\r\r]rQLszGroebnerBasis.genscCs|jjSrz)rrr|r\r\r]rPszGroebnerBasis.domaincCs|jjSrz)rrbr|r\r\r]rbTszGroebnerBasis.ordercCs t|jSrz)rwrr|r\r\r]__len__XszGroebnerBasis.__len__cCs |jjrt|jSt|jSdSrz)rriterrr|r\r\r]rN[s zGroebnerBasis.__iter__cCs|jjr|j}n|j}||Srz)rrr)r}itemrr\r\r] __getitem__aszGroebnerBasis.__getitem__cCst|jt|jfSrz)hashrrrrr|r\r\r]riszGroebnerBasis.__hash__cCsPt||jr$|j|jko"|j|jkSt|rH|jt|kpF|jt|kSdSdS)NF)rNrrrrIrrlrr}rr\r\r]rls  zGroebnerBasis.__eq__cCs ||k Srzr\rr\r\r]rtszGroebnerBasis.__ne__cCsTdd}tdgt|j}|jj}|jD] }|j|d}||r*||9}q*t|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|dkSr)sumrr#)monomialr\r\r] single_varsz5GroebnerBasis.is_zero_dimensional..single_varrr)r-rwrQrrbrr9rz)r}rr3rbrrr\r\r]rws   z!GroebnerBasis.is_zero_dimensionalc s|jj}t|}||kr |S|js.tdt|j}j}t | |dddl m }|j j|\}}t|D](\} } | jj} || || <q|t|||} 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)rrbrrcsg|]}tt|qSr\rrrr\r]rrz&GroebnerBasis.fglm..cSsg|]}|jdddqS)TrEru)rArr\r\r]rr)rrbr.rrfrlrrr{rirrrrQrrrarrr+rr) r}rbZ src_orderZ dst_orderrrrrrrrrr\rr]fglms0   zGroebnerBasis.fglmTcsRt||j}|gt|j}|jj}d}|rV|jrV|jsVt | dd}ddl m }|j jj\}} t|D](\} }|jj}|||| <q|d|dd\} } fdd | D} tt | } |r(zd d | D| } }WntyYn 0| |} } jsFd 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 FrTrrruNcsg|]}tt|qSr\rrrr\r]r rz(GroebnerBasis.reduce..cSsg|] }|qSr\rrr\r\r]rrcSsg|] }|qSr\rrr\r\r]rr)rOrorrlrrrrr{rirrrrQrbrrrarrrrjrr4rrU)r}r~r rrrrrrrrr!rrrr\rr]rs2  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 rur)r)r}rr\r\r]containsszGroebnerBasis.containsN)T)rVr r r rtrrrrrrrrQrrbrrNrrrrrrrrr\r\r\r]rs6        B Arcsdtgfddt|}|jr>t|g|RiSdvrNdd<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}}t|D]}gg}}t|D]b}|jrH|||q,|jr|jjr|jjr|jdkr||j| |jq,||q,|s||q|d}|ddD]}| |}q|rt|}|j r| |}n| t ||}||q|st ||} nZ|d} |ddD]}| |} q(|rnt|}|j r\| |} n| t ||} | j|ddiS)NrrurQr\)r rlrrr rmrnrarrrr(rOrorrrK) r~rsrZ poly_termsr\r{Z poly_factorsrproductrY_polyrrr\r]rAsJ        zpoly.._polyrF)rdr,r rmrOrerr\rr]r0s 4 r)r)N)N)FNNNFFF)NNFF)NN)T)rrT)r  functoolsrroperatorrtypingr sympy.corerrr r sympy.core.basicr Zsympy.core.decoratorsr Zsympy.core.exprtoolsr rrZsympy.core.evalfrrrrrsympy.core.functionrZsympy.core.mulrrsympy.core.numbersrrrsympy.core.relationalrrsympy.core.sortingrsympy.core.symbolrrsympy.core.sympifyr r!sympy.core.traversalr"r#sympy.logic.boolalgr$ sympy.polysr%rdZsympy.polys.constructorr&Zsympy.polys.domainsr'r(r)Z!sympy.polys.domains.domainelementr*Zsympy.polys.fglmtoolsr+Zsympy.polys.groebnertoolsr,rZsympy.polys.monomialsr-sympy.polys.orderingsr.sympy.polys.polyclassesr/r0r1sympy.polys.polyerrorsr2r3r4r5r6r7r8r9r:r;r<sympy.polys.polyutilsr=r>r?r@rArBsympy.polys.rationaltoolsrCZsympy.polys.rootisolationrDZsympy.utilitiesrErFrGsympy.utilities.exceptionsrHsympy.utilities.iterablesrIrJrrZmpmath.libmp.libhyperrKr_rOrrrrrr'r&r(r'r.r9r=rrrrrr#r$r%rSrUrWrYrZr]rarIrdrRrerrfrhrjrkrmrnrrrsr^rwrxrcrfrtrwrrrrryrr}rrrrrrrrrrrrrr\r\r\r]s              4     "d] ( ^  : 4       " "    " & & 4 $  ( T 3 M 2 u    -    .  ! :, ,   b 7      +f ; 5