a Ÿ¬Z>ddl?m@ZAddlBmCZCddlDmEZEddlFmGZGmHZHmIZIddlJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUddlVmWZWmXZXmYZYmZZZm[Z[m\Z\ddl]m^Z^ddl_m`Z`ddlambZbmcZcmdZddd lemfZfdd!lgmhZhmiZidd"l2Zjdd"lkZkdd#llmmZmd$d%„ZnecGd&d'„d'eƒƒZoecGd(d)„d)eoƒƒZpecd*d+„ƒZqd,d-„Zrecd.d/„ƒZsd0d1„Ztd2d3„Zuecd·d4d5„ƒZvecd6d7„ƒZwecd8d9„ƒZxecd:d;„ƒZyecdd?„ƒZ{ecd@dA„ƒZ|ecdBdC„ƒZ}ecdDdE„ƒZ~ecdFdG„ƒZecdHdI„ƒZ€ecdJdK„ƒZecdLdM„ƒZ‚ecdNdO„ƒZƒecdPdQ„ƒZ„ecdRdS„ƒZ…ecdTdU„ƒZ†ecdVdW„ƒZ‡ecdXdYœdZd[„ƒZˆecd\d]„ƒZ‰ecd^d_„ƒZŠecd`da„ƒZ‹ecd¸dbdc„ƒZŒecddde„ƒZecd¹dfdg„ƒZŽecdhdi„ƒZecdjdk„ƒZecdldm„ƒZ‘ecdndo„ƒZ’ecdpdq„ƒZ“ecdrds„ƒZ”ecdtdu„ƒZ•ecdvdw„ƒZ–ecdxdy„ƒZ—ecdzd{„ƒZ˜ecd|d}„ƒZ™ecd~d„ƒZšd€d„Z›d‚dƒ„Zœd„d…„Zd†d‡„Zždˆd‰„ZŸdŠd‹„Z dŒd„Z¡dŽd„Z¢ecdd‘„ƒZ£ecd’d“„ƒZ¤ecd”d•„ƒZ¥ecdXd–œd—d˜„ƒZ¦ecdºd™dš„ƒZ§ecd»d›dœ„ƒZ¨ecd¼ddž„ƒZ©ecd½d d¡„ƒZªecd¾d¤d¥„ƒZ«ecd¦d§„ƒZ¬ecd¨d©„ƒZecdŸdªœd«d¬„ƒZ®ecdd®„ƒZ¯ecd¯d°„ƒZ@ecd±d²„ƒZ°ecGd³d´„d´eƒƒZ±ecdµd¶„ƒZ²d"S)¿z8User-friendly public interface to polynomial functions. é)ÚwrapsÚreduce©Úmul)ÚSÚExprÚAddÚTuple)ÚBasic)Ú _sympifyit)ÚFactorsÚ factor_ncÚfactor_terms)Úpure_complexÚevalfÚfastlogÚ_evalf_with_bounded_errorÚquad_to_mpmath)Ú Derivative)ÚMulÚ_keep_coeff)ÚilcmÚIÚInteger)Ú RelationalÚEquality)Úordered)ÚDummyÚSymbol)ÚsympifyÚ_sympify)Úpreorder_traversalÚ bottom_up)ÚBooleanAtom)Úpolyoptions)Úconstruct_domain)ÚFFÚQQÚZZ)Ú DomainElement)Úmatrix_fglm)Úgroebner)ÚMonomial)Úmonomial_key)ÚDMPÚDMFÚANP)ÚOperationNotSupportedÚDomainErrorÚCoercionFailedÚUnificationFailedÚGeneratorsNeededÚPolynomialErrorÚMultivariatePolynomialErrorÚExactQuotientFailedÚPolificationFailedÚComputationFailedÚGeneratorsError)Úbasic_from_dictÚ _sort_gensÚ_unify_gensÚ _dict_reorderÚ_dict_from_exprÚ_parallel_dict_from_expr)Útogether)Údup_isolate_real_roots_list)ÚgroupÚpublicÚ filldedent)Úsympy_deprecation_warning)ÚiterableÚsiftN)Ú NoConvergencecstˆƒ‡fdd„ƒ}|S)Ncs¦t|ƒ}t|tƒrˆ||ƒSt|tƒržz|j|g|j¢RŽ}WnRty|jrZtYSt | ¡ˆjƒ}||ƒ}|turˆtdddd|YS0ˆ||ƒSntSdS)Na@ Mixing Poly with non-polynomial expressions in binary operations is deprecated. Either explicitly convert the non-Poly operand to a Poly with as_poly() or convert the Poly to an Expr with as_expr(). z1.6z)deprecated-poly-nonpoly-binary-operations)Zdeprecated_since_versionZactive_deprecations_target) r Ú isinstanceÚPolyrÚ from_exprÚgensr6Z is_MatrixÚNotImplementedÚgetattrÚas_exprÚ__name__rG)ÚfÚgZexpr_methodÚresult©Úfunc©úe/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/sympy/polys/polytools.pyÚwrapperCs( ø z_polifyit..wrapper)r)rWrZrXrVrYÚ _polifyitBsr[csBeZdZdZdZdZdZdZdd„Ze dd„ƒZ ed d „ƒZedd„ƒZ d d„Ze dd„ƒZe dd„ƒZe dd„ƒZe dd„ƒZe dd„ƒZe dd„ƒZe dd„ƒZe dd„ƒZe dd „ƒZ‡fd!d"„Zed#d$„ƒZed%d&„ƒZed'd(„ƒZed)d*„ƒZed+d,„ƒZed-d.„ƒZed/d0„ƒZd1d2„Z d3d4„Z!dtd6d7„Z"d8d9„Z#d:d;„Z$dd?„Z&d@dA„Z'dBdC„Z(dudDdE„Z)dFdG„Z*dHdI„Z+dJdK„Z,dLdM„Z-dNdO„Z.dPdQ„Z/dRdS„Z0dvdTdU„Z1dwdVdW„Z2dxdXdY„Z3dydZd[„Z4dzd\d]„Z5d^d_„Z6d`da„Z7dbdc„Z8ddde„Z9dfdg„Z:d{didj„Z;d|dkdl„Zdqdr„Z?dsdt„Z@d}dudv„ZAdwdx„ZBdydz„ZCd{d|„ZDd}d~„ZEdd€„ZFdd‚„ZGdƒd„„ZHd…d†„ZId‡dˆ„ZJd‰dŠ„ZKd‹dŒ„ZLddŽ„ZMdd„ZNd‘d’„ZOd“d”„ZPd•d–„ZQd—d˜„ZRd™dš„ZSd~d›dœ„ZTdddž„ZUd€dŸd „ZVdd¡d¢„ZWd£d¤„ZXd‚d¦d§„ZYd¨d©„ZZdªd«„Z[d¬d„Z\d®d¯„Z]dƒd°d±„Z^d²d³„Z_d„d´dµ„Z`d¶d·„Zad¸d¹„Zbd…d»d¼„Zcd†d½d¾„Zdd‡d¿dÀ„ZedˆdÁdÂ„Zfd‰dÃdÄ„ZgdÅdÆ„ZhdÇdÈ„ZidŠdÉdÊ„ZjdËdÌ„ZkdÍdÎ„ZldÏdÐ„ZmemZnd‹dÑdÒ„ZodÓdÔ„ZpdŒdÕdÖ„Zqdd×dØ„ZrdŽdÙdÚ„ZsdÛdÜ„ZtdÝdÞ„Zuddßdà„Zvdádâ„Zwddãdä„Zxd‘dådæ„Zydçdè„Zzdédê„Z{dëdì„Z|dídî„Z}d’dïdð„Z~dñdò„Zdódô„Z€dõdö„Zd÷dø„Z‚dùdú„Zƒdûdü„Z„d“dýdþ„Z…dÿd„Z†dd„Z‡dd„Zˆdd„Z‰d”dd„ZŠd•d d „Z‹dd„ZŒd d„Zd–dd„ZŽd—dd„Zd˜dd„Zd™dd„Z‘dšdd„Z’d›dd„Z“dœdd„Z”dd „Z•d!d"„Z–d#d$„Z—dd%d&„Z˜ed'd(„ƒZ™ed)d*„ƒZšed+d,„ƒZ›ed-d.„ƒZœed/d0„ƒZed1d2„ƒZžed3d4„ƒZŸed5d6„ƒZ ed7d8„ƒZ¡ed9d:„ƒZ¢ed;d<„ƒZ£ed=d>„ƒZ¤ed?d@„ƒZ¥edAdB„ƒZ¦dCdD„Z§dEdF„Z¨e©dGdH„ƒZªe©dIdJ„ƒZ«e©dKdL„ƒZ¬e©dMdN„ƒZe©dOdP„ƒZ®e©dQdR„ƒZ¯e°dSe±ƒdTdU„ƒZ²e©dVdW„ƒZ³e©dXdY„ƒZ´e©dZd[„ƒZµe©d\d]„ƒZ¶e©d^d_„ƒZ·e©d`da„ƒZ¸e°dbe±ƒdcdd„ƒZ¹e°dbe±ƒdedf„ƒZºe°dge±ƒdhdi„ƒZ»e°dbe±ƒdjdk„ƒZ¼dldm„Z½dždndo„Z¾dŸdpdq„Z¿drds„ZÀ‡ZÁS( rLaP Generic class for representing and operating on polynomial expressions. See :ref:`polys-docs` for general documentation. Poly is a subclass of Basic rather than Expr but instances can be converted to Expr with the :py:meth:`~.Poly.as_expr` method. .. deprecated:: 1.6 Combining Poly with non-Poly objects in binary operations is deprecated. Explicitly convert both objects to either Poly or Expr first. See :ref:`deprecated-poly-nonpoly-binary-operations`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y Create a univariate polynomial: >>> Poly(x*(x**2 + x - 1)**2) Poly(x**5 + 2*x**4 - x**3 - 2*x**2 + x, x, domain='ZZ') Create a univariate polynomial with specific domain: >>> from sympy import sqrt >>> Poly(x**2 + 2*x + sqrt(3), domain='R') Poly(1.0*x**2 + 2.0*x + 1.73205080756888, x, domain='RR') Create a multivariate polynomial: >>> Poly(y*x**2 + x*y + 1) Poly(x**2*y + x*y + 1, x, y, domain='ZZ') Create a univariate polynomial, where y is a constant: >>> Poly(y*x**2 + x*y + 1,x) Poly(y*x**2 + y*x + 1, x, domain='ZZ[y]') You can evaluate the above polynomial as a function of y: >>> Poly(y*x**2 + x*y + 1,x).eval(2) 6*y + 1 See Also ======== sympy.core.expr.Expr ©ÚreprNTg—nƒ$@cOs˜t ||¡}d|vrtdƒ‚t|ttttfƒr:| ||¡St |t drnt|tƒr\| ||¡S| t|ƒ|¡Sn&t|ƒ}|jrˆ| ||¡S| ||¡SdS)z:Create a new polynomial instance out of something useful. Úorderz&'order' keyword is not implemented yet)ÚexcludeN)ÚoptionsÚ build_optionsÚNotImplementedErrorrKr.r/r0r)Ú_from_domain_elementrHÚstrÚdictÚ _from_dictÚ _from_listÚlistrÚis_PolyÚ _from_polyÚ _from_expr©Úclsr]rNÚargsÚoptrXrXrYÚ__new__¡s zPoly.__new__cGsTt|tƒstd|ƒ‚n"|jt|ƒdkr:td||fƒ‚t |¡}||_||_|S)z:Construct :class:`Poly` instance from raw representation. z%invalid polynomial representation: %sézinvalid arguments: %s, %s) rKr.r6ÚlevÚlenr rpr]rN)rmr]rNÚobjrXrXrYÚnewÀs ÿ zPoly.newcCst|j ¡g|j¢RŽS©N)r<r]Ú to_sympy_dictrN©ÚselfrXrXrYÚexprÏsz Poly.exprcCs|jf|jSrv)rzrNrxrXrXrYrnÓsz Poly.argscCs|jf|jSrvr\rxrXrXrYÚ_hashable_content×szPoly._hashable_contentcOst ||¡}| ||¡S)ú(Construct a polynomial from a ``dict``. )r`rarfrlrXrXrYÚ from_dictÚszPoly.from_dictcOst ||¡}| ||¡S)ú(Construct a polynomial from a ``list``. )r`rargrlrXrXrYÚ from_listàszPoly.from_listcOst ||¡}| ||¡S)ú*Construct a polynomial from a polynomial. )r`rarjrlrXrXrYÚ from_polyæszPoly.from_polycOst ||¡}| ||¡S©ú+Construct a polynomial from an expression. )r`rarkrlrXrXrYrMìszPoly.from_exprcCsz|j}|stdƒ‚t|ƒd}|j}|dur>t||d\}}n | ¡D]\}}| |¡||<qF|jt |||¡g|¢RŽS)r|z0Cannot initialize from 'dict' without generatorsrqN©ro) rNr5rsÚdomainr%ÚitemsÚconvertrur.r})rmr]rorNÚlevelr…ÚmonomÚcoeffrXrXrYrfòsÿzPoly._from_dictcCs€|j}|stdƒ‚nt|ƒdkr(tdƒ‚t|ƒd}|j}|durTt||d\}}ntt|j|ƒƒ}|j t |||¡g|¢RŽS)r~z0Cannot initialize from 'list' without generatorsrqz#'list' representation not supportedNr„)rNr5rsr7r…r%rhÚmapr‡rur.r)rmr]rorNrˆr…rXrXrYrgsÿÿzPoly._from_listcCs˜||jkr |j|jg|j¢RŽ}|j}|j}|j}|rl|j|krlt|jƒt|ƒkrb| | ¡|¡S|j |Ž}d|vr„|r„| |¡}n|dur”| ¡}|S)r€r…T)Ú __class__rur]rNÚfieldr…ÚsetrkrQÚreorderÚ set_domainÚto_field)rmr]rorNrr…rXrXrYrjs zPoly._from_polycCst||ƒ\}}| ||¡Sr‚)r@rf)rmr]rorXrXrYrk3szPoly._from_exprcCs@|j}|j}t|ƒd}| |¡g}|jt |||¡g|¢RŽS©Nrq)rNr…rsr‡rur.r)rmr]rorNr…rˆrXrXrYrc9s zPoly._from_domain_elementcs tƒ ¡Srv©ÚsuperÚ__hash__rx©rŒrXrYr•Csz Poly.__hash__cCsPtƒ}|j}tt|ƒƒD],}| ¡D]}||r$|||jO}qq$q||jBS)a Free symbols of a polynomial expression. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(x**2 + 1).free_symbols {x} >>> Poly(x**2 + y).free_symbols {x, y} >>> Poly(x**2 + y, x).free_symbols {x, y} >>> Poly(x**2 + y, x, z).free_symbols {x, y} )rŽrNÚrangersÚmonomsÚfree_symbolsÚfree_symbols_in_domain)ryÚsymbolsrNÚir‰rXrXrYr™FszPoly.free_symbolscCsP|jjtƒ}}|jr.|jD]}||jO}qn|jrL| ¡D]}||jO}q<|S)aj Free symbols of the domain of ``self``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 1).free_symbols_in_domain set() >>> Poly(x**2 + y).free_symbols_in_domain set() >>> Poly(x**2 + y, x).free_symbols_in_domain {y} )r]ÚdomrŽÚis_Compositer›r™Úis_EXÚcoeffs)ryr…r›ÚgenrŠrXrXrYršes zPoly.free_symbols_in_domaincCs |jdS)zÊ Return the principal generator. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).gen x r©rNrxrXrXrYr¡ƒszPoly.gencCs| ¡S)aŠGet 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_domainrxrXrXrYr…”szPoly.domaincCs&|j|j |jj|jj¡g|j¢RŽS)z3Return zero polynomial with ``self``'s properties. )rur]ÚzerorrrrNrxrXrXrYr¤«sz Poly.zerocCs&|j|j |jj|jj¡g|j¢RŽS)z2Return one polynomial with ``self``'s properties. )rur]ÚonerrrrNrxrXrXrYr¥°szPoly.onecCs&|j|j |jj|jj¡g|j¢RŽS)z3Return unit polynomial with ``self``'s properties. )rur]ÚunitrrrrNrxrXrXrYr¦µsz 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)rSrTÚ_ÚperÚFÚGrXrXrYÚunifyºsz Poly.unifycs¸tˆƒ‰ˆjsZz(ˆjjˆjˆjˆj ˆjj ˆ¡¡fWStyXtdˆˆfƒ‚Yn0tˆjt ƒr‚tˆjt ƒr‚t ˆjˆjƒ}ˆjj ˆjj|¡t |ƒd‰}ˆj|krtˆj ¡ˆj|ƒ\}}ˆjjˆkrê‡‡fdd„|Dƒ}t ttt||ƒƒƒˆ|ƒ}nˆj ˆ¡}ˆj|krttˆj ¡ˆj|ƒ\}}ˆjjˆkrX‡‡fdd„|Dƒ}t ttt||ƒƒƒˆ|ƒ} nˆj ˆ¡} ntdˆˆfƒ‚ˆj‰ˆ|df‡fdd„ } ˆ| || fS)NúCannot unify %s with %srqcsg|]}ˆ |ˆjj¡‘qSrX©r‡r]r©Ú.0Úc)rrSrXrYÚ éózPoly._unify..csg|]}ˆ |ˆjj¡‘qSrXr®r¯)rrTrXrYr²ôr³csD|dur2|d|…||dd…}|s2| |¡Sˆj|g|¢RŽSr’©Úto_sympyru©r]rrNÚremove©rmrXrYr©þs zPoly._unify..per)rrir]rr©Ú from_sympyr3r4rKr.r>rNr¬rsr?Úto_dictrerhÚzipr‡rŒ)rSrTrNrrZf_monomsZf_coeffsrªZg_monomsZg_coeffsr«r©rX)rmrrSrTrYr§Ös:("ÿÿ zPoly._unifyNcCsX|dur|j}|durD|d|…||dd…}|sD|jj |¡S|jj|g|¢RŽS)ab Create a Poly out of the given representation. Examples ======== >>> from sympy import Poly, ZZ >>> from sympy.abc import x, y >>> from sympy.polys.polyclasses import DMP >>> a = Poly(x**2 + 1) >>> a.per(DMP([ZZ(1), ZZ(1)], ZZ), gens=[y]) Poly(y + 1, y, domain='ZZ') Nrq)rNr]rrµrŒru)rSr]rNr·rXrXrYr© szPoly.percCs&t |jd|i¡}| |j |j¡¡S)z Set the ground domain of ``f``. r…)r`rarNr©r]r‡r…)rSr…rorXrXrYr&szPoly.set_domaincCs|jjS)z Get the ground domain of ``f``. )r]r©rSrXrXrYr£+szPoly.get_domaincCstj |¡}| t|ƒ¡S)zò Set the modulus of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(5*x**2 + 2*x - 1, x).set_modulus(2) Poly(x**2 + 1, x, modulus=2) )r`ZModulusÚ preprocessrr&)rSÚmodulusrXrXrYÚset_modulus/szPoly.set_moduluscCs&| ¡}|jrt| ¡ƒStdƒ‚dS)zÖ Get the modulus of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, modulus=2).get_modulus() 2 z$not a polynomial over a Galois fieldN)r£Zis_FiniteFieldrZcharacteristicr6)rSr…rXrXrYÚget_modulus@szPoly.get_moduluscCsN||jvr>|jr| ||¡Sz| ||¡WSty<Yn0| ¡ ||¡S)z)Internal implementation of :func:`subs`. )rNÚ is_numberÚevalÚreplacer6rQÚsubs)rSÚoldrurXrXrYÚ _eval_subsUs zPoly._eval_subscCsL|j ¡\}}g}tt|jƒƒD]}||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¢)r]r_r—rsrNÚappendr©)rSÚJrurNÚjrXrXrYr_bszPoly.excludecKs¤|dur$|jr|j|}}ntdƒ‚||ks6||jvr:|S||jvrŽ||jvrŽ| ¡}|jrf||jvrŽt|jƒ}||| |¡<|j |j |dStd|||fƒ‚dS)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 caser¢zCannot replace %s with %s in %s)Ú is_univariater¡r6rNr£ržr›rhÚindexr©r])rSÚxÚyÚ_ignorerrNrXrXrYrÃysÿ zPoly.replacecOs| ¡j|i|¤ŽS)z-Match expression from Poly. See Basic.match())rQÚmatch)rSrnÚkwargsrXrXrYrÏœsz Poly.matchcOs|t d|¡}|s t|j|d}nt|jƒt|ƒkr:tdƒ‚tttt |j ¡|j|ƒŽƒƒ}|jt ||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') rXr„z7generators list can differ only up to order of elementsrqr¢)r`ÚOptionsr=rNrŽr6rerhr»r?r]rºr©r.rrs)rSrNrnror]rXrXrYr sÿ zPoly.reordercCsŽ|jdd}| |¡}i}| ¡D]4\}}t|d|…ƒrFtd|ƒ‚||||d…<q"|j|d…}|jt |t |ƒd|j j¡g|¢RŽS)a( Remove dummy generators from ``f`` that are to the left of specified ``gen`` in the generators as ordered. When ``gen`` is an integer, it refers to the generator located at that position within the tuple of generators of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(y**2 + y*z**2, x, y, z).ltrim(y) Poly(y**2 + y*z**2, y, z, domain='ZZ') >>> Poly(z, x, y, z).ltrim(-1) Poly(z, z, domain='ZZ') T)ÚnativeNzCannot left trim %srq)Úas_dictÚ _gen_to_levelr†Úanyr6rNrur.r}rsr]r)rSr¡r]rÉÚtermsr‰rŠrNrXrXrYÚltrimºs z Poly.ltrimc Gs†tƒ}|D]B}z|j |¡}Wn"ty@td||fƒ‚Yq 0| |¡q | ¡D]*}t|ƒD]\}}||vrb|rbdSqbqVdS)aJ Return ``True`` if ``Poly(f, *gens)`` retains ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(x*y + 1, x, y, z).has_only_gens(x, y) True >>> Poly(x*y + z, x, y, z).has_only_gens(x, y) False ú%s doesn't have %s as generatorFT)rŽrNrËÚ ValueErrorr;Úaddr˜Ú enumerate)rSrNÚindicesr¡rËr‰rœÚeltrXrXrYÚ has_only_gensÞs ÿ zPoly.has_only_genscCs,t|jdƒr|j ¡}n t|dƒ‚| |¡S)zø Make the ground domain a ring. Examples ======== >>> from sympy import Poly, QQ >>> from sympy.abc import x >>> Poly(x**2 + 1, domain=QQ).to_ring() Poly(x**2 + 1, x, domain='ZZ') Úto_ring)Úhasattrr]rßr1r©©rSrUrXrXrYrßs zPoly.to_ringcCs,t|jdƒr|j ¡}n t|dƒ‚| |¡S)zý Make the ground domain a field. Examples ======== >>> from sympy import Poly, ZZ >>> from sympy.abc import x >>> Poly(x**2 + 1, x, domain=ZZ).to_field() Poly(x**2 + 1, x, domain='QQ') r‘)ràr]r‘r1r©rárXrXrYr‘s z Poly.to_fieldcCs,t|jdƒr|j ¡}n t|dƒ‚| |¡S)zý Make the ground domain exact. Examples ======== >>> from sympy import Poly, RR >>> from sympy.abc import x >>> Poly(x**2 + 1.0, x, domain=RR).to_exact() Poly(x**2 + 1, x, domain='QQ') Úto_exact)ràr]râr1r©rárXrXrYrâ*s z Poly.to_exactcCs4t|jdd||jjpdd\}}|j||j|dS)a Recalculate the ground domain of a polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**2 + 1, x, domain='QQ[y]') >>> f Poly(x**2 + 1, x, domain='QQ[y]') >>> f.retract() Poly(x**2 + 1, x, domain='ZZ') >>> f.retract(field=True) Poly(x**2 + 1, x, domain='QQ') T©r¤N)rZ composite©r…)r%rÓr…ržr}rN)rSrrr]rXrXrYÚretract?sÿ zPoly.retractcCsh|durd||}}}n | |¡}t|ƒt|ƒ}}t|jdƒrT|j |||¡}n t|dƒ‚| |¡S)z1Take a continuous subsequence of terms of ``f``. NrÚslice)rÔÚintràr]rær1r©)rSrÌÚmÚnrÉrUrXrXrYræWs z Poly.slicecs‡fdd„ˆjj|dDƒS)aQ Returns all non-zero coefficients from ``f`` in lex order. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x + 3, x).coeffs() [1, 2, 3] See Also ======== all_coeffs coeff_monomial nth csg|]}ˆjj |¡‘qSrX©r]rrµr¯r¼rXrYr²{r³zPoly.coeffs..©r^)r]r ©rSr^rXr¼rYr gszPoly.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ë)r]r˜rìrXrXrYr˜}szPoly.monomscs‡fdd„ˆjj|dDƒS)ac Returns all non-zero terms from ``f`` in lex order. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x*y**2 + x*y + 3*y, x, y).terms() [((2, 0), 1), ((1, 2), 2), ((1, 1), 1), ((0, 1), 3)] See Also ======== all_terms cs"g|]\}}|ˆjj |¡f‘qSrXrê©r°rèr±r¼rXrYr²£r³zPoly.terms..rë)r]rÖrìrXr¼rYrÖ‘sz Poly.termscs‡fdd„ˆj ¡DƒS)a Returns all coefficients from a univariate polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x - 1, x).all_coeffs() [1, 0, 2, -1] csg|]}ˆjj |¡‘qSrXrêr¯r¼rXrYr²³r³z#Poly.all_coeffs..)r]Ú all_coeffsr¼rXr¼rYrî¥szPoly.all_coeffscCs |j ¡S)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 )r]Ú all_monomsr¼rXrXrYrïµszPoly.all_monomscs‡fdd„ˆj ¡DƒS)a Returns all terms from a univariate polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x - 1, x).all_terms() [((3,), 1), ((2,), 0), ((1,), 2), ((0,), -1)] cs"g|]\}}|ˆjj |¡f‘qSrXrêrír¼rXrYr²×r³z"Poly.all_terms..)r]Ú all_termsr¼rXr¼rYrðÉszPoly.all_termscOsxi}| ¡D]L\}}|||ƒ}t|tƒr2|\}}n|}|r||vrL|||<qtd|ƒ‚q|j|g|pj|j¢Ri|¤Ž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)rÖrKÚtupler6r}rN)rSrWrNrnrÖr‰rŠrUrXrXrYÚtermwiseÙs ÿz Poly.termwisecCst| ¡ƒ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 )rsrÓr¼rXrXrYÚlengthþszPoly.lengthFcCs$|r|jj|dS|jj|dSdS)a Switch to a ``dict`` representation. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x*y**2 - y, x, y).as_dict() {(0, 1): -1, (1, 2): 2, (2, 0): 1} rãN)r]rºrw)rSrÒr¤rXrXrYrÓszPoly.as_dictcCs|r|j ¡S|j ¡SdS)z%Switch to a ``list`` representation. N)r]Zto_listZ to_sympy_list)rSrÒrXrXrYÚas_list!s zPoly.as_listc Gs˜|s |jSt|ƒdkr‚t|dtƒr‚|d}t|jƒ}| ¡D]B\}}z| |¡}Wn"tyvt d||fƒ‚Yq>0|||<q>t |j ¡g|¢RŽS)ar Convert a Poly instance to an Expr instance. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2 + 2*x*y**2 - y, x, y) >>> f.as_expr() x**2 + 2*x*y**2 - y >>> f.as_expr({x: 5}) 10*y**2 - y + 25 >>> f.as_expr(5, 6) 379 rqrrØ) rzrsrKrerhrNr†rËrÙr;r<r]rw)rSrNÚmappingr¡ÚvaluerËrXrXrYrQ(s ÿ zPoly.as_exprcOsFz,t|g|¢Ri|¤Ž}|js$WdS|WSWnty@YdS0dS)a{Converts ``self`` to a polynomial or returns ``None``. >>> from sympy import sin >>> from sympy.abc import x, y >>> print((x**2 + x*y).as_poly()) Poly(x**2 + x*y, x, y, domain='ZZ') >>> print((x**2 + x*y).as_poly(x, y)) Poly(x**2 + x*y, x, y, domain='ZZ') >>> print((x**2 + sin(y)).as_poly(x, y)) None N)rLrir6)ryrNrnÚpolyrXrXrYÚas_polyNs zPoly.as_polycCs,t|jdƒr|j ¡}n t|dƒ‚| |¡S)a Convert algebraic coefficients to rationals. Examples ======== >>> from sympy import Poly, I >>> from sympy.abc import x >>> Poly(x**2 + I*x + 1, x, extension=I).lift() Poly(x**4 + 3*x**2 + 1, x, domain='QQ') Úlift)ràr]rùr1r©rárXrXrYrùhs z Poly.liftcCs4t|jdƒr|j ¡\}}n t|dƒ‚|| |¡fS)a+ Reduce degree of ``f`` by mapping ``x_i**m`` to ``y_i``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**6*y**2 + x**3 + 1, x, y).deflate() ((3, 2), Poly(x**2*y + x + 1, x, y, domain='ZZ')) Údeflate)ràr]rúr1r©©rSrÈrUrXrXrYrú}s zPoly.deflatecCsz|jj}|jr|S|js$td|ƒ‚t|jdƒr@|jj|d}n t|dƒ‚|r\|j|j }n|j |j}|j |g|¢RŽS)a Inject ground domain generators into ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2*y + x*y**3 + x*y + 1, x) >>> f.inject() Poly(x**2*y + x*y**3 + x*y + 1, x, y, domain='ZZ') >>> f.inject(front=True) Poly(y**3*x + y*x**2 + y*x + 1, y, x, domain='ZZ') z Cannot inject generators over %sÚinject©Úfront)r]rÚis_Numericalrir2ràrür1r›rNru)rSrþrrUrNrXrXrYrü’s zPoly.injectcGsÂ|jj}|jstd|ƒ‚t|ƒ}|jd|…|krJ|j|d…d}}n4|j|d…|krv|jd|…d}}ntdƒ‚|j|Ž}t|jdƒr¦|jj ||d}n t |dƒ‚|j|g|¢RŽS)aŽ Eject selected generators into the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2*y + x*y**3 + x*y + 1, x, y) >>> f.eject(x) Poly(x*y**3 + (x**2 + x)*y + 1, y, domain='ZZ[x]') >>> f.eject(y) Poly(y*x**2 + (y**3 + y)*x + 1, x, domain='ZZ[y]') zCannot eject generators over %sNTFz'can only eject front or back generatorsÚejectrý)r]rrÿr2rsrNrbrüràrr1ru)rSrNrÚkZ_gensrþrUrXrXrYr·s ÿ z Poly.ejectcCs4t|jdƒr|j ¡\}}n t|dƒ‚|| |¡fS)a Remove GCD of terms from the polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**6*y**2 + x**3*y, x, y).terms_gcd() ((3, 1), Poly(x**3*y + 1, x, y, domain='ZZ')) Ú terms_gcd)ràr]rr1r©rûrXrXrYrás zPoly.terms_gcdcCs.t|jdƒr|j |¡}n t|dƒ‚| |¡S)zö Add an element of the ground domain to ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 1).add_ground(2) Poly(x + 3, x, domain='ZZ') Ú add_ground)ràr]rr1r©©rSrŠrUrXrXrYrös zPoly.add_groundcCs.t|jdƒr|j |¡}n t|dƒ‚| |¡S)zý Subtract an element of the ground domain from ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 1).sub_ground(2) Poly(x - 1, x, domain='ZZ') Ú sub_ground)ràr]rr1r©rrXrXrYrs zPoly.sub_groundcCs.t|jdƒr|j |¡}n t|dƒ‚| |¡S)zÿ Multiply ``f`` by a an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 1).mul_ground(2) Poly(2*x + 2, x, domain='ZZ') Ú mul_ground)ràr]rr1r©rrXrXrYr s zPoly.mul_groundcCs.t|jdƒr|j |¡}n t|dƒ‚| |¡S)aO Quotient of ``f`` by a an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x + 4).quo_ground(2) Poly(x + 2, x, domain='ZZ') >>> Poly(2*x + 3).quo_ground(2) Poly(x + 1, x, domain='ZZ') Ú quo_ground)ràr]rr1r©rrXrXrYr5s zPoly.quo_groundcCs.t|jdƒr|j |¡}n t|dƒ‚| |¡S)a£ Exact quotient of ``f`` by a an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x + 4).exquo_ground(2) Poly(x + 2, x, domain='ZZ') >>> Poly(2*x + 3).exquo_ground(2) Traceback (most recent call last): ... ExactQuotientFailed: 2 does not divide 3 in ZZ Úexquo_ground)ràr]rr1r©rrXrXrYrMs zPoly.exquo_groundcCs,t|jdƒr|j ¡}n t|dƒ‚| |¡S)zò Make all coefficients in ``f`` positive. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).abs() Poly(x**2 + 1, x, domain='ZZ') Úabs)ràr]r r1r©rárXrXrYr gs zPoly.abscCs,t|jdƒr|j ¡}n t|dƒ‚| |¡S)a4 Negate all coefficients in ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).neg() Poly(-x**2 + 1, x, domain='ZZ') >>> -Poly(x**2 - 1, x) Poly(-x**2 + 1, x, domain='ZZ') Úneg)ràr]r r1r©rárXrXrYr |s zPoly.negcCsTt|ƒ}|js| |¡S| |¡\}}}}t|jdƒrB| |¡}n t|dƒ‚||ƒS)a[ Add two polynomials ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).add(Poly(x - 2, x)) Poly(x**2 + x - 1, x, domain='ZZ') >>> Poly(x**2 + 1, x) + Poly(x - 2, x) Poly(x**2 + x - 1, x, domain='ZZ') rÚ)rrirr§ràr]rÚr1©rSrTr¨r©rªr«rUrXrXrYrÚ”s zPoly.addcCsTt|ƒ}|js| |¡S| |¡\}}}}t|jdƒrB| |¡}n t|dƒ‚||ƒS)a` Subtract two polynomials ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).sub(Poly(x - 2, x)) Poly(x**2 - x + 3, x, domain='ZZ') >>> Poly(x**2 + 1, x) - Poly(x - 2, x) Poly(x**2 - x + 3, x, domain='ZZ') Úsub)rrirr§ràr]rr1rrXrXrYr³s zPoly.subcCsTt|ƒ}|js| |¡S| |¡\}}}}t|jdƒrB| |¡}n t|dƒ‚||ƒS)ap Multiply two polynomials ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).mul(Poly(x - 2, x)) Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ') >>> Poly(x**2 + 1, x)*Poly(x - 2, x) Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ') r)rrirr§ràr]rr1rrXrXrYrÒs zPoly.mulcCs,t|jdƒr|j ¡}n t|dƒ‚| |¡S)a3 Square a polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x - 2, x).sqr() Poly(x**2 - 4*x + 4, x, domain='ZZ') >>> Poly(x - 2, x)**2 Poly(x**2 - 4*x + 4, x, domain='ZZ') Úsqr)ràr]r r1r©rárXrXrYr ñs zPoly.sqrcCs6t|ƒ}t|jdƒr"|j |¡}n t|dƒ‚| |¡S)aX Raise ``f`` to a non-negative power ``n``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x - 2, x).pow(3) Poly(x**3 - 6*x**2 + 12*x - 8, x, domain='ZZ') >>> Poly(x - 2, x)**3 Poly(x**3 - 6*x**2 + 12*x - 8, x, domain='ZZ') Úpow)rçràr]rr1r©©rSrérUrXrXrYr s zPoly.powcCsH| |¡\}}}}t|jdƒr.| |¡\}}n t|dƒ‚||ƒ||ƒfS)a# Polynomial pseudo-division of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).pdiv(Poly(2*x - 4, x)) (Poly(2*x + 4, x, domain='ZZ'), Poly(20, x, domain='ZZ')) Úpdiv)r§ràr]rr1)rSrTr¨r©rªr«ÚqÚrrXrXrYr#s z Poly.pdivcCs<| |¡\}}}}t|jdƒr*| |¡}n t|dƒ‚||ƒS)aN Polynomial pseudo-remainder of ``f`` by ``g``. Caveat: The function prem(f, g, x) can be safely used to compute in Z[x] _only_ subresultant polynomial remainder sequences (prs's). To safely compute Euclidean and Sturmian prs's in Z[x] employ anyone of the corresponding functions found in the module sympy.polys.subresultants_qq_zz. The functions in the module with suffix _pg compute prs's in Z[x] employing rem(f, g, x), whereas the functions with suffix _amv compute prs's in Z[x] employing rem_z(f, g, x). The function rem_z(f, g, x) differs from prem(f, g, x) in that to compute the remainder polynomials in Z[x] it premultiplies the divident times the absolute value of the leading coefficient of the divisor raised to the power degree(f, x) - degree(g, x) + 1. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).prem(Poly(2*x - 4, x)) Poly(20, x, domain='ZZ') Úprem)r§ràr]rr1rrXrXrYr:s z Poly.premcCs<| |¡\}}}}t|jdƒr*| |¡}n t|dƒ‚||ƒS)aœ Polynomial pseudo-quotient of ``f`` by ``g``. See the Caveat note in the function prem(f, g). Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).pquo(Poly(2*x - 4, x)) Poly(2*x + 4, x, domain='ZZ') >>> Poly(x**2 - 1, x).pquo(Poly(2*x - 2, x)) Poly(2*x + 2, x, domain='ZZ') Úpquo)r§ràr]rr1rrXrXrYras z Poly.pquoc Csz| |¡\}}}}t|jdƒrhz| |¡}Wqrtyd}z | | ¡| ¡¡‚WYd}~qrd}~00n t|dƒ‚||ƒS)a¼ Polynomial exact pseudo-quotient of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).pexquo(Poly(2*x - 2, x)) Poly(2*x + 2, x, domain='ZZ') >>> Poly(x**2 + 1, x).pexquo(Poly(2*x - 4, x)) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 ÚpexquoN)r§ràr]rr8rurQr1)rSrTr¨r©rªr«rUÚexcrXrXrYr}s, zPoly.pexquocCsª| |¡\}}}}d}|r<|jr<|js<| ¡| ¡}}d}t|jdƒrX| |¡\}} n t|dƒ‚|ršz| ¡| ¡} }Wnt yŽYn0| |}} ||ƒ|| ƒ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')) FTÚdiv) r§Úis_RingÚis_Fieldr‘ràr]rr1rßr3)rSrTÚautorr©rªr«rårrÚQÚRrXrXrYrœs zPoly.divc CsŠ| |¡\}}}}d}|r<|jr<|js<| ¡| ¡}}d}t|jdƒrT| |¡}n t|dƒ‚|r‚z| ¡}Wnt y€Yn0||ƒ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') FTÚrem) r§rrr‘ràr]rr1rßr3) rSrTrrr©rªr«rårrXrXrYrÃs zPoly.remc CsŠ| |¡\}}}}d}|r<|jr<|js<| ¡| ¡}}d}t|jdƒrT| |¡}n t|dƒ‚|r‚z| ¡}Wnt y€Yn0||ƒS)aa Computes polynomial quotient of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).quo(Poly(2*x - 4, x)) Poly(1/2*x + 1, x, domain='QQ') >>> Poly(x**2 - 1, x).quo(Poly(x - 1, x)) Poly(x + 1, x, domain='ZZ') FTÚquo) r§rrr‘ràr]rr1rßr3) rSrTrrr©rªr«rårrXrXrYrès zPoly.quoc CsÈ| |¡\}}}}d}|r<|jr<|js<| ¡| ¡}}d}t|jdƒr’z| |¡}WqœtyŽ} z | | ¡| ¡¡‚WYd} ~ qœd} ~ 00n t |dƒ‚|rÀz| ¡}Wnty¾Yn0||ƒ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 FTÚexquoN) r§rrr‘ràr]rr8rurQr1rßr3) rSrTrrr©rªr«rårrrXrXrYr s", z Poly.exquocCsŽt|tƒrXt|jƒ}||kr*|krDnn|dkr>||S|SqŠtd|||fƒ‚n2z|j t|ƒ¡WStyˆtd|ƒ‚Yn0dS)z3Returns level associated with the given generator. rz -%s <= gen < %s expected, got %sz"a valid generator expected, got %sN)rKrçrsrNr6rËrrÙ)rSr¡rórXrXrYrÔ7s ÿÿzPoly._gen_to_levelrcCs0| |¡}t|jdƒr"|j |¡St|dƒ‚dS)au Returns degree of ``f`` in ``x_j``. The degree of 0 is negative infinity. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + y*x + 1, x, y).degree() 2 >>> Poly(x**2 + y*x + y, x, y).degree(y) 1 >>> Poly(0, x).degree() -oo ÚdegreeN)rÔràr]r r1)rSr¡rÉrXrXrYr Ks zPoly.degreecCs$t|jdƒr|j ¡St|dƒ‚dS)zé Returns a list of degrees of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + y*x + 1, x, y).degree_list() (2, 1) Údegree_listN)ràr]r!r1r¼rXrXrYr!fs zPoly.degree_listcCs$t|jdƒr|j ¡St|dƒ‚dS)a Returns the total degree of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + y*x + 1, x, y).total_degree() 2 >>> Poly(x + y**5, x, y).total_degree() 5 Útotal_degreeN)ràr]r"r1r¼rXrXrYr"ys zPoly.total_degreecCs~t|tƒstdt|ƒƒ‚||jvr8|j |¡}|j}nt|jƒ}|j|f}t|jdƒrp|j |j |¡|dSt|dƒ‚dS)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Ú homogenizer¢Úhomogeneous_orderN)rKrÚ TypeErrorÚtyperNrËrsràr]r©r#r1)rSÚsrœrNrXrXrYr#Žs zPoly.homogenizecCs$t|jdƒr|j ¡St|dƒ‚dS)a- Returns the homogeneous order of ``f``. A homogeneous polynomial is a polynomial whose all monomials with non-zero coefficients have the same total degree. This degree is the homogeneous order of ``f``. If you only want to check if a polynomial is homogeneous, then use :func:`Poly.is_homogeneous`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**5 + 2*x**3*y**2 + 9*x*y**4) >>> f.homogeneous_order() 5 r$N)ràr]r$r1r¼rXrXrYr$°s zPoly.homogeneous_ordercCsF|dur| |¡dSt|jdƒr.|j ¡}n t|dƒ‚|jj |¡S)zâ Returns the leading coefficient of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(4*x**3 + 2*x**2 + 3*x, x).LC() 4 NrÚLC)r ràr]r(r1rrµ)rSr^rUrXrXrYr(És zPoly.LCcCs0t|jdƒr|j ¡}n t|dƒ‚|jj |¡S)zá Returns the trailing coefficient of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x**2 + 3*x, x).TC() 0 ÚTC)ràr]r)r1rrµrárXrXrYr)ás zPoly.TCcCs(t|jdƒr| |¡dSt|dƒ‚dS)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 r éÿÿÿÿÚECN)ràr]r r1rìrXrXrYr+öszPoly.ECcCs|jt||jƒjŽS)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,rNÚ exponents)rSr‰rXrXrYÚcoeff_monomial s#zPoly.coeff_monomialcGsVt|jdƒr>t|ƒt|jƒkr&tdƒ‚|jjttt|ƒƒŽ}n t |dƒ‚|jj |¡S)a. Returns the ``n``-th coefficient of ``f`` where ``N`` are the exponents of the generators in the term of interest. Examples ======== >>> from sympy import Poly, sqrt >>> from sympy.abc import x, y >>> Poly(x**3 + 2*x**2 + 3*x, x).nth(2) 2 >>> Poly(x**3 + 2*x*y**2 + y**2, x, y).nth(1, 2) 2 >>> Poly(4*sqrt(x)*y) Poly(4*y*(sqrt(x)), y, sqrt(x), domain='ZZ') >>> _.nth(1, 1) 4 See Also ======== coeff_monomial r,z,exponent of each generator must be specified)ràr]rsrNrÙr,rhr‹rçr1rrµ)rSÚNrUrXrXrYr,.s zPoly.nthrqcCstdƒ‚dS)NzyEither convert to Expr with `as_expr` method to use Expr's coeff method or else use the `coeff_monomial` method of Polys.©rb)rSrÌréÚrightrXrXrYrŠPsÿz Poly.coeffcCst| |¡d|jƒS)aƒ Returns the leading monomial of ``f``. The Leading monomial signifies the monomial having the highest power of the principal generator in the expression f. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).LM() x**2*y**0 r©r,r˜rNrìrXrXrYÚLM\szPoly.LMcCst| |¡d|jƒS)zû Returns the last non-zero monomial of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).EM() x**0*y**1 r*r2rìrXrXrYÚEMpszPoly.EMcCs"| |¡d\}}t||jƒ|fS)a— Returns the leading term of ``f``. The Leading term signifies the term having the highest power of the principal generator in the expression f along with its coefficient. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).LT() (x**2*y**0, 4) r©rÖr,rN©rSr^r‰rŠrXrXrYÚLT€szPoly.LTcCs"| |¡d\}}t||jƒ|fS)zü Returns the last non-zero term of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).ET() (x**0*y**1, 3) r*r5r6rXrXrYÚET•szPoly.ETcCs0t|jdƒr|j ¡}n t|dƒ‚|jj |¡S)z× Returns maximum norm of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(-x**2 + 2*x - 3, x).max_norm() 3 Úmax_norm)ràr]r9r1rrµrárXrXrYr9¦s z Poly.max_normcCs0t|jdƒr|j ¡}n t|dƒ‚|jj |¡S)zÑ Returns l1 norm of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(-x**2 + 2*x - 3, x).l1_norm() 6 Úl1_norm)ràr]r:r1rrµrárXrXrYr:»s zPoly.l1_normcCs|}|jjjstj|fS| ¡}|jr2|jj ¡}t|jdƒrN|j ¡\}}n t |dƒ‚| |¡| |¡}}|rx|js€||fS|| ¡fSdS)aƒ Clear denominators, but keep the ground domain. Examples ======== >>> from sympy import Poly, S, QQ >>> from sympy.abc import x >>> f = Poly(x/2 + S(1)/3, x, domain=QQ) >>> f.clear_denoms() (6, Poly(3*x + 2, x, domain='QQ')) >>> f.clear_denoms(convert=True) (6, Poly(3*x + 2, x, domain='ZZ')) Úclear_denomsN)r]rrrÚOner£Úhas_assoc_RingÚget_ringràr;r1rµr©rß)ryr‡rSrrŠrUrXrXrYr;Ðs zPoly.clear_denomscCsv|}| |¡\}}}}||ƒ}||ƒ}|jr2|js:||fS|jdd\}}|jdd\}}| |¡}| |¡}||fS)aš Clear denominators in a rational function ``f/g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2/y + 1, x) >>> g = Poly(x**3 + y, x) >>> p, q = f.rat_clear_denoms(g) >>> p Poly(x**2 + y, x, domain='ZZ[y]') >>> q Poly(y*x**3 + y**2, x, domain='ZZ[y]') T©r‡)r§rr=r;r)ryrTrSrr©ÚaÚbrXrXrYÚrat_clear_denoms÷s zPoly.rat_clear_denomscOs¢|}| dd¡r"|jjjr"| ¡}t|jdƒr”|sF| |jjdd¡S|j}|D]8}t|t ƒrh|\}}n |d}}| t |ƒ| |¡¡}qP| |¡St|dƒ‚dS)a‚ Computes indefinite integral of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x + 1, x).integrate() Poly(1/3*x**3 + x**2 + x, x, domain='QQ') >>> Poly(x*y**2 + x, x, y).integrate((0, 1), (1, 0)) Poly(1/2*x**2*y**2 + 1/2*x**2, x, y, domain='QQ') rTÚ integraterq©rèN) Úgetr]rrr‘ràr©rCrKrñrçrÔr1)ryÚspecsrnrSr]Úspecr¡rèrXrXrYrC s zPoly.integratecOs¢| dd¡s"t|g|¢Ri|¤ŽSt|jdƒr”|sF| |jjdd¡S|j}|D]8}t|tƒrh|\}}n |d}}| t|ƒ| |¡¡}qP| |¡St |dƒ‚dS)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') ÚevaluateTÚdiffrqrDN)rErràr]r©rIrKrñrçrÔr1)rSrFrÐr]rGr¡rèrXrXrYrIF s z Poly.diffc CsP|}|duršt|tƒr<|}| ¡D]\}}| ||¡}q"|St|ttfƒrŽ|}t|ƒt|jƒkrhtdƒ‚t |j|ƒD]\}}| ||¡}qt|Sd|} }n | |¡} t|jdƒsºt |dƒ‚z|j || ¡} Wntty@|sötd||jjfƒ‚nFt|gƒ\}\}| ¡ ||j¡}| |¡}| ||¡}|j || ¡} Yn0|j| | dS)aÁ Evaluate ``f`` at ``a`` in the given variable. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(x**2 + 2*x + 3, x).eval(2) 11 >>> Poly(2*x*y + 3*x + y + 2, x, y).eval(x, 2) Poly(5*y + 8, y, domain='ZZ') >>> f = Poly(2*x*y + 3*x + y + 2*z, x, y, z) >>> f.eval({x: 2}) Poly(5*y + 2*z + 6, y, z, domain='ZZ') >>> f.eval({x: 2, y: 5}) Poly(2*z + 31, z, domain='ZZ') >>> f.eval({x: 2, y: 5, z: 7}) 45 >>> f.eval((2, 5)) Poly(2*z + 31, z, domain='ZZ') >>> f(2, 5) Poly(2*z + 31, z, domain='ZZ') Nztoo many values providedrrÂzCannot evaluate at %s in %s©r·)rKrer†rÂrñrhrsrNrÙr»rÔràr]r1r3r2rr%r£Zunify_with_symbolsrr‡r©) ryrÌr@rrSrõr¡röÚvaluesrÉrUZa_domainZ new_domainrXrXrYrÂn s: z Poly.evalcGs | |¡S)az Evaluate ``f`` at the give values. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> f = Poly(2*x*y + 3*x + y + 2*z, x, y, z) >>> f(2) Poly(5*y + 2*z + 6, y, z, domain='ZZ') >>> f(2, 5) Poly(2*z + 31, z, domain='ZZ') >>> f(2, 5, 7) 45 )rÂ)rSrKrXrXrYÚ__call__¹ sz Poly.__call__c Csd| |¡\}}}}|r.|jr.| ¡| ¡}}t|jdƒrJ| |¡\}}n t|dƒ‚||ƒ||ƒfS)aÑ Half extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15 >>> g = x**3 + x**2 - 4*x - 4 >>> Poly(f).half_gcdex(Poly(g)) (Poly(-1/5*x + 3/5, x, domain='QQ'), Poly(x + 1, x, domain='QQ')) Ú half_gcdex)r§rr‘ràr]rMr1) rSrTrrr©rªr«r'ÚhrXrXrYrMÏ s zPoly.half_gcdexc Csl| |¡\}}}}|r.|jr.| ¡| ¡}}t|jdƒrL| |¡\}}} n t|dƒ‚||ƒ||ƒ|| ƒfS)a Extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15 >>> g = x**3 + x**2 - 4*x - 4 >>> Poly(f).gcdex(Poly(g)) (Poly(-1/5*x + 3/5, x, domain='QQ'), Poly(1/5*x**2 - 6/5*x + 2, x, domain='QQ'), Poly(x + 1, x, domain='QQ')) Úgcdex)r§rr‘ràr]rOr1) rSrTrrr©rªr«r'ÚtrNrXrXrYrOî s z Poly.gcdexcCsX| |¡\}}}}|r.|jr.| ¡| ¡}}t|jdƒrF| |¡}n t|dƒ‚||ƒS)a’ Invert ``f`` modulo ``g`` when possible. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).invert(Poly(2*x - 1, x)) Poly(-4/3, x, domain='QQ') >>> Poly(x**2 - 1, x).invert(Poly(x - 1, x)) Traceback (most recent call last): ... NotInvertible: zero divisor Úinvert)r§rr‘ràr]rQr1)rSrTrrr©rªr«rUrXrXrYrQ s zPoly.invertcCs2t|jdƒr|j t|ƒ¡}n t|dƒ‚| |¡S)ad Compute ``f**(-1)`` mod ``x**n``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(1, x).revert(2) Poly(1, x, domain='ZZ') >>> Poly(1 + x, x).revert(1) Poly(1, x, domain='ZZ') >>> Poly(x**2 - 2, x).revert(2) Traceback (most recent call last): ... NotReversible: only units are reversible in a ring >>> Poly(1/x, x).revert(1) Traceback (most recent call last): ... PolynomialError: 1/x contains an element of the generators set Úrevert)ràr]rRrçr1r©rrXrXrYrR. s zPoly.revertcCsB| |¡\}}}}t|jdƒr*| |¡}n t|dƒ‚tt||ƒƒ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)r§ràr]rSr1rhr‹rrXrXrYrSP s zPoly.subresultantsc Csv| |¡\}}}}t|jdƒrB|r6|j||d\}}qL| |¡}n t|dƒ‚|rj||ddtt||ƒƒfS||ddS)a‘ Computes the resultant of ``f`` and ``g`` via PRS. If includePRS=True, it includes the subresultant PRS in the result. Because the PRS is used to calculate the resultant, this is more efficient than calling :func:`subresultants` separately. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**2 + 1, x) >>> f.resultant(Poly(x**2 - 1, x)) 4 >>> f.resultant(Poly(x**2 - 1, x), includePRS=True) (4, [Poly(x**2 + 1, x, domain='ZZ'), Poly(x**2 - 1, x, domain='ZZ'), Poly(-2, x, domain='ZZ')]) Ú resultant©Ú includePRSrrJ)r§ràr]rTr1rhr‹) rSrTrVr¨r©rªr«rUrrXrXrYrTi s zPoly.resultantcCs0t|jdƒr|j ¡}n t|dƒ‚|j|ddS)zà Computes the discriminant of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 2*x + 3, x).discriminant() -8 ÚdiscriminantrrJ)ràr]rWr1r©rárXrXrYrWŽ s zPoly.discriminantcCsddlm}|||ƒS)aCompute the *dispersion set* of two polynomials. For two polynomials `f(x)` and `g(x)` with `\deg f > 0` and `\deg g > 0` the dispersion set `\operatorname{J}(f, g)` is defined as: .. math:: \operatorname{J}(f, g) & := \{a \in \mathbb{N}_0 | \gcd(f(x), g(x+a)) \neq 1\} \\ & = \{a \in \mathbb{N}_0 | \deg \gcd(f(x), g(x+a)) \geq 1\} For a single polynomial one defines `\operatorname{J}(f) := \operatorname{J}(f, f)`. Examples ======== >>> from sympy import poly >>> from sympy.polys.dispersion import dispersion, dispersionset >>> from sympy.abc import x Dispersion set and dispersion of a simple polynomial: >>> fp = poly((x - 3)*(x + 3), x) >>> sorted(dispersionset(fp)) [0, 6] >>> dispersion(fp) 6 Note that the definition of the dispersion is not symmetric: >>> fp = poly(x**4 - 3*x**2 + 1, x) >>> gp = fp.shift(-3) >>> sorted(dispersionset(fp, gp)) [2, 3, 4] >>> dispersion(fp, gp) 4 >>> sorted(dispersionset(gp, fp)) [] >>> dispersion(gp, fp) -oo Computing the dispersion also works over field extensions: >>> from sympy import sqrt >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ') >>> sorted(dispersionset(fp, gp)) [2] >>> sorted(dispersionset(gp, fp)) [1, 4] We can even perform the computations for polynomials having symbolic coefficients: >>> from sympy.abc import a >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x) >>> sorted(dispersionset(fp)) [0, 1] See Also ======== dispersion References ========== 1. [ManWright94]_ 2. [Koepf98]_ 3. [Abramov71]_ 4. [Man93]_ r)Ú dispersionset)Úsympy.polys.dispersionrX)rSrTrXrXrXrYrX£ sHzPoly.dispersionsetcCsddlm}|||ƒS)aïCompute 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)rYrZ)rSrTrZrXrXrYrZî sHzPoly.dispersionc CsP| |¡\}}}}t|jdƒr0| |¡\}}}n t|dƒ‚||ƒ||ƒ||ƒfS)a# Returns the GCD of ``f`` and ``g`` and their cofactors. Returns polynomials ``(h, cff, cfg)`` such that ``h = gcd(f, g)``, and ``cff = quo(f, h)`` and ``cfg = quo(g, h)`` are, so called, cofactors of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).cofactors(Poly(x**2 - 3*x + 2, x)) (Poly(x - 1, x, domain='ZZ'), Poly(x + 1, x, domain='ZZ'), Poly(x - 2, x, domain='ZZ')) Ú cofactors)r§ràr]r[r1) rSrTr¨r©rªr«rNÚcffÚcfgrXrXrYr[9s zPoly.cofactorscCs<| |¡\}}}}t|jdƒr*| |¡}n t|dƒ‚||ƒS)a Returns the polynomial GCD of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).gcd(Poly(x**2 - 3*x + 2, x)) Poly(x - 1, x, domain='ZZ') Úgcd)r§ràr]r^r1rrXrXrYr^Vs zPoly.gcdcCs<| |¡\}}}}t|jdƒr*| |¡}n t|dƒ‚||ƒS)a Returns polynomial LCM of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).lcm(Poly(x**2 - 3*x + 2, x)) Poly(x**3 - 2*x**2 - x + 2, x, domain='ZZ') Úlcm)r§ràr]r_r1rrXrXrYr_ms zPoly.lcmcCs<|jj |¡}t|jdƒr(|j |¡}n t|dƒ‚| |¡S)a Reduce ``f`` modulo a constant ``p``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**3 + 3*x**2 + 5*x + 7, x).trunc(3) Poly(-x**3 - x + 1, x, domain='ZZ') Útrunc)r]rr‡ràr`r1r©)rSÚprUrXrXrYr`„s z Poly.trunccCsF|}|r|jjjr| ¡}t|jdƒr2|j ¡}n t|dƒ‚| |¡S)az Divides all coefficients by ``LC(f)``. Examples ======== >>> from sympy import Poly, ZZ >>> from sympy.abc import x >>> Poly(3*x**2 + 6*x + 9, x, domain=ZZ).monic() Poly(x**2 + 2*x + 3, x, domain='QQ') >>> Poly(3*x**2 + 4*x + 2, x, domain=ZZ).monic() Poly(x**2 + 4/3*x + 2/3, x, domain='QQ') Úmonic)r]rrr‘ràrbr1r©©ryrrSrUrXrXrYrb›s z Poly.moniccCs0t|jdƒr|j ¡}n t|dƒ‚|jj |¡S)zå Returns the GCD of polynomial coefficients. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(6*x**2 + 8*x + 12, x).content() 2 Úcontent)ràr]rdr1rrµrárXrXrYrd¸s zPoly.contentcCs>t|jdƒr|j ¡\}}n t|dƒ‚|jj |¡| |¡fS)a Returns the content and a primitive form of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**2 + 8*x + 12, x).primitive() (2, Poly(x**2 + 4*x + 6, x, domain='ZZ')) Ú primitive)ràr]rer1rrµr©)rSÚcontrUrXrXrYreÍs zPoly.primitivecCs<| |¡\}}}}t|jdƒr*| |¡}n t|dƒ‚||ƒS)a Computes the functional composition of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + x, x).compose(Poly(x - 1, x)) Poly(x**2 - x, x, domain='ZZ') Úcompose)r§ràr]rgr1rrXrXrYrgâs zPoly.composecCs2t|jdƒr|j ¡}n t|dƒ‚tt|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)ràr]rhr1rhr‹r©rárXrXrYrhùs zPoly.decomposecCs.t|jdƒr|j |¡}n t|dƒ‚| |¡S)a Efficiently compute Taylor shift ``f(x + a)``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 2*x + 1, x).shift(2) Poly(x**2 + 2*x + 1, x, domain='ZZ') Úshift)ràr]rir1r©)rSr@rUrXrXrYris z Poly.shiftcCs^| |¡\}}| |¡\}}| |¡\}}t|jdƒrJ|j |j|j¡}n t|dƒ‚| |¡S)a3 Efficiently evaluate the functional transformation ``q**n * f(p/q)``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 2*x + 1, x).transform(Poly(x + 1, x), Poly(x - 1, x)) Poly(4, x, domain='ZZ') Ú transform)r¬ràr]rjr1r©)rSrarÚPrrªrUrXrXrYrj#s zPoly.transformcCsL|}|r|jjjr| ¡}t|jdƒr2|j ¡}n t|dƒ‚tt|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) r]rrr‘ràrlr1rhr‹r©rcrXrXrYrl=s z Poly.sturmcs4tˆjdƒrˆj ¡}n tˆdƒ‚‡fdd„|DƒS)aI Computes greatest factorial factorization of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**5 + 2*x**4 - x**3 - 2*x**2 >>> Poly(f).gff_list() [(Poly(x, x, domain='ZZ'), 1), (Poly(x + 2, x, domain='ZZ'), 4)] Úgff_listcsg|]\}}ˆ |¡|f‘qSrX©r©©r°rTrr¼rXrYr²or³z!Poly.gff_list..)ràr]rmr1rárXr¼rYrmZs z Poly.gff_listcCs,t|jdƒr|j ¡}n t|dƒ‚| |¡S)a¿ Computes the product, ``Norm(f)``, of the conjugates of a polynomial ``f`` defined over a number field ``K``. Examples ======== >>> from sympy import Poly, sqrt >>> from sympy.abc import x >>> a, b = sqrt(2), sqrt(3) A polynomial over a quadratic extension. Two conjugates x - a and x + a. >>> f = Poly(x - a, x, extension=a) >>> f.norm() Poly(x**2 - 2, x, domain='QQ') A polynomial over a quartic extension. Four conjugates x - a, x - a, x + a and x + a. >>> f = Poly(x - a, x, extension=(a, b)) >>> f.norm() Poly(x**4 - 4*x**2 + 4, x, domain='QQ') Únorm)ràr]rpr1r©)rSrrXrXrYrpqs z Poly.normcCs>t|jdƒr|j ¡\}}}n t|dƒ‚|| |¡| |¡fS)af Computes square-free norm of ``f``. Returns ``s``, ``f``, ``r``, such that ``g(x) = f(x-sa)`` and ``r(x) = Norm(g(x))`` is a square-free polynomial over ``K``, where ``a`` is the algebraic extension of the ground domain. Examples ======== >>> from sympy import Poly, sqrt >>> from sympy.abc import x >>> s, f, r = Poly(x**2 + 1, x, extension=[sqrt(3)]).sqf_norm() >>> s 1 >>> f Poly(x**2 - 2*sqrt(3)*x + 4, x, domain='QQ') >>> r Poly(x**4 - 4*x**2 + 16, x, domain='QQ') Úsqf_norm)ràr]rqr1r©)rSr'rTrrXrXrYrq”s z Poly.sqf_normcCs,t|jdƒr|j ¡}n t|dƒ‚| |¡S)zü Computes square-free part of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 - 3*x - 2, x).sqf_part() Poly(x**2 - x - 2, x, domain='ZZ') Úsqf_part)ràr]rrr1r©rárXrXrYrr³s z Poly.sqf_partcsHtˆjdƒrˆj |¡\}}n tˆdƒ‚ˆjj |¡‡fdd„|DƒfS)a Returns a list of square-free factors of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = 2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16 >>> Poly(f).sqf_list() (2, [(Poly(x + 1, x, domain='ZZ'), 2), (Poly(x + 2, x, domain='ZZ'), 3)]) >>> Poly(f).sqf_list(all=True) (2, [(Poly(1, x, domain='ZZ'), 1), (Poly(x + 1, x, domain='ZZ'), 2), (Poly(x + 2, x, domain='ZZ'), 3)]) Úsqf_listcsg|]\}}ˆ |¡|f‘qSrXrnror¼rXrYr²ãr³z!Poly.sqf_list..)ràr]rsr1rrµ)rSÚallrŠÚfactorsrXr¼rYrsÈs z Poly.sqf_listcs6tˆjdƒrˆj |¡}n tˆdƒ‚‡fdd„|DƒS)a‰ Returns a list of square-free factors of ``f``. Examples ======== >>> from sympy import Poly, expand >>> from sympy.abc import x >>> f = expand(2*(x + 1)**3*x**4) >>> f 2*x**7 + 6*x**6 + 6*x**5 + 2*x**4 >>> Poly(f).sqf_list_include() [(Poly(2, x, domain='ZZ'), 1), (Poly(x + 1, x, domain='ZZ'), 3), (Poly(x, x, domain='ZZ'), 4)] >>> Poly(f).sqf_list_include(all=True) [(Poly(2, x, domain='ZZ'), 1), (Poly(1, x, domain='ZZ'), 2), (Poly(x + 1, x, domain='ZZ'), 3), (Poly(x, x, domain='ZZ'), 4)] Úsqf_list_includecsg|]\}}ˆ |¡|f‘qSrXrnror¼rXrYr² r³z)Poly.sqf_list_include..)ràr]rvr1)rSrtrurXr¼rYrvås zPoly.sqf_list_includecsntˆjdƒrDzˆj ¡\}}WqNty@tjˆdfgfYS0n tˆdƒ‚ˆjj |¡‡fdd„|DƒfS)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_listrqcsg|]\}}ˆ |¡|f‘qSrXrnror¼rXrYr² r³z$Poly.factor_list..) ràr]rwr2rr<r1rrµ)rSrŠrurXr¼rYrw s zPoly.factor_listcsVtˆjdƒr:zˆj ¡}WqDty6ˆdfgYS0n tˆdƒ‚‡fdd„|DƒS)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_includerqcsg|]\}}ˆ |¡|f‘qSrXrnror¼rXrYr²: r³z,Poly.factor_list_include..)ràr]rxr2r1)rSrurXr¼rYrx! s zPoly.factor_list_includecCs |dur"t |¡}|dkr"tdƒ‚|dur4t |¡}|durFt |¡}t|jdƒrl|jj||||||d}n t|dƒ‚|rÀdd„}|s”tt||ƒƒSdd „} |\} }tt|| ƒƒtt| |ƒƒfSd d„}|sÚtt||ƒƒSdd „} |\} }tt|| ƒƒtt| |ƒƒfSdS)aÑ Compute isolating intervals for roots of ``f``. For real roots the Vincent-Akritas-Strzebonski (VAS) continued fractions method is used. References ========== .. [#] Alkiviadis G. Akritas and Adam W. Strzebonski: A Comparative Study of Two Real Root Isolation Methods . Nonlinear Analysis: Modelling and Control, Vol. 10, No. 4, 297-304, 2005. .. [#] Alkiviadis G. Akritas, Adam W. Strzebonski and Panagiotis S. Vigklas: Improving the Performance of the Continued Fractions Method Using new Bounds of Positive Roots. Nonlinear Analysis: Modelling and Control, Vol. 13, No. 3, 265-279, 2008. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 3, x).intervals() [((-2, -1), 1), ((1, 2), 1)] >>> Poly(x**2 - 3, x).intervals(eps=1e-2) [((-26/15, -19/11), 1), ((19/11, 26/15), 1)] Nrú!'eps' must be a positive rationalÚ intervals©rtÚepsÚinfÚsupÚfastÚsqfcSs|\}}t |¡t |¡fSrv©r'rµ)Úintervalr'rPrXrXrYÚ_realh szPoly.intervals.._realcSs@|\\}}\}}t |¡tt |¡t |¡tt |¡fSrv©r'rµr)Ú rectangleÚuÚvr'rPrXrXrYÚ_complexo sÿz Poly.intervals.._complexcSs$|\\}}}t |¡t |¡f|fSrvr)r‚r'rPrrXrXrYrƒx scSsH|\\\}}\}}}t |¡tt |¡t |¡tt |¡f|fSrvr„)r…r†r‡r'rPrrXrXrYrˆ sÿÿ) r'r‡rÙràr]rzr1rhr‹)rSrtr|r}r~rr€rUrƒrˆZ real_partZcomplex_partrXrXrYrz< s4 ÿ zPoly.intervalsc Cs®|r|jstdƒ‚t |¡t |¡}}|durJt |¡}|dkrJtdƒ‚|dur\t|ƒ}n|durhd}t|jdƒr|jj|||||d\}}n t |dƒ‚t |¡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 supportedNrryrqÚrefine_root)r|Ústepsr)Úis_sqfr6r'r‡rÙrçràr]r‰r1rµ) rSr'rPr|rŠrÚ check_sqfrÚTrXrXrYr‰ˆ s zPoly.refine_rootcCsLd\}}|dur^t|ƒ}|tjur(d}n6| ¡\}}|sDt |¡}ntttj||fƒƒd}}|dur´t|ƒ}|tjur~d}n6| ¡\}}|sšt |¡}ntttj||fƒƒd}}|ræ|ræt |j dƒrÚ|j j||d}n t|dƒ‚n^|r|dur|tj f}|r|dur|tj f}t |j dƒr:|j j||d}n t|dƒ‚t|ƒS)a< Return the number of roots of ``f`` in ``[inf, sup]`` interval. Examples ======== >>> from sympy import Poly, I >>> from sympy.abc import x >>> Poly(x**4 - 4, x).count_roots(-3, 3) 2 >>> Poly(x**4 - 4, x).count_roots(0, 1 + 3*I) 1 )TTNFÚcount_real_roots©r}r~Úcount_complex_roots)rrÚNegativeInfinityÚas_real_imagr'r‡rhr‹ÚInfinityràr]rŽr1r¤rr)rSr}r~Zinf_realZsup_realÚreZimÚcountrXrXrYÚ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)ÚsympyÚpolysÚrootoftoolsZrootof)rSrËr˜rXrXrYÚrootì sz Poly.rootcCs,tjjjj||d}|r|St|ddSdS)aL Return a list of real roots with multiplicities. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**3 - 7*x**2 + 4*x + 4).real_roots() [-1/2, 2, 2] >>> Poly(x**3 + x + 1).real_roots() [CRootOf(x**3 + x + 1, 0)] r—F©ÚmultipleN)r™ršr›ÚCRootOfÚ real_rootsrD)rSržr˜ZrealsrXrXrYr szPoly.real_rootscCs,tjjjj||d}|r|St|ddSdS)aœ Return a list of real and complex roots with multiplicities. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**3 - 7*x**2 + 4*x + 4).all_roots() [-1/2, 2, 2] >>> Poly(x**3 + x + 1).all_roots() [CRootOf(x**3 + x + 1, 0), CRootOf(x**3 + x + 1, 1), CRootOf(x**3 + x + 1, 2)] r—FrN)r™ršr›rŸÚ all_rootsrD)rSržr˜ÚrootsrXrXrYr¡ szPoly.all_rootséé2cs¼ddlm‰|jrtd|ƒ‚| ¡dkr.gS|jjturNdd„| ¡Dƒ}nŠ|jjt urŒdd„| ¡Dƒ}t |Ž‰‡fdd„| ¡Dƒ}nL‡fdd„| ¡Dƒ}zd d„|Dƒ}Wn"tyÖtd |jjƒ‚Yn0t jj}ˆt j_zÄz>t j|||d| ¡dd }tttt|‡fdd„dƒƒ}Wnxty z>t j|||d| ¡dd }tttt|‡fdd„dƒƒ}Wn$tyštdˆ|fƒ‚Yn0Yn0W|t j_n |t j_0|S)aš Compute numerical approximations of roots of ``f``. Parameters ========== n ... the number of digits to calculate maxsteps ... the maximum number of iterations to do If the accuracy `n` cannot be reached in `maxsteps`, it will raise an exception. You need to rerun with higher maxsteps. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 3).nroots(n=15) [-1.73205080756888, 1.73205080756888] >>> Poly(x**2 - 3).nroots(n=30) [-1.73205080756887729352744634151, 1.73205080756887729352744634151] r©Úsignz$Cannot compute numerical roots of %scSsg|]}t|ƒ‘qSrX©rç©r°rŠrXrXrYr²^r³zPoly.nroots..cSsg|] }|j‘qSrX)rr¨rXrXrYr²`r³csg|]}t|ˆƒ‘qSrXr§r¨)ÚfacrXrYr²br³csg|]}|jˆd ¡‘qS)©ré)rr’r¨rªrXrYr²dsÿcSsg|]}tj|Ž‘qSrX)ÚmpmathZmpcr¨rXrXrYr²gr³z!Numerical domain expected, got %sFé )ÚmaxstepsÚcleanupÚerrorZ extrapreccs$|jr dnd|jt|jƒˆ|jƒfS©Nrqr©ÚimagÚrealr ©rr¥rXrYÚxr³zPoly.nroots..©Úkeyr£cs$|jr dnd|jt|jƒˆ|jƒfSr°r±r´r¥rXrYrµr³z7convergence to root failed; try n < %s or maxsteps > %s)Z$sympy.functions.elementary.complexesr¦Úis_multivariater7r r]rr(rîr'rr%r2r«ÚmpÚdpsZ polyrootsrhr‹rÚsortedrJ)rSrérr®r Zdenomsrºr¢rX)r©rér¦rYÚnroots9s^ÿ ÿÿÿÿ ÿÿ ÿÿzPoly.nrootscCsP|jrtd|ƒ‚i}| ¡dD](\}}|jr"| ¡\}}||||<q"|S)a Compute roots of ``f`` by factorization in the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**6 - 4*x**4 + 4*x**3 - x**2).ground_roots() {0: 2, 1: 2} z!Cannot compute ground roots of %srq)r¸r7rwÚ is_linearrî)rSr¢Úfactorrr@rArXrXrYÚground_roots‰sÿzPoly.ground_rootscCsr|jrtdƒ‚t|ƒ}|jr.|dkr.t|ƒ}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 polynomialrqz&'n' must an integer and n >= 1, got %srP)r¸r7rÚ is_IntegerrçrÙr¡rrTrŒrMrÃ)rSrér/rÌrPrrXrXrYÚnth_power_roots_poly¤sÿ zPoly.nth_power_roots_polycs¢|jrtdƒ‚|j ¡}|j ¡ |¡}|d}td|diƒ\}}}}t|ƒ}|d|d‰‡fdd„} | |ƒ| |ƒ} }| j |j d| j |j d|kS)a° Decide whether two roots of this polynomial are equal. Examples ======== >>> from sympy import Poly, cyclotomic_poly, exp, I, pi >>> f = Poly(cyclotomic_poly(5)) >>> r0 = exp(2*I*pi/5) >>> indices = [i for i, r in enumerate(f.all_roots()) if f.same_root(r, r0)] >>> print(indices) [3] Raises ====== DomainError If the domain of the polynomial is not :ref:`ZZ`, :ref:`QQ`, :ref:`RR`, or :ref:`CC`. MultivariatePolynomialError If the polynomial is not univariate. PolynomialError If the polynomial is of degree < 2. zMust be a univariate polynomialé rqécstt|ˆdƒS)NrD)rr©rÌrDrXrYrµör³z Poly.same_root..)r¸r7r]Zmignotte_sep_bound_squaredr…Ú get_fieldrµrrr³r²)rSr@rAZdom_delta_sqZdelta_sqZeps_sqrr¨réZevÚAÚBrXrDrYÚ same_rootÌsÿ zPoly.same_rootcCs| |¡\}}}}t|dƒr,|j||d}n t|dƒ‚|s~|jrH| ¡}|\}} } }| |¡}| | ¡} || || ƒ||ƒfStt||ƒƒSdS)aÐ Cancel common factors in a rational function ``f/g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**2 - 2, x).cancel(Poly(x**2 - 2*x + 1, x)) (1, Poly(2*x + 2, x, domain='ZZ'), Poly(x - 1, x, domain='ZZ')) >>> Poly(2*x**2 - 2, x).cancel(Poly(x**2 - 2*x + 1, x), include=True) (Poly(2*x + 2, x, domain='ZZ'), Poly(x - 1, x, domain='ZZ')) Úcancel)ÚincludeN) r§ràrÉr1r=r>rµrñr‹)rSrTrÊrr©rªr«rUÚcpÚcqrarrXrXrYrÉÿs zPoly.cancelcCs|jjS)a Returns ``True`` if ``f`` is a zero polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(0, x).is_zero True >>> Poly(1, x).is_zero False )r]Úis_zeror¼rXrXrYrÍ$szPoly.is_zerocCs|jjS)a Returns ``True`` if ``f`` is a unit polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(0, x).is_one False >>> Poly(1, x).is_one True )r]Úis_oner¼rXrXrYrÎ7szPoly.is_onecCs|jjS)a Returns ``True`` if ``f`` is a square-free polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 2*x + 1, x).is_sqf False >>> Poly(x**2 - 1, x).is_sqf True )r]r‹r¼rXrXrYr‹JszPoly.is_sqfcCs|jjS)a Returns ``True`` if the leading coefficient of ``f`` is one. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 2, x).is_monic True >>> Poly(2*x + 2, x).is_monic False )r]Úis_monicr¼rXrXrYrÏ]sz Poly.is_moniccCs|jjS)a; Returns ``True`` if GCD of the coefficients of ``f`` is one. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**2 + 6*x + 12, x).is_primitive False >>> Poly(x**2 + 3*x + 6, x).is_primitive True )r]Úis_primitiver¼rXrXrYrÐpszPoly.is_primitivecCs|jjS)aJ Returns ``True`` if ``f`` is an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x, x).is_ground False >>> Poly(2, x).is_ground True >>> Poly(y, x).is_ground True )r]Ú is_groundr¼rXrXrYrÑƒszPoly.is_groundcCs|jjS)a, Returns ``True`` if ``f`` is linear in all its variables. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x + y + 2, x, y).is_linear True >>> Poly(x*y + 2, x, y).is_linear False )r]r½r¼rXrXrYr½˜szPoly.is_linearcCs|jjS)a6 Returns ``True`` if ``f`` is quadratic in all its variables. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x*y + 2, x, y).is_quadratic True >>> Poly(x*y**2 + 2, x, y).is_quadratic False )r]Úis_quadraticr¼rXrXrYrÒ«szPoly.is_quadraticcCs|jjS)a% Returns ``True`` if ``f`` is zero or has only one term. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(3*x**2, x).is_monomial True >>> Poly(3*x**2 + 1, x).is_monomial False )r]Úis_monomialr¼rXrXrYrÓ¾szPoly.is_monomialcCs|jjS)aZ Returns ``True`` if ``f`` is a homogeneous polynomial. A homogeneous polynomial is a polynomial whose all monomials with non-zero coefficients have the same total degree. If you want not only to check if a polynomial is homogeneous but also compute its homogeneous order, then use :func:`Poly.homogeneous_order`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + x*y, x, y).is_homogeneous True >>> Poly(x**3 + x*y, x, y).is_homogeneous False )r]Úis_homogeneousr¼rXrXrYrÔÑszPoly.is_homogeneouscCs|jjS)aG Returns ``True`` if ``f`` has no factors over its domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + x + 1, x, modulus=2).is_irreducible True >>> Poly(x**2 + 1, x, modulus=2).is_irreducible False )r]Úis_irreducibler¼rXrXrYrÕészPoly.is_irreduciblecCst|jƒdkS)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 rq©rsrNr¼rXrXrYrÊüszPoly.is_univariatecCst|jƒdkS)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 rqrÖr¼rXrXrYr¸szPoly.is_multivariatecCs|jjS)a“ Returns ``True`` if ``f`` is a cyclotomic polnomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**16 + x**14 - x**10 + x**8 - x**6 + x**2 + 1 >>> Poly(f).is_cyclotomic False >>> g = x**16 + x**14 - x**10 - x**8 - x**6 + x**2 + 1 >>> Poly(g).is_cyclotomic True )r]Ú is_cyclotomicr¼rXrXrYr×*szPoly.is_cyclotomiccCs| ¡Srv)r r¼rXrXrYÚ__abs__BszPoly.__abs__cCs| ¡Srv)r r¼rXrXrYÚ__neg__EszPoly.__neg__cCs | |¡Srv©rÚ©rSrTrXrXrYÚ__add__HszPoly.__add__cCs | |¡SrvrÚrÛrXrXrYÚ__radd__Lsz Poly.__radd__cCs | |¡Srv©rrÛrXrXrYÚ__sub__PszPoly.__sub__cCs | |¡SrvrÞrÛrXrXrYÚ__rsub__Tsz Poly.__rsub__cCs | |¡SrvrrÛrXrXrYÚ__mul__XszPoly.__mul__cCs | |¡SrvrrÛrXrXrYÚ__rmul__\sz Poly.__rmul__récCs |jr|dkr| |¡StSdS)Nr)rÀrrO)rSrérXrXrYÚ__pow__`s zPoly.__pow__cCs | |¡Srv©rrÛrXrXrYÚ __divmod__gszPoly.__divmod__cCs | |¡SrvrärÛrXrXrYÚ__rdivmod__kszPoly.__rdivmod__cCs | |¡Srv©rrÛrXrXrYÚ__mod__oszPoly.__mod__cCs | |¡SrvrçrÛrXrXrYÚ__rmod__ssz Poly.__rmod__cCs | |¡Srv©rrÛrXrXrYÚ__floordiv__wszPoly.__floordiv__cCs | |¡SrvrêrÛrXrXrYÚ __rfloordiv__{szPoly.__rfloordiv__rTcCs| ¡| ¡Srv©rQrÛrXrXrYÚ__truediv__szPoly.__truediv__cCs| ¡| ¡SrvrírÛrXrXrYÚ__rtruediv__ƒszPoly.__rtruediv__Úotherc Csv||}}|jsFz|j||j| ¡d}WntttfyDYdS0|j|jkrVdS|jj|jjkrjdS|j|jkS©NräF) rirŒrNr£r6r2r3r]r)ryrðrSrTrXrXrYÚ__eq__‡s zPoly.__eq__cCs ||kSrvrXrÛrXrXrYÚ__ne__™szPoly.__ne__cCs|jSrv)rÍr¼rXrXrYÚ__bool__sz Poly.__bool__cCs|s||kS| t|ƒ¡SdSrv)Ú _strict_eqr©rSrTÚstrictrXrXrYÚeq szPoly.eqcCs|j||dS)N©r÷)rørörXrXrYÚne¦szPoly.necCs*t||jƒo(|j|jko(|jj|jddS©NTrù)rKrŒrNr]rørÛrXrXrYrõ©szPoly._strict_eq)NN)N)N)N)N)N)N)FF)F)F)T)T)T)T)r)N)N)rqF)N)N)N)N)F)NT)T)T)T)F)N)N)T)T)F)F)FNNNFF)NNFF)NN)T)TT)TT)r£r¤T)F)F)F)ÂrRÚ __module__Ú__qualname__Ú__doc__Ú __slots__Úis_commutativeriZ_op_priorityrpÚclassmethodruÚpropertyrzrnr{r}rrrMrfrgrjrkrcr•r™ršr¡r…r¤r¥r¦r¬r§r©rr£r¿rÀrÆr_rÃrÏrr×rÞrßr‘rârårær r˜rÖrîrïrðròrórÓrôrQrørùrúrürrrrrrrr r rÚrrr rrrrrrrrrrÔr r!r"r#r$r(r)r+r.r,rŠr3r4r7r8r9r:r;rBrCrIZ_eval_derivativerÂrLrMrOrQrRrSrTrWrXrZr[r^r_r`rbrdrergrhrirjrlrmrprqrrrsrvrwrxrzr‰r–rœr r¡r¼r¿rÁrÈrÉrÍrÎr‹rÏrÐrÑr½rÒrÓrÔrÕrÊr¸r×rØrÙr[rÜrÝrßràrárârrOrãrårærèrérërìrîrïròrórôrørúrõÚ __classcell__rXrXr–rYrLdsÖ5 3 #$"%&%*''%%*"%"''(&K!"%KK #!L%?P(3% rLcsVeZdZdZdd„Z‡fdd„Zedd„ƒZede ƒd d „ƒZ dd„Zd d„Z‡Z S)ÚPurePolyz)Class for representing pure polynomials. cCs|jfS)z$Allow SymPy to hash Poly instances. )r]rxrXrXrYr{±szPurePoly._hashable_contentcs tƒ ¡Srvr“rxr–rXrYr•µszPurePoly.__hash__cCs|jS)aR Free symbols of a polynomial. Examples ======== >>> from sympy import PurePoly >>> from sympy.abc import x, y >>> PurePoly(x**2 + 1).free_symbols set() >>> PurePoly(x**2 + y).free_symbols set() >>> PurePoly(x**2 + y, x).free_symbols {y} )ršrxrXrXrYr™¸szPurePoly.free_symbolsrðc Cs¾||}}|jsFz|j||j| ¡d}WntttfyDYdS0t|jƒt|jƒkr^dS|jj |jj kr²z|jj |jj |j¡}WntyœYdS0| |¡}| |¡}|j|jkSrñ) rirŒrNr£r6r2r3rsr]rr¬r4r)ryrðrSrTrrXrXrYròÍs zPurePoly.__eq__cCst||jƒo|jj|jddSrû)rKrŒr]rørÛrXrXrYrõåszPurePoly._strict_eqcsþt|ƒ}|jsZz(|jj|j|j|j |jj |¡¡fWStyXtd||fƒ‚Yn0t|j ƒt|j ƒkr~td||fƒ‚t |jtƒr–t |jtƒs¦td||fƒ‚|j‰|j }|jj |jj|¡}|j |¡}|j |¡}||df‡fdd„ }||||fS)NrcsD|dur2|d|…||dd…}|s2| |¡Sˆj|g|¢RŽSr’r´r¶r¸rXrYr©ÿs zPurePoly._unify..per)rrir]rr©r¹r3r4rsrNrKr.rŒr¬r‡)rSrTrNrrªr«r©rXr¸rYr§ès"( zPurePoly._unify)rRrürýrþr{r•rr™rrOròrõr§rrXrXr–rYrs rcOst ||¡}t||ƒSr‚)r`raÚ_poly_from_expr©rzrNrnrorXrXrYÚpoly_from_exprsrcCs|t|ƒ}}t|tƒs&t|||ƒ‚nJ|jrb|j ||¡}|j|_|j|_|j durZd|_ ||fS|j rp| ¡}t||ƒ\}}|jst|||ƒ‚tt t| ¡ƒŽƒ\}}|j}|durÊt||d\|_}ntt|j|ƒƒ}ttt ||ƒƒƒ}t ||¡}|j dur d|_ ||fS)rƒNTr„F)rrKr r9rirŒrjrNr…ršÚexpandr@rhr»r†r%r‹r¹rerLrf)rzroÚorigr÷r]r˜r r…rXrXrYrs2 rcOst ||¡}t||ƒS)ú(Construct polynomials from expressions. )r`raÚ_parallel_poly_from_expr)ÚexprsrNrnrorXrXrYÚparallel_poly_from_expr:sr cCs–ddlm}t|ƒdkrŠ|\}}t|tƒrŠt|tƒrŠ|j ||¡}|j ||¡}| |¡\}}|j|_|j |_ |j dur~d|_ ||g|fSt|ƒg}}gg}}d}t|ƒD]T\} } t | ƒ} t| tƒrô| jrÚ| | ¡qø| | ¡|jrø| ¡} nd}| | ¡q®|rt|||dƒ‚|r:|D]} || ¡|| <q"t||ƒ\}}|js^t|||dƒ‚|jD]}t||ƒrdtdƒ‚qdgg} }g}g}|D]@}ttt| ¡ƒŽƒ\}}| |¡| |¡| t|ƒ¡q–|j }|durüt| |d\|_ } ntt|j| ƒƒ} |D]$}| | d|…¡| |d…} qg}t||ƒD]2\}}ttt||ƒƒƒ}t ||¡}| |¡qD|j durŽt|ƒ|_ ||fS) r r©Ú PiecewiserÃNTFz&Piecewise generators do not make senser„)Ú$sympy.functions.elementary.piecewiserrsrKrLrŒrjr¬rNr…ršrhrÛrr rirÇrr9rQrAr6r»r†Úextendr%r‹r¹rerfÚbool)rrorrSrTZorigsZ_exprsZ_polysÚfailedrœrzÚrepsrZcoeffs_listÚlengthsrïrîr]r˜r r…ršr÷rXrXrYrAsv rcCst|ƒ}||vr|||<|S)z7Add a new ``(key, value)`` pair to arguments ``dict``. )re)rnr·rörXrXrYÚ_update_args srcCsút|dd}t|ddj}|jr0|}| ¡j}n*|j}|sZ|rLt|ƒ\}}nt||ƒ\}}|rn|rhtjStjS|s¤|jr’||jvr’t| ¡ƒ\}}||jvrØtjSn4|jsØt |j ƒdkrØttd|t t|j ƒƒ|fƒƒ‚| |¡}t|tƒrôt|ƒ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 Trùrqz¾ 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_NumberrirQrrÚZeror‘rNrsr™r%rFÚnextrr rKrçr)rSr¡Z gen_is_NumraZisNumr¨rUrXrXrYr ªs. ü r cGsHt|ƒ}|jr| ¡}|jr"d}n|jr2|p0|j}t||ƒ ¡}t|ƒS)aÂ Return the total_degree of ``f`` in the given variables. Examples ======== >>> from sympy import total_degree, Poly >>> from sympy.abc import x, y >>> total_degree(1) 0 >>> total_degree(x + x*y) 2 >>> total_degree(x + x*y, x) 1 If the expression is a Poly and no variables are given then the generators of the Poly will be used: >>> p = Poly(x + x*y, y) >>> total_degree(p) 1 To deal with the underlying expression of the Poly, convert it to an Expr: >>> total_degree(p.as_expr()) 2 This is done automatically if any variables are given: >>> total_degree(p, x) 1 See also ======== degree r)rrirQrrNrLr"r)rSrNraÚrvrXrXrYr"ås( r"c Ostt |dg¡zt|g|¢Ri|¤Ž\}}Wn0ty\}ztdd|ƒ‚WYd}~n d}~00| ¡}ttt|ƒƒS)zÓ Return a list of degrees of ``f`` in all variables. Examples ======== >>> from sympy import degree_list >>> from sympy.abc import x, y >>> degree_list(x**2 + y*x + 1) (2, 1) ršr!rqN) r`Ú allowed_flagsrr9r:r!rñr‹r)rSrNrnrªrorÚdegreesrXrXrYr!s"r!c Oslt |dg¡zt|g|¢Ri|¤Ž\}}Wn0ty\}ztdd|ƒ‚WYd}~n d}~00|j|jdS)zÀ Return the leading coefficient of ``f``. Examples ======== >>> from sympy import LC >>> from sympy.abc import x, y >>> LC(4*x**2 + 2*x*y**2 + x*y + 3*y) 4 ršr(rqNrë)r`rrr9r:r(r^©rSrNrnrªrorrXrXrYr(5s"r(c Ostt |dg¡zt|g|¢Ri|¤Ž\}}Wn0ty\}ztdd|ƒ‚WYd}~n d}~00|j|jd}| ¡S)zÀ Return the leading monomial of ``f``. Examples ======== >>> from sympy import LM >>> from sympy.abc import x, y >>> LM(4*x**2 + 2*x*y**2 + x*y + 3*y) x**2 ršr3rqNrë)r`rrr9r:r3r^rQ)rSrNrnrªrorr‰rXrXrYr3Ns"r3c Os|t |dg¡zt|g|¢Ri|¤Ž\}}Wn0ty\}ztdd|ƒ‚WYd}~n d}~00|j|jd\}}|| ¡S)z¾ Return the leading term of ``f``. Examples ======== >>> from sympy import LT >>> from sympy.abc import x, y >>> LT(4*x**2 + 2*x*y**2 + x*y + 3*y) 4*x**2 ršr7rqNrë)r`rrr9r:r7r^rQ)rSrNrnrªrorr‰rŠrXrXrYr7hs"r7c Os–t |dg¡z&t||fg|¢Ri|¤Ž\\}}}Wn0tyd}ztdd|ƒ‚WYd}~n d}~00| |¡\}} |jsŠ| ¡| ¡fS|| fSdS)zÏ Compute polynomial pseudo-division of ``f`` and ``g``. Examples ======== >>> from sympy import pdiv >>> from sympy.abc import x >>> pdiv(x**2 + 1, 2*x - 4) (2*x + 4, 20) ršrrÃN)r`rr r9r:rršrQ© rSrTrNrnrªr«rorrrrXrXrYr‚s&"rc Os†t |dg¡z&t||fg|¢Ri|¤Ž\\}}}Wn0tyd}ztdd|ƒ‚WYd}~n d}~00| |¡}|js~| ¡S|SdS)zÅ Compute polynomial pseudo-remainder of ``f`` and ``g``. Examples ======== >>> from sympy import prem >>> from sympy.abc import x >>> prem(x**2 + 1, 2*x - 4) 20 ršrrÃN)r`rr r9r:rršrQ© rSrTrNrnrªr«rorrrXrXrYr s&" rc Os¨t |dg¡z&t||fg|¢Ri|¤Ž\\}}}Wn0tyd}ztdd|ƒ‚WYd}~n d}~00z| |¡}Wntyt||ƒ‚Yn0|js | ¡S|SdS)zõ Compute polynomial pseudo-quotient of ``f`` and ``g``. Examples ======== >>> from sympy import pquo >>> from sympy.abc import x >>> pquo(x**2 + 1, 2*x - 4) 2*x + 4 >>> pquo(x**2 - 1, 2*x - 1) 2*x + 1 ršrrÃN) r`rr r9r:rr8ršrQ© rSrTrNrnrªr«rorrrXrXrYr¾s&"rc Os†t |dg¡z&t||fg|¢Ri|¤Ž\\}}}Wn0tyd}ztdd|ƒ‚WYd}~n d}~00| |¡}|js~| ¡S|SdS)a_ Compute polynomial exact pseudo-quotient of ``f`` and ``g``. Examples ======== >>> from sympy import pexquo >>> from sympy.abc import x >>> pexquo(x**2 - 1, 2*x - 2) 2*x + 2 >>> pexquo(x**2 + 1, 2*x - 4) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 ršrrÃN)r`rr r9r:rršrQr rXrXrYrás&" rc Osžt |ddg¡z&t||fg|¢Ri|¤Ž\\}}}Wn0tyf}ztdd|ƒ‚WYd}~n d}~00|j||jd\}} |js’| ¡| ¡fS|| fSdS)a Compute polynomial division of ``f`` and ``g``. Examples ======== >>> from sympy import div, ZZ, QQ >>> from sympy.abc import x >>> div(x**2 + 1, 2*x - 4, domain=ZZ) (0, x**2 + 1) >>> div(x**2 + 1, 2*x - 4, domain=QQ) (x/2 + 1, 5) rršrrÃN©r) r`rr r9r:rrršrQrrXrXrYrs&"rc OsŽt |ddg¡z&t||fg|¢Ri|¤Ž\\}}}Wn0tyf}ztdd|ƒ‚WYd}~n d}~00|j||jd}|js†| ¡S|SdS)a Compute polynomial remainder of ``f`` and ``g``. Examples ======== >>> from sympy import rem, ZZ, QQ >>> from sympy.abc import x >>> rem(x**2 + 1, 2*x - 4, domain=ZZ) x**2 + 1 >>> rem(x**2 + 1, 2*x - 4, domain=QQ) 5 rršrrÃNr!) r`rr r9r:rrršrQrrXrXrYr$s&"rc OsŽt |ddg¡z&t||fg|¢Ri|¤Ž\\}}}Wn0tyf}ztdd|ƒ‚WYd}~n d}~00|j||jd}|js†| ¡S|SdS)zç Compute polynomial quotient of ``f`` and ``g``. Examples ======== >>> from sympy import quo >>> from sympy.abc import x >>> quo(x**2 + 1, 2*x - 4) x/2 + 1 >>> quo(x**2 - 1, x - 1) x + 1 rršrrÃNr!) r`rr r9r:rrršrQr rXrXrYrDs&"rc OsŽt |ddg¡z&t||fg|¢Ri|¤Ž\\}}}Wn0tyf}ztdd|ƒ‚WYd}~n d}~00|j||jd}|js†| ¡S|SdS)aQ Compute polynomial exact quotient of ``f`` and ``g``. Examples ======== >>> from sympy import exquo >>> from sympy.abc import x >>> exquo(x**2 - 1, x - 1) x + 1 >>> exquo(x**2 + 1, 2*x - 4) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 rršrrÃNr!) r`rr r9r:rrršrQr rXrXrYrds&"rc Osøt |ddg¡z&t||fg|¢Ri|¤Ž\\}}}WnŠtyÀ}zrt|jƒ\}\} } z| | | ¡\}}WntyŠtdd|ƒ‚Yn"0| |¡| |¡fWYd}~SWYd}~n d}~00|j||j d\}}|jsì| ¡| ¡fS||fSdS)aT Half extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``. Examples ======== >>> from sympy import half_gcdex >>> from sympy.abc import x >>> half_gcdex(x**4 - 2*x**3 - 6*x**2 + 12*x + 15, x**3 + x**2 - 4*x - 4) (3/5 - x/5, x + 1) rršrMrÃNr!) r`rr r9r%rrMrbr:rµrršrQ) rSrTrNrnrªr«rorr…r@rAr'rNrXrXrYrM‡s&6rMcOst |ddg¡z&t||fg|¢Ri|¤Ž\\}}}Wn”tyÊ}z|t|jƒ\}\} } z| | | ¡\}}} WntyŒtdd|ƒ‚Yn*0| |¡| |¡| | ¡fWYd}~SWYd}~n d}~00|j||j d\}}} |js| ¡| ¡| ¡fS||| fSdS)aZ Extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``. Examples ======== >>> from sympy import gcdex >>> from sympy.abc import x >>> gcdex(x**4 - 2*x**3 - 6*x**2 + 12*x + 15, x**3 + x**2 - 4*x - 4) (3/5 - x/5, x**2/5 - 6*x/5 + 2, x + 1) rršrOrÃNr!) r`rr r9r%rrOrbr:rµrršrQ)rSrTrNrnrªr«rorr…r@rAr'rPrNrXrXrYrO®s&>rOcOsÔt |ddg¡z&t||fg|¢Ri|¤Ž\\}}}Wnvty¬}z^t|jƒ\}\} } z | | | | ¡¡WWYd}~Sty–t dd|ƒ‚Yn0WYd}~n d}~00|j||j d}|jsÌ| ¡S|SdS)a Invert ``f`` modulo ``g`` when possible. Examples ======== >>> from sympy import invert, S, mod_inverse >>> from sympy.abc import x >>> invert(x**2 - 1, 2*x - 1) -4/3 >>> invert(x**2 - 1, x - 1) Traceback (most recent call last): ... NotInvertible: zero divisor For more efficient inversion of Rationals, use the :obj:`~.mod_inverse` function: >>> mod_inverse(3, 5) 2 >>> (S(2)/5).invert(S(7)/3) 5/2 See Also ======== sympy.core.numbers.mod_inverse rršNrQrÃr!) r`rr r9r%rrµrQrbr:rršrQ)rSrTrNrnrªr«rorr…r@rArNrXrXrYrQÕs!& (rQc OsŒt |dg¡z&t||fg|¢Ri|¤Ž\\}}}Wn0tyd}ztdd|ƒ‚WYd}~n d}~00| |¡}|js„dd„|DƒS|SdS)zã Compute subresultant PRS of ``f`` and ``g``. Examples ======== >>> from sympy import subresultants >>> from sympy.abc import x >>> subresultants(x**2 + 1, x**2 - 1) [x**2 + 1, x**2 - 1, -2] ršrSrÃNcSsg|]}| ¡‘qSrXrí©r°rrXrXrYr²#r³z!subresultants..)r`rr r9r:rSrš© rSrTrNrnrªr«rorrUrXrXrYrS s&" rSFrUc OsÄt |dg¡z&t||fg|¢Ri|¤Ž\\}}}Wn0tyd}ztdd|ƒ‚WYd}~n d}~00|r~|j||d\} } n | |¡} |js°|r¨| ¡dd„| DƒfS| ¡S|r¼| | fS| SdS)z½ Compute resultant of ``f`` and ``g``. Examples ======== >>> from sympy import resultant >>> from sympy.abc import x >>> resultant(x**2 + 1, x**2 - 1) 4 ršrTrÃNrUcSsg|]}| ¡‘qSrXrír"rXrXrYr²Er³zresultant..)r`rr r9r:rTršrQ)rSrTrVrNrnrªr«rorrUrrXrXrYrT(s&" rTc Os|t |dg¡zt|g|¢Ri|¤Ž\}}Wn0ty\}ztdd|ƒ‚WYd}~n d}~00| ¡}|jst| ¡S|SdS)z¹ Compute discriminant of ``f``. Examples ======== >>> from sympy import discriminant >>> from sympy.abc import x >>> discriminant(x**2 + 2*x + 3) -8 ršrWrqN)r`rrr9r:rWršrQ©rSrNrnrªrorrUrXrXrYrWMs"rWcOst |dg¡z&t||fg|¢Ri|¤Ž\\}}}Wn”tyÈ}z|t|jƒ\}\} } z| | | ¡\}}} WntyŠtdd|ƒ‚Yn*0| |¡| |¡| | ¡fWYd}~SWYd}~n d}~00| |¡\}}} |j sö| ¡| ¡| ¡fS||| fSdS)a Compute GCD and cofactors of ``f`` and ``g``. Returns polynomials ``(h, cff, cfg)`` such that ``h = gcd(f, g)``, and ``cff = quo(f, h)`` and ``cfg = quo(g, h)`` are, so called, cofactors of ``f`` and ``g``. Examples ======== >>> from sympy import cofactors >>> from sympy.abc import x >>> cofactors(x**2 - 1, x**2 - 3*x + 2) (x - 1, x + 1, x - 2) ršr[rÃN)r`rr r9r%rr[rbr:rµršrQ)rSrTrNrnrªr«rorr…r@rArNr\r]rXrXrYr[ks&>r[c s¤t|ƒ}‡‡fdd„}||ƒ}|dur*|St ˆdg¡zžt|gˆ¢Riˆ¤Ž\}}t|ƒdkrÔtdd„|DƒƒrÔ|d‰‡fd d „|dd…Dƒ}tdd„|DƒƒrÔd}|D]} t|| ¡dƒ}q®tˆ|ƒWSWnZt y0} z@|| j ƒ}|dur|WYd} ~ Std t|ƒ| ƒ‚WYd} ~ n d} ~ 00|sR|jsFt jStd|dS|d|dd…}}|D]}| |¡}|jrlqŒql|jsœ| ¡S|SdS)zÑ Compute GCD of a list of polynomials. Examples ======== >>> from sympy import gcd_list >>> from sympy.abc import x >>> gcd_list([x**3 - 1, x**2 - 1, x**2 - 3*x + 2]) x - 1 cslˆshˆsht|ƒ\}}|s|jS|jrh|d|dd…}}|D]}| ||¡}| |¡r>q^q>| |¡SdS©Nrrq)r%r¤rÿr^rÎrµ©Úseqr…ZnumbersrUÚnumber©rnrNrXrYÚtry_non_polynomial_gcd¥s z(gcd_list..try_non_polynomial_gcdNršrqcss|]}|jo|jVqdSrv©Úis_algebraicÚ is_irrational©r°rÝrXrXrYÚ Ãr³zgcd_list..r*csg|]}ˆ| ¡‘qSrX©Úratsimpr.©r@rXrYr²År³zgcd_list..css|]}|jVqdSrv©Úis_rational©r°ÚfrcrXrXrYr/Ær³rÚgcd_listr„)rr`rr rsrtr_Úas_numer_denomr r9rr:ršrrrLr^rÎrQ)r'rNrnr*rUršroÚlstÚlcr6rr÷rX©r@rnrNrYr7”sB & r7c Osft|dƒr2|dur|f|}t|g|¢Ri|¤ŽS|durBtdƒ‚t |dg¡zxt||fg|¢Ri|¤Ž\\}}}tt||fƒ\}}|jrÆ|j rÆ|jrÆ|j rÆ|| ¡} | jrÆt|| ¡dƒWSWnztyB} z`t| jƒ\}\}}z | | ||¡¡WWYd} ~ Sty,tdd| ƒ‚Yn0WYd} ~ n d} ~ 00| |¡}|js^| ¡S|SdS)zµ Compute GCD of ``f`` and ``g``. Examples ======== >>> from sympy import gcd >>> from sympy.abc import x >>> gcd(x**2 - 1, x**2 - 3*x + 2) x - 1 Ú__iter__Nz2gcd() takes 2 arguments or a sequence of argumentsršrr^rÃ)ràr7r%r`rr r‹rr,r-r1r4r r8r9r%rrµr^rbr:ršrQ© rSrTrNrnrªr«ror@rAr6rr…rUrXrXrYr^és0 " ( r^c s’t|ƒ}‡‡fdd„}||ƒ}|dur*|St ˆdg¡zšt|gˆ¢Riˆ¤Ž\}}t|ƒdkrÐtdd„|DƒƒrÐ|d‰‡fd d „|dd…Dƒ}tdd„|DƒƒrÐd}|D]} t|| ¡dƒ}q®ˆ|WSWnZty,} z@|| j ƒ}|dur|WYd} ~ St dt|ƒ| ƒ‚WYd} ~ n d} ~ 00|sN|jsBtj Std|d S|d|dd…}}|D]}| |¡}qh|jsŠ| ¡S|SdS)zï Compute LCM of a list of polynomials. Examples ======== >>> from sympy import lcm_list >>> from sympy.abc import x >>> lcm_list([x**3 - 1, x**2 - 1, x**2 - 3*x + 2]) x**5 - x**4 - 2*x**3 - x**2 + x + 2 cs^ˆsZˆsZt|ƒ\}}|s|jS|jrZ|d|dd…}}|D]}| ||¡}q>| |¡SdSr%)r%r¥rÿr_rµr&r)rXrYÚtry_non_polynomial_lcm.s z(lcm_list..try_non_polynomial_lcmNršrqcss|]}|jo|jVqdSrvr+r.rXrXrYr/Ir³zlcm_list..r*csg|]}ˆ| ¡‘qSrXr0r.r2rXrYr²Kr³zlcm_list..css|]}|jVqdSrvr3r5rXrXrYr/Lr³Úlcm_listr„r)rr`rr rsrtr_r8r9rr:ršrr<rLrQ)r'rNrnr>rUršror9r:r6rr÷rXr;rYr?s> &r?c Osbt|dƒr2|dur|f|}t|g|¢Ri|¤ŽS|durBtdƒ‚t |dg¡ztt||fg|¢Ri|¤Ž\\}}}tt||fƒ\}}|jrÂ|j rÂ|jrÂ|j rÂ|| ¡} | jrÂ|| ¡dWSWnzt y>} z`t| jƒ\}\}}z | | ||¡¡WWYd} ~ Sty(tdd| ƒ‚Yn0WYd} ~ n d} ~ 00| |¡}|jsZ| ¡S|SdS)zÅ Compute LCM of ``f`` and ``g``. Examples ======== >>> from sympy import lcm >>> from sympy.abc import x >>> lcm(x**2 - 1, x**2 - 3*x + 2) x**3 - 2*x**2 - x + 2 r<Nz2lcm() takes 2 arguments or a sequence of argumentsršrqr_rÃ)ràr?r%r`rr r‹rr,r-r1r4r8r9r%rrµr_rbr:ršrQr=rXrXrYr_ks0 " ( r_c sæt|ƒ}t|tƒr2t‡‡fdd„|j|jfDƒŽSt|tƒrJtd|fƒ‚t|tƒrZ|jr^|Sˆ dd¡r®|j ‡‡fdd„|jDƒŽ}ˆ d¡dˆd<t |gˆ¢Riˆ¤ŽSˆ d d ¡}t ˆdg¡zt|gˆ¢Riˆ¤Ž\}}Wn,ty}z|jWYd}~Sd}~00| ¡\} }|jjrd|jjrD|jd d \} }| ¡\}}|jjrj|| }ntj}tdd„t|j| ƒDƒŽ}|dkr¢tj}|dkr¢|S|rºt||| ¡ƒSt|| ¡dd ¡\}}t|||ddS)az Remove GCD of terms from ``f``. If the ``deep`` flag is True, then the arguments of ``f`` will have terms_gcd applied to them. If a fraction is factored out of ``f`` and ``f`` is an Add, then an unevaluated Mul will be returned so that automatic simplification does not redistribute it. The hint ``clear``, when set to False, can be used to prevent such factoring when all coefficients are not fractions. Examples ======== >>> from sympy import terms_gcd, cos >>> from sympy.abc import x, y >>> terms_gcd(x**6*y**2 + x**3*y, x, y) x**3*y*(x**3*y + 1) The default action of polys routines is to expand the expression given to them. terms_gcd follows this behavior: >>> terms_gcd((3+3*x)*(x+x*y)) 3*x*(x*y + x + y + 1) If this is not desired then the hint ``expand`` can be set to False. In this case the expression will be treated as though it were comprised of one or more terms: >>> terms_gcd((3+3*x)*(x+x*y), expand=False) (3*x + 3)*(x*y + x) In order to traverse factors of a Mul or the arguments of other functions, the ``deep`` hint can be used: >>> terms_gcd((3 + 3*x)*(x + x*y), expand=False, deep=True) 3*x*(x + 1)*(y + 1) >>> terms_gcd(cos(x + x*y), deep=True) cos(x*(y + 1)) Rationals are factored out by default: >>> terms_gcd(x + y/2) (2*x + y)/2 Only the y-term had a coefficient that was a fraction; if one does not want to factor out the 1/2 in cases like this, the flag ``clear`` can be set to False: >>> terms_gcd(x + y/2, clear=False) x + y/2 >>> terms_gcd(x*y/2 + y**2, clear=False) y*(x/2 + y) The ``clear`` flag is ignored if all coefficients are fractions: >>> terms_gcd(x/3 + y/2, clear=False) (2*x + 3*y)/6 See Also ======== sympy.core.exprtools.gcd_terms, sympy.core.exprtools.factor_terms c3s$|]}t|gˆ¢Riˆ¤ŽVqdSrv©r)r°r'r)rXrYr/är³zterms_gcd..z5Inequalities cannot be used with terms_gcd. Found: %sÚdeepFcs"g|]}t|gˆ¢Riˆ¤Ž‘qSrXr@)r°r@r)rXrYr²ìr³zterms_gcd..rÚclearTršNr?cSsg|]\}}||‘qSrXrX)r°rÌrÉrXrXrYr²r³rq)rB) rrKrÚlhsÚrhsrr%rÚis_AtomrErWrnÚpoprr`rrr9rzr…rrr;rerr<rr»rNrrQZas_coeff_Mul) rSrNrnr rurBrªrorrÈÚdenomrŠÚtermrXr)rYržsFC rc Os„t |ddg¡zt|g|¢Ri|¤Ž\}}Wn0ty^}ztdd|ƒ‚WYd}~n d}~00| t|ƒ¡}|js|| ¡S|SdS)zË Reduce ``f`` modulo a constant ``p``. Examples ======== >>> from sympy import trunc >>> from sympy.abc import x >>> trunc(2*x**3 + 3*x**2 + 5*x + 7, 3) -x**3 - x + 1 rršr`rqN) r`rrr9r:r`rršrQ)rSrarNrnrªrorrUrXrXrYr`s"r`c Os„t |ddg¡zt|g|¢Ri|¤Ž\}}Wn0ty^}ztdd|ƒ‚WYd}~n d}~00|j|jd}|js|| ¡S|SdS)zÍ Divide all coefficients of ``f`` by ``LC(f)``. Examples ======== >>> from sympy import monic >>> from sympy.abc import x >>> monic(3*x**2 + 4*x + 2) x**2 + 4*x/3 + 2/3 rršrbrqNr!) r`rrr9r:rbrršrQr$rXrXrYrb2s"rbc Osft |dg¡zt|g|¢Ri|¤Ž\}}Wn0ty\}ztdd|ƒ‚WYd}~n d}~00| ¡S)z¸ Compute GCD of coefficients of ``f``. Examples ======== >>> from sympy import content >>> from sympy.abc import x >>> content(6*x**2 + 8*x + 12) 2 ršrdrqN)r`rrr9r:rdrrXrXrYrdPs"rdc Osˆt |dg¡zt|g|¢Ri|¤Ž\}}Wn0ty\}ztdd|ƒ‚WYd}~n d}~00| ¡\}}|js||| ¡fS||fSdS)a• Compute content and the primitive form of ``f``. Examples ======== >>> from sympy.polys.polytools import primitive >>> from sympy.abc import x >>> primitive(6*x**2 + 8*x + 12) (2, 3*x**2 + 4*x + 6) >>> eq = (2 + 2*x)*x + 2 Expansion is performed by default: >>> primitive(eq) (2, x**2 + x + 1) Set ``expand`` to False to shut this off. Note that the extraction will not be recursive; use the as_content_primitive method for recursive, non-destructive Rational extraction. >>> primitive(eq, expand=False) (1, x*(2*x + 2) + 2) >>> eq.as_content_primitive() (2, x*(x + 1) + 1) ršrerqN)r`rrr9r:reršrQ)rSrNrnrªrorrfrUrXrXrYreis "rec Os†t |dg¡z&t||fg|¢Ri|¤Ž\\}}}Wn0tyd}ztdd|ƒ‚WYd}~n d}~00| |¡}|js~| ¡S|SdS)zÀ Compute functional composition ``f(g)``. Examples ======== >>> from sympy import compose >>> from sympy.abc import x >>> compose(x**2 + x, x - 1) x**2 - x ršrgrÃN)r`rr r9r:rgršrQr#rXrXrYrg—s&" rgc Os‚t |dg¡zt|g|¢Ri|¤Ž\}}Wn0ty\}ztdd|ƒ‚WYd}~n d}~00| ¡}|jszdd„|DƒS|SdS)zÜ Compute functional decomposition of ``f``. Examples ======== >>> from sympy import decompose >>> from sympy.abc import x >>> decompose(x**4 + 2*x**3 - x - 1) [x**2 - x - 1, x**2 + x] ršrhrqNcSsg|]}| ¡‘qSrXrír"rXrXrYr²Îr³zdecompose..)r`rrr9r:rhršr$rXrXrYrhµs"rhc OsŠt |ddg¡zt|g|¢Ri|¤Ž\}}Wn0ty^}ztdd|ƒ‚WYd}~n d}~00|j|jd}|js‚dd„|DƒS|SdS) zò Compute Sturm sequence of ``f``. Examples ======== >>> from sympy import sturm >>> from sympy.abc import x >>> sturm(x**3 - 2*x**2 + x - 3) [x**3 - 2*x**2 + x - 3, 3*x**2 - 4*x + 1, 2*x/9 + 25/9, -2079/4] rršrlrqNr!cSsg|]}| ¡‘qSrXrír"rXrXrYr²ìr³zsturm..)r`rrr9r:rlrršr$rXrXrYrlÓs"rlc Os‚t |dg¡zt|g|¢Ri|¤Ž\}}Wn0ty\}ztdd|ƒ‚WYd}~n d}~00| ¡}|jszdd„|DƒS|SdS)a& Compute a list of greatest factorial factors of ``f``. Note that the input to ff() and rf() should be Poly instances to use the definitions here. Examples ======== >>> from sympy import gff_list, ff, Poly >>> from sympy.abc import x >>> f = Poly(x**5 + 2*x**4 - x**3 - 2*x**2, x) >>> gff_list(f) [(Poly(x, x, domain='ZZ'), 1), (Poly(x + 2, x, domain='ZZ'), 4)] >>> (ff(Poly(x), 1)*ff(Poly(x + 2), 4)) == f True >>> f = Poly(x**12 + 6*x**11 - 11*x**10 - 56*x**9 + 220*x**8 + 208*x**7 - 1401*x**6 + 1090*x**5 + 2715*x**4 - 6720*x**3 - 1092*x**2 + 5040*x, x) >>> gff_list(f) [(Poly(x**3 + 7, x, domain='ZZ'), 2), (Poly(x**2 + 5*x, x, domain='ZZ'), 3)] >>> ff(Poly(x**3 + 7, x), 2)*ff(Poly(x**2 + 5*x, x), 3) == f True ršrmrqNcSsg|]\}}| ¡|f‘qSrXrírorXrXrYr²r³zgff_list..)r`rrr9r:rmrš)rSrNrnrªrorrurXrXrYrmñs "rmcOstdƒ‚dS)z3Compute greatest factorial factorization of ``f``. zsymbolic falling factorialNr0©rSrNrnrXrXrYÚgff srJc Osšt |dg¡zt|g|¢Ri|¤Ž\}}Wn0ty\}ztdd|ƒ‚WYd}~n d}~00| ¡\}}}|jsˆt|ƒ| ¡| ¡fSt|ƒ||fSdS)a½ Compute square-free norm of ``f``. Returns ``s``, ``f``, ``r``, such that ``g(x) = f(x-sa)`` and ``r(x) = Norm(g(x))`` is a square-free polynomial over ``K``, where ``a`` is the algebraic extension of the ground domain. Examples ======== >>> from sympy import sqf_norm, sqrt >>> from sympy.abc import x >>> sqf_norm(x**2 + 1, extension=[sqrt(3)]) (1, x**2 - 2*sqrt(3)*x + 4, x**4 - 4*x**2 + 16) ršrqrqN) r`rrr9r:rqršrrQ) rSrNrnrªrorr'rTrrXrXrYrq&s"rqc Os|t |dg¡zt|g|¢Ri|¤Ž\}}Wn0ty\}ztdd|ƒ‚WYd}~n d}~00| ¡}|jst| ¡S|SdS)z¿ Compute square-free part of ``f``. Examples ======== >>> from sympy import sqf_part >>> from sympy.abc import x >>> sqf_part(x**3 - 3*x - 2) x**2 - x - 2 ršrrrqN)r`rrr9r:rrršrQr$rXrXrYrrHs"rrcCs&|dkrdd„}ndd„}t||dS)z&Sort a list of ``(expr, exp)`` pairs. r€cSs.|\}}|jj}|t|ƒt|jƒt|jƒ|fSrv©r]rsrNrdr…©rtr÷Úexpr]rXrXrYr·isz_sorted_factors..keycSs.|\}}|jj}t|ƒt|jƒ|t|jƒ|fSrvrKrLrXrXrYr·nsr¶)r»)ruÚmethodr·rXrXrYÚ_sorted_factorsfs rOcCstdd„|DƒŽS)z*Multiply a list of ``(expr, exp)`` pairs. cSsg|]\}}| ¡|‘qSrXrí©r°rSrrXrXrYr²xr³z$_factors_product..)r©rurXrXrYÚ_factors_productvsrRcstjg}‰dd„t |¡Dƒ}|D]¶}|jsBt|tƒrNt|ƒrN||9}q$nV|jr˜|j tj kr˜|j\}‰|jr€ˆjr€||9}q$|jr¤ˆ |ˆf¡q$n|tj}‰zt ||ƒ\}}Wn4tyê} zˆ | jˆf¡WYd} ~ q$d} ~ 00t||dƒ} | ƒ\}}|tjurNˆjr&||ˆ9}n(|jr>ˆ |ˆf¡n| |tjf¡ˆtjurfˆ |¡q$ˆjrˆˆ ‡fdd„|Dƒ¡q$g} |D]8\}}| ¡jr¸ˆ ||ˆf¡n| ||f¡qˆ t| ƒˆf¡q$|dkr‡fdd„dd „ˆDƒDƒ‰|ˆfS) z.Helper function for :func:`_symbolic_factor`. cSs"g|]}t|dƒr| ¡n|‘qS)Ú_eval_factor)ràrS©r°rœrXrXrYr²sÿz)_symbolic_factor_list..NZ_listcsg|]\}}||ˆf‘qSrXrXrP)rMrXrYr²£r³r€cs(g|] ‰tt‡fdd„ˆDƒƒˆf‘qS)c3s|]\}}|ˆkr|VqdSrvrX)r°rSr¨©rrXrYr/¯r³z3_symbolic_factor_list...)rr)r°rQrUrYr²¯sÿcSsh|]\}}|’qSrXrX)r°r¨rœrXrXrYÚ °r³z(_symbolic_factor_list..)rr<rÚ make_argsrrKrrÚis_PowÚbaseZExp1rnrÇrr9rzrPrÀZis_positiverÚ is_integerrQrR)rzrorNrŠrnÚargrYr÷r¨rrWZ_coeffZ_factorsrðrSrrX)rMrurYÚ_symbolic_factor_list{sXÿ & ÿr\cs˜t|tƒrFt|dƒr| ¡Stt|ˆddˆˆƒ\}}t|t|ƒƒSt|dƒrl|j‡‡fdd„|j DƒŽSt|dƒr| ‡‡fdd„|Dƒ¡S|Sd S) z%Helper function for :func:`_factor`. rSÚfraction)r]rncsg|]}t|ˆˆƒ‘qSrX©Ú_symbolic_factor©r°r[©rNrorXrYr²½r³z$_symbolic_factor..r<csg|]}t|ˆˆƒ‘qSrXr^r`rarXrYr²¿r³N)rKrràrSr\rBrrRrWrnrŒ)rzrorNrŠrurXrarYr_µs r_cCsPt |ddg¡t ||¡}t|ƒ}t|ttfƒr@t|tƒrJ|d}}nt|ƒ ¡\}}t |||ƒ\}}t |||ƒ\} } | r|j std|ƒ‚| t dd¡}|| fD]:}t|ƒD],\} \}}|js´t||ƒ\}}||f|| <q´q¨t||ƒ}t| |ƒ} |jsdd„|Dƒ}d d„| Dƒ} || }|j s4||fS||| fSntd|ƒ‚d S)z>Helper function for :func:`sqf_list` and :func:`factor_list`. Úfracršrqza polynomial expected, got %sT)rcSsg|]\}}| ¡|f‘qSrXrírPrXrXrYr²ãr³z(_generic_factor_list..cSsg|]\}}| ¡|f‘qSrXrírPrXrXrYr²är³N)r`rrarrKrrLrBr8r\rbr6ÚclonererÛrirrOrš)rzrNrnrNroZnumerrGrËÚfprÌZfqZ_optrurœrSrr¨rŠrXrXrYÚ_generic_factor_listÄs6 recCs<| dd¡}t |g¡t ||¡}||d<tt|ƒ||ƒS)z4Helper function for :func:`sqf` and :func:`factor`. r]T)rFr`rrar_r)rzrNrnrNr]rorXrXrYÚ_generic_factorðs rfcs–ddlm‰d‡fdd„ }d ‡fdd„ }dd „}| ¡jr’||ƒr’| ¡}|||ƒ}|rp|d|d d|dfS|||ƒ}|r’dd|d|d fSdS)a! try to transform a polynomial to have rational coefficients try to find a transformation ``x = alpha*y`` ``f(x) = lc*alpha**n * g(y)`` where ``g`` is a polynomial with rational coefficients, ``lc`` the leading coefficient. If this fails, try ``x = y + beta`` ``f(x) = g(y)`` Returns ``None`` if ``g`` not found; ``(lc, alpha, None, g)`` in case of rescaling ``(None, None, beta, g)`` in case of translation Notes ===== Currently it transforms only polynomials without roots larger than 2. Examples ======== >>> from sympy import sqrt, Poly, simplify >>> from sympy.polys.polytools import to_rational_coeffs >>> from sympy.abc import x >>> p = Poly(((x**2-1)*(x-2)).subs({x:x*(1 + sqrt(2))}), x, domain='EX') >>> lc, r, _, g = to_rational_coeffs(p) >>> lc, r (7 + 5*sqrt(2), 2 - 2*sqrt(2)) >>> g Poly(x**3 + x**2 - 1/4*x - 1/4, x, domain='QQ') >>> r1 = simplify(1/r) >>> Poly(lc*r**3*(g.as_expr()).subs({x:x*r1}), x, domain='EX') == p True r©ÚsimplifyNcs@t|jƒdkr|jdjs"d|fS| ¡}| ¡}|p<| ¡}| ¡dd…}‡fdd„|Dƒ}t|ƒdkr<|dr<ˆ|d|dƒ}g}tt|ƒƒD]2}ˆ||||dƒ}|jsÄq<| |¡qœˆd|ƒ} |jd} | |g}td|dƒD]"}| ||d| ||¡qþt |Ž}t|ƒ}|| |fSdS)a$ try rescaling ``x -> alpha*x`` to convert f to a polynomial with rational coefficients. Returns ``alpha, f``; if the rescaling is successful, ``alpha`` is the rescaling factor, and ``f`` is the rescaled polynomial; else ``alpha`` is ``None``. rqrNcsg|]}ˆ|ƒ‘qSrXrX)r°ÚcoeffxrgrXrYr²/r³z._try_rescale..éþÿÿÿr*)rsrNrEr r(rbrîr—r4rÇrrL)rSÚf1rér:r Z rescale1_xZcoeffs1rœriZ rescale_xrÌr‡rgrXrYÚ_try_rescale!s0 z(to_rational_coeffs.._try_rescalec sœt|jƒdkr|jdjs"d|fS| ¡}|p4| ¡}| ¡dd…}ˆ|dƒ}|jr˜|js˜t|j dd„dd\}}|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``. rqrNcSs |jduS©NTr3)ÚzrXrXrYrµSr³z._try_translate..T©Úbinary)rsrNrEr rbrîÚis_Addr4rIrnrWri) rSrkrér r±ZratZnonratÚalphaÚf2rgrXrYÚ_try_translateCsÿ z*to_rational_coeffs.._try_translatecSsp| ¡}d}|D]Z}t |¡D]J}t|ƒj}dd„| ¡Dƒ}|sDqt|ƒdkrTd}t|ƒdkrdSqq|S)zS Return True if ``f`` is a sum with square roots but no other root FcSs,g|]$\}}|jr|jr|jdkr|j‘qS)rÃ)rÁZis_Rationalr)r°rAZwxrXrXrYr²bsÿzAto_rational_coeffs.._has_square_roots..rÃT)r rrWrrur†ÚminÚmax)rar Zhas_sqrÍrÌrSrrXrXrYÚ_has_square_rootsYs z-to_rational_coeffs.._has_square_rootsrqrÃ)N)N)Úsympy.simplify.simplifyrhr£rŸrb)rSrlrtrwrkrrXrgrYÚto_rational_coeffsùs&" ryc Csddlm}t||dd}| ¡}t|ƒ}|s2dS|\}}}} t| ¡ƒ} |r¶|| d|||ƒ}|d|ƒ}g} | dd…dD],}| ||d |||i¡ƒ|df¡q†nF| d}g} | dd…dD](}| |d |||i¡|df¡qÒ|| 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 rrgZEXräNrq) rxrhrLr ryrwrQrÇrÄ)rarÌrhÚp1réÚresr:rrPrTrur±Zr1r@rnrXrXrYÚ_torational_factor_listxs&,&r|cOst|||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)]) r€©rN©rerIrXrXrYrs¤srscOst|||ddS)zë Compute square-free factorization of ``f``. Examples ======== >>> from sympy import sqf >>> from sympy.abc import x >>> sqf(2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16) 2*(x + 1)**2*(x + 2)**3 r€r})rfrIrXrXrYr€¶sr€cOst|||ddS)a Compute a list of irreducible factors of ``f``. Examples ======== >>> from sympy import factor_list >>> from sympy.abc import x, y >>> factor_list(2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y) (2, [(x + y, 1), (x**2 + 1, 2)]) r¾r}r~rIrXrXrYrwÈsrw)rAc sØt|ƒ}|rz‡‡fdd„}t||ƒ}i}| tt¡}|D]6}t|gˆ¢Riˆ¤Ž}|js^|jr8||kr8|||<q8| |¡Szt |ˆˆddWSt yÒ} z.|js¶t|ƒWYd} ~ St | ƒ‚WYd} ~ n d} ~ 00dS)a Compute the factorization of expression, ``f``, into irreducibles. (To factor an integer into primes, use ``factorint``.) There two modes implemented: symbolic and formal. If ``f`` is not an instance of :class:`Poly` and generators are not specified, then the former mode is used. Otherwise, the formal mode is used. In symbolic mode, :func:`factor` will traverse the expression tree and factor its components without any prior expansion, unless an instance of :class:`~.Add` is encountered (in this case formal factorization is used). This way :func:`factor` can handle large or symbolic exponents. By default, the factorization is computed over the rationals. To factor over other domain, e.g. an algebraic or finite field, use appropriate options: ``extension``, ``modulus`` or ``domain``. Examples ======== >>> from sympy import factor, sqrt, exp >>> from sympy.abc import x, y >>> factor(2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y) 2*(x + y)*(x**2 + 1)**2 >>> factor(x**2 + 1) x**2 + 1 >>> factor(x**2 + 1, modulus=2) (x + 1)**2 >>> factor(x**2 + 1, gaussian=True) (x - I)*(x + I) >>> factor(x**2 - 2, extension=sqrt(2)) (x - sqrt(2))*(x + sqrt(2)) >>> factor((x**2 - 1)/(x**2 + 4*x + 4)) (x - 1)*(x + 1)/(x + 2)**2 >>> factor((x**2 + 4*x + 4)**10000000*(x**2 + 1)) (x + 2)**20000000*(x**2 + 1) By default, factor deals with an expression as a whole: >>> eq = 2**(x**2 + 2*x + 1) >>> factor(eq) 2**(x**2 + 2*x + 1) If the ``deep`` flag is True then subexpressions will be factored: >>> factor(eq, deep=True) 2**((x + 1)**2) If the ``fraction`` flag is False then rational expressions will not be combined. By default it is True. >>> factor(5*x + 3*exp(2 - 7*x), deep=True) (5*x*exp(7*x) + 3*exp(2))*exp(-7*x) >>> factor(5*x + 3*exp(2 - 7*x), deep=True, fraction=False) 5*x + 3*exp(2)*exp(-7*x) See Also ======== sympy.ntheory.factor_.factorint cs*t|gˆ¢Riˆ¤Ž}|js"|jr&|S|S)zS Factor, but avoid changing the expression when unable to. )r¾Úis_MulrX)rzr©r)rXrYÚ_try_factor szfactor.._try_factorr¾r}N) rr"Zatomsrrr¾rrXÚxreplacerfr6rr ) rSrArNrnr€ZpartialsZmuladdrar©ÚmsgrXr)rYr¾Ús"D r¾c Cs2t|dƒsDzt|ƒ}Wnty,gYS0|j||||||dSt|dd\}} t| jƒdkrft‚t|ƒD]\} }|j j || <qn|dur¨| j |¡}|dkr¨tdƒ‚|dur¼| j |¡}|durÐ| j |¡}t || j |||||d }g} |D]8\\}}}| j |¡| j |¡}}| ||f|f¡qð| SdS) a/ Compute isolating intervals for roots of ``f``. Examples ======== >>> from sympy import intervals >>> from sympy.abc import x >>> intervals(x**2 - 3) [((-2, -1), 1), ((1, 2), 1)] >>> intervals(x**2 - 3, eps=1e-2) [((-26/15, -19/11), 1), ((19/11, 26/15), 1)] r<r{r'rärqNrry)r|r}r~r÷r)ràrLr5rzr rsrNr7rÛr]r…r‡rÙrCrµrÇ)rªrtr|r}r~r÷rr€ršrorœr÷rzrUr'rPrÜrXrXrYrz=s6 ÿrzcCs\z&t|ƒ}t|tƒs$|jjs$tdƒ‚WntyDtd|ƒ‚Yn0|j||||||dS)zí Refine an isolating interval of a root to the given precision. Examples ======== >>> from sympy import refine_root >>> from sympy.abc import x >>> refine_root(x**2 - 3, 1, 2, eps=1e-2) (19/11, 26/15) úgenerator must be a Symbolz,Cannot refine a root of %s, not a polynomial)r|rŠrrŒ)rLrKr¡Ú is_Symbolr6r5r‰)rSr'rPr|rŠrrŒrªrXrXrYr‰usÿ r‰cCsXz*t|dd}t|tƒs(|jjs(tdƒ‚WntyHtd|ƒ‚Yn0|j||dS)až Return the number of roots of ``f`` in ``[inf, sup]`` interval. If one of ``inf`` or ``sup`` is complex, it will return the number of roots in the complex rectangle with corners at ``inf`` and ``sup``. Examples ======== >>> from sympy import count_roots, I >>> from sympy.abc import x >>> count_roots(x**4 - 4, -3, 3) 2 >>> count_roots(x**4 - 4, 0, 1 + 3*I) 1 F©Zgreedyrƒz*Cannot count roots of %s, not a polynomialr)rLrKr¡r„r6r5r–)rSr}r~rªrXrXrYr–’sr–TcCsVz*t|dd}t|tƒs(|jjs(tdƒ‚WntyHtd|ƒ‚Yn0|j|dS)zä Return a list of real roots with multiplicities of ``f``. Examples ======== >>> from sympy import real_roots >>> from sympy.abc import x >>> real_roots(2*x**3 - 7*x**2 + 4*x + 4) [-1/2, 2, 2] Fr…rƒz1Cannot compute real roots of %s, not a polynomialr)rLrKr¡r„r6r5r )rSržrªrXrXrYr ³sÿ r r£r¤cCsZz*t|dd}t|tƒs(|jjs(tdƒ‚WntyHtd|ƒ‚Yn0|j|||dS)aL Compute numerical approximations of roots of ``f``. Examples ======== >>> from sympy import nroots >>> from sympy.abc import x >>> nroots(x**2 - 3, n=15) [-1.73205080756888, 1.73205080756888] >>> nroots(x**2 - 3, n=30) [-1.73205080756887729352744634151, 1.73205080756887729352744634151] Fr…rƒz6Cannot compute numerical roots of %s, not a polynomial)rérr®)rLrKr¡r„r6r5r¼)rSrérr®rªrXrXrYr¼Ïsÿ r¼c Os~t |g¡z8t|g|¢Ri|¤Ž\}}t|tƒsB|jjsBtdƒ‚Wn0tyt}zt dd|ƒ‚WYd}~n d}~00| ¡S)zñ Compute roots of ``f`` by factorization in the ground domain. Examples ======== >>> from sympy import ground_roots >>> from sympy.abc import x >>> ground_roots(x**6 - 4*x**4 + 4*x**3 - x**2) {0: 2, 1: 2} rƒr¿rqN)r`rrrKrLr¡r„r6r9r:r¿rrXrXrYr¿îs"r¿c Os–t |g¡z8t|g|¢Ri|¤Ž\}}t|tƒsB|jjsBtdƒ‚Wn0tyt}zt dd|ƒ‚WYd}~n d}~00| |¡}|jsŽ| ¡S|SdS)a¦ Construct a polynomial with n-th powers of roots of ``f``. Examples ======== >>> from sympy import nth_power_roots_poly, factor, roots >>> from sympy.abc import x >>> f = x**4 - x**2 + 1 >>> g = factor(nth_power_roots_poly(f, 2)) >>> g (x**2 - x + 1)**2 >>> R_f = [ (r**2).expand() for r in roots(f) ] >>> R_g = roots(g).keys() >>> set(R_f) == set(R_g) True rƒrÁrqN) r`rrrKrLr¡r„r6r9r:rÁršrQ)rSrérNrnrªrorrUrXrXrYrÁs" rÁ)Ú _signsimpcsrddlm}ddlm‰ddlm}t |dg¡t|ƒ}|rF||ƒ}i}d|vr^|d|d<t |t tfƒs¤|js†t |t ƒs†t |tƒsŠ|St|dd}| ¡\}}n‚t|ƒdkr|\}}t |tƒròt |tƒrò|j|d <|j|d <| dd¡|d<| ¡| ¡}}n t |tƒrt|ƒStd|ƒ‚zj| ˆ¡r:tƒ‚|||fg|¢Ri|¤Ž\} \} }| jsŒt |t tfƒs~| ¡WStj||fWSWn*tyº}z|jrÀ| ˆ¡sÀt|ƒ‚|jsÐ|j r"t!|j"‡fdd „dd\} }dd„|Dƒ}|j#t$|j#| Žƒg|¢RŽWYd}~Sg}t%|ƒ}t&|ƒ|D]P}t |t tt'fƒrTq:z| (|t$|ƒf¡| )¡Wnt*y†Yn0q:| +t,|ƒ¡WYd}~SWYd}~n d}~00d| $|¡} \}}| dd¡ròd |vrò| j-|d <t |t tfƒs| | ¡| ¡S| ¡| ¡}}| dd¡s@| ||fS| t|g|¢Ri|¤Žt|g|¢Ri|¤ŽfSdS)a[ Cancel common factors in a rational function ``f``. Examples ======== >>> from sympy import cancel, sqrt, Symbol, together >>> from sympy.abc import x >>> A = Symbol('A', commutative=False) >>> cancel((2*x**2 - 2)/(x**2 - 2*x + 1)) (2*x + 2)/(x - 1) >>> cancel((sqrt(3) + sqrt(15)*A)/(sqrt(2) + sqrt(10)*A)) sqrt(6)/2 Note: due to automatic distribution of Rationals, a sum divided by an integer will appear as a sum. To recover a rational form use `together` on the result: >>> cancel(x/2 + 1) x/2 + 1 >>> together(_) (x + 2)/2 r)Úsignsimpr)ÚsringršT)ÚradicalrÃrNr…zunexpected argument: %scs|jduo| ˆ¡Srm)rÚhasrÄrrXrYrµ}szcancel..rocSsg|]}t|ƒ‘qSrX)rÉrTrXrXrYr²€r³zcancel..NrqF).rxr‡rrÚsympy.polys.ringsrˆr`rrrKrñr rrrrr8rsrLrNr…rErQrÙrŠr6Zngensrrr<rrqrrIrnrWrÉr!rr#rÇÚskiprbrrer›)rSr†rNrnr‡rˆrorarrrªr«r‚r±ZncrZpotÚerkrrXrrYrÉ8s~ " þ ( 0 rÉc sšt |ddg¡z(t|gt|ƒg|¢Ri|¤Ž\}‰Wn0tyh}ztdd|ƒ‚WYd}~n d}~00ˆj}d}ˆjrž|jrž|j sžˆ t| ¡d¡‰d}dd l m}|ˆjˆjˆjƒ\} } t|ƒD](\}}| ˆj¡j ¡}| |¡||<qÈ|d |d d…¡\} }‡fdd„| Dƒ} t t|ƒˆ¡}|rpzd d„| Dƒ| ¡}}WntydYn0||} }ˆjsŽdd„| Dƒ| ¡fS| |fSdS)a< Reduces a polynomial ``f`` modulo a set of polynomials ``G``. Given a polynomial ``f`` and a set of polynomials ``G = (g_1, ..., g_n)``, computes a set of quotients ``q = (q_1, ..., q_n)`` and the remainder ``r`` such that ``f = q_1*g_1 + ... + q_n*g_n + r``, where ``r`` vanishes or ``r`` is a completely reduced polynomial with respect to ``G``. Examples ======== >>> from sympy import reduced >>> from sympy.abc import x, y >>> reduced(2*x**4 + y**2 - x**2 + y**3, [x**3 - x, y**3 - y]) ([2*x, 1], x**2 + y**2 + y) ršrÚreducedrNFräT©Úxringrqcsg|]}t t|ƒˆ¡‘qSrX©rLrfre©r°rr„rXrYr²Êr³zreduced..cSsg|]}| ¡‘qSrX©rßr’rXrXrYr²Ïr³cSsg|]}| ¡‘qSrXrír’rXrXrYr²Ör³)r`rr rhr9r:r…rrrrcrerÅr‹rrNr^rÛrr]rºr}rrLrfrßr3ršrQ)rSr«rNrnršrr…rårÚ_ringr¨rœr÷rrÚ_QÚ_rrXr„rYrŽŸs6(" rŽcOst|g|¢Ri|¤ŽS)a‚ Computes the reduced Groebner basis for a set of polynomials. Use the ``order`` argument to set the monomial ordering that will be used to compute the basis. Allowed orders are ``lex``, ``grlex`` and ``grevlex``. If no order is specified, it defaults to ``lex``. For more information on Groebner bases, see the references and the docstring of :func:`~.solve_poly_system`. Examples ======== Example taken from [1]. >>> from sympy import groebner >>> from sympy.abc import x, y >>> F = [x*y - 2*y, 2*y**2 - x**2] >>> groebner(F, x, y, order='lex') GroebnerBasis([x**2 - 2*y**2, x*y - 2*y, y**3 - 2*y], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, order='grlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grlex') >>> groebner(F, x, y, order='grevlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grevlex') By default, an improved implementation of the Buchberger algorithm is used. Optionally, an implementation of the F5B algorithm can be used. The algorithm can be set using the ``method`` flag or with the :func:`sympy.polys.polyconfig.setup` function. >>> F = [x**2 - x - 1, (2*x - 1) * y - (x**10 - (1 - x)**10)] >>> groebner(F, x, y, method='buchberger') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, method='f5b') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex') References ========== 1. [Buchberger01]_ 2. [Cox97]_ )Ú GroebnerBasis©rªrNrnrXrXrYr+Û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 )r—Úis_zero_dimensionalr˜rXrXrYr™sr™c@sÂeZdZdZdd„Zedd„ƒZedd„ƒZedd „ƒZ ed d„ƒZ edd „ƒZedd„ƒZedd„ƒZ dd„Zdd„Zdd„Zdd„Zdd„Zdd„Zedd„ƒZd d!„Zd(d#d$„Zd%d&„Zd'S))r—z%Represents a reduced Groebner basis. c sÂt |ddg¡zt|g|¢Ri|¤Ž\}‰Wn4tyb}ztdt|ƒ|ƒ‚WYd}~n d}~00ddlm}|ˆjˆj ˆj ƒ‰‡fdd„|Dƒ}t|ˆˆjd }‡fd d„|Dƒ}| |ˆ¡S)z>Compute a reduced Groebner basis for a system of polynomials. ršrNr+Nr)ÚPolyRingcs g|]}|rˆ |j ¡¡‘qSrX)r}r]rº©r°r÷)ÚringrXrYr²3r³z)GroebnerBasis.__new__..r}csg|]}t |ˆ¡‘qSrX)rLrf©r°rTr„rXrYr²6r³)r`rr r9r:rsr‹ršrNr…r^Ú _groebnerrNÚ_new)rmrªrNrnršrršr«rX)rorœrYrp's&zGroebnerBasis.__new__cCst |¡}t|ƒ|_||_|Srv)r rprñÚ_basisÚ_options)rmÚbasisr`rtrXrXrYrŸ:s zGroebnerBasis._newcCs$dd„|jDƒ}t|Žt|jjŽfS)Ncss|]}| ¡VqdSrvrí)r°rarXrXrYr/Er³z%GroebnerBasis.args..)r r r¡rN)ryr¢rXrXrYrnCszGroebnerBasis.argscCsdd„|jDƒS)NcSsg|]}| ¡‘qSrXrír›rXrXrYr²Jr³z'GroebnerBasis.exprs..)r rxrXrXrYrHszGroebnerBasis.exprscCs t|jƒSrv)rhr rxrXrXrYršLszGroebnerBasis.polyscCs|jjSrv)r¡rNrxrXrXrYrNPszGroebnerBasis.genscCs|jjSrv)r¡r…rxrXrXrYr…TszGroebnerBasis.domaincCs|jjSrv)r¡r^rxrXrXrYr^XszGroebnerBasis.ordercCs t|jƒSrv)rsr rxrXrXrYÚ__len__\szGroebnerBasis.__len__cCs |jjrt|jƒSt|jƒSdSrv)r¡ršÚiterrrxrXrXrYr<_s zGroebnerBasis.__iter__cCs|jjr|j}n|j}||Srv)r¡ršr)ryÚitemr¢rXrXrYÚ__getitem__eszGroebnerBasis.__getitem__cCst|jt|j ¡ƒfƒSrv)Úhashr rñr¡r†rxrXrXrYr•mszGroebnerBasis.__hash__cCsPt||jƒr$|j|jko"|j|jkSt|ƒrH|jt|ƒkpF|jt|ƒkSdSdS)NF)rKrŒr r¡rHršrhr©ryrðrXrXrYròps zGroebnerBasis.__eq__cCs ||kSrvrXr¨rXrXrYróxszGroebnerBasis.__ne__cCsTdd„}tdgt|jƒƒ}|jj}|jD] }|j|d}||ƒr*||9}q*t|ƒS)a{ Checks if the ideal generated by a Groebner basis is zero-dimensional. The algorithm checks if the set of monomials not divisible by the leading monomial of any element of ``F`` is bounded. References ========== David A. Cox, John B. Little, Donal O'Shea. Ideals, Varieties and Algorithms, 3rd edition, p. 230 cSsttt|ƒƒdkSr’)Úsumr‹r)ÚmonomialrXrXrYÚ single_varŠsz5GroebnerBasis.is_zero_dimensional..single_varrrë)r,rsrNr¡r^ršr3rt)ryr«r-r^r÷rªrXrXrYr™{s z!GroebnerBasis.is_zero_dimensionalcsê|j‰ˆj}t|ƒ}||kr |S|js.tdƒ‚t|jƒ}ˆj}ˆ t | ¡|d¡‰ddlm}|ˆj ˆj|ƒ\}}t|ƒD](\} } | ˆj¡j ¡} | | ¡|| <q|t|||ƒ}‡fdd„|Dƒ}|jsÞdd„|Dƒ}|ˆ_| |ˆ¡S)aÙ Convert a Groebner basis from one ordering to another. The FGLM algorithm converts reduced Groebner bases of zero-dimensional ideals from one ordering to another. This method is often used when it is infeasible to compute a Groebner basis with respect to a particular ordering directly. Examples ======== >>> from sympy.abc import x, y >>> from sympy import groebner >>> F = [x**2 - 3*y - x + 1, y**2 - 2*x + y - 1] >>> G = groebner(F, x, y, order='grlex') >>> list(G.fglm('lex')) [2*x - y**2 - y + 1, y**4 + 2*y**3 - 3*y**2 - 16*y + 7] >>> list(groebner(F, x, y, order='lex')) [2*x - y**2 - y + 1, y**4 + 2*y**3 - 3*y**2 - 16*y + 7] References ========== .. [1] J.C. Faugere, P. Gianni, D. Lazard, T. Mora (1994). Efficient Computation of Zero-dimensional Groebner Bases by Change of Ordering z?Cannot convert Groebner bases of ideals with positive dimension)r…r^rrcsg|]}t t|ƒˆ¡‘qSrXr‘rr„rXrYr²Õr³z&GroebnerBasis.fglm..cSsg|]}|jddd‘qS)Tr?rq)r;rrXrXrYr²Ør³)r¡r^r-r™rbrhr r…rcrerÅr‹rrNrÛrr]rºr}r*rrŸ)ryr^Z src_orderZ dst_orderršr…rr”r¨rœr÷r«rXr„rYÚfglm›s0 þzGroebnerBasis.fglmTcsRt ||j¡}|gt|jƒ}|j‰ˆj}d}|rV|jrV|jsVˆ t | ¡d¡‰d}ddlm}|ˆj ˆjˆjƒ\}} t|ƒD](\} }| ˆj¡j ¡}| |¡|| <q€|d |dd…¡\}}‡fdd „|Dƒ}t t |ƒˆ¡}|r(zd d „|Dƒ| ¡} }WntyYn0| |}}ˆjsFdd „|Dƒ| ¡fS||fSdS)a# Reduces a polynomial modulo a Groebner basis. Given a polynomial ``f`` and a set of polynomials ``G = (g_1, ..., g_n)``, computes a set of quotients ``q = (q_1, ..., q_n)`` and the remainder ``r`` such that ``f = q_1*f_1 + ... + q_n*f_n + r``, where ``r`` vanishes or ``r`` is a completely reduced polynomial with respect to ``G``. Examples ======== >>> from sympy import groebner, expand >>> from sympy.abc import x, y >>> f = 2*x**4 - x**2 + y**3 + y**2 >>> G = groebner([x**3 - x, y**3 - y]) >>> G.reduce(f) ([2*x, 1], x**2 + y**2 + y) >>> Q, r = _ >>> expand(sum(q*g for q, g in zip(Q, G)) + r) 2*x**4 - x**2 + y**3 + y**2 >>> _ == f True FräTrrrqNcsg|]}t t|ƒˆ¡‘qSrXr‘r’r„rXrYr²r³z(GroebnerBasis.reduce..cSsg|]}| ¡‘qSrXr“r’rXrXrYr²r³cSsg|]}| ¡‘qSrXrír’rXrXrYr²r³)rLrkr¡rhr r…rrrcrerÅr‹rrNr^rÛrr]rºr}rrfrßr3ršrQ)ryrzrr÷ršr…rårr”r¨rœrrr•r–rXr„rYrÝs2 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 rqr)r)ryr÷rXrXrYÚcontainsszGroebnerBasis.containsN)T)rRrürýrþrprrŸrrnrršrNr…r^r£r<r¦r•ròrór™r¬rrrXrXrXrYr—#s6 B Ar—csdt ˆg¡‡‡fdd„‰t|ƒ}|jr>t|g|¢Riˆ¤ŽSdˆvrNdˆd<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]ê}gg}}t |¡D]b}|jrH| ˆ||ƒ¡q,|jr„|jjr„|jjr„|jdkr„| ˆ|j|ƒ |j¡¡q,| |¡q,|s | |¡q|d}|dd…D]}| |¡}q´|rôt|Ž}|jrâ| |¡}n| t ||¡¡}| |¡q|st ||¡} nZ|d} |dd…D]}| |¡} q(|rnt|Ž}|jr\| |¡} n| t ||¡¡} | j| dd¡iˆ¤ŽS)NrrqrNrX)rrWrrqrÇrXrYrMrÀrrrrLrkrÚrrE) rzrorÖZ poly_termsrHruZpoly_factorsr¾ÚproductrU©Ú_polyrnrXrYr°EsJ ÿÿÿzpoly.._polyrF)r`rrrirLrarrXr¯rYr÷4s4r÷)r)N)N)FNNNFFF)NNFF)NN)T)r£r¤T)³rþÚ functoolsrrÚoperatorrZ sympy.corerrrr Zsympy.core.basicr Zsympy.core.decoratorsrZsympy.core.exprtoolsrr rZsympy.core.evalfrrrrrZsympy.core.functionrZsympy.core.mulrrZsympy.core.numbersrrrZsympy.core.relationalrrZsympy.core.sortingrZsympy.core.symbolrrZsympy.core.sympifyrr Zsympy.core.traversalr!r"Zsympy.logic.boolalgr#Zsympy.polysr$r`Zsympy.polys.constructorr%Zsympy.polys.domainsr&r'r(Z!sympy.polys.domains.domainelementr)Zsympy.polys.fglmtoolsr*Zsympy.polys.groebnertoolsr+ržZsympy.polys.monomialsr,Zsympy.polys.orderingsr-Zsympy.polys.polyclassesr.r/r0Zsympy.polys.polyerrorsr1r2r3r4r5r6r7r8r9r:r;Zsympy.polys.polyutilsr<r=r>r?r@rAZsympy.polys.rationaltoolsrBZsympy.polys.rootisolationrCZsympy.utilitiesrDrErFZsympy.utilities.exceptionsrGZsympy.utilities.iterablesrHrIr™r«Zmpmath.libmp.libhyperrJr[rLrrrr rrr r"r!r(r3r7rrrrrrrrrMrOrQrSrTrWr[r7r^r?r_rr`rbrdrergrhrlrmrJrqrrrOrRr\r_rerfryr|rsr€rwr¾rzr‰r–r r¼r¿rÁrÉrŽr™r—r÷rXrXrXrYÚsŠ4 "h] ( _ : 4 " " " & & 4 $ ( T3 M2 u - . ! :, , b7 +f ; 5