o 8Va/@sDdZddlmZmZddlmZddlmZmZm Z m Z m Z m Z m Z mZmZddlmZddlmZmZddlmZddlmZdd lmZdd lmZdd lmZdd lm Z dd l!m"Z"m#Z#ddl$m%Z%ddl&m'Z(ddl)m*Z*ddl+m,Z,m-Z-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;mm?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZIddlJmKZKmLZLmMZMmNZNmOZOmPZPddlQmRZRddlSmTZTddlUmVZVmWZWmXZXmYZYddlZm[Z[ddl&Z\ddl]Z]ddl^m_Z_d d!Z`eXGd"d#d#eZaeXGd$d%d%eaZbeXd&d'Zcd(d)ZdeXd*d+Zed,d-Zfd.d/ZgeXdd0d1ZheXd2d3ZieXd4d5ZjeXd6d7ZkeXd8d9ZleXd:d;ZmeXdd?ZoeXd@dAZpeXdBdCZqeXdDdEZreXdFdGZseXdHdIZteXdJdKZueXdLdMZveXdNdOZweXdPdQZxeXdRdSZyeXdTdUdVdWZzeXdXdYZ{eXdZd[Z|eXd\d]Z}eXdd^d_Z~eXd`daZeXddbdcZeXdddeZeXdfdgZeXdhdiZeXdjdkZeXdldmZeXdndoZeXdpdqZeXdrdsZeXdtduZeXdvdwZeXdxdyZeXdzd{Zd|d}Zd~dZddZddZddZddZddZddZeXddZeXddZeXddZeXdTdddZeXdddZeXdddZeXdddZeXdddZeXdddZeXddZeXddZeXddZeXddZeXddZ4eXddZeXGdddeZeXddZdS)z8User-friendly public interface to polynomial functions. )wrapsreducemul) SBasicExprIIntegerAddMulDummyTuple)preorder_traversal)iterableordered) _sympifyit) pure_complex) Derivative) _keep_coeff) Relational)Symbol)sympify_sympify) 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)groupsiftpublic filldedent)SymPyDeprecationWarningN) NoConvergencecstfdd}|S)Nc st|}t|tr||St|trQz |j|g|jR}Wn,tyK|jr-tYSt | j }||}|turGt ddddd |YSw||StS)Nz@Mixing Poly with non-polynomial expressions in binary operationsiHz1.6z.the as_expr or as_poly method to convert types)ZfeatureZissueZdeprecated_since_versionZ useinstead)r isinstancePolyr from_exprgensr-Z is_MatrixNotImplementedgetattras_expr__name__r?warn)fgZ expr_methodresultfunc7/usr/lib/python3/dist-packages/sympy/polys/polytools.pywrapper=s.     z_polifyit..wrapper)r)rNrQrOrMrP _polifyit<srRcs6eZdZdZdZdZdZdZddZe 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!drd6d7Z"d8d9Z#d:d;Z$dd?Z&d@dAZ'dBdCZ(dsdDdEZ)dFdGZ*dHdIZ+dJdKZ,dLdMZ-dNdOZ.dPdQZ/dRdSZ0dsdTdUZ1dsdVdWZ2dsdXdYZ3dsdZd[Z4dsd\d]Z5d^d_Z6d`daZ7dbdcZ8dddeZ9dfdgZ:dtdidjZ;dudkdlZdqdrZ?dsdtZ@dududvZAdwdxZBdydzZCd{d|ZDd}d~ZEddZFddZGddZHddZIddZJddZKddZLddZMddZNddZOddZPddZQddZRddZSdvddZTdvddZUdvddZVdvddZWddZXdwddZYddZZddZ[ddZ\ddZ]dsddZ^ddZ_dsddZ`ddZaddZbdxddZcdsddZddsddZedsdd„ZfdsddĄZgddƄZhddȄZiduddʄZjdd̄Zkdd΄ZlddЄZmemZndydd҄ZoddԄZpdvddքZqdvdd؄ZrdvddڄZsdd܄ZtddބZududdZvddZwdsddZxdsddZyddZzddZ{ddZ|ddZ}dvddZ~ddZddZddZddZddZddZdvddZddZddZddZddZduddZdud d Zd d Zd dZdzddZd{ddZdrddZdvddZd|ddZd|ddZd}ddZdd Zd!d"Zdud#d$Ze d%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@ZdAdBZdCdDZedEdFZedGdHZedIdJZedKdLZedMdNZedOdPZedQedRdSZedTdUZedVdWZedXdYZedZd[Zed\d]Zed^d_Zed`edadbZed`edcddZedeedfdgZed`edhdiZdjdkZdudldmZdudndoZdpdqZZS(~rBad 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. 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 reprDTgn$@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_optionsNotImplementedErrorrAr%r&r'r _from_domain_elementrstrdict _from_dict _from_listlistris_Poly _from_poly _from_exprclsrTrDargsoptrOrOrP__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) rAr%r-levlenrrgrTrD)rdrTrDobjrOrOrPnews  zPoly.newcCst|jg|jRSN)r3rT to_sympy_dictrDselfrOrOrPexprsz Poly.exprcC|jf|jSrm)rqrDrorOrOrPresz Poly.argscCrrrmrSrorOrOrP_hashable_contentszPoly._hashable_contentcOt||}|||S)(Construct a polynomial from a ``dict``. )rWrXr]rcrOrOrP from_dict  zPoly.from_dictcOrt)(Construct a polynomial from a ``list``. )rWrXr^rcrOrOrP from_listrwzPoly.from_listcOrt)*Construct a polynomial from a polynomial. )rWrXrarcrOrOrP from_polyrwzPoly.from_polycOrt+Construct a polynomial from an expression. )rWrXrbrcrOrOrPrCrwzPoly.from_exprcCsz|j}|s tdt|d}|j}|durt||d\}}n|D] \}}||||<q#|jt |||g|RS)ruz/can't initialize from 'dict' without generatorsrhNrf) rDr,rjdomainritemsconvertrlr%rv)rdrTrfrDlevelrmonomcoeffrOrOrPr]s zPoly._from_dictcCs~|j}|s tdt|dkrtdt|d}|j}|dur)t||d\}}ntt|j|}|j t |||g|RS)rxz/can't initialize from 'list' without generatorsrhz#'list' representation not supportedNr~) rDr,rjr.rrr_maprrlr%ry)rdrTrfrDrrrOrOrPr^s  zPoly._from_listcCs||jkr|j|jg|jR}|j}|j}|j}|r6|j|kr6t|jt|kr1|||S|j |}d|vrC|rC| |}|S|durK| }|S)rzrT) __class__rlrTrDfieldrsetrbrGreorder set_domainto_field)rdrTrfrDrrrOrOrPra s    zPoly._from_polycCst||\}}|||Sr|)r7r])rdrTrfrOrOrPrb"s zPoly._from_exprcCs@|j}|j}t|d}||g}|jt|||g|RSNrh)rDrrjrrlr%ry)rdrTrfrDrrrOrOrPrZ(s   zPoly._from_domain_elementc tSrmsuper__hash__rorrOrPr2 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} )rrDrangerjmonoms free_symbolsfree_symbols_in_domain)rpsymbolsrDirrOrOrPr5s  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} )rTdomr is_Compositerris_EXcoeffs)rprrgenrrOrOrPrTs    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 rrDrorOrOrPrrs 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_domainrorOrOrPrsz Poly.domaincC&|j|j|jj|jjg|jRS)z3Return zero polynomial with ``self``'s properties. )rlrTzerorirrDrorOrOrPr&z Poly.zerocCr)z2Return one polynomial with ``self``'s properties. )rlrTonerirrDrorOrOrPrrzPoly.onecCr)z3Return unit polynomial with ``self``'s properties. )rlrTunitrirrDrorOrOrPrrz 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)rJrK_perFGrOrOrPunifysz 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)Ncan't unify %s with %srhcg|] }|jjqSrOrrTr.0c)rrJrOrP zPoly._unify..crrOrr)rrKrOrPrrcD|dur|d|||dd}|s||Sj|g|RSrto_sympyrlrTrrDremoverdrOrPr  zPoly._unify..per)rr`rTrr from_sympyr*r+rAr%r5rDrrjr6to_dictr\r_ziprr) rJrKrDriZf_monomsZf_coeffsrZg_monomsZg_coeffsrrrO)rdrrJrKrPrs<( "      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') Nrh)rDrTrrrrl)rJrTrDrrOrOrPrszPoly.percCs&t|jd|i}||j|jS)z Set the ground domain of ``f``. r)rWrXrDrrTrr)rJrrfrOrOrPrszPoly.set_domaincC|jjS)z Get the ground domain of ``f``. )rTrrJrOrOrPrzPoly.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) )rWZModulusZ preprocessrr)rJmodulusrOrOrP set_moduluss 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)rZis_FiniteFieldr Zcharacteristicr-)rJrrOrOrP get_modulus/s zPoly.get_moduluscCsN||jvr|jr|||Sz|||WStyYnw|||S)z)Internal implementation of :func:`subs`. )rD is_numberevalreplacer-rGsubs)rJoldrlrOrOrP _eval_subsDs   zPoly._eval_subscCsL|j\}}g}tt|jD]}||vr||j|q|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') r)rTrVrrjrDappendr)rJJrlrDjrOrOrPrVQsz 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 caserzcan't replace %s with %s in %s) is_univariaterr-rDrrrr_indexrrT)rJxy_ignorerrDrOrOrPrhs z Poly.replacecOs|j|i|S)z-Match expression from Poly. See Basic.match())rGmatch)rJrekwargsrOrOrPrsz 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') rOr~z7generators list can differ only up to order of elementsrhr)rWZOptionsr4rDrr-r\r_rr6rTrrr%rrj)rJrDrerfrTrOrOrPrs  "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)nativeNzcan't left trim %srh) as_dict _gen_to_levelranyr-rDrlr%rvrjrTr)rJrrTrtermsrrrDrOrOrPltrims   (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)rrDr ValueErrorr2addr enumerate)rJrDindicesrrrreltrOrOrP 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)hasattrrTrr(rrJrLrOrOrPr    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)rrTrr(rrrOrOrPrrz 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)rrTrr(rrrOrOrPrrz 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)rZ compositer)rrrrrvrD)rJrrrTrOrOrPretract.s   z Poly.retractcCsh|dur d||}}}n||}t|t|}}t|jdr*|j|||}nt|d||S)z1Take a continuous subsequence of terms of ``f``. Nrslice)rintrrTrr(r)rJrmnrrLrOrOrPrFs    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|qSrOrTrrrrrOrPrjzPoly.coeffs..rU)rTrrJrUrOrrPrVsz 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)rTrrrOrOrPrlsz 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|fqSrOrrrrrrOrPr"zPoly.terms..r)rTrrrOrrPrsz 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] crrOrrrrOrPrrz#Poly.all_coeffs..)rT all_coeffsrrOrrPrzPoly.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 )rT all_monomsrrOrOrPrs 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)] crrOrrrrOrPrrz"Poly.all_terms..)rT all_termsrrOrrPrrzPoly.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)rrAtupler-rvrD)rJrNrDrerrrrLrOrOrPtermwises    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 )rjrrrOrOrPlengths 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)rTrrn)rJrrrOrOrPrsz Poly.as_dictcCs|r|jS|jS)z%Switch to a ``list`` representation. )rTZto_listZ to_sympy_list)rJrrOrOrPas_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 rhrr) rqrjrAr\r_rDrrrr2r3rTrn)rJrDmappingrvaluerrOrOrPrGs    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)rBr`r-)rprDrepolyrOrOrPas_poly=s 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)rrTrr(rrrOrOrPrWrz 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)rrTrr(rrJrrLrOrOrPrl  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') zcan't inject generators over %sinjectfront) rTr is_Numericalr`r)rr r(rrDrl)rJr rrLrDrOrOrPr 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]') zcan't eject generators over %sNTFz'can only eject front or back generatorsejectr ) rTrr r)rjrDrYr rr r(rl)rJrDrkZ_gensr rLrOrOrPr 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)rrTrr(rrrOrOrPrrzPoly.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)rrTrr(rrJrrLrOrOrPr   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)rrTrr(rrrOrOrPrrzPoly.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)rrTrr(rrrOrOrPrrzPoly.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)rrTrr(rrrOrOrPr$s   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)rrTrr(rrrOrOrPr<s   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)rrTrr(rrrOrOrPrVrzPoly.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)rrTrr(rrrOrOrPrk    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)rr`rrrrTrr(rJrKrrrrrLrOrOrPr    zPoly.addcCr)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)rr`rrrrTrr(rrOrOrPrrzPoly.subcCr)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)rr`rrrrTrr(rrOrOrPrrzPoly.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)rrTrr(rrrOrOrPrrzPoly.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)rrrTr r(rrJrrLrOrOrPr 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)rrrTr"r()rJrKrrrrqrrOrOrPr"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)rrrTr&r(rrOrOrPr&)s    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)rrrTr'r(rrOrOrPr'Ps    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)rrrTr(r/rlrGr()rJrKrrrrrLexcrOrOrPr(ls   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_FieldrrrTr*r(rr*) rJrKautorrrrrr#r$QRrOrOrPr*s     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) rr+r,rrrTr1r(rr*) rJrKr-rrrrrr$rOrOrPr1"     zPoly.remc Cr0)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) rr+r,rrrTr3r(rr*) rJrKr-rrrrrr#rOrOrPr3r2zPoly.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) rr+r,rrrTr4r/rlrGr(rr*) rJrKr-rrrrrr#r)rOrOrPr4s,    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)rArrjrDr-rrr)rJrrrOrOrPr&s   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)rrrTr5r()rJrrrOrOrPr5:s    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)rrTr7r(rrOrOrPr7Us   zPoly.degree_listcCr6)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)rrTr8r(rrOrOrPr8hs   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) rAr TypeErrortyperDrrjrrTrr9r()rJsrrDrOrOrPr9}s       zPoly.homogenizecCr6)a- Returns the homogeneous order of ``f``. A homogeneous polynomial is a polynomial whose all monomials with non-zero coefficients have the same total degree. This degree is the homogeneous order of ``f``. If you only want to check if a polynomial is homogeneous, then use :func:`Poly.is_homogeneous`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**5 + 2*x**3*y**2 + 9*x*y**4) >>> f.homogeneous_order() 5 r:)rrTr:r(rrOrOrPr:s   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)rrrTr>r(rr)rJrUrLrOrOrPr>s    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)rrTr@r(rrrrOrOrPr@   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)rrTrr(rrOrOrPrCs  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#rD exponents)rJrrOrOrPcoeff_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 rDz,exponent of each generator must be specified) rrTrjrDrrDr_rrr(rr)rJNrLrOrOrPrDs  zPoly.nthrhcCtd)NzyEither convert to Expr with `as_expr` method to use Expr's coeff method or else use the `coeff_monomial` method of Polys.rY)rJrrrightrOrOrPr?sz 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#rrDrrOrOrPLMKszPoly.LMcCrK)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 rBrLrrOrOrPEM_szPoly.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#rDrJrUrrrOrOrPLToszPoly.LTcCrO)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) rBrPrQrOrOrPETszPoly.ETcCr?)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)rrTrTr(rrrrOrOrPrTrAz Poly.max_normcCr?)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)rrTrUr(rrrrOrOrPrUrAz 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)rTrr,rOnerhas_assoc_Ringget_ringrrVr(rrr)rprrJrrrLrOrOrPrVs       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)rr,rXrVr)rprKrJrrabrOrOrPrat_clear_denomss   zPoly.rat_clear_denomscOs|}|ddr|jjjr|}t|jdrK|s#||jjddS|j}|D]}t|t ur5|\}}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') r-T integraterhr) getrTrr+rrrr^r<rrrr()rpspecsrerJrTspecrrrOrOrPr^ s      zPoly.integratecOs|ddst|g|Ri|St|jdrK|s#||jjddS|j}|D]}t|tur5|\}}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') ZevaluateTdiffrhr_) r`rrrTrrcr<rrrr()rJrarrTrbrrrOrOrPrc5 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 providedrrzcan't evaluate at %s in %sr)rAr\rrrr_rjrDrrrrrTr(r*r)rrrZunify_with_symbolsrrr) rprr[r-rJrrrvaluesrrLZa_domainZ new_domainrOrOrPr] 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)rJrerOrOrP__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)rr+rrrTrhr() rJrKr-rrrrr=hrOrOrPrh 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)rr+rrrTrjr() rJrKr-rrrrr=trirOrOrPrj 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)rr+rrrTrlr()rJrKr-rrrrrLrOrOrPrl 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)rrTrmrr(rr!rOrOrPrm 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)rrrTrnr(r_rrrOrOrPrn? 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 includePRSrrd)rrrTror(r_r) rJrKrqrrrrrLr/rOrOrProX 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 discriminantrrd)rrTrrr(rrrOrOrPrr} rAzPoly.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.dispersionrt)rJrKrtrOrOrPrt  H zPoly.dispersionsetcCrs)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)rurw)rJrKrwrOrOrPrw rvzPoly.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)rrrTrxr() rJrKrrrrricffcfgrOrOrPrx( 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)rrrTr{r(rrOrOrPr{E    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)rrrTr}r(rrOrOrPr}\ r|zPoly.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)rTrrrr~r(r)rJprLrOrOrPr~s 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)rTrr+rrrr(rrpr-rJrLrOrOrPr s    z Poly.moniccCr?)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)rrTrr(rrrrOrOrPr rAz 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)rrTrr(rrr)rJcontrLrOrOrPr 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)rrrTrr(rrOrOrPr r|z 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)rrTrr(r_rrrrOrOrPr 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)rrTrr(r)rJr[rLrOrOrPr rz 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)rrrTrr(r)rJrr#Pr.rrLrOrOrPr 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) rTrr+rrrr(r_rrrrOrOrPr, 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|] \}}||fqSrOrrrKrrrOrPr^ z!Poly.gff_list..)rrTrr(rrOrrPrI 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)rrTrr(r)rJr$rOrOrPr` 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)rrTrr(r)rJr=rKr$rOrOrPr 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)rrTrr(rrrOrOrPr 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_listcrrOrrrrOrPr rz!Poly.sqf_list..)rrTrr(rr)rJallrfactorsrOrrPr 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_includecrrOrrrrOrPr rz)Poly.sqf_list_include..)rrTrr()rJrrrOrrPr 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_listrhcrrOrrrrOrPr rz$Poly.factor_list..) rrTrr)rrWr(rr)rJrrrOrrPr 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_includerhcrrOrrrrOrPr) rz,Poly.factor_list_include..)rrTrr)r()rJrrOrrPr 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|fSrmrr)intervalr=rkrOrOrP_realW szPoly.intervals.._realcSs@|\\}}\}}t|tt|t|tt|fSrmrrr ) rectangleuvr=rkrOrOrP_complex^ sz Poly.intervals.._complexcSs$|\\}}}t|t|f|fSrmr)rr=rkrrOrOrPrg s cSsH|\\\}}\}}}t|tt|t|tt|f|fSrmr)rrrr=rkrrOrOrPrn s ) rrrrrTrr(r_r) rJrrrrrrrLrrZ real_partZ complex_partrOrOrPr+ 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 supportedNrrrh refine_root)rstepsr) is_sqfr-rrrrrrTrr(r) rJr=rkrrr check_sqfrTrOrOrPrw 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)rrNegativeInfinity as_real_imagrrr_rZInfinityrrTrr(rrr )rJrrZinf_realZsup_realreZimcountrOrOrP count_roots s<             zPoly.count_rootscCstjjj|||dS)a  Get an indexed root of a polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(2*x**3 - 7*x**2 + 4*x + 4) >>> f.root(0) -1/2 >>> f.root(1) 2 >>> f.root(2) 2 >>> f.root(3) Traceback (most recent call last): ... IndexError: root index out of [-3, 2] range, got 3 >>> Poly(x**5 + x + 1).root(0) CRootOf(x**3 - x**2 + 1, 0) radicals)sympypolys rootoftoolsZrootof)rJrrrOrOrProot 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_rootsr;)rJrrZrealsrOrOrPr s 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_rootsr;)rJrrrootsrOrOrPrs zPoly.all_roots2c shddlm|jrtd||dkrgS|jjtur'dd|D}nI|jjt urLdd|D}ddl m }||fdd|D}n$fd d|D}z d d|D}Wnt yot d |jjwtjj}tj_z6ztj|||d |d d}tttt|fddd}Wntytd|fwW|tj_|S|tj_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] rsignz#can't compute numerical roots of %scSg|]}t|qSrOrrrrOrOrPrMzPoly.nroots..cSsg|]}|jqSrO)r#rrOrOrPrOs)ilcmcsg|]}t|qSrOrr)facrOrPrRcsg|] }|jdqS)r)ZevalfrrrrOrPrTscSsg|]}tj|qSrO)mpmathZmpcrrOrOrPrWsz!Numerical domain expected, got %sF )maxstepscleanuperrorZ extrapreccs$|jrdnd|jt|j|jfS)Nrhr)imagrealr)r$rrOrPhs$zPoly.nroots..keyz7convergence to root failed; try n < %s or maxsteps > %s)Z$sympy.functions.elementary.complexesris_multivariater.r5rTrrrrZsympy.core.numbersrr;r)rZmpdpsZ polyrootsr_rrsortedr@) rJrrrrZdenomsrrrrO)rrrrPnroots(sX         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 can't compute ground roots of %srh)rr.r is_linearr)rJrfactorrr[r\rOrOrP ground_rootsrs 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 polynomialrhz&'n' must an integer and n >= 1, got %srk) rr.r is_Integerrrrr rorrCr)rJrrGrrkr$rOrOrPnth_power_roots_polys   zPoly.nth_power_roots_polyc 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) rrrr(rXrYrrr) rJrKrrrrrrLcpcqrr#rOrOrPrs     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 )rTis_zerorrOrOrPrz 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 )rTis_onerrOrOrPrrz 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 )rTrrrOrOrPrrz 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 )rTis_monicrrOrOrPrrz 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 )rT is_primitiverrOrOrPr&rzPoly.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 )rT is_groundrrOrOrPr9szPoly.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 )rTrrrOrOrPrNrzPoly.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 )rT is_quadraticrrOrOrPrarzPoly.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 )rT is_monomialrrOrOrPrtrzPoly.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 )rTis_homogeneousrrOrOrPrzPoly.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 )rTis_irreduciblerrOrOrPrrzPoly.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 rhrjrDrrOrOrPrzPoly.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 rhrrrOrOrPrrzPoly.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 )rT is_cyclotomicrrOrOrPrrzPoly.is_cyclotomiccCrrm)rrrOrOrP__abs__z Poly.__abs__cCrrm)rrrOrOrP__neg__rz Poly.__neg__cCrfrmrrJrKrOrOrP__add__ z Poly.__add__cC ||SrmrrrOrOrP__radd__rz Poly.__radd__cCrfrmrrrOrOrP__sub__rz Poly.__sub__cCrrmrrrOrOrP__rsub__ rz Poly.__rsub__cCrfrmrrrOrOrP__mul__rz Poly.__mul__cCrrmrrrOrOrP__rmul__rz Poly.__rmul__rcCs|jr |dkr ||StS)Nr)rr rE)rJrrOrOrP__pow__s z Poly.__pow__cCrfrmr*rrOrOrP __divmod__rzPoly.__divmod__cCrrmrrrOrOrP __rdivmod__!rzPoly.__rdivmod__cCrfrmr1rrOrOrP__mod__%rz Poly.__mod__cCrrmrrrOrOrP__rmod__)rz Poly.__rmod__cCrfrmr3rrOrOrP __floordiv__-rzPoly.__floordiv__cCrrmr rrOrOrP __rfloordiv__1rzPoly.__rfloordiv__rKcCs||SrmrGrrOrOrP __truediv__5zPoly.__truediv__cCs||Srmr rrOrOrP __rtruediv__9rzPoly.__rtruediv__otherc Csv||}}|js#z |j||j|d}Wn tttfy"YdSw|j|jkr+dS|jj|jjkr5dS|j|jkSNrF) r`rrDrr-r)r*rTr)rprrJrKrOrOrP__eq__=s   z Poly.__eq__cC ||k SrmrOrrOrOrP__ne__Orz Poly.__ne__cCs|j Srm)rrrOrOrP__bool__Srz Poly.__bool__cCs|s||kS|t|Srm) _strict_eqrrJrKstrictrOrOrPeqVszPoly.eqcCs|j||d S)Nr)rrrOrOrPne\szPoly.necCs*t||jo|j|jko|jj|jddSNTr)rArrDrTrrrOrOrPr_s*zPoly._strict_eqNNrm)FF)FTr)rhFNT)FNNNFFNNFFrrrT)rH __module__ __qualname____doc__ __slots__is_commutativer`Z _op_priorityrg classmethodrlpropertyrqrersrvryr{rCr]r^rarbrZrrrrrrrrrrrrrrrrrVrrrrrrrrrrrrrrrrrrrrrGrrrr r rrrrrrrrrrrrr r"r&r'r(r*r1r3r4rr5r7r8r9r:r>r@rCrFrDrrMrNrRrSrTrUrVr]r^rcZ_eval_derivativerrgrhrjrlrmrnrorrrtrwrxr{r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrRrrrrrrrrErrrrr r r rrrrrrrr __classcell__rOrOrrPrBYs/                     3 #$"     %  & %*'  ' % %* "  % "    ''(& K   !" %  KK     #  ! L%? J (%        rBcsVeZdZdZddZfddZeddZede 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. )rTrorOrOrPrsgrzPurePoly._hashable_contentcrrmrrorrOrPrkrzPurePoly.__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} )rrorOrOrPrnszPurePoly.free_symbolsrc Cs||}}|js#z |j||j|d}Wn tttfy"YdSwt|jt|jkr/dS|jj |jj krYz |jj |jj |j}Wn t yNYdSw| |}| |}|j|jkSr) r`rrDrr-r)r*rjrTrrr+r)rprrJrKrrOrOrPrs$     zPurePoly.__eq__cCst||jo|jj|jddSr)rArrTrrrOrOrPrszPurePoly._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)NrcrrrrrrOrPrrzPurePoly._unify..per)rr`rTrrrr*r+rjrDrAr%rrr)rJrKrDrrrrrOrrPrs$(    zPurePoly._unify)rHr$r%r&rsrr*rrrErrrr+rOrOrrPr,cs   r,cOt||}t||Sr|)rWrX_poly_from_exprrqrDrerfrOrOrPpoly_from_expr  r0cCs|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)r}NTr~F)rrArr0r`rrarDrrexpandr7r_rrrrrr\rBr])rqrforigrrTrrrrOrOrPr.s2      r.cOr-)(Construct polynomials from expressions. )rWrX_parallel_poly_from_expr)exprsrDrerfrOrOrPparallel_poly_from_exprr1r7cCsddlm}t|dkrE|\}}t|trEt|trE|j||}|j||}||\}}|j|_|j |_ |j dur?d|_ ||g|fSt |g}}gg}}d}t |D]*\} } t | } t| trz| jrm|| n|| |jry| } nd}|| qW|rt|||d|r|D] } || || <qt||\} }|jst|||d|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|j dur?t||_ ||fS) r4r PiecewiseNTFz&Piecewise generators do not make senser~)$sympy.functions.elementary.piecewiser9rjrArBrrarrDrrr_rrrr`rr2r0rGr8r-rrextendrrrr\r]bool)r6rfr9rJrKZorigsZ_exprsZ_polysZfailedrrqrepsrZ coeffs_listZlengthsrrrTrrrrrrOrOrPr5sz                 r5cCst|}||vr |||<|S)z7Add a new ``(key, value)`` pair to arguments ``dict``. )r\)rerrrOrOrP _update_argsVsr?cCst|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 Trrhz 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_Numberr`rGr0rZerorrDrjrr;r>nextrr5rArr )rJrZ gen_is_NumrZisNumrrLrOrOrPr5`s0    r5cGsNt|}|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)rr`rGr@rDrBr8r )rJrDrZrvrOrOrPr8s( r8c 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) rr7rhN) rW allowed_flagsr0r0r1r7rrr )rJrDrerrfr)ZdegreesrOrOrPr7s r7c 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 rr>rhNr)rWrCr0r0r1r>rUrJrDrerrfr)rOrOrPr>s r>c 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 rrMrhNr)rWrCr0r0r1rMrUrG)rJrDrerrfr)rrOrOrPrMs rMc 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 rrRrhNr)rWrCr0r0r1rRrUrG)rJrDrerrfr)rrrOrOrPrRs  rRc 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"r:N)rWrCr7r0r1r"rrG rJrKrDrerrrfr)r#r$rOrOrPr"8s& 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 rr&r:N)rWrCr7r0r1r&rrG rJrKrDrerrrfr)r$rOrOrPr&V&  r&c 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 rr'r:N) rWrCr7r0r1r'r/rrG rJrKrDrerrrfr)r#rOrOrPr'ts&   r'c OrF)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 rr(r:N)rWrCr7r0r1r(rrGrIrOrOrPr(s&  r(c 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) r-rr*r:Nr-) rWrCr7r0r1r*r-rrGrErOrOrPr*s& r*c 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 r-rr1r:NrJ) rWrCr7r0r1r1r-rrGrGrOrOrPr1& r1c OrK)z Compute polynomial quotient of ``f`` and ``g``. Examples ======== >>> from sympy import quo >>> from sympy.abc import x >>> quo(x**2 + 1, 2*x - 4) x/2 + 1 >>> quo(x**2 - 1, x - 1) x + 1 r-rr3r:NrJ) rWrCr7r0r1r3r-rrGrIrOrOrPr3rLr3c OrK)aQ Compute polynomial exact quotient of ``f`` and ``g``. Examples ======== >>> from sympy import exquo >>> from sympy.abc import x >>> exquo(x**2 - 1, x - 1) x + 1 >>> exquo(x**2 + 1, 2*x - 4) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 r-rr4r:NrJ) rWrCr7r0r1r4r-rrGrIrOrOrPr4s& r4c 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) r-rrhr:NrJ) rWrCr7r0rr6rhrYr1rr-rrG) rJrKrDrerrrfr)rr[r\r=rirOrOrPrh=s"&    rhc 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) r-rrjr:NrJ) rWrCr7r0rr6rjrYr1rr-rrG)rJrKrDrerrrfr)rr[r\r=rkrirOrOrPrjds"&  (  rjc Ost|ddgzt||fg|Ri|\\}}}Wn3tyN}z't|j\}\} } z||| | WWYd}~StyIt dd|wd}~ww|j||j d} |j s^| S| S)aE Invert ``f`` modulo ``g`` when possible. Examples ======== >>> from sympy import invert, S >>> from sympy.core.numbers import mod_inverse >>> from sympy.abc import x >>> invert(x**2 - 1, 2*x - 1) -4/3 >>> invert(x**2 - 1, x - 1) Traceback (most recent call last): ... NotInvertible: zero divisor For more efficient inversion of Rationals, use the :obj:`~.mod_inverse` function: >>> mod_inverse(3, 5) 2 >>> (S(2)/5).invert(S(7)/3) 5/2 See Also ======== sympy.core.numbers.mod_inverse r-rNrlr:rJ) rWrCr7r0rr6rrlrYr1r-rrG) rJrKrDrerrrfr)rr[r\rirOrOrPrls "&   rlc 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] rrnr:NcSg|]}|qSrOr rr$rOrOrPrrz!subresultants..)rWrCr7r0r1rnr rJrKrDrerrrfr)rLrOrOrPrns&  rnFrpc 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 rror:NrpcSrMrOr rNrOrOrPrrzresultant..)rWrCr7r0r1rorrG) rJrKrqrDrerrrfr)rLr/rOrOrPros"&  roc 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 rrrrhN)rWrCr0r0r1rrrrGrJrDrerrfr)rLrOrOrPrr rrc 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) rrxr:N) rWrCr7r0rr6rxrYr1rrrG)rJrKrDrerrrfr)rr[r\riryrzrOrOrPrx"s"&  (  rxc 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||SdSNrrh)rrr r{rrseqrZnumbersrLZnumberrerDrOrPtry_non_polynomial_gcd\s    z(gcd_list..try_non_polynomial_gcdNrrhcs|] }|jo |jVqdSrm is_algebraic is_irrationalrrrOrOrP zzgcd_list..rBcg|]}|qSrOratsimpr\r[rOrPr|rzgcd_list..cs|]}|jVqdSrm is_rationalrfrcrOrOrPr]}rgcd_listr~)rrWrCr7rjrr}as_numer_denomrr0r6r1rrrArBr{rrG) rUrDrerWrLrrflstlcrgr)rrOr[rerDrPriKsJ   ric 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 argumentsrrr{r:)rrir;rWrCr7rrrZr[rarerrjr0rr6rr{rYr1rrG rJrKrDrerrrfr[r\rgr)rrLrOrOrPr{s8  "     r{c svt|}fdd}||}|dur|StdgzMt|gRi\}}t|dkrhtdd|Drh|dfd d |ddD}td d|Drhd}|D] } t|| d}qW|WSWn%ty} z|| j }|dur|WYd} ~ St d t|| d} ~ ww|s|j st j Std|d S|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 cs^s-s-t|\}}|s|jS|jr-|d|dd}}|D]}|||}q||SdSrS)rrr r}rrTrVrOrPtry_non_polynomial_lcms  z(lcm_list..try_non_polynomial_lcmNrrhcsrXrmrYr\rOrOrPr]r^zlcm_list..rBcr_rOr`r\rbrOrPrrzlcm_list..csrcrmrdrfrOrOrPr]rhlcm_listr~r)rrWrCr7rjrr}rjr0r6r1rrrWrBrG) rUrDrerprLrrfrkrlrgr)rrOrmrPrqsD    rqc 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 rnNz2lcm() takes 2 arguments or a sequence of argumentsrrhr}r:)rrqr;rWrCr7rrrZr[rarerjr0rr6rr}rYr1rrGrorOrOrPr}"s8  "     r}c sddlm}t|}t||r|fdd|j|jfDSt|tr+td|ft|tr3|j r5|S ddr]|j fdd |j D} ddd <t|gRiS d d }td gzt|gRi\}}Wnty} z | jWYd} ~ Sd} ~ ww|\} }|jjr|jjr|jd d\} }|\} }|jjr| | } ntj} tdd t|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 r)Equalityc3s&|]}t|gRiVqdSrmr)rr=rVrOrPr]s$zterms_gcd..z6Inequalities can not be used with terms_gcd. Found: %sdeepFcs"g|] }t|gRiqSrOrs)rr[rVrOrPrrzterms_gcd..r2clearTrNrZcSsg|]\}}||qSrOrO)rrrrOrOrPrrrh)ru)!sympy.core.relationalrrrrAZlhsZrhsrr;ris_Atomr`rNrepoprrWrCr0r0rqrr+r,rVrrrWr rrDrrGZ as_coeff_Mul)rJrDrerrr3rlrurrfr)rdenomrtermrOrVrPrUsN B        rc 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 r-rr~rhN) rWrCr0r0r1r~rrrG)rJrrDrerrfr)rLrOrOrPr~ r~c 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 r-rrrhNrJ) rWrCr0r0r1rr-rrGrQrOrOrPrr{rc 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 rrrhN)rWrCr0r0r1rrDrOrOrPrs 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) rrrhN)rWrCr0r0r1rrrG)rJrDrerrfr)rrLrOrOrPr!s    rc OrF)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 rrr:N)rWrCr7r0r1rrrGrOrOrOrPrOrHrc 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] rrrhNcSrMrOr rNrOrOrPrrzdecompose..)rWrCr0r0r1rrrQrOrOrPrms 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] r-rrrhNrJcSrMrOr rNrOrOrPrrzsturm..)rWrCr0r0r1rr-rrQrOrOrPrs 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 rrrhNcSg|] \}}||fqSrOr rrOrOrPrrzgff_list..)rWrCr0r0r1rr)rJrDrerrfr)rrOrOrPrs  rcOrH)z3Compute greatest factorial factorization of ``f``. zsymbolic falling factorialrIrJrDrerOrOrPgffsrc 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) rrrhN) rWrCr0r0r1rrr rG) rJrDrerrfr)r=rKr$rOrOrPrs rc OrP)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 rrrhN)rWrCr0r0r1rrrGrQrOrOrPrrRrcCs&|dkr dd}ndd}t||dS)z&Sort a list of ``(expr, exp)`` pairs. rcSs&|\}}|jj}|t|t|j|fSrmrTrjrDrkrexprTrOrOrPr!z_sorted_factors..keycSs&|\}}|jj}t|t|j||fSrmrrrOrOrPr&rr)r)rmethodrrOrOrP_sorted_factorss  rcCstdd|DS)z*Multiply a list of ``(expr, exp)`` pairs. cSsg|] \}}||qSrOr rrJrrOrOrPr0rz$_factors_product..)r rrOrOrP_factors_product.src 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)rrrrrOrOrPr7sz)_symbolic_factor_list..NZ_listcsg|] \}}||fqSrOrOr)rrOrPr[rrcs(g|]ttfddDfqS)c3s |] \}}|kr|VqdSrmrO)rrJrrrOrPr]gsz3_symbolic_factor_list...)rr)rrrrPrgs cSsh|]\}}|qSrOrO)rrrrOrOrP hrz(_symbolic_factor_list..)rrWr make_argsr@rArris_PowbaseZExp1rerr.r0rqrFrZ is_positiver< is_integerrGr)rqrfrrreargrrrr)rNZ_coeffZ_factorsrrJrrO)rrrP_symbolic_factor_list3s^            rcst|tr#t|dr|Stt|dd\}}t|t|St|dr6|jfdd|j DSt|drH| fdd|DS|S) z%Helper function for :func:`_factor`. rfraction)rrecg|]}t|qSrO_symbolic_factorrrrrfrOrPrurz$_symbolic_factor..rncrrOrrrrOrPrwr) rArrrrr9rrrNrer)rqrfrrrrOrrPrms    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`. fracrrhza polynomial expected, got %sT)r2cSr}rOr rrOrOrPrrz(_generic_factor_list..cSr}rOr rrOrOrPrr)rWrCrXrrArrBr9rjrrr-cloner\rr`r.rr)rqrDrerrfZnumerryrfprZfqZ_optrrrJrrrrOrOrP_generic_factor_list|s:           rcCs<|dd}t|gt||}||d<tt|||S)z4Helper function for :func:`sqf` and :func:`factor`. rT)rxrWrCrXrr)rqrDrerrrfrOrOrP_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 sHddlm}t|jdkr|jdjsd|fS|}|}|p$|}|dd}fdd|D}t|dkr|dr|d|d}g}t t|D]}||||d} | j sfdS| | qRd|} |jd} | |g} t d|dD]}| ||d| ||q|| }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``. r)r rhNcsg|]}|qSrOrO)rcoeffxrrOrPrrz._try_rescale..rB) Zsympy.core.addr rjrDrwr5r>rrrrerrB) rJf1r rrlrZ rescale1_xZcoeffs1rrZ rescale_xrrrrOrP _try_rescales4       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``. rhrNcSs |jduSr!rd)zrOrOrPr s z._try_translate..Tbinary) rjrDrwr5rris_Addrer<rerNr) rJrrrrZratZnonratZalphaf2rrOrP_try_translates     z*to_rational_coeffs.._try_translatecSs|ddlm}|}d}|D]-}t|D]%}||j}dd|D}|s(qt|dkr0d}t|dkr:dSqq|S)zS Return True if ``f`` is a sum with square roots but no other root r)FactorsFcSs,g|]\}}|jr|jr|jdkr|jqS)r:)rZ is_Rationalr#)rr\ZwxrOrOrPrs  zAto_rational_coeffs.._has_square_roots..r:T) sympy.core.exprtoolsrrr rrrminmax)rrrZhas_sqrrrJr$rOrOrP_has_square_rootss     z-to_rational_coeffs.._has_square_rootsrhr:rm)sympy.simplify.simplifyrrrr)rJrrrrr$rOrrPto_rational_coeffss &#  rc 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 rrZEXrNrh) rrrBr5rrrGrr)rrrZp1rresrlr$rkrKrrZr1r[rrOrOrP_torational_factor_list2s(    *&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)]) rrrr~rOrOrPr^rcOr)z Compute square-free factorization of ``f``. Examples ======== >>> from sympy import sqf >>> from sympy.abc import x >>> sqf(2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16) 2*(x + 1)**2*(x + 2)**3 rr)rr~rOrOrPrprrcOr)a  Compute a list of irreducible factors of ``f``. Examples ======== >>> from sympy import factor_list >>> from sympy.abc import x, y >>> factor_list(2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y) (2, [(x + y, 1), (x**2 + 1, 2)]) rrrr~rOrOrPrrr)rtc st|}|rCddlm}fdd}|||}i}|tt}|D]}t|gRi} | js5| jr=| |kr=| ||<q"| |Sz t |ddWSt yo} z|j sgddl m} | |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 won't be combined. By default it is True. >>> factor(5*x + 3*exp(2 - 7*x), deep=True) (5*x*exp(7*x) + 3*exp(2))*exp(-7*x) >>> factor(5*x + 3*exp(2 - 7*x), deep=True, fraction=False) 5*x + 3*exp(2)*exp(-7*x) See Also ======== sympy.ntheory.factor_.factorint r) bottom_upcs*t|gRi}|js|jr|S|S)zS Factor, but avoid changing the expression when unable to. )ris_Mulr)rqrrVrOrP _try_factors zfactor.._try_factorrr) factor_ncN)rrrZatomsr r rrrxreplacerr-r(rr) rJrtrDrerrZpartialsZmuladdrrmsgrrOrVrPrs,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)] rnrrrrhNrr)rrrrr)rrBr,rr7rjrDr.rrTrrrr:rr)rrrrrrrrrrfrrrrLr=rkrrOrOrPrs8       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+can't refine a root of %s, not a polynomial)rrrr)rBrAr is_Symbolr-r,r)rJr=rkrrrrrrOrOrPr1s 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 FZgreedyrz)can't count roots of %s, not a polynomialr)rBrArrr-r,r)rJrrrrOrOrPrNs   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] Frrz0can't compute real roots of %s, not a polynomialr)rBrArrr-r,r)rJrrrOrOrPros   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] Frrz5can't compute numerical roots of %s, not a polynomial)rrr)rBrArrr-r,r)rJrrrrrOrOrPrs  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} rrrhN) rWrCr0rArBrrr-r0r1rrDrOrOrPrs  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 rrrhN) rWrCr0rArBrrr-r0r1rrrG)rJrrDrerrfr)rLrOrOrPrs   rc sBddlm}ddlmddlm}t|dgt|}i}d|vr)|d|d<t |t t fsL|j s=t |t s=t |ts?|S||dd}|\}}n?t|dkr||\}}t |trrt |trr|j|d <|j|d <|dd|d<||}}nt |t r||Std |z1|rt|||fg|Ri|\}\} } |jst |t t fs|WStj||fWSWntyG} z~|jr|st| |js|jrt |j!fd d dd\} } dd| D} |j"t#|j"| g| RWYd} ~ Sg}t$|}t%||D](}t |t t t&frq z|'|t#|f|(Wq t)y5Yq w|*t+|WYd} ~ Sd} ~ wwd| #| } \}}|ddrcd |vrc|j,|d <t |t t fsu| ||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) factor_termsr8)sringrT)Zradicalr:rDrzunexpected argument: %scs|jduo | Sr!)r(has)rr8rOrPr7szcancel..rcSrrO)rrrOrOrPr:rzcancel..NrhF)-rrr;r9sympy.polys.ringsrrWrCrrArrr@rrrjrjrBrDrr`rGrrr-Zngensr2rrWr(rrr<rerNrrrBrrskiprYrr\r)rJrDrerrrfrr#r/rrrrZncr>Zpoterr.rOr8rPrs           "  (  .rc 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) rr-reducedrNFrTxringrhcg|] }tt|qSrOrBr]r\rr#r~rOrPrrzreduced..cSrMrOrrrOrOrPrrcSrMrOr rrOrOrPrr)rWrCr7r_r0r1rr-r+r,rr\ get_fieldrrrDrUrrrTrrvr*rBr]rr*rrG)rJrrDrerr)rrr_ringrrrr.r$_Q_rrOr~rPrYs<(    rcOst|g|Ri|S)a Computes the reduced Groebner basis for a set of polynomials. Use the ``order`` argument to set the monomial ordering that will be used to compute the basis. Allowed orders are ``lex``, ``grlex`` and ``grevlex``. If no order is specified, it defaults to ``lex``. For more information on Groebner bases, see the references and the docstring of :func:`~.solve_poly_system`. Examples ======== Example taken from [1]. >>> from sympy import groebner >>> from sympy.abc import x, y >>> F = [x*y - 2*y, 2*y**2 - x**2] >>> groebner(F, x, y, order='lex') GroebnerBasis([x**2 - 2*y**2, x*y - 2*y, y**3 - 2*y], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, order='grlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grlex') >>> groebner(F, x, y, order='grevlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grevlex') By default, an improved implementation of the Buchberger algorithm is used. Optionally, an implementation of the F5B algorithm can be used. The algorithm can be set using the ``method`` flag or with the :func:`sympy.polys.polyconfig.setup` function. >>> F = [x**2 - x - 1, (2*x - 1) * y - (x**10 - (1 - x)**10)] >>> groebner(F, x, y, method='buchberger') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, method='f5b') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex') References ========== 1. [Buchberger01]_ 2. [Cox97]_ ) GroebnerBasisrrDrerOrOrPr"s3r"cOst|g|Ri|jS)a[ Checks if the ideal generated by a Groebner basis is zero-dimensional. The algorithm checks if the set of monomials not divisible by the leading monomial of any element of ``F`` is bounded. References ========== David A. Cox, John B. Little, Donal O'Shea. Ideals, Varieties and Algorithms, 3rd edition, p. 230 )ris_zero_dimensionalrrOrOrPrsrc@seZdZdZddZeddZeddZedd Z ed d Z ed d Z eddZ eddZ ddZddZddZddZddZddZeddZd d!Zd(d#d$Zd%d&Zd'S))rz%Represents a reduced Groebner basis. c st|ddgzt|g|Ri|\}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|jqSrO)rvrTrrr)ringrOrPrs z)GroebnerBasis.__new__..rcsg|]}t|qSrO)rBr]rrKr~rOrPrr)rWrCr7r0r1rjrrrDrrU _groebnerr_new)rdrrDrerr)rrrO)rfrrPrgs  zGroebnerBasis.__new__cCst|}t||_||_|Srm)rrgr_basis_options)rdbasisrWrkrOrOrPrs  zGroebnerBasis._newcCs$dd|jD}t|t|jjfS)Ncss|]}|VqdSrmr )rrrOrOrPr]sz%GroebnerBasis.args..)rrrrD)rprrOrOrPreszGroebnerBasis.argscCsdd|jDS)NcSrMrOr rrOrOrPrrz'GroebnerBasis.exprs..)rrorOrOrPr6rzGroebnerBasis.exprscC t|jSrm)r_rrorOrOrPrrzGroebnerBasis.polyscCrrm)rrDrorOrOrPrD rzGroebnerBasis.genscCrrm)rrrorOrOrPrrzGroebnerBasis.domaincCrrm)rrUrorOrOrPrUrzGroebnerBasis.ordercCrrm)rjrrorOrOrP__len__rzGroebnerBasis.__len__cCs|jjr t|jSt|jSrm)rriterr6rorOrOrPrns  zGroebnerBasis.__iter__cCs$|jjr |j}||S|j}||Srm)rrr6)rpitemrrOrOrP __getitem__s zGroebnerBasis.__getitem__cCst|jt|jfSrm)hashrrrrrorOrOrPr'szGroebnerBasis.__hash__cCsLt||jr|j|jko|j|jkSt|r$|jt|kp#|jt|kSdS)NF)rArrrrrr_r6rprrOrOrPr*s zGroebnerBasis.__eq__cCrrmrOrrOrOrPr2rzGroebnerBasis.__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=)monomialrOrOrP single_varDsz5GroebnerBasis.is_zero_dimensional..single_varrr)r#rjrDrrUrrMr)rprrErUrrrOrOrPr5s  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>can't convert Groebner bases of ideals with positive dimension)rrUrrcrrOrrr~rOrPrrz&GroebnerBasis.fglm..cSsg|] }|jdddqS)TrZrh)rVrrOrOrPrr)rrUr$rrYr_rrrr\rrrrDrrrTrrvr!r,r) rprUZ src_orderZ dst_orderrrrrrrrrrOr~rPfglmUs0    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 FrTrrrhNcrrOrrr~rOrPrrz(GroebnerBasis.reduce..cSrMrOrrrOrOrPrrcSrMrOr rrOrOrPrr)rBrbrr_rrr+r,rr\rrrrDrUrrrTrrvr*r]rr*rrG)rprqr-rrrrrrrrr.r$rrrOr~rPrs4   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 rhr)r)rprrOrOrPcontainsszGroebnerBasis.containsNr)rHr$r%r&rgr)rr*rer6rrDrrUrrnrrrrrrrrrOrOrOrPrs8         B Arcsdtgfddt|}|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)NrrhrDrO)r rr rrrrrrr rr@rBrbrrr`) rqrfrZ poly_termsrzrZ poly_factorsrproductrL_polyrerOrPrsJ         zpoly.._polyr2F)rWrCrr`rBrXr/rOrrPrs 4  rr rm)FNNNFFFr"rrr#)r& functoolsrroperatorrZ sympy.corerrrr r r r r rZsympy.core.basicrZsympy.core.compatibilityrrZsympy.core.decoratorsrZsympy.core.evalfrZsympy.core.functionrZsympy.core.mulrrvrZsympy.core.symbolrZsympy.core.sympifyrrZsympy.logic.boolalgrZ sympy.polysrrWZsympy.polys.constructorrZsympy.polys.domainsrrrZ!sympy.polys.domains.domainelementr Zsympy.polys.fglmtoolsr!Zsympy.polys.groebnertoolsr"rZsympy.polys.monomialsr#Zsympy.polys.orderingsr$Zsympy.polys.polyclassesr%r&r'Zsympy.polys.polyerrorsr(r)r*r+r,r-r.r/r0r1r2Zsympy.polys.polyutilsr3r4r5r6r7r8Zsympy.polys.rationaltoolsr9Zsympy.polys.rootisolationr:Zsympy.utilitiesr;r<r=r>Zsympy.utilities.exceptionsr?rrZmpmath.libmp.libhyperr@rRrBr,r0r.r7r5r?r5r8r7r>rMrRr"r&r'r(r*r1r3r4rhrjrlrnrorrrxrir{rqr}rr~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrOrOrOrPs ,               4    )] ( _ : 4       " "    " & & 5 $  ( T 3 M 2 v    -    .  ! :, ,   d 7      + d ; 5