o *ήc@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|trNz |j|g|jR}Wn)tyH|jr-tYSt | j }||}|turDt dddd|YSw||StS)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)fg expr_methodresultfunc.wrapper)r)r\r_r]r[r^ _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/dRdSZ0dudTdUZ1dudVdWZ2dudXdYZ3dudZd[Z4dud\d]Z5d^d_Z6d`daZ7dbdcZ8dddeZ9dfdgZ:dvdidjZ;dwdkdlZdqdrZ?dsdtZ@dwdudvZAdwdxZBdydzZCd{d|ZDd}d~ZEddZFddZGddZHddZIddZJddZKddZLddZMddZNddZOddZPddZQddZRddZSdxddZTdxddZUdxddZVdxddZWddZXdyddZYddZZddZ[ddZ\ddZ]duddZ^ddZ_duddZ`ddZaddZbdzddZcduddZdduddZedudd„ZfduddĄZgddƄZhddȄZidwddʄZjdd̄Zkdd΄ZlddЄZmemZnd{dd҄ZoddԄZpdxddքZqdxdd؄ZrdxddڄZsdd܄ZtddބZudwddZvddZwduddZxduddZyddZzddZ{ddZ|ddZ}dxddZ~ddZddZddZddZddZddZdxddZddZddZddZddZdwddZdwd d Zd d Zd dZd|ddZd}ddZdtddZdxddZd~ddZd~ddZdddZdd Zd!d"Zd#d$Zdwd%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`daZedbedcddZedbededfZedgedhdiZedbedjdkZdldmZdwdndoZdwdpdqZdrdsZZS(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 dr6t|t r.| ||S| t||St|}|jrC|||S|||S)z:Create a new polynomial instance out of something useful. orderz&'order' keyword is not implemented yet)exclude)options build_optionsNotImplementedErrorrNr/r0r1r*_from_domain_elementrIstrdict _from_dict _from_listlistr is_Poly _from_poly _from_exprclsrbrQargsoptr]r]r^__new__s       z Poly.__new__cGsRt|ts td||jt|dkrtd||ft|}||_||_|S)z:Construct :class:`Poly` instance from raw representation. z%invalid polynomial representation: %szinvalid arguments: %s, %s) rNr/r7levlenr rurbrQ)rrrbrQobjr]r]r^news  zPoly.newcCst|jg|jRSN)r=rb to_sympy_dictrQselfr]r]r^exprsz Poly.exprcC|jf|jSr{)rrQr}r]r]r^rssz Poly.argscCrr{rar}r]r]r^_hashable_contentszPoly._hashable_contentcOt||}|||S)(Construct a polynomial from a ``dict``. )rerfrkrqr]r]r^ from_dict  zPoly.from_dictcOr)(Construct a polynomial from a ``list``. )rerfrlrqr]r]r^ from_listrzPoly.from_listcOr)*Construct a polynomial from a polynomial. )rerfrorqr]r]r^ from_polyrzPoly.from_polycOr+Construct a polynomial from an expression. )rerfrprqr]r]r^rPrzPoly.from_exprcCsz|j}|s tdt|d}|j}|durt||d\}}n|D] \}}||||<q#|jt |||g|RS)rz0Cannot initialize from 'dict' without generatorsrvNrt) rQr6rxdomainr&itemsconvertrzr/r)rrrbrtrQlevelrmonomcoeffr]r]r^rks zPoly._from_dictcCs~|j}|s tdt|dkrtdt|d}|j}|dur)t||d\}}ntt|j|}|j t |||g|RS)rz0Cannot initialize from 'list' without generatorsrvz#'list' representation not supportedNr) rQr6rxr8rr&rmmaprrzr/r)rrrbrtrQrrr]r]r^rls  zPoly._from_listcCs||jkr|j|jg|jR}|j}|j}|j}|r6|j|kr6t|jt|kr1|||S|j |}d|vrC|rC| |}|S|durK| }|S)rrT) __class__rzrbrQfieldrsetrprUreorder set_domainto_field)rrrbrtrQrrr]r]r^ros    zPoly._from_polycCst||\}}|||Sr)rArk)rrrbrtr]r]r^rp4s zPoly._from_exprcCs@|j}|j}t|d}||g}|jt|||g|RSNrv)rQrrxrrzr/r)rrrbrtrQrrr]r]r^rh:s   zPoly._from_domain_elementc tSr{super__hash__r}rr]r^rD z Poly.__hash__cCsPt}|j}tt|D]}|D]}||r!|||jO}nqq ||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} )rrQrangerxmonoms free_symbolsfree_symbols_in_domain)r~symbolsrQirr]r]r^rGs  zPoly.free_symbolscCsR|jjt}}|jr|jD]}||jO}q|S|jr'|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} )rbdomr 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^rs zPoly.gencC|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.domaincC&|j|j|jj|jjg|jRS)z3Return zero polynomial with ``self``'s properties. )rzrbzerorwrrQr}r]r]r^r&z Poly.zerocCr)z2Return one polynomial with ``self``'s properties. )rzrbonerwrrQr}r]r]r^rrzPoly.onecCr)z3Return unit polynomial with ``self``'s properties. )rzrbunitrwrrQr}r]r]r^rrz 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 stjs+zjjjjjjjfWSty*tdfwtjt rtjt rt j j }jj jj|t |d}j |kr~tjj |\}}jjkrpfdd|D}t ttt|||}nj}j |krtjj |\}}jjkrfdd|D}t ttt|||} nj} ntdfj|dffdd } | || fS)NCannot unify %s with %srvcg|] }|jjqSr]rrbr.0c)rrWr]r^ zPoly._unify..crr]rr)rrXr]r^rrcD|dur|d|||dd}|s||Sj|g|RSrto_sympyrzrbrrQremoverrr]r^r  zPoly._unify..per)r rnrbrr from_sympyr4r5rNr/r?rQrrxr@to_dictrjrmziprr) rWrXrQrwf_monomsf_coeffsrg_monomsg_coeffsrrr])rrrrWrXr^rs<( "      z Poly._unifyNcCsX|dur|j}|dur"|d|||dd}|s"|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') Nrv)rQrbrrrrz)rWrbrQrr]r]r^r szPoly.percCs&t|jd|i}||j|jS)z Set the ground domain of ``f``. r)rerfrQrrbrr)rWrrtr]r]r^r'szPoly.set_domaincC|jjS)z Get the ground domain of ``f``. )rbrrWr]r]r^r,zPoly.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) )reModulus preprocessrr')rWmodulusr]r]r^ set_modulus0s zPoly.set_moduluscCs"|}|jr t|Std)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 field)ris_FiniteFieldrcharacteristicr7)rWrr]r]r^ get_modulusAs zPoly.get_moduluscCsN||jvr|jr|||Sz|||WStyYnw|||S)z)Internal implementation of :func:`subs`. )rQ is_numberevalreplacer7rUsubs)rWoldrzr]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)rbrd enumeraterQr)rWrzrQr]rr^rdcsz Poly.excludecKs|dur|jr|j|}}ntd||ks||jvr|S||jvrG||jvrG|}|jr3||jvrGt|j}||||<|j |j |dStd|||f)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_univariaterr7rQrrrrmindexrrb)rWxy_ignorerrQr]r]r^rvs z Poly.replacecOs|j|i|S)z-Match expression from Poly. See Basic.match())rUmatch)rWrskwargsr]r]r^rsz Poly.matchcOs|td|}|st|j|d}n t|jt|krtdtttt |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 elementsrvr)reOptionsr>rQrr7rjrmrr@rbrrr/rrx)rWrQrsrtrbr]r]r^rs  "z Poly.reordercCs|jdd}||}i}|D]\}}t|d|r#td|||||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 %srv) as_dict _gen_to_levelranyr7rQrzr/rrxrbr)rWrrbrtermsrrrQr]r]r^ltrims   (z Poly.ltrimc Gst}|D]}z|j|}Wntytd||fw||q|D]}t|D]\}}||vr=|r=dSq/q)dS)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_genscC,t|jdr |j}nt|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)hasattrrbrr2rrWrZr]r]r^r    z Poly.to_ringcCr)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)rrbrr2rrr]r]r^rrz Poly.to_fieldcCr)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)rrbrr2rrr]r]r^r'rz Poly.to_exactcCs4t|jdd||jjp dd\}}|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)rWrrrbr]r]r^retract<s   z Poly.retractcCsh|dur d||}}}n||}t|t|}}t|jdr*|j|||}nt|d||S)z1Take a continuous subsequence of terms of ``f``. Nrslice)rintrrbrr2r)rWrmnrrZr]r]r^rTs    z Poly.slicecfddjj|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 cg|] }jj|qSr]rbrrrrr]r^rxzPoly.coeffs..rc)rbrrWrcr]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 )rbrr r]r]r^rzsz Poly.monomscr)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 c"g|] \}}|jj|fqSr]rrrrrr]r^r"zPoly.terms..r )rbrr r]rr^rsz Poly.termscfddjDS)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] crr]rrrr]r^rr z#Poly.all_coeffs..)rb all_coeffsrr]rr^rzPoly.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 )rb all_monomsrr]r]r^rs zPoly.all_monomscr)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)] cr r]rr rr]r^rrz"Poly.all_terms..)rb all_termsrr]rr^rrzPoly.all_termscOsxi}|D]&\}}|||}t|tr|\}}n|}|r,||vr&|||<qtd|q|j|g|p5|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\rQrsrrrrZr]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 )rxrrr]r]r^lengths z Poly.lengthFcCs |r |jj|dS|jj|dS)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} r)rbrr|)rWrrr]r]r^r sz Poly.as_dictcCs|r|jS|jS)z%Switch to a ``list`` representation. )rbto_list to_sympy_list)rWrr]r]r^as_lists  z Poly.as_listc Gs|s|jSt|dkr?t|dtr?|d}t|j}|D]\}}z||}Wnty9t d||fw|||<qt |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 rvrr) rrxrNrjrmrQrrrr<r=rbr|)rWrQmappingrvaluerr]r]r^rU%s    z Poly.as_exprcOs>zt|g|Ri|}|jsWdS|WStyYdSw)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)rOrnr7)r~rQrspolyr]r]r^as_polyKs z Poly.as_polycCr)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)rrbrr2rrr]r]r^rerz Poly.liftcC4t|jdr|j\}}nt|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)rrbr r2rrWrrZr]r]r^r z  z Poly.deflatecCsz|jj}|jr |S|jstd|t|jdr |jj|d}nt|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) rbr is_Numericalrnr3rr#r2rrQrz)rWr%rrZrQr]r]r^r#s    z Poly.injectcGs|jj}|js td|t|}|jd||kr%|j|dd}}n|j| d|kr;|jd| d}}ntd|j|}t|jdrS|jj ||d}nt |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$) rbrr&r3rxrQrgr#rr'r2rz)rWrQrk_gensr%rZr]r]r^r's     z Poly.ejectcCr)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)rrbr*r2rr!r]r]r^r*r"zPoly.terms_gcdcC.t|jdr |j|}nt|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)rrbr,r2rrWrrZr]r]r^r,   zPoly.add_groundcCr+)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)rrbr/r2rr-r]r]r^r/r.zPoly.sub_groundcCr+)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)rrbr0r2rr-r]r]r^r0r.zPoly.mul_groundcCr+)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)rrbr1r2rr-r]r]r^r12s   zPoly.quo_groundcCr+)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)rrbr2r2rr-r]r]r^r2Js   zPoly.exquo_groundcCr)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)rrbr3r2rrr]r]r^r3drzPoly.abscCr)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)rrbr4r2rrr]r]r^r4y    zPoly.negcCRt|}|js ||S||\}}}}t|jdr$||}||St|d)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 rnr,rrrbrr2rWrXrrrrrZr]r]r^r    zPoly.addcCr6)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 rnr/rrrbr9r2r7r]r]r^r9r8zPoly.subcCr6)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 rnr0rrrbrr2r7r]r]r^rr8zPoly.mulcCr)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)rrbr:r2rrr]r]r^r:r5zPoly.sqrcCs6t|}t|jdr|j|}nt|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)rrrbr;r2rrWrrZr]r]r^r;s    zPoly.powcCsH||\}}}}t|jdr||\}}nt|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)rrrbr=r2)rWrXrrrrqrr]r]r^r= s   z Poly.pdivcC:||\}}}}t|jdr||}||St|d)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)rrrbrAr2r7r]r]r^rA7s    z Poly.premcCr@)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)rrrbrBr2r7r]r]r^rB^s    z Poly.pquoc Csj||\}}}}t|jdr0z ||}W||Sty/}z |||d}~wwt|d)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)rrrbrCr9rzrUr2)rWrXrrrrrZexcr]r]r^rCzs   z Poly.pexquoc Cs||\}}}}d}|r|jr|js||}}d}t|jdr,||\}} nt|d|rMz || } } Wn t yGYnw| | }} |||| 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_FieldrrrbrEr2rr4) rWrXautorrrrrr>r?QRr]r]r^rEs     zPoly.divc C||\}}}}d}|r|jr|js||}}d}t|jdr*||}nt|d|rGz |}W||St yFY||Sw||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) rrFrGrrrbrLr2rr4) rWrXrHrrrrrr?r]r]r^rL"     zPoly.remc CrK)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) rrFrGrrrbrNr2rr4) rWrXrHrrrrrr>r]r]r^rNrMzPoly.quoc Cs||\}}}}d}|r|jr|js||}}d}t|jdrBz||}WntyA} z | | | d} ~ wwt |d|r_z | }W||St y^Y||Sw||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) rrFrGrrrbrOr9rzrUr2rr4) rWrXrHrrrrrr>rDr]r]r^rO s,    z Poly.exquocCst|tr*t|j}| |kr|kr!nn |dkr||S|Std|||fz |jt|WSty@td|w)z3Returns level associated with the given generator. rz -%s <= gen < %s expected, got %sz"a valid generator expected, got %s)rNrrxrQr7rr r)rWrrr]r]r^r4s   zPoly._gen_to_levelrcCs,||}t|jdr|j|St|d)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 degree)rrrbrPr2)rWrrr]r]r^rPHs    z Poly.degreecC t|jdr |jSt|d)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_list)rrbrRr2rr]r]r^rRcs   zPoly.degree_listcCrQ)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_degree)rrbrSr2rr]r]r^rSvs   zPoly.total_degreecCszt|ts tdt|||jvr|j|}|j}n t|j}|j|f}t|jdr8|j |j ||dSt |d)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_order) rNr TypeErrortyperQrrxrrbrrTr2)rWsrrQr]r]r^rTs       zPoly.homogenizecCrQ)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 rU)rrbrUr2rr]r]r^rUs   zPoly.homogeneous_ordercCsF|dur ||dSt|jdr|j}nt|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)rrrbrYr2rr)rWrcrZr]r]r^rYs    zPoly.LCcC0t|jdr |j}nt|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)rrbr[r2rrrr]r]r^r[   zPoly.TCcCs$t|jdr ||dSt|d)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 rEC)rrbrr2r r]r]r^r^s  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|jdrt|t|jkrtd|jjttt|}nt |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 r_z,exponent of each generator must be specified) rrbrxrQrr_rmrrr2rr)rWNrZr]r]r^r_+s  zPoly.nthrvcCtd)NzyEither convert to Expr with `as_expr` method to use Expr's coeff method or else use the `coeff_monomial` method of Polys.rg)rWrrrightr]r]r^rMsz Poly.coeffcCt||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-rrQr r]r]r^LMYszPoly.LMcCrf)z Returns the last non-zero monomial of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).EM() x**0*y**1 r]rgr r]r]r^EMmszPoly.EMcC"||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-rQrWrcrrr]r]r^LT}szPoly.LTcCrj)z Returns the last non-zero term of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).ET() (x**0*y**1, 3) r]rkrlr]r]r^ETszPoly.ETcCrZ)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)rrbror2rrrr]r]r^ror\z Poly.max_normcCrZ)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)rrbrpr2rrrr]r]r^rpr\z Poly.l1_normcCs|}|jjjs tj|fS|}|jr|jj}t|jdr'|j \}}nt |d| || |}}|r<|js@||fS|| fS)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_denoms)rbrrGrOnerhas_assoc_Ringget_ringrrqr2rrr)r~rrWrrrZr]r]r^rqs       zPoly.clear_denomscCsv|}||\}}}}||}||}|jr|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)rrGrsrqr0)r~rXrWrrabr]r]r^rat_clear_denomss   zPoly.rat_clear_denomscOs|}|ddr|jjjr|}t|jdrJ|s#||jjddS|j}|D]}t|t r4|\}}n|d}}|t || |}q(||St |d)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') rHT integratervr) getrbrrFrrrryrNrrrr2)r~specsrsrWrbspecrrr]r]r^ry s      zPoly.integratecOs|ddst|g|Ri|St|jdrJ|s#||jjddS|j}|D]}t|tr4|\}}n|d}}|t|| |}q(||St |d)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') evaluateTdiffrvrz) r{rrrbrrrNrrrr2)rWr|rrbr}rrr]r]r^rC s       z Poly.diffc CsL|}|durMt|tr|}|D] \}}|||}q|St|ttfrG|}t|t|jkr4tdt |j|D] \}}|||}q:|Sd|} }n| |} t |j ds]t |dz |j || } Wn8ty|sytd||j jft|g\} \}|| |j} || }| || }|j || } Ynw|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)rNrjrrrrmrxrQrrrrrbr2r4r3rr&runify_with_symbolsrrr) r~rrvrHrWrrrvaluesrrZa_domain new_domainr]r]r^rk s<         z Poly.evalcG ||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)rWrr]r]r^__call__ s z Poly.__call__c Csd||\}}}}|r|jr||}}t|jdr%||\}}nt|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)rrFrrrbrr2) rWrXrHrrrrrXhr]r]r^r s   zPoly.half_gcdexc Csl||\}}}}|r|jr||}}t|jdr&||\}}} nt|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)rrFrrrbrr2) rWrXrHrrrrrXtrr]r]r^r s   z Poly.gcdexcCsV||\}}}}|r|jr||}}t|jdr&||}||St|d)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)rrFrrrbrr2)rWrXrHrrrrrZr]r]r^r s    z Poly.invertcCs2t|jdr|jt|}nt|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)rrbrrr2rr<r]r]r^r+ s   z Poly.revertcCsB||\}}}}t|jdr||}nt|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)rrrbrr2rmrr7r]r]r^rM s    zPoly.subresultantsc Csv||\}}}}t|jdr!|r|j||d\}}n ||}nt|d|r5||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 includePRSrr)rrrbrr2rmr) rWrXrrrrrrZrJr]r]r^rf s    zPoly.resultantcCs0t|jdr |j}nt|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 discriminantrr)rrbrr2rrr]r]r^r r\zPoly.discriminantcCddlm}|||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)rWrXrr]r]r^r  H zPoly.dispersionsetcCr)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)rr)rWrXrr]r]r^r rzPoly.dispersionc CsP||\}}}}t|jdr||\}}}nt|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)rrrbrr2) rWrXrrrrrcffcfgr]r]r^r6 s   zPoly.cofactorscCr@)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)rrrbrr2r7r]r]r^rS    zPoly.gcdcCr@)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)rrrbrr2r7r]r]r^rj rzPoly.lcmcCs<|jj|}t|jdr|j|}nt|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)rbrrrrr2r)rWprZr]r]r^r s    z Poly.trunccCsF|}|r |jjjr |}t|jdr|j}nt|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)rbrrFrrrr2rr~rHrWrZr]r]r^r s    z Poly.moniccCrZ)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)rrbrr2rrrr]r]r^r r\z Poly.contentcCs>t|jdr|j\}}nt|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)rrbrr2rrr)rWcontrZr]r]r^r s  zPoly.primitivecCr@)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)rrrbrr2r7r]r]r^r rz Poly.composecCs2t|jdr |j}nt|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)rrbrr2rmrrrr]r]r^r s   zPoly.decomposecCr+)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)rrbrr2r)rWrvrZr]r]r^r r.z Poly.shiftcCs^||\}}||\}}||\}}t|jdr%|j|j|j}nt|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)rrrbrr2r)rWrr>PrIrrZr]r]r^r s   zPoly.transformcCsL|}|r |jjjr |}t|jdr|j}nt|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) rbrrFrrrr2rmrrrr]r]r^r: s   z Poly.sturmcs4tjdr j}ntdfdd|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_listcg|] \}}||fqSr]rrrXr(rr]r^rl z!Poly.gff_list..)rrbrr2rr]rr^rW s   z Poly.gff_listcCr)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)rrbrr2r)rWr?r]r]r^rn s    z Poly.normcCs>t|jdr|j\}}}nt|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)rrbrr2r)rWrXrXr?r]r]r^r s  z Poly.sqf_normcCr)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)rrbrr2rrr]r]r^r rz Poly.sqf_partcsHtjdrj|\}}ntdjj|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_listcrr]rrrr]r^r rz!Poly.sqf_list..)rrbrr2rr)rWallrfactorsr]rr^r s   z Poly.sqf_listcs6tjdr j|}ntdfdd|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_includecrr]rrrr]r^r rz)Poly.sqf_list_include..)rrbrr2)rWrrr]rr^r s  zPoly.sqf_list_includecsltjdr!z j\}}Wnty tjdfgfYSwtdjj|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_listrvcrr]rrrr]r^r rz$Poly.factor_list..) rrbrr3rrrr2rr)rWrrr]rr^r s    zPoly.factor_listcsTtjdrzj}WntydfgYSwtdfdd|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_includervcrr]rrrr]r^r7 rz,Poly.factor_list_include..)rrbrr3r2)rWrr]rr^r s   zPoly.factor_list_includec Cs|durt|}|dkrtd|durt|}|dur#t|}t|jdr6|jj||||||d}nt|d|r`dd}|sJtt||Sdd } |\} } tt|| tt| | fSd d}|smtt||Sd d } |\} } tt|| tt| | fS) 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 intervalsrepsinfsupfastsqfcSs|\}}t|t|fSr{r(r)intervalrXrr]r]r^_reale szPoly.intervals.._realcSs@|\\}}\}}t|tt|t|tt|fSr{r(rr) rectangleuvrXrr]r]r^_complexl sz Poly.intervals.._complexcSs$|\\}}}t|t|f|fSr{r)rrXrr(r]r]r^ru s cSsH|\\\}}\}}}t|tt|t|tt|f|fSr{r)rrrrXrr(r]r]r^r| s ) r(rrrrbrr2rmr) rWrrrrrrrZrr real_part complex_partr]r]r^r9 s4      zPoly.intervalsc Cs|r |js tdt|t|}}|dur%t|}|dkr%td|dur.t|}n|dur4d}t|jdrH|jj|||||d\}}nt |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 supportedNrrrv refine_root)rstepsr) is_sqfr7r(rrrrrbrr2r) rWrXrrrr check_sqfrTr]r]r^r s     zPoly.refine_rootcCsDd\}}|dur/t|}|tjurd}n|\}}|s"t|}n tttj||fd}}|durZt|}|tjur?d}n|\}}|sMt|}n tttj||fd}}|ru|rut |j drp|j j ||d}t|St |d|r|dur|tj f}|r|dur|tj f}t |j dr|j j||d}t|St |d)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(rrmrInfinityrrbrr2rrr)rWrrinf_realsup_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.rootcC(tjjjj||d}|r|St|ddS)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)] rFmultiple)rrrCRootOf real_rootsrE)rWrrrealsr]r]r^rs zPoly.real_rootscCr)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)] rFr)rrrr all_rootsrE)rWrrrootsr]r]r^rs zPoly.all_roots2c s|jr td||dkrgS|jjtur!dd|D}nC|jjtur@dd|D}t|fdd|D}n$fdd|D}z dd|D}Wnt yct d |jjwt j j }t j _ dd lmzfzt j|||d |d d }tttt|fddd}Wn8tyzt j|||d |dd }tttt|fddd}Wntytd|fwYnwW|t j _ |SW|t j _ |S|t j _ w)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 %srcSg|]}t|qSr]rrrr]r]r^rZzPoly.nroots..cSsg|]}|jqSr])r>rr]r]r^r\scsg|]}t|qSr]rr)facr]r^r^csg|] }|jdqS)r)rrrrr]r^r`scSsg|]}tj|qSr])mpmathmpcrr]r]r^rcsz!Numerical domain expected, got %ssignF )maxstepscleanuperror extraprecc$|jrdnd|jt|j|jfSNrvrimagrealr3r?rr]r^u$zPoly.nroots..keyrcrrrrrr]r^r|rz7convergence to root failed; try n < %s or maxsteps > %s)is_multivariater8rPrbrr)rr(rrVr3rmpdps$sympy.functions.elementary.complexesr polyrootsrmrr sortedrK)rWrrrrdenomsr rr])rrrr^nroots6sp         z Poly.nrootscCsP|jr td|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 %srv)rr8r is_linearr)rWrfactorr(rvrwr]r]r^ ground_rootss zPoly.ground_rootscCsr|jrtdt|}|jr|dkrt|}ntd||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 polynomialrvz&'n' must an integer and n >= 1, got %sr) rr8r is_IntegerrrrrrrrPr)rWrrbrrr?r]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 rvcstt|dS)Nrz)rrrrzr]r^rsz Poly.same_root..) rr8rbmignotte_sep_bound_squaredr get_fieldrrrrr) rWrvrw dom_delta_sqdelta_sqeps_sqr?rrevABr]rzr^ same_roots  $zPoly.same_rootc Cs||\}}}}t|dr|j||d}nt|d|s?|jr$|}|\}} } } ||}|| } || || || fStt||S)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)include) rrr r2rsrtrrr) rWrXr!rrrrrZcpcqrr>r]r]r^r s     z Poly.cancelcCr)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 )rbis_zerorr]r]r^r$!z Poly.is_zerocCr)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 )rbis_onerr]r]r^r&4r%z Poly.is_onecCr)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 )rbrrr]r]r^rGr%z Poly.is_sqfcCr)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 )rbis_monicrr]r]r^r'Zr%z Poly.is_moniccCr)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 )rb is_primitiverr]r]r^r(mr%zPoly.is_primitivecCr)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 )rb is_groundrr]r]r^r)szPoly.is_groundcCr)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 )rbrrr]r]r^rr%zPoly.is_linearcCr)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 )rb is_quadraticrr]r]r^r*r%zPoly.is_quadraticcCr)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 )rb is_monomialrr]r]r^r+r%zPoly.is_monomialcCr)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 )rbis_homogeneousrr]r]r^r,zPoly.is_homogeneouscCr)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 )rbis_irreduciblerr]r]r^r.r%zPoly.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 rvrxrQrr]r]r^rzPoly.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 rvr/rr]r]r^rr0zPoly.is_multivariatecCr)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 )rb is_cyclotomicrr]r]r^r1'r-zPoly.is_cyclotomiccCrr{)r3rr]r]r^__abs__?z Poly.__abs__cCrr{)r4rr]r]r^__neg__Br3z Poly.__neg__cCrr{rrWrXr]r]r^__add__E z Poly.__add__cC ||Sr{r5r6r]r]r^__radd__Ir8z Poly.__radd__cCrr{r9r6r]r]r^__sub__Mr8z Poly.__sub__cCr9r{r;r6r]r]r^__rsub__Qr8z Poly.__rsub__cCrr{rr6r]r]r^__mul__Ur8z Poly.__mul__cCr9r{rr6r]r]r^__rmul__Yr8z Poly.__rmul__rcCs|jr |dkr ||StS)Nr)rr;rS)rWrr]r]r^__pow__]s z Poly.__pow__cCrr{rEr6r]r]r^ __divmod__dr8zPoly.__divmod__cCr9r{rAr6r]r]r^ __rdivmod__hr8zPoly.__rdivmod__cCrr{rLr6r]r]r^__mod__lr8z Poly.__mod__cCr9r{rDr6r]r]r^__rmod__pr8z Poly.__rmod__cCrr{rNr6r]r]r^ __floordiv__tr8zPoly.__floordiv__cCr9r{rGr6r]r]r^ __rfloordiv__xr8zPoly.__rfloordiv__rXcCs||Sr{rUr6r]r]r^ __truediv__|zPoly.__truediv__cCs||Sr{rJr6r]r]r^ __rtruediv__rLzPoly.__rtruediv__otherc Csv||}}|js#z |j||j|d}Wn tttfy"YdSw|j|jkr+dS|jj|jjkr5dS|j|jkSNrF) rnrrQrr7r3r4rbr)r~rNrWrXr]r]r^__eq__s   z Poly.__eq__cC ||k Sr{r]r6r]r]r^__ne__r8z Poly.__ne__cCs|j Sr{)r$rr]r]r^__bool__r3z Poly.__bool__cCs|s||kS|t|Sr{) _strict_eqr rWrXstrictr]r]r^eqszPoly.eqcCs|j||d S)NrV)rWrUr]r]r^neszPoly.necCs*t||jo|j|jko|jj|jddSNTrX)rNrrQrbrWr6r]r]r^rTs*zPoly._strict_eqNNr{)FF)FTr)rvFNT)FNNNFFNNFFrrrT)rV __module__ __qualname____doc__ __slots__is_commutativern _op_priorityru classmethodrzpropertyrrsrrrrrPrkrlrorprhrrrrrrrrrrrrrrrrrdrrrrrrrrrrrrrrrrrrrrrUrrr r#r'r*r,r/r0r1r2r3r4rr9rr:r;r=rArBrCrErLrNrOrrPrRrSrTrUrYr[r^rar_rrhrirmrnrorprqrxryr_eval_derivativerrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r$r&rr'r(r)rr*r+r,r.rrr1r2r4r`r7r:r<r=r>r?r rSr@rBrCrErFrHrIrKrMrPrRrSrWrYrT __classcell__r]r]rr^rOes5                     3 #$"     %  & %*'  ' % %* "  % "    ''(& K   !" %  KK     #  ! 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. )rbr}r]r]r^rrzPurePoly._hashable_contentcrr{rr}rr]r^rrzPurePoly.__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_symbolsrNc Cs||}}|js#z |j||j|d}Wn tttfy"YdSwt|jt|jkr/dS|jj |jj krYz |jj |jj |j}Wn t yNYdSw| |}| |}|j|jkSrO) rnrrQrr7r3r4rxrbrrr5r)r~rNrWrXrr]r]r^rPs$     zPurePoly.__eq__cCst||jo|jj|jddSrZ)rNrrbrWr6r]r]r^rTszPurePoly._strict_eqcst|}|js+z|jj|j|j|j|jj|fWSty*td||fwt|j t|j kr=td||ft |jt rIt |jt sQtd||f|j |j }|jj |jj|}|j|}|j|}||dffdd }||||fS)Nrcrrrrrr]r^rrzPurePoly._unify..per)r rnrbrrrr4r5rxrQrNr/rrr)rWrXrQrrrrr]rr^rs$(    zPurePoly._unify)rVrarbrcrrrhrr rSrPrTrrjr]r]rr^rks   rkcOt||}t||Sr)rerf_poly_from_exprrrQrsrtr]r]r^poly_from_expr  rocCs|t|}}t|tst||||jr0|j||}|j|_|j|_|j dur,d|_ ||fS|j r7| }t ||\}}|jsGt|||t t t |\}}|j}|durdt||d\|_}nt t|j|}tt t ||}t||}|j durd|_ ||fS)rNTrF)r rNr r:rnrrorQrrexpandrArmrrr&rrrjrOrk)rrtorigrrbrrrr]r]r^rms2      rmcOrl)(Construct polynomials from expressions. )rerf_parallel_poly_from_expr)exprsrQrsrtr]r]r^parallel_poly_from_expr7rprvcCst|dkr?|\}}t|tr?t|tr?|j||}|j||}||\}}|j|_|j|_|jdur9d|_||g|fSt |g}}gg}}d}t |D]*\}} t | } t| t rt| j rg||n|||jrs| } nd}|| qQ|rt|||d|r|D] }||||<qt||\} }|jst|||dddlm} |jD] } t| | rtdqgg} }g}g}| D]}t tt |\}}| ||||t|q|j}|durt| |d\|_} nt t|j| } |D]} || d| | | d} qg}t||D]\}}tt t||}t||}||q|jdur?t||_||fS) rsrNTFr Piecewisez&Piecewise generators do not make senser)rxrNrOrrorrQrrrmrr r rnappendrqr:rUrB$sympy.functions.elementary.piecewiserxr7rrextendr&rrrjrkbool)rurtrWrXorigs_exprs_polysfailedrrrepsrxr( coeffs_listlengthsrrrbrrrrrr]r]r^rt>sz                 rtcCst|}||vr |||<|S)z7Add a new ``(key, value)`` pair to arguments ``dict``. )rj)rsrrr]r]r^ _update_argssrcCst|dd}t|ddj}|jr|}|j}n|j}|s-|r&t|\}}nt||\}}|r7|r4tjStjS|sR|jrI||jvrIt|\}}||jvrQtjSn|jslt |j dkrlt t d|t t|j |f||}t|trzt|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 TrXrvz 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_NumberrnrUrorZerorrQrxrrVrGnextrrPrNrr)rWr gen_is_NumrisNumrrZr]r]r^rPs0    rPcGsNt|}|jr |}|jrd}t|S|jr|p|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 rnrUrrQrOrSr)rWrQrrvr]r]r^rSs( rSc Osht|dgzt|g|Ri|\}}Wnty(}ztdd|d}~ww|}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) rrRrvN) re allowed_flagsror:r;rRrrr)rWrQrsrrtrDdegreesr]r]r^rRs rRc Os`t|dgzt|g|Ri|\}}Wnty(}ztdd|d}~ww|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 rrYrvNr )rerror:r;rYrcrWrQrsrrtrDr]r]r^rY1s rYc Osht|dgzt|g|Ri|\}}Wnty(}ztdd|d}~ww|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 rrhrvNr )rerror:r;rhrcrU)rWrQrsrrtrDrr]r]r^rhJs rhc Ospt|dgzt|g|Ri|\}}Wnty(}ztdd|d}~ww|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 rrmrvNr )rerror:r;rmrcrU)rWrQrsrrtrDrrr]r]r^rmds  rmc Ost|dgzt||fg|Ri|\\}}}Wnty,}ztdd|d}~ww||\}} |js?|| fS|| fS)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) rr=rN)rerrvr:r;r=rrU rWrXrQrsrrrtrDr>r?r]r]r^r=~s& r=c Ovt|dgzt||fg|Ri|\\}}}Wnty,}ztdd|d}~ww||}|js9|S|S)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 rrArN)rerrvr:r;rArrU rWrXrQrsrrrtrDr?r]r]r^rA&  rAc Ost|dgzt||fg|Ri|\\}}}Wnty,}ztdd|d}~wwz||}Wn ty@t||w|jsH|S|S)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 rrBrN) rerrvr:r;rBr9rrU rWrXrQrsrrrtrDr>r]r]r^rBs&   rBc Or)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 rrCrN)rerrvr:r;rCrrUrr]r]r^rCs&  rCc Ost|ddgzt||fg|Ri|\\}}}Wnty-}ztdd|d}~ww|j||jd\}} |jsC|| fS|| fS)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) rHrrErNrH) rerrvr:r;rErHrrUrr]r]r^rEs& rEc O~t|ddgzt||fg|Ri|\\}}}Wnty-}ztdd|d}~ww|j||jd}|js=|S|S)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 rHrrLrNr) rerrvr:r;rLrHrrUrr]r]r^rL & rLc Or)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 rHrrNrNr) rerrvr:r;rNrHrrUrr]r]r^rN@rrNc Or)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 rHrrOrNr) rerrvr:r;rOrHrrUrr]r]r^rO`s& rOc Ost|ddgzt||fg|Ri|\\}}}Wn=tyX}z1t|j\}\} } z || | \} } Wn tyCtdd|w| | | | fWYd}~Sd}~ww|j||j d\} } |j sn| | fS| | fS)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) rHrrrNr) rerrvr:r&rurrgr;rrHrrU) rWrXrQrsrrrtrDrrvrwrXrr]r]r^rs"&    rc Ost|ddgzt||fg|Ri|\\}}}WnBty]}z6t|j\}\} } z || | \} } } Wn tyDtdd|w| | | | | | fWYd}~Sd}~ww|j||j d\} } } |j sw| | | fS| | | fS)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) rHrrrNr) rerrvr:r&rurrgr;rrHrrU)rWrXrQrsrrrtrDrrvrwrXrrr]r]r^rs"&  (  rc Ost|ddgzt||fg|Ri|\\}}}Wn3tyN}z't|j\}\} } z||| | WWYd}~StyIt dd|wd}~ww|j||j d} |j s^| S| S)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 rHrNrrr) rerrvr:r&rurrrgr;rHrrU) rWrXrQrsrrrtrDrrvrwrr]r]r^rs !&   rc Os|t|dgzt||fg|Ri|\\}}}Wnty,}ztdd|d}~ww||}|js>> from sympy import subresultants >>> from sympy.abc import x >>> subresultants(x**2 + 1, x**2 - 1) [x**2 + 1, x**2 - 1, -2] rrrNcSg|]}|qSr]rJrr?r]r]r^rrz!subresultants..)rerrvr:r;rr rWrXrQrsrrrtrDrZr]r]r^rs&  rFrc Ost|dgzt||fg|Ri|\\}}}Wnty,}ztdd|d}~ww|r9|j||d\} } n||} |jsR|rN| dd| DfS| S|rX| | fS| S)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 rrrNrcSrr]rJrr]r]r^rArzresultant..)rerrvr:r;rrrU) rWrXrrQrsrrrtrDrZrJr]r]r^r$s"&  rc Olt|dgzt|g|Ri|\}}Wnty(}ztdd|d}~ww|}|js4|S|S)z Compute discriminant of ``f``. Examples ======== >>> from sympy import discriminant >>> from sympy.abc import x >>> discriminant(x**2 + 2*x + 3) -8 rrrvN)rerror:r;rrrUrWrQrsrrtrDrZr]r]r^rI rc Ost|dgzt||fg|Ri|\\}}}WnBty\}z6t|j\}\} } z || | \} } } Wn tyCtdd|w| | | | | | fWYd}~Sd}~ww||\} } } |j ss| | | fS| | | fS)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) rrrN) rerrvr:r&rurrgr;rrrU)rWrXrQrsrrrtrDrrvrwrrrr]r]r^rgs"&  (  rc st|}fdd}||}|dur|StdgzOt|gRi\}}t|dkrjtdd|Drj|dfd d |ddD}td d|Drjd}|D] } t|| d }qWt|WSWn%t y} z|| j }|dur|WYd} ~ St d t|| d} ~ ww|s|j st jStd |dS|d |dd}}|D] } || }|jrnq|j s|S|S)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 csls4s4t|\}}|s|jS|jr4|d|dd}}|D]}|||}||r.nq||SdSNrrv)r&rr&rr&rseqrnumbersrZnumberrsrQr]r^try_non_polynomial_gcds    z(gcd_list..try_non_polynomial_gcdNrrvcs|] }|jo |jVqdSr{ is_algebraic is_irrationalrrr]r]r^ zgcd_list..r]cg|]}|qSr]ratsimprrvr]r^rrzgcd_list..cs|]}|jVqdSr{ is_rationalrfrcr]r]r^rrgcd_listr)r rerrvrxrras_numer_denomr3r:rur;rrrrOrr&rU) rrQrsrrZrrtlstlcrrDrr]rvrsrQr^rsJ   rc OsLt|dr|dur|f|}t|g|Ri|S|dur!tdt|dgz>> 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 argumentsrrrr)rrrVrerrvrr rrrrr3rr:r&rurrrgr;rrU rWrXrQrsrrrtrvrwrrDrrZr]r]r^rs8  "     rc st|}dttffdd }||}|dur|StdgzMt|gRi\}}t|dkrmtdd|Drm|d fd d |dd D}td d|Drmd}|D] } t|| d}q\|WSWn%t y} z|| j }|dur|WYd} ~ St d t|| d} ~ ww|s|j stjStd|dS|d|dd}}|D]} || }q|j s|S|S)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 returncsds0s0t|\}}|s||jS|jr0|d|dd}}|D]}|||}q"||SdSr)r&rrr&rrrr]r^try_non_polynomial_lcm*s   z(lcm_list..try_non_polynomial_lcmNrrvcsrr{rrr]r]r^rErzlcm_list..r]crr]rrrr]r^rGrzlcm_list..csrr{rrr]r]r^rHrlcm_listrr)r rrrerrvrxrrrr:rur;rrrrrOrU) rrQrsrrZrrtrrrrDrr]rr^rsD    rc OsHt|dr|dur|f|}t|g|Ri|S|dur!tdt|dgz:t||fg|Ri|\\}}}tt||f\}}|jra|j ra|jra|j ra|| } | j ra|| dWSWn3t y} z't| j\} \}}z| | ||WWYd} ~ Stytdd| wd} ~ ww||} |js| S| S)z Compute LCM of ``f`` and ``g``. Examples ======== >>> from sympy import lcm >>> from sympy.abc import x >>> lcm(x**2 - 1, x**2 - 3*x + 2) x**3 - 2*x**2 - x + 2 rNz2lcm() takes 2 arguments or a sequence of argumentsrrvrr)rrrVrerrvrr rrrrrr:r&rurrrgr;rrUrr]r]r^rgs8  "     rc st|}t|trtfdd|j|jfDSt|tr%td|ft|tr-|jr/|S ddrW|j fdd|j D} ddd<t |gRiS d d }td gzt|gRi\}}Wnty}z |jWYd }~Sd }~ww| \} }|jjr|jjr|jd d \} }|\} }|jjr| | } 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|gRiVqdSr{r*)rrXrr]r^rs$zterms_gcd..z5Inequalities cannot be used with terms_gcd. Found: %sdeepFcs"g|] }t|gRiqSr]r)rrvrr]r^rrzterms_gcd..rqclearTrNrucSsg|]\}}||qSr]r])rrrr]r]r^rrrv)r) r rNrlhsrhsrrVris_Atomr{r\rspopr*rerror:rrrFrGrqrrrrrrrQrrU as_coeff_Mul) rWrQrsrrrzrrrtrDrdenomrtermr]rr^r*sLC        r*c Ostt|ddgzt|g|Ri|\}}Wnty)}ztdd|d}~ww|t|}|js8|S|S)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 rHrrrvN) rerror:r;rr rrU)rWrrQrsrrtrDrZr]r]r^r rc Ostt|ddgzt|g|Ri|\}}Wnty)}ztdd|d}~ww|j|jd}|js8|S|S)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 rHrrrvNr) rerror:r;rrHrrUrr]r]r^r.rrc OsXt|dgzt|g|Ri|\}}W|Sty+}ztdd|d}~ww)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 rrrvN)rerror:r;rrr]r]r^rLs rc Osxt|dgzt|g|Ri|\}}Wnty(}ztdd|d}~ww|\}}|js8||fS||fS)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) rrrvN)rerror:r;rrrU)rWrQrsrrtrDrrZr]r]r^res    rc Or)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 rrrN)rerrvr:r;rrrUrr]r]r^rrrc Ort|dgzt|g|Ri|\}}Wnty(}ztdd|d}~ww|}|js7dd|DS|S)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] rrrvNcSrr]rJrr]r]r^rrzdecompose..)rerror:r;rrrr]r]r^rs rc Oszt|ddgzt|g|Ri|\}}Wnty)}ztdd|d}~ww|j|jd}|js;dd|DS|S) 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] rHrrrvNrcSrr]rJrr]r]r^rrzsturm..)rerror:r;rrHrrr]r]r^rs rc Or)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 rrrvNcSg|] \}}||fqSr]rJrr]r]r^rrzgff_list..)rerror:r;rr)rWrQrsrrtrDrr]r]r^rs  rcOrc)z3Compute greatest factorial factorization of ``f``. zsymbolic falling factorialrdrWrQrsr]r]r^gffsrc Ost|dgzt|g|Ri|\}}Wnty(}ztdd|d}~ww|\}}}|js>t|||fSt|||fS)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) rrrvN) rerror:r;rrrrU) rWrQrsrrtrDrXrXr?r]r]r^r"s rc Or)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 rrrvN)rerror:r;rrrUrr]r]r^rDrrcCs&|dkr dd}ndd}t||dS)z&Sort a list of ``(expr, exp)`` pairs. rcSs.|\}}|jj}|t|t|jt|j|fSr{rbrxrQrirryrexprbr]r]r^rez_sorted_factors..keycSs.|\}}|jj}t|t|j|t|j|fSr{rrr]r]r^rjrr)r )rmethodrr]r]r^_sorted_factorsbs  rcCstdd|DS)z*Multiply a list of ``(expr, exp)`` pairs. cSsg|] \}}||qSr]rJrrWr(r]r]r^rtrz$_factors_product..)rrr]r]r^_factors_productrsrc stjg}ddt|D}|D]}|js t|tr%t|r%||9}q|jrJ|j tj krJ|j \}|jr>jr>||9}q|jrI |fqn|tj}z t ||\}}Wntys} z | jfWYd} ~ qd} ~ wwt||d} | \} } | tjurjr|| 9}n| jr | fn| | tjftjur| qjrfdd| Dqg} | D]\}}|jrԈ ||fq| ||fq t| fq|dkrfdddd DD|fS) z.Helper function for :func:`_symbolic_factor`. cSs"g|] }t|dr |n|qS) _eval_factor)rrrrr]r]r^r{sz)_symbolic_factor_list..N_listcsg|] \}}||fqSr]r]r)rr]r^rrrcs(g|]ttfddDfqS)c3s |] \}}|kr|VqdSr{r])rrWrr(r]r^rsz3_symbolic_factor_list...)rr)rrrr^rs cSsh|]\}}|qSr]r])rrrr]r]r^ rz(_symbolic_factor_list..)rrrr make_argsrrNrris_PowbaseExp1rsryrmr:rrTr is_positiver{ is_integerrUr)rrtrrrsargrrrrDr\_coeff_factorsrNrWr(r])rrr^_symbolic_factor_listws^            rcst|tr#t|dr|Stt|dd\}}t|t|St|dr6|jfdd|j DSt|drH| fdd|DS|S) z%Helper function for :func:`_factor`. rfraction)rrscg|]}t|qSr]_symbolic_factorrrrrtr]r^rrz$_symbolic_factor..rcrr]rrrr]r^rr) rNrrrrrCrrr\rsr)rrtrrrr]rr^rs    rcCsDt|ddgt||}t|}t|ttfrt|tr$|d}}nt|\}}t |||\}}t |||\} } | rG|j sGt d|| t dd} || fD]} t| D]\} \}}|jsot|| \}}||f| | <qYqSt||}t| |} |jsdd|D}d d| D} || }|j s||fS||| fSt d|) z>Helper function for :func:`sqf_list` and :func:`factor_list`. fracrrvza polynomial expected, got %sT)rqcSrr]rJrr]r]r^rrz(_generic_factor_list..cSrr]rJrr]r]r^rr)rerrfr rNrrOrCrrrr7clonerjrrnrmrr)rrQrsrrtnumerrr"fpr#fq_optrrrWr(rrr]r]r^_generic_factor_lists:           rcCs<|dd}t|gt||}||d<tt|||S)z4Helper function for :func:`sqf` and :func:`factor`. rT)rrerrfrr )rrQrsrrrtr]r]r^_generic_factors   rcsddlmd fdd }d fdd }dd }|jrI||rI|}|||}|r8|d|d d|d fS|||}|rIdd|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 |jdjsd|fS|}|}|p|}|dd}fdd|D}t|dkr|dr|d|d}g}tt|D]}||||d}|js`dS| |qLd|} |jd} | |g} td|dD]}| ||d| ||q}t | }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``. rvrNcsg|]}|qSr]r])rcoeffxrr]r^r+rz._try_rescale..r]) rxrQrrPrYrrrrryr rO) rWf1rrr rescale1_xcoeffs1rr rescale_xrrrr]r^ _try_rescales2      z(to_rational_coeffs.._try_rescalec st|jdkr |jdjsd|fS|}|p|}|dd}|d}|jrL|jsLt|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``. rvrNcSs |jduSr^r)zr]r]r^rOs z._try_translate..Tbinary) rxrQrrPrris_AddrrJrsr\r) rWrrrrratnonratalphaf2rr]r^_try_translate?s     z*to_rational_coeffs.._try_translatecSsp|}d}|D]-}t|D]%}t|j}dd|D}|s"qt|dkr*d}t|dkr4dSqq|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>)rrwwxr]r]r^r^s  zAto_rational_coeffs.._has_square_roots..rT)rr rr rrminmax)rrhas_sqrrrWr?r]r]r^_has_square_rootsUs    z-to_rational_coeffs.._has_square_rootsrvrr{)sympy.simplify.simplifyrrrr)rWrrr rr?r]rr^to_rational_coeffss &"  r c Cs ddlm}t||dd}|}t|}|sdS|\}}}} t| } |r^|| d|||} |d|} g} | dddD]}| ||d||| i|dfqC| | fS| d} g} | dddD]}| |d|||i|dfql| | 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 rrEXrNrv) r rrOrPr rrUryr)rrrp1rresrr?rrXrrr1rvrr]r]r^_torational_factor_listts(    *&rcOt|||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)]) rrrrr]r]r^rrcOr)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)rrr]r]r^rrrcOr)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)]) rrrrr]r]r^rrr)rc st|}|r=fdd}t||}i}|tt}|D]}t|gRi}|js/|jr7||kr7|||<q||Sz t |ddWSt yc} z|j s[t |WYd} ~ St | d} ~ ww)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_Mulr)rrrr]r^ _try_factors zfactor.._try_factorrrN) r r#atomsrr rrrxreplacerr7rer) rWrrQrsrpartialsmuladdrrmsgr]rr^rs(D   rc Cs.t|ds"zt|}Wn tygYSw|j||||||dSt|dd\}} t| jdkr3tt|D] \} } | j j || <q7|durT| j |}|dkrTt d|dur^| j |}|durh| j |}t || j |||||d } g} | D]\\}}}| j || j |}}| ||f|fqx| S) 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)] rrr(rrvNrr)rrrrVr)rrOr6rrvrxrQr8rrbrrrrDrry)rrrrrrVrrrrtrrrrZrXrrr]r]r^r9s8       rcCsXzt|}t|ts|jjstdWn ty td|w|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)rWrXrrrrrrr]r]r^rqs rcCsTzt|dd}t|ts|jjstdWn ty"td|w|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   rTcCsRzt|dd}t|ts|jjstdWn ty"td|w|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   rrrcCsVzt|dd}t|ts|jjstdWn ty"td|w|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 Oszt|gz$t|g|Ri|\}}t|ts!|jjs&tdW| SW| Sty<}zt dd|d}~ww)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} rrrvN) rerrorNrOrrr7r:r;rrr]r]r^rs  rc Ost|gzt|g|Ri|\}}t|ts!|jjs!tdWnty4}zt dd|d}~ww| |}|j sA| S|S)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 rrrvN) rerrorNrOrrr7r:r;rrrU)rWrrQrsrrtrDrZr]r]r^rs   r) _signsimpc sNddlm}ddlm}t|dgt|}|r||}i}d|vr)|d|d<t|tt fsL|j s=t|t s=t|t s?|St |dd}|\}}n?t|dkr||\}}t|trrt|trr|j|d<|j|d <|dd|d<||}}nt|t rt |Std |dd lmz1|rt|||fg|Ri|\} \} } | jst|tt fs|WStj||fWSWntyM} z~|jr|st| |js|j rt!|j"fd d dd\} }dd|D}|j#t$|j#| g|RWYd} ~ Sg}t%|}t&||D](}t|tt t'fr qz|(|t$|f|)Wqt*y;Yqw|+t,|WYd} ~ Sd} ~ wwd| $| } \}}|ddrid|vri| j-|d<t|tt fs{| ||S||}}|dds| ||fS| t|g|Ri|t|g|Ri|fS)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: %srwcs|jduo | Sr^)rehasrrwr]r^ryszcancel..rcSrr])r rr]r]r^r|rzcancel..NrvF).r r"sympy.polys.ringsr#rerr rNrr rrrrrrxrOrQrr{rUrrzrxr%r7ngensrqrrrrerrrJrsr\r r"rr$ryskiprgrrjr)rWr!rQrsr"r#rtrr>rJrrrrncrpoterrIr]rwr^r 4s           "  (  .r c st|ddgzt|gt|g|Ri|\}Wnty.}ztdd|d}~wwj}d}jrI|jrI|j sI t | dd}dd l m}|jjj\} } t|D]\} } | jj} | | || <q^|d|d d\} }fd d | D} tt |}|rzd d | D|}}Wn tyYnw||} }jsdd | D|fS| |fS)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) rrHreducedrNFrTxringrvcg|] }tt|qSr]rOrkrjrr>rr]r^rrzreduced..cSrr]rr1r]r]r^rrcSrr]rJr1r]r]r^rr)rerrvrmr:r;rrHrFrGrrjrr&r.rQrcrrrbrrrErOrkrr4rrU)rWrrQrsrrDrrr._ringrrrrIr?_Q_rr]rr^r,s<(    r,cOst|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]_ ) GroebnerBasisrrQrsr]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 )r6is_zero_dimensionalr7r]r]r^r8 sr8c@seZdZdZddZeddZeddZedd Z ed d Z ed d Z eddZ eddZ ddZddZddZddZddZddZeddZd d!Zd(d#d$Zd%d&Zd'S))r6z%Represents a reduced Groebner basis. c st|ddgzt|g|Ri|\}Wnty+}ztdt||d}~wwddlm}|jj j fdd|D}t |j d }fd d|D}| |S) z>Compute a reduced Groebner basis for a system of polynomials. rrr,Nr)PolyRingcs g|] }|r|jqSr])rrbrrr)ringr]r^r/s z)GroebnerBasis.__new__..rcsg|]}t|qSr])rOrkrrXrr]r^r2r)rerrvr:r;rxr&r9rQrrc _groebnerr_new)rrrrQrsrrDr9rr])rtr;r^ru#s  zGroebnerBasis.__new__cCst|}t||_||_|Sr{)r rur_basis_options)rrbasisreryr]r]r^r>6s  zGroebnerBasis._newcCs$dd|jD}t|t|jjfS)Ncss|]}|VqdSr{rJ)rrr]r]r^rAsz%GroebnerBasis.args..)r?r r@rQ)r~rAr]r]r^rs?szGroebnerBasis.argscCsdd|jDS)NcSrr]rJr:r]r]r^rFrz'GroebnerBasis.exprs..)r?r}r]r]r^ruDrLzGroebnerBasis.exprscC t|jSr{)rmr?r}r]r]r^rHr8zGroebnerBasis.polyscCrr{)r@rQr}r]r]r^rQLrzGroebnerBasis.genscCrr{)r@rr}r]r]r^rPrzGroebnerBasis.domaincCrr{)r@rcr}r]r]r^rcTrzGroebnerBasis.ordercCrBr{)rxr?r}r]r]r^__len__XrzGroebnerBasis.__len__cCs|jjr t|jSt|jSr{)r@riterrur}r]r]r^r[s  zGroebnerBasis.__iter__cCs$|jjr |j}||S|j}||Sr{)r@rru)r~itemrAr]r]r^ __getitem__as zGroebnerBasis.__getitem__cCst|jt|jfSr{)hashr?rr@rr}r]r]r^riszGroebnerBasis.__hash__cCsLt||jr|j|jko|j|jkSt|r$|jt|kp#|jt|kSdS)NF)rNrr?r@rIrrmrur~rNr]r]r^rPls zGroebnerBasis.__eq__cCrQr{r]rHr]r]r^rRtrzGroebnerBasis.__ne__cCsTdd}tdgt|j}|jj}|jD]}|j|d}||r%||9}qt|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-rxrQr@rcrrhr)r~rKr`rcrrJr]r]r^r8ws  z!GroebnerBasis.is_zero_dimensionalc s|jj}t|}||kr|S|jstdt|j}j}t | |dddl m }|j j|\}}t|D]\} } | jj} || || <q>t|||} fdd| D} |jsodd| 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)rrcrr-cr/r]r0r<rr]r^rrz&GroebnerBasis.fglm..cSsg|] }|jdddqS)Trurv)rqr<r]r]r^rr)r@rcr.r8rgrmr?rrrjrr&r.rQrrrbrrr+rGr>) r~rc src_order dst_orderrrr.r3rrrrr]rr^fglms0    zGroebnerBasis.fglmTcsHt||j}|gt|j}|jj}d}|r+|jr+|js+t | dd}ddl m }|j jj\}} t|D]\} }|jj}|||| <q@|d|dd\} } fdd | D} tt | } |rzd d | D| } }Wn tyYnw| |} } jsd d | D| fS| | fS) 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 FrTrr-rvNcr/r]r0r1rr]r^r rz(GroebnerBasis.reduce..cSrr]r2r1r]r]r^rrcSrr]rJr1r]r]r^rr)rOrpr@rmr?rrFrGrrjrr&r.rQrcrrrbrrrErkrr4rrU)r~rrHrrrrr.r3rrrIr?r4r5r]rr^rs4   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 rvr)r)r~rr]r]r^containsszGroebnerBasis.containsNr\)rVrarbrcrurgr>rhrsrurrQrrcrCrrFrrPrRr8rNrrOr]r]r]r^r6s8         B Ar6csdtgfddt|}|jrt|g|RiSdvr'dd<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 s~gg}}t|D]u}gg}}t|D]1}|jr$|||q|jrB|jjrB|jjrB|jdkrB||j| |jq||q|sP||q |d}|ddD]}| |}qZ|rzt|}|j rq| |}n | t ||}||q |st ||} n*|d} |ddD]}| |} q|rt|}|j r| |} n | t ||} | j|ddiS)NrrvrQr])r rrrryrrrrr;rrrOrprrr{) rrtr poly_termsrr poly_factorsrproductrZ_polyrsr]r^rTAsJ         zpoly.._polyrqF)rerr rnrOrfrnr]rSr^r0s 4  rr]r{)FNNNFFFr_r[r\r`)rc functoolsrroperatorrtypingr sympy.corerrr r sympy.core.basicr sympy.core.decoratorsr sympy.core.exprtoolsr rrsympy.core.evalfrrrrrsympy.core.functionrsympy.core.mulrrsympy.core.numbersrrrsympy.core.relationalrrsympy.core.sortingrsympy.core.symbolrrsympy.core.sympifyr r!sympy.core.traversalr"r#sympy.logic.boolalgr$ sympy.polysr%resympy.polys.constructorr&sympy.polys.domainsr'r(r)!sympy.polys.domains.domainelementr*sympy.polys.fglmtoolsr+sympy.polys.groebnertoolsr,r=sympy.polys.monomialsr-sympy.polys.orderingsr.sympy.polys.polyclassesr/r0r1sympy.polys.polyerrorsr2r3r4r5r6r7r8r9r:r;r<sympy.polys.polyutilsr=r>r?r@rArBsympy.polys.rationaltoolsrCsympy.polys.rootisolationrDsympy.utilitiesrErFrGsympy.utilities.exceptionsrHsympy.utilities.iterablesrIrJrrmpmath.libmp.libhyperrKr`rOrkrormrvrtrrPrSrRrYrhrmr=rArBrCrErLrNrOrrrrrrrrrrrr*rrrrrrrrrrrrrrrrrr rrrrrrrrrrrrr r,r8r6rr]r]r]r^s              4    "d] ( ^ : 4       " "    " & & 4 $  ( T 3 M 2 u    -    .  ! :, ,   b 7      +f ; 5